Changeset 69aa451 in sasmodels

Timestamp:

Mar 23, 2016 11:39:08 AM (9 years ago)

Author:

Paul Kienzle <pkienzle@…>

Branches:

master, core_shell_microgels, costrafo411, magnetic_model, release_v0.94, release_v0.95, ticket-1257-vesicle-product, ticket_1156, ticket_1265_superball, ticket_822_more_unit_tests

Children:

e9b1663d

Parents:

6fd8de0

Message:

refactor parameter representation

Location:

sasmodels

Files:

• compare.py (modified) (1 diff)
• core.py (modified) (1 diff)
• generate.py (modified) (17 diffs)
• kernel_iq.c (modified) (1 diff)
• kerneldll.py (modified) (1 diff)
• mixture.py (modified) (4 diffs)
• modelinfo.py (added)
• models/rpa.py (modified) (1 diff)

sasmodels/compare.py

@@ -870 +870 @@
         pars, pd_types = bumps_model.create_parameters(model_info, **opts['pars'])
         if not opts['is2d']:
-            for name in model_info['par_type']['1d']:
+            for p in model_info['parameters'].type['1d']:
                 for ext in ['', '_pd', '_pd_n', '_pd_nsigma']:
-                    k = name+ext
+                    k = p.name+ext
                     v = pars.get(k, None)
                     if v is not None:

sasmodels/core.py

@@ -218 +218 @@
         active = lambda name: False
     elif kernel.dim == '1d':
-        active = lambda name: name in set(kernel.info['par_type']['1d'])
+        pars_1d = set(p.name for p in kernel.info['parameters'].type['1d'])
+        active = lambda name: name in pars_1d
     elif kernel.dim == '2d':
-        active = lambda name: name in set(kernel.info['par_type']['2d'])
+        pars_2d = set(p.name for p in kernel.info['parameters'].type['2d'])
+        active = lambda name: name in pars_1d
     else:
         active = lambda name: True

sasmodels/generate.py

@@ -69 +69 @@
 The constructor code will generate the necessary vectors for computing
 them with the desired polydispersity.
-
-The available kernel parameters are defined as a list, with each parameter
-defined as a sublist with the following elements:
-
-    *name* is the name that will be used in the call to the kernel
-    function and the name that will be displayed to the user.  Names
-    should be lower case, with words separated by underscore.  If
-    acronyms are used, the whole acronym should be upper case.
-
-    *units* should be one of *degrees* for angles, *Ang* for lengths,
-    *1e-6/Ang^2* for SLDs.
-
-    *default value* will be the initial value for  the model when it
-    is selected, or when an initial value is not otherwise specified.
-
-    *limits = [lb, ub]* are the hard limits on the parameter value, used to
-    limit the polydispersity density function.  In the fit, the parameter limits
-    given to the fit are the limits  on the central value of the parameter.
-    If there is polydispersity, it will evaluate parameter values outside
-    the fit limits, but not outside the hard limits specified in the model.
-    If there are no limits, use +/-inf imported from numpy.
-
-    *type* indicates how the parameter will be used.  "volume" parameters
-    will be used in all functions.  "orientation" parameters will be used
-    in *Iqxy* and *Imagnetic*.  "magnetic* parameters will be used in
-    *Imagnetic* only.  If *type* is the empty string, the parameter will
-    be used in all of *Iq*, *Iqxy* and *Imagnetic*.  "sld" parameters
-    can automatically be promoted to magnetic parameters, each of which
-    will have a magnitude and a direction, which may be different from
-    other sld parameters.
-
-    *description* is a short description of the parameter.  This will
-    be displayed in the parameter table and used as a tool tip for the
-    parameter value in the user interface.
-
 The kernel module must set variables defining the kernel meta data:
 
@@ -216 +181 @@
 from __future__ import print_function
 
-# TODO: identify model files which have changed since loading and reload them.
+#TODO: determine which functions are useful outside of generate
+#__all__ = ["model_info", "make_doc", "make_source", "convert_type"]
 
 import sys
@@ -224 +190 @@
 import string
 import warnings
-from collections import namedtuple
 
 import numpy as np
 
-# TODO: promote Parameter and model_info to classes
-PARAMETER_FIELDS = ['name', 'units', 'default', 'limits', 'type', 'description']
-Parameter = namedtuple('Parameter', PARAMETER_FIELDS)
-
-#TODO: determine which functions are useful outside of generate
-#__all__ = ["model_info", "make_doc", "make_source", "convert_type"]
+from .modelinfo import ModelInfo, Parameter, make_parameter_table
+
+# TODO: identify model files which have changed since loading and reload them.
 
 TEMPLATE_ROOT = dirname(__file__)
@@ -246 +208 @@
 except TypeError:
     F128 = None
-
-# Scale and background, which are parameters common to every form factor
-COMMON_PARAMETERS = [
-    ["scale", "", 1, [0, np.inf], "", "Source intensity"],
-    ["background", "1/cm", 1e-3, [0, np.inf], "", "Source background"],
-    ]
 
 # Conversion from units defined in the parameter table for each model
@@ -354 +310 @@
     return [_search(search_path, f) for f in model_info['source']]
 
+def timestamp(model_info):
+    """
+    Return a timestamp for the model corresponding to the most recently
+    changed file or dependency.
+    """
+    source_files = (model_sources(model_info)
+                    + model_templates()
+                    + [model_info['filename']])
+    newest = max(getmtime(f) for f in source_files)
+    return newest
+
 def convert_type(source, dtype):
     """
@@ -448 +415 @@
          }
     """
-    par_decl = ', '.join('double ' + p for p in pars) if pars else 'void'
+    par_decl = ', '.join(p.as_argument() for p in pars) if pars else 'void'
     return _FN_TEMPLATE % {'name': name, 'body': body, 'pars': par_decl}
 
@@ -455 +422 @@
     Return a list of *prefix.parameter* from parameter items.
     """
-    prefix += "."
-    return [prefix+p for p in pars]
+    return [p.as_call_reference(prefix) for p in pars]
 
 _IQXY_PATTERN = re.compile("^((inline|static) )? *(double )? *Iqxy *([(]|$)",
@@ -499 +465 @@
     # for computing volume even if we allow non-disperse volume parameters.
 
-    # kernel_iq assumes scale and background are the first parameters;
-    # they should be first for 1d and 2d parameter lists as well.
-    assert model_info['parameters'][0].name == 'scale'
-    assert model_info['parameters'][1].name == 'background'
-
-    # Identify parameter types
-    iq_parameters = model_info['par_type']['1d'][2:]
-    iqxy_parameters = model_info['par_type']['2d'][2:]
-    vol_parameters = model_info['par_type']['volume']
+    partable = model_info['parameters']
+
+    # Identify parameters for Iq, Iqxy, Iq_magnetic and form_volume.
+    # Note that scale and volume are not possible types.
 
     # Load templates and user code
@@ -517 +478 @@
     source = [kernel_header] + user_code
 
+    vol_parameters = partable.kernel_pars('volume')
+    iq_parameters = partable.kernel_pars('1d')
+    iqxy_parameters = partable.kernel_pars('2d')
+
+    # Make parameters for q, qx, qy so that we can use them in declarations
+    q, qx, qy = [Parameter(name=v) for v in ('q', 'qx', 'qy')]
     # Generate form_volume function, etc. from body only
     if model_info['form_volume'] is not None:
-        pnames = [p for p in vol_parameters]
-        source.append(_gen_fn('form_volume', pnames, model_info['form_volume']))
+        pars = vol_parameters
+        source.append(_gen_fn('form_volume', pars, model_info['form_volume']))
     if model_info['Iq'] is not None:
-        pnames = ['q'] + [p for p in iq_parameters]
-        source.append(_gen_fn('Iq', pnames, model_info['Iq']))
+        pars = [q] + iq_parameters
+        source.append(_gen_fn('Iq', pars, model_info['Iq']))
     if model_info['Iqxy'] is not None:
-        pnames = ['qx', 'qy'] + [p for p in iqxy_parameters]
-        source.append(_gen_fn('Iqxy', pnames, model_info['Iqxy']))
+        pars = [qx, qy] + iqxy_parameters
+        source.append(_gen_fn('Iqxy', pars, model_info['Iqxy']))
 
     # Define the parameter table
     source.append("#define PARAMETER_TABLE \\")
-    source.append("\\\n    ".join("double %s;"%p.name
-                                   for p in model_info['parameters'][2:]))
+    source.append("\\\n".join(p.as_definition()
+                                  for p in model_info['parameters'][2:]))
 
     # Define the function calls
     if vol_parameters:
-        refs = ",".join(_call_pars("v", vol_parameters))
-        call_volume = "#define CALL_VOLUME(v) form_volume(%s)"%refs
+        refs = _call_pars("v.", vol_parameters)
+        call_volume = "#define CALL_VOLUME(v) form_volume(%s)" % (",".join(refs))
     else:
         # Model doesn't have volume.  We could make the kernel run a little
@@ -544 +511 @@
     source.append(call_volume)
 
-    refs = ["q[i]"] + _call_pars("v", iq_parameters)
+    refs = ["q[i]"] + _call_pars("v.", iq_parameters)
     call_iq = "#define CALL_IQ(q,i,v) Iq(%s)" % (",".join(refs))
     if _have_Iqxy(user_code):
         # Call 2D model
-        refs = ["q[2*i]", "q[2*i+1]"] + _call_pars("v", iqxy_parameters)
+        refs = ["q[2*i]", "q[2*i+1]"] + _call_pars("v.", iqxy_parameters)
         call_iqxy = "#define CALL_IQ(q,i,v) Iqxy(%s)" % (",".join(refs))
     else:
@@ -559 +526 @@
     # Fill in definitions for numbers of parameters
     source.append("#define MAX_PD %s"%model_info['max_pd'])
-    source.append("#define NPARS %d"%(len(model_info['parameters'])-2))
+    source.append("#define NPARS %d"%(len(partable.kernel_pars())))
 
     # TODO: allow mixed python/opencl kernels?
@@ -597 +564 @@
     """
     par_set = {}
-    par_set['1d'] = [p.name for p in pars if p.type not in ('orientation', 'magnetic')]
-    par_set['2d'] = [p.name for p in pars if p.type != 'magnetic']
-    par_set['magnetic'] = [p.name for p in pars]
-    par_set['pd'] = [p.name for p in pars if p.type in ('volume', 'orientation')]
-    par_set['pd_relative'] = [p.name for p in pars if p.type == 'volume']
-    if 'theta' in par_set['2d']:
-        # find id of theta in parameter set (or whatever variable is
-        # used for spherical normalization during polydispersity...
-        par_set['theta_par'] = [k for k,p in enumerate(pars) if p.name=='theta'][0]
-    else:
-        par_set['theta_par'] = -1
-    return par_set
-
-def collect_types(pars):
-    """
-    Build parameter categories out of the the parameter definitions.
-
-    Returns a dictionary of categories.
-
-    Note: these categories are subject to change, depending on the needs of
-    the UI and the needs of the kernel calling function.
-
-    The categories are as follows:
-
-    * *volume* list of volume parameter names
-    * *orientation* list of orientation parameters
-    * *magnetic* list of magnetic parameters
-    * *sld* list of parameters that have no type info
-    * *other* list of parameters that have no type info
-
-    Each parameter is in one and only one category.
-    """
-    par_type = {
-        'volume': [], 'orientation': [], 'magnetic': [], 'sld': [], 'other': [],
-    }
-    for p in pars:
-        par_type[p.type if p.type else 'other'].append(p.name)
-    return  par_type
-
 
 def process_parameters(model_info):
@@ -641 +569 @@
     Process parameter block, precalculating parameter details.
     """
-    # convert parameters into named tuples
-    for p in model_info['parameters']:
-        if p[4] == '' and (p[0].startswith('sld') or p[0].endswith('sld')):
-            p[4] = 'sld'
-            # TODO: make sure all models explicitly label their sld parameters
-            #raise ValueError("%s.%s needs to be explicitly set to type 'sld'" %(model_info['id'], p[0]))
-
-    pars = [Parameter(*p) for p in model_info['parameters']]
-    # Fill in the derived attributes
-    par_type = collect_types(pars)
-    par_type.update(categorize_parameters(pars))
-    model_info['parameters'] = pars
-    model_info['par_type'] = par_type
+    partable = model_info['parameters']
     if model_info.get('demo', None) is None:
-        model_info['demo'] = dict((p.name, p.default) for p in pars)
-    model_info['has_2d'] = par_type['orientation'] or par_type['magnetic']
+        model_info['demo'] = partable.defaults
+
     # Don't use more polydisperse parameters than are available in the model
     # Note: we can do polydispersity on arbitrary parameters, so it is not
     # clear that this is a good idea; it does however make the poly_details
     # code easier to write, so we will leave it in for now.
-    model_info['max_pd'] = min(len(par_type['pd']), MAX_PD)
+    model_info['max_pd'] = min(partable.num_pd, MAX_PD)
 
 def mono_details(model_info):
+    # TODO: move max_pd into ParameterTable?
     max_pd = model_info['max_pd']
-    npars = len(model_info['parameters']) - 2
-    p = 5*max_pd
-    c = p + 3*npars
-
-    details = np.zeros(c + 2, 'int32')
+    pars = model_info['parameters'].kernel_pars()
+    npars = len(pars)
+    par_offset = 5*max_pd
+    constants_offset = par_offset + 3*npars
+
+    details = np.zeros(constants_offset + 2, 'int32')
     details[0*max_pd:1*max_pd] = range(max_pd)       # pd_par: arbitrary order; use first
     details[1*max_pd:2*max_pd] = [1]*max_pd          # pd_length: only one element
@@ -675 +593 @@
     details[3*max_pd:4*max_pd] = [1]*max_pd          # pd_stride: vectors of length 1
     details[4*max_pd:5*max_pd] = [0]*max_pd          # pd_isvol: doens't matter if no norm
-    details[p+0*npars:p+1*npars] = range(2, npars+2) # par_offset: skip scale and background
-    details[p+1*npars:p+2*npars] = [0]*npars         # no coordination
+    details[par_offset+0*npars:par_offset+1*npars] = range(2, npars+2) # par_offset: skip scale and background
+    details[par_offset+1*npars:par_offset+2*npars] = [0]*npars         # no coordination
     #details[p+npars] = 1 # par_coord[0] is coordinated with the first par?
-    details[p+2*npars:p+3*npars] = 0 # fast coord with 0
-    details[c]   = 1     # fast_coord_count: one fast index
-    details[c+1] = -1    # theta_par: None
+    details[par_offset+2*npars:par_offset+3*npars] = 0 # fast coord with 0
+    details[constants_offset]   = 1     # fast_coord_count: one fast index
+    details[constants_offset+1] = -1    # theta_par: None
     return details
 
 def poly_details(model_info, weights):
-    print("entering poly",weights)
-
-    print([p.name for p in model_info['parameters']])
-    pars = model_info['parameters'][2:]  # skip scale and background
     weights = weights[2:]
+
+    # TODO: move max_pd into ParameterTable?
     max_pd = model_info['max_pd']
-    npars = len(pars) # scale and background already removed
+    pars = model_info['parameters'].kernel_pars
+    npars = len(pars)
     par_offset = 5*max_pd
     constants_offset = par_offset + 3*npars
@@ -745 +662 @@
     """
     if model_info['Iq'] is not None and model_info['Iqxy'] is None:
-        if model_info['par_type']['1d'] != model_info['par_type']['2d']:
+        partable = model_info['parameters']
+        if partable.type['1d'] != partable.type['2d']:
             raise ValueError("Iqxy model is missing")
         Iq = model_info['Iq']
@@ -751 +669 @@
             return Iq(np.sqrt(qx**2 + qy**2), **kw)
         model_info['Iqxy'] = Iqxy
+
 
 def make_model_info(kernel_module):
@@ -800 +719 @@
     """
     # TODO: maybe turn model_info into a class ModelDefinition
-    parameters = COMMON_PARAMETERS + kernel_module.parameters
+    #print("make parameter table", kernel_module.parameters)
+    parameters = make_parameter_table(kernel_module.parameters)
     filename = abspath(kernel_module.__file__)
     kernel_id = splitext(basename(filename))[0]

sasmodels/kernel_iq.c

@@ -14 +14 @@
 #ifndef _PAR_BLOCK_ // protected block so we can include this code twice.
 #define _PAR_BLOCK_
-
-#define MAX_PD 4  // MAX_PD is the max number of polydisperse parameters
 
 typedef struct {

sasmodels/kerneldll.py

@@ -140 +140 @@
 
     source = generate.convert_type(source, dtype)
-    source_files = (generate.model_sources(model_info)
-                    + [model_info['filename']]
-                    + generate.model_templates())
+    newest = generate.timestamp(model_info)
     dll = dll_path(model_info, dtype)
-    newest = max(os.path.getmtime(f) for f in source_files)
     if not os.path.exists(dll) or os.path.getmtime(dll) < newest:
         # Replace with a proper temp file

sasmodels/mixture.py

@@ -14 +14 @@
 import numpy as np
 
-from .generate import process_parameters, COMMON_PARAMETERS, Parameter
+from .modelinfo import Parameter, ParameterTable
 
 SCALE=0
@@ -34 +34 @@
 
     # Build new parameter list
-    pars = COMMON_PARAMETERS + []
+    pars = []
     for k, part in enumerate(parts):
         # Parameter prefix per model, A_, B_, ...
+        # Note that prefix must also be applied to id and length_control
+        # to support vector parameters
         prefix = chr(ord('A')+k) + '_'
-        for p in part['parameters']:
-            # No background on the individual mixture elements
-            if p.name == 'background':
-                continue
-            # TODO: promote Parameter to a full class
-            # this code knows too much about the implementation!
-            p = list(p)
-            if p[0] == 'scale':  # allow model subtraction
-                p[3] = [-np.inf, np.inf]  # limits
-            p[0] = prefix+p[0]   # relabel parameters with A_, ...
+        pars.append(Parameter(prefix+'scale'))
+        for p in part['parameters'].kernel_pars:
+            p = copy(p)
+            p.name = prefix+p.name
+            p.id = prefix+p.id
+            if p.length_control is not None:
+                p.length_control = prefix+p.length_control
             pars.append(p)
+    partable = ParameterTable(pars)
 
     model_info = {}
@@ -58 +58 @@
     model_info['docs'] = model_info['title']
     model_info['category'] = "custom"
-    model_info['parameters'] = pars
+    model_info['parameters'] = partable
     #model_info['single'] = any(part['single'] for part in parts)
     model_info['structure_factor'] = False
@@ -67 +67 @@
     # Remember the component info blocks so we can build the model
     model_info['composition'] = ('mixture', parts)
-    process_parameters(model_info)
-    return model_info
 
 

sasmodels/models/rpa.py

@@ -86 +86 @@
 #   ["name", "units", default, [lower, upper], "type","description"],
 parameters = [
-    ["case_num", CASES, 0, [0, 10], "", "Component organization"],
+    ["case_num", "", 1, CASES, "", "Component organization"],
 
-    ["Na", "", 1000.0, [1, inf], "", "Degree of polymerization"],
-    ["Phia", "", 0.25, [0, 1], "", "volume fraction"],
-    ["va", "mL/mol", 100.0, [0, inf], "", "specific volume"],
-    ["La", "fm", 10.0, [-inf, inf], "", "scattering length"],
-    ["ba", "Ang", 5.0, [0, inf], "", "segment length"],
-
-    ["Nb", "", 1000.0, [1, inf], "", "Degree of polymerization"],
-    ["Phib", "", 0.25, [0, 1], "", "volume fraction"],
-    ["vb", "mL/mol", 100.0, [0, inf], "", "specific volume"],
-    ["Lb", "fm", 10.0, [-inf, inf], "", "scattering length"],
-    ["bb", "Ang", 5.0, [0, inf], "", "segment length"],
-
-    ["Nc", "", 1000.0, [1, inf], "", "Degree of polymerization"],
-    ["Phic", "", 0.25, [0, 1], "", "volume fraction"],
-    ["vc", "mL/mol", 100.0, [0, inf], "", "specific volume"],
-    ["Lc", "fm", 10.0, [-inf, inf], "", "scattering length"],
-    ["bc", "Ang", 5.0, [0, inf], "", "segment length"],
-
-    ["Nd", "", 1000.0, [1, inf], "", "Degree of polymerization"],
-    ["Phid", "", 0.25, [0, 1], "", "volume fraction"],
-    ["vd", "mL/mol", 100.0, [0, inf], "", "specific volume"],
-    ["Ld", "fm", 10.0, [-inf, inf], "", "scattering length"],
-    ["bd", "Ang", 5.0, [0, inf], "", "segment length"],
+    ["N[4]", "", 1000.0, [1, inf], "", "Degree of polymerization"],
+    ["Phi[4]", "", 0.25, [0, 1], "", "volume fraction"],
+    ["v[4]", "mL/mol", 100.0, [0, inf], "", "specific volume"],
+    ["L[4]", "fm", 10.0, [-inf, inf], "", "scattering length"],
+    ["b[4]", "Ang", 5.0, [0, inf], "", "segment length"],
 
     ["Kab", "", -0.0004, [-inf, inf], "", "Interaction parameter"],