Changes in / [d459d4e:f3d7abd] in sasmodels


Ignore:
Location:
sasmodels
Files:
1 added
5 edited

Legend:

Unmodified
Added
Removed

  • sasmodels/compare.py

    raf92b73 r72a081d  
    369369            model = MultiplicationModel(P, S) 
    370370        else: 
    371             raise ValueError("mixture models not handled yet") 
     371            raise ValueError("sasview mixture models not supported by compare") 
    372372    else: 
    373373        model = get_model(model_info['oldname']) 
    … …  
    424424    Return a model calculator using the OpenCL calculation engine. 
    425425    """ 
    426     def builder(model_info): 
    427         try: 
    428             return core.build_model(model_info, dtype=dtype, platform="ocl") 
    429         except Exception as exc: 
    430             print(exc) 
    431             print("... trying again with single precision") 
    432             return core.build_model(model_info, dtype='single', platform="ocl") 
    433     if model_info['composition']: 
    434         composition_type, parts = model_info['composition'] 
    435         if composition_type == 'product': 
    436             P, S = [builder(p) for p in parts] 
    437             model = product.ProductModel(P, S) 
    438         else: 
    439             raise ValueError("mixture models not handled yet") 
    440     else: 
    441         model = builder(model_info) 
     426    try: 
     427        model = core.build_model(model_info, dtype=dtype, platform="ocl") 
     428    except Exception as exc: 
     429        print(exc) 
     430        print("... trying again with single precision") 
     431        model = core.build_model(model_info, dtype='single', platform="ocl") 
    442432    calculator = DirectModel(data, model, cutoff=cutoff) 
    443433    calculator.engine = "OCL%s"%DTYPE_MAP[dtype] 
    … …  
    450440    if dtype == 'quad': 
    451441        dtype = 'longdouble' 
    452     def builder(model_info): 
    453         return core.build_model(model_info, dtype=dtype, platform="dll") 
    454  
    455     if model_info['composition']: 
    456         composition_type, parts = model_info['composition'] 
    457         if composition_type == 'product': 
    458             P, S = [builder(p) for p in parts] 
    459             model = product.ProductModel(P, S) 
    460         else: 
    461             raise ValueError("mixture models not handled yet") 
    462     else: 
    463         model = builder(model_info) 
     442    model = core.build_model(model_info, dtype=dtype, platform="dll") 
    464443    calculator = DirectModel(data, model, cutoff=cutoff) 
    465444    calculator.engine = "OMP%s"%DTYPE_MAP[dtype] 
    … …  
    715694        print("expected parameters: model N1 N2") 
    716695 
    717     def _get_info(name): 
    718         try: 
    719             model_info = core.load_model_info(name) 
    720         except ImportError, exc: 
    721             print(str(exc)) 
    722             print("Use one of:\n    " + models) 
    723             sys.exit(1) 
    724         return model_info 
    725  
    726696    name = args[0] 
    727     if '*' in name: 
    728         parts = [_get_info(k) for k in name.split('*')] 
    729         model_info = product.make_product_info(*parts) 
    730     else: 
    731         model_info = _get_info(name) 
     697    try: 
     698        model_info = core.load_model_info(name) 
     699    except ImportError, exc: 
     700        print(str(exc)) 
     701        print("Could not find model; use one of:\n    " + models) 
     702        sys.exit(1) 
    732703 
    733704    invalid = [o[1:] for o in flags 
    … …  
    749720        'res'       : 0.0, 
    750721        'accuracy'  : 'Low', 
    751         'cutoff'    : 1e-5, 
     722        'cutoff'    : 0.0, 
    752723        'seed'      : -1,  # default to preset 
    753724        'mono'      : False, 

  • sasmodels/core.py

    rd5ba841 r72a081d  
    33""" 
    44 
    5 from os.path import basename, dirname, join as joinpath 
     5from os.path import basename, dirname, join as joinpath, splitext 
    66from glob import glob 
     7import imp 
    78 
    89import numpy as np 
    … …  
    1112from . import weights 
    1213from . import generate 
    13  
     14# TODO: remove circular references between product and core 
     15# product uses call_ER/call_VR, core uses make_product_info/ProductModel 
     16#from . import product 
     17from . import mixture 
    1418from . import kernelpy 
    1519from . import kerneldll 
    … …  
    4650    Load model info and build model. 
    4751    """ 
     52    return build_model(load_model_info(model_name), **kw) 
     53 
     54def load_model_info_from_path(path): 
     55    # Pull off the last .ext if it exists; there may be others 
     56    name = basename(splitext(path)[0]) 
     57 
     58    # Not cleaning name since don't need to be able to reload this 
     59    # model later 
     60    # Should probably turf the model from sys.modules after we are done... 
     61 
     62    # Placing the model in the 'sasmodels.custom' name space, even 
     63    # though it doesn't actually exist.  imp.load_source doesn't seem 
     64    # to care. 
     65    kernel_module = imp.load_source('sasmodels.custom.'+name, path) 
     66 
     67    # Now that we have the module, we can load it as usual 
     68    model_info = generate.make_model_info(kernel_module) 
     69    return model_info 
     70 
     71def load_model_info(model_name): 
     72    """ 
     73    Load a model definition given the model name. 
     74 
     75    This returns a handle to the module defining the model.  This can be 
     76    used with functions in generate to build the docs or extract model info. 
     77    """ 
    4878    parts = model_name.split('+') 
    4979    if len(parts) > 1: 
    50         from .mixture import MixtureModel 
    51         models = [load_model(p, **kw) for p in parts] 
    52         return MixtureModel(models) 
     80        model_info_list = [load_model_info(p) for p in parts] 
     81        return mixture.make_mixture_info(model_info_list) 
    5382 
    5483    parts = model_name.split('*') 
    5584    if len(parts) > 1: 
     85        from . import product 
    5686        # Note: currently have circular reference 
    57         from .product import ProductModel 
    5887        if len(parts) > 2: 
    5988            raise ValueError("use P*S to apply structure factor S to model P") 
    60         P, Q = [load_model(p, **kw) for p in parts] 
    61         return ProductModel(P, Q) 
    62  
    63     return build_model(load_model_info(model_name), **kw) 
    64  
    65 def load_model_info(model_name): 
    66     """ 
    67     Load a model definition given the model name. 
    68  
    69     This returns a handle to the module defining the model.  This can be 
    70     used with functions in generate to build the docs or extract model info. 
    71     """ 
     89        P_info, Q_info = [load_model_info(p) for p in parts] 
     90        return product.make_product_info(P_info, Q_info) 
     91 
    7292    #import sys; print "\n".join(sys.path) 
    7393    __import__('sasmodels.models.'+model_name) 
    … …  
    95115    otherwise it uses the default "ocl". 
    96116    """ 
    97     source = generate.make_source(model_info) 
    98     if dtype is None: 
    99         dtype = 'single' if model_info['single'] else 'double' 
    100     if callable(model_info.get('Iq', None)): 
    101         return kernelpy.PyModel(model_info) 
     117    composition = model_info.get('composition', None) 
     118    if composition is not None: 
     119        composition_type, parts = composition 
     120        models = [build_model(p, dtype=dtype, platform=platform) for p in parts] 
     121        if composition_type == 'mixture': 
     122            return mixture.MixtureModel(model_info, models) 
     123        elif composition_type == 'product': 
     124            from . import product 
     125            P, S = parts 
     126            return product.ProductModel(model_info, P, S) 
     127        else: 
     128            raise ValueError('unknown mixture type %s'%composition_type) 
    102129 
    103130    ## for debugging: 
    … …  
    109136    # open(model_info['name']+'.c','w').write(source) 
    110137    # source = open(model_info['name']+'.cl','r').read() 
    111  
     138    source = generate.make_source(model_info) 
     139    if dtype is None: 
     140        dtype = 'single' if model_info['single'] else 'double' 
     141    if callable(model_info.get('Iq', None)): 
     142        return kernelpy.PyModel(model_info) 
    112143    if (platform == "dll" 
    113144            or not HAVE_OPENCL 

  • sasmodels/models/hayter_msa_kernel.c

    rd529d93 rce43de0  
    1414   
    1515double Iq(double QQ, 
    16       double radius_effective, double zz, double VolFrac, double Temp, double csalt, double dialec)   
     16      double radius_effective, double VolFrac, double zz, double Temp, double csalt, double dialec) 
    1717{ 
    1818    double gMSAWave[17]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17}; 

  • sasmodels/product.py

    rd5ba841 r72a081d  
    6868 
    6969class ProductModel(object): 
    70     def __init__(self, P, S): 
     70    def __init__(self, model_info, P, S): 
     71        self.info = model_info 
    7172        self.P = P 
    7273        self.S = S 
    73         self.info = make_product_info(P.info, S.info) 
    7474 
    7575    def __call__(self, q_vectors): 

  • sasmodels/sasview_model.py

    r08376e7 r72a081d  
    1616import math 
    1717from copy import deepcopy 
    18 import warnings 
    1918import collections 
    2019 
    … …  
    2221 
    2322from . import core 
     23from . import generate 
     24from . import custom 
    2425 
    2526def standard_models(): 
    2627    return [make_class(model_name) for model_name in core.list_models()] 
    2728 
    28 def make_class(model_name, namestyle='name'): 
     29# TODO: rename to make_class_from_name and update sasview 
     30def make_class(model_name): 
    2931    """ 
    3032    Load the sasview model defined in *kernel_module*. 
    … …  
    3739    """ 
    3840    model_info = core.load_model_info(model_name) 
     41    return make_class_from_info(model_info) 
     42 
     43def make_class_from_file(path): 
     44    model_info = core.load_model_info_from_path(path) 
     45    return make_class_from_info(model_info) 
     46 
     47def make_class_from_info(model_info): 
    3948    def __init__(self, multfactor=1): 
    4049        SasviewModel.__init__(self) 
    4150    attrs = dict(__init__=__init__, _model_info=model_info) 
    42     ConstructedModel = type(model_info[namestyle], (SasviewModel,), attrs) 
     51    ConstructedModel = type(model_info['name'], (SasviewModel,), attrs) 
    4352    return ConstructedModel 
    4453 
Note: See TracChangeset for help on using the changeset viewer.