Changes in / [7be65ea:34375ea] in sasmodels


Ignore:
Location:
sasmodels
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • sasmodels/compare.py

    rcd3dba0 r73a3e22  
    1616from . import core 
    1717from . import kerneldll 
    18 from . import generate 
     18from . import models 
    1919from .data import plot_theory, empty_data1D, empty_data2D 
    2020from .direct_model import DirectModel 
     
    116116        return 2*np.random.rand()*(v if v != 0 else 1) 
    117117 
    118 def randomize_model(pars, seed=None): 
     118def randomize_model(name, pars, seed=None): 
    119119    if seed is None: 
    120120        seed = np.random.randint(1e9) 
     
    122122    # Note: the sort guarantees order of calls to random number generator 
    123123    pars = dict((p,randomize(p,v)) for p,v in sorted(pars.items())) 
    124  
    125     return pars, seed 
    126  
    127 def constrain_pars(model_definition, pars): 
    128     name = model_definition.name 
     124    # The capped cylinder model has a constraint on its parameters 
    129125    if name == 'capped_cylinder' and pars['cap_radius'] < pars['radius']: 
    130126        pars['radius'],pars['cap_radius'] = pars['cap_radius'],pars['radius'] 
    131  
    132     # These constraints are only needed for comparison to sasview 
    133     if name in ('teubner_strey','broad_peak'): 
    134         del pars['scale'] 
    135     if name in ('guinier',): 
    136         del pars['background'] 
    137     if getattr(model_definition, 'category', None) == 'structure-factor': 
    138         del pars['scale'], pars['background'] 
    139  
     127    return pars, seed 
    140128 
    141129def parlist(pars): 
     
    221209 
    222210def compare(name, pars, Ncpu, Nocl, opts, set_pars): 
    223     model_definition = core.load_model_definition(name) 
    224  
    225211    view = 'linear' if '-linear' in opts else 'log' if '-log' in opts else 'q4' if '-q4' in opts else 'log' 
    226212 
     
    245231    if '-random' in opts or '-random' in opt_values: 
    246232        seed = int(opt_values['-random']) if '-random' in opt_values else None 
    247         pars, seed = randomize_model(pars, seed=seed) 
    248         constrain_pars(model_definition, pars) 
     233        pars, seed = randomize_model(name, pars, seed=seed) 
    249234        print "Randomize using -random=%i"%seed 
    250235    pars.update(set_pars)  # set value after random to control value 
     
    256241        print "pars",parlist(pars) 
    257242 
     243    model_definition = core.load_model_definition(name) 
    258244    # OpenCl calculation 
    259245    if Nocl > 0: 
     
    261247                                    dtype=dtype, cutoff=cutoff, Nevals=Nocl) 
    262248        print "opencl t=%.1f ms, intensity=%.0f"%(ocl_time, sum(ocl)) 
    263         #print "ocl", ocl 
    264249        #print max(ocl), min(ocl) 
    265250 
     
    276261            #print "ocl/sasview", (ocl-pars['background'])/(cpu-pars['background']) 
    277262            print "sasview t=%.1f ms, intensity=%.0f"%(cpu_time, sum(cpu)) 
    278             #print "sasview",cpu 
    279263        except ImportError: 
    280264            Ncpu = 0 
     
    412396 
    413397 
    414 def get_demo_pars(model_definition): 
    415     info = generate.make_info(model_definition) 
    416     pars = dict((p[0],p[2]) for p in info['parameters']) 
    417     pars.update(info['demo']) 
     398def get_demo_pars(name): 
     399    __import__('sasmodels.models.'+name) 
     400    model = getattr(models, name) 
     401    pars = getattr(model, 'demo', None) 
     402    if pars is None: pars = dict((p[0],p[2]) for p in model.parameters) 
    418403    return pars 
    419404 
     
    440425    # if model does not define demo parameters 
    441426    name = args[0] 
    442     model_definition = core.load_model_definition(name) 
    443     pars = get_demo_pars(model_definition) 
     427    pars = get_demo_pars(name) 
    444428 
    445429    Nopencl = int(args[1]) if len(args) > 1 else 5 
  • sasmodels/compare_many.py

    rcd3dba0 re922c5d  
    99from .compare import (MODELS, randomize_model, suppress_pd, eval_sasview, 
    1010                      eval_opencl, eval_ctypes, make_data, get_demo_pars, 
    11                       columnize, constrain_pars) 
     11                      columnize) 
    1212 
    1313def get_stats(target, value, index): 
     
    3636def compare_instance(name, data, index, N=1, mono=True, cutoff=1e-5): 
    3737    model_definition = core.load_model_definition(name) 
    38     pars = get_demo_pars(model_definition) 
     38    pars = get_demo_pars(name) 
    3939    header = '\n"Model","%s","Count","%d"'%(name, N) 
    4040    if not mono: header += ',"Cutoff",%g'%(cutoff,) 
    4141    print(header) 
    4242 
     43    # Stuff the failure flag into a mutable object so we can update it from 
     44    # within the nested function.  Note that the nested function uses "pars" 
     45    # which is dynamically scoped, not lexically scoped in this context.  That 
     46    # is, pars is replaced each time in the loop, so don't assume that it is 
     47    # the default values defined above. 
    4348    def trymodel(fn, *args, **kw): 
    4449        try: 
    45             result, _ = fn(model_definition, pars_i, data, *args, **kw) 
    46         except KeyboardInterrupt: 
    47             raise 
     50            result, _ = fn(model_definition, pars, data, *args, **kw) 
    4851        except: 
    49             print >>sys.stderr, traceback.format_exc() 
    50             print >>sys.stderr, "when comparing",name,"for seed",seed 
    51             if hasattr(data, 'qx_data'): 
    52                 result = np.NaN*data.data 
    53             else: 
    54                 result = np.NaN*data.x 
     52            result = np.NaN 
     53            traceback.print_exc() 
    5554        return result 
    5655 
    5756    num_good = 0 
    5857    first = True 
    59     for k in range(N): 
    60         print >>sys.stderr, name, k 
    61         pars_i, seed = randomize_model(pars) 
    62         constrain_pars(model_definition, pars_i) 
    63         if mono: suppress_pd(pars_i) 
     58    for _ in range(N): 
     59        pars, seed = randomize_model(name, pars) 
     60        if mono: suppress_pd(pars) 
     61 
     62        # Force parameter constraints on a per-model basis. 
     63        if name in ('teubner_strey','broad_peak'): 
     64            pars['scale'] = 1.0 
     65        #if name == 'parallelepiped': 
     66        #    pars['a_side'],pars['b_side'],pars['c_side'] = \ 
     67        #        sorted([pars['a_side'],pars['b_side'],pars['c_side']]) 
     68 
    6469 
    6570        good = True 
     
    9297            good = good and (stats[0] < 1e-14) 
    9398 
    94         columns += [v for _,v in sorted(pars_i.items())] 
     99        columns += [v for _,v in sorted(pars.items())] 
    95100        if first: 
    96             print_column_headers(pars_i, labels) 
     101            print_column_headers(pars, labels) 
    97102            first = False 
    98103        if good: 
  • sasmodels/generate.py

    rcd3dba0 r4eac427  
    9999The kernel module must set variables defining the kernel meta data: 
    100100 
    101     *id* is an implicit variable formed from the filename.  It will be 
    102     a valid python identifier, and will be used as the reference into 
    103     the html documentation, with '_' replaced by '-'. 
    104  
    105     *name* is the model name as displayed to the user.  If it is missing, 
    106     it will be constructed from the id. 
     101    *name* is the model name 
    107102 
    108103    *title* is a short description of the model, suitable for a tool tip, 
     
    119114    the kernel functions. 
    120115 
    121     *category* is the default category for the model.  Models in the 
    122     *structure-factor* category do not have *scale* and *background* 
    123     added. 
    124  
    125116    *source* is the list of C-99 source files that must be joined to 
    126117    create the OpenCL kernel functions.  The files defining the functions 
     
    143134    this step is significant. 
    144135 
     136An *info* dictionary is constructed from the kernel meta data and 
     137returned to the caller. 
     138 
     139Additional fields can be defined in the kernel definition file that 
     140are not needed for sas modelling. 
     141 
    145142    *demo* is a dictionary of parameter=value defining a set of 
    146     parameters to use by default when *compare* is called.  Any 
    147     parameter not set in *demo* gets the initial value from the 
    148     parameter list.  *demo* is mostly needed to set the default 
    149     polydispersity values for tests. 
     143    parameters to use by default when *compare* is called. 
    150144 
    151145    *oldname* is the name of the model in sasview before sasmodels 
     
    155149    of the new model against the values of the old model before 
    156150    you are ready to add the new model to sasmodels. 
    157  
    158  
    159 An *info* dictionary is constructed from the kernel meta data and 
    160 returned to the caller. 
    161151 
    162152The model evaluator, function call sequence consists of q inputs and the return vector, 
     
    200190 
    201191import sys 
    202 from os.path import abspath, dirname, join as joinpath, exists, basename 
     192from os.path import abspath, dirname, join as joinpath, exists 
    203193import re 
    204194 
     
    243233# description and its parameter table.  The remainder of the doc comes 
    244234# from the module docstring. 
    245 DOC_HEADER = """.. _%(id)s: 
    246  
    247 %(name)s 
     235DOC_HEADER = """.. _%(name)s: 
     236 
     237%(label)s 
    248238======================================================= 
    249239 
     
    264254    Generate the parameter table to include in the sphinx documentation. 
    265255    """ 
     256    pars = COMMON_PARAMETERS + pars 
    266257    column_widths = [ 
    267258        max(len(p[0]) for p in pars), 
     
    532523        } 
    533524 
    534 def make_info(kernel_module): 
    535     """ 
    536     Interpret the model definition file, categorizing the parameters. 
    537     """ 
     525def make(kernel_module): 
     526    """ 
     527    Build an OpenCL/ctypes function from the definition in *kernel_module*. 
     528 
     529    The module can be loaded with a normal python import statement if you 
     530    know which module you need, or with __import__('sasmodels.model.'+name) 
     531    if the name is in a string. 
     532    """ 
     533    # TODO: allow Iq and Iqxy to be defined in python 
    538534    #print kernelfile 
    539     category = getattr(kernel_module, 'category', None) 
    540     parameters = COMMON_PARAMETERS + kernel_module.parameters 
    541     # Default the demo parameters to the starting values for the individual 
    542     # parameters if an explicit demo parameter set has not been specified. 
    543     demo_parameters = getattr(kernel_module, 'demo', None) 
    544     if demo_parameters is None: 
    545         demo_parameters = dict((p[0],p[2]) for p in parameters) 
    546     filename = abspath(kernel_module.__file__) 
    547     kernel_id = basename(filename)[:-3] 
    548     name = getattr(kernel_module, 'name', None) 
    549     if name is None: 
    550         name = " ".join(w.capitalize() for w in kernel_id.split('_')) 
    551535    info = dict( 
    552         id = kernel_id,  # string used to load the kernel 
    553536        filename=abspath(kernel_module.__file__), 
    554         name=name, 
     537        name=kernel_module.name, 
    555538        title=kernel_module.title, 
    556539        description=kernel_module.description, 
    557         category=category, 
    558         parameters=parameters, 
    559         demo=demo_parameters, 
     540        parameters=COMMON_PARAMETERS + kernel_module.parameters, 
    560541        source=getattr(kernel_module, 'source', []), 
    561542        oldname=kernel_module.oldname, 
     
    569550    info['partype'] = categorize_parameters(info['parameters']) 
    570551    info['defaults'] = dict((p[0], p[2]) for p in info['parameters']) 
    571     return info 
    572  
    573 def make(kernel_module): 
    574     """ 
    575     Build an OpenCL/ctypes function from the definition in *kernel_module*. 
    576  
    577     The module can be loaded with a normal python import statement if you 
    578     know which module you need, or with __import__('sasmodels.model.'+name) 
    579     if the name is in a string. 
    580     """ 
    581     info = make_info(kernel_module) 
     552 
    582553    # Assume if one part of the kernel is python then all parts are. 
    583554    source = make_model(info) if not callable(info['Iq']) else None 
     
    588559    Return the documentation for the model. 
    589560    """ 
    590     info = make_info(kernel_module) 
    591     subst = dict(id=info['id'].replace('_', '-'), 
    592                  name=info['name'], 
    593                  title=info['title'], 
    594                  parameters=make_partable(info['parameters']), 
     561    subst = dict(name=kernel_module.name.replace('_', '-'), 
     562                 label=" ".join(kernel_module.name.split('_')).capitalize(), 
     563                 title=kernel_module.title, 
     564                 parameters=make_partable(kernel_module.parameters), 
    595565                 docs=kernel_module.__doc__) 
    596566    return DOC_HEADER % subst 
  • sasmodels/models/HayterMSAsq.py

    rcd3dba0 r63b32bb  
    7575               "dielectric constant of solvent (default water), for Debye length"], 
    7676             ] 
    77 category = "structure-factor" 
    7877 
    7978# No volume normalization despite having a volume parameter 
  • sasmodels/models/bcc.py

    rcd3dba0 r485aee2  
    134134    radius=40, 
    135135    theta=60, phi=60, psi=60, 
    136     radius_pd=.2, radius_pd_n=2, 
     136    radius_pd=.2, radius_pd_n=0.2, 
    137137    theta_pd=15, theta_pd_n=0, 
    138138    phi_pd=15, phi_pd_n=0, 
  • sasmodels/models/parallelepiped.py

    rcd3dba0 r9fd094c  
    158158            a_side_pd=0.1, a_side_pd_n=10, 
    159159            b_side_pd=0.1, b_side_pd_n=1, 
    160             c_side_pd=0.1, c_side_pd_n=1, 
     160            c_side_pd=0.1, c_side_pd_n=10, 
    161161            theta_pd=10, theta_pd_n=1, 
    162162            phi_pd=10, phi_pd_n=1, 
Note: See TracChangeset for help on using the changeset viewer.