-                      ree8f734
+                      r6d6508e
 Core model handling routines.
 """
+from __future__ import print_function
 __all__ = [
     "list_models", "load_model_info", "precompile_dll",
     "build_model", "make_kernel", "call_kernel", "call_ER_VR",
+    "list_models", "load_model", "load_model_info",
+    "build_model", "precompile_dll",
+    ]
 from os.path import basename, dirname, join as joinpath, splitext
+from os.path import basename, dirname, join as joinpath
 from glob import glob
 import numpy as np
-from . import models
-from . import weights
 from . import generate
+# TODO: remove circular references between product and core
+# product uses call_ER/call_VR, core uses make_product_info/ProductModel
+#from . import product
+from . import modelinfo
+from . import product
 from . import mixture
 from . import kernelpy
 …
 except Exception:
     HAVE_OPENCL = False
-try:
-    np.meshgrid([])
-    meshgrid = np.meshgrid
-except ValueError:
-    # CRUFT: np.meshgrid requires multiple vectors
-    def meshgrid(*args):
-        if len(args) > 1:
-            return np.meshgrid(*args)
-        else:
-            return [np.asarray(v) for v in args]
 # TODO: refactor composite model support
 …
     parts = model_name.split('*')
     if len(parts) > 1:
-        from . import product
-        # Note: currently have circular reference
         if len(parts) > 2:
             raise ValueError("use P*S to apply structure factor S to model P")
 …
     kernel_module = generate.load_kernel_module(model_name)
     return generate.make_model_info(kernel_module)
+    return modelinfo.make_model_info(kernel_module)
 …
     otherwise it uses the default "ocl".
     """
     composition = model_info.get('composition', None)
+    composition = model_info.composition
     if composition is not None:
         composition_type, parts = composition
 …
     ##  4. rerun "python -m sasmodels.direct_model $MODELNAME"
     ##  5. uncomment open().read() so that source will be regenerated from model
     # open(model_info['name']+'.c','w').write(source)
     # source = open(model_info['name']+'.cl','r').read()
+    # open(model_info.name+'.c','w').write(source)
+    # source = open(model_info.name+'.cl','r').read()
     source = generate.make_source(model_info)
     if dtype is None:
         dtype = 'single' if model_info['single'] else 'double'
     if callable(model_info.get('Iq', None)):
+        dtype = 'single' if model_info.single else 'double'
+    if callable(model_info.Iq):
         return kernelpy.PyModel(model_info)
     if (platform == "dll"
 …
     source = generate.make_source(model_info)
     return kerneldll.make_dll(source, model_info, dtype=dtype) if source else None
-def get_weights(parameter, values):
-    """
-    Generate the distribution for parameter *name* given the parameter values
-    in *pars*.
-    Uses "name", "name_pd", "name_pd_type", "name_pd_n", "name_pd_sigma"
-    from the *pars* dictionary for parameter value and parameter dispersion.
-    """
-    value = float(values.get(parameter.name, parameter.default))
-    relative = parameter.relative_pd
-    limits = parameter.limits
-    disperser = values.get(parameter.name+'_pd_type', 'gaussian')
-    npts = values.get(parameter.name+'_pd_n', 0)
-    width = values.get(parameter.name+'_pd', 0.0)
-    nsigma = values.get(parameter.name+'_pd_nsigma', 3.0)
-    if npts == 0 or width == 0:
-        return [value], []
-    value, weight = weights.get_weights(
-        disperser, npts, width, nsigma, value, limits, relative)
-    return value, weight / np.sum(weight)
-def dispersion_mesh(pars):
-    """
-    Create a mesh grid of dispersion parameters and weights.
-    Returns [p1,p2,...],w where pj is a vector of values for parameter j
-    and w is a vector containing the products for weights for each
-    parameter set in the vector.
-    """
-    value, weight = zip(*pars)
-    weight = [w if w else [1.] for w in weight]
-    value = [v.flatten() for v in meshgrid(*value)]
-    weight = np.vstack([v.flatten() for v in meshgrid(*weight)])
-    weight = np.prod(weight, axis=0)
-    return value, weight
-def call_kernel(kernel, pars, cutoff=0, mono=False):
-    """
-    Call *kernel* returned from *model.make_kernel* with parameters *pars*.
-    *cutoff* is the limiting value for the product of dispersion weights used
-    to perform the multidimensional dispersion calculation more quickly at a
-    slight cost to accuracy. The default value of *cutoff=0* integrates over
-    the entire dispersion cube.  Using *cutoff=1e-5* can be 50% faster, but
-    with an error of about 1%, which is usually less than the measurement
-    uncertainty.
-    *mono* is True if polydispersity should be set to none on all parameters.
-    """
-    parameters = kernel.info['parameters']
-    if mono:
-        active = lambda name: False
-    elif kernel.dim == '1d':
-        active = lambda name: name in parameters.pd_1d
-    elif kernel.dim == '2d':
-        active = lambda name: name in parameters.pd_2d
-    else:
-        active = lambda name: True
-    vw_pairs = [(get_weights(p, pars) if active(p.name)
-                 else ([pars.get(p.name, p.default)], []))
-                for p in parameters.call_parameters]
-    details, weights, values = build_details(kernel, vw_pairs)
-    return kernel(details, weights, values, cutoff)
-def build_details(kernel, pairs):
-    values, weights = zip(*pairs)
-    if max([len(w) for w in weights]) > 1:
-        details = generate.poly_details(kernel.info, weights)
-    else:
-        details = kernel.info['mono_details']
-    weights, values = [np.hstack(v) for v in (weights, values)]
-    weights = weights.astype(dtype=kernel.dtype)
-    values = values.astype(dtype=kernel.dtype)
-    return details, weights, values
-def call_ER_VR(model_info, vol_pars):
-    """
-    Return effect radius and volume ratio for the model.
-    *info* is either *kernel.info* for *kernel=make_kernel(model,q)*
-    or *model.info*.
-    *pars* are the parameters as expected by :func:`call_kernel`.
-    """
-    ER = model_info.get('ER', None)
-    VR = model_info.get('VR', None)
-    value, weight = dispersion_mesh(vol_pars)
-    individual_radii = ER(*value) if ER else 1.0
-    whole, part = VR(*value) if VR else (1.0, 1.0)
-    effect_radius = np.sum(weight*individual_radii) / np.sum(weight)
-    volume_ratio = np.sum(weight*part)/np.sum(weight*whole)
-    return effect_radius, volume_ratio
-def call_ER(model_info, values):
-    """
-    Call the model ER function using *values*. *model_info* is either
-    *model.info* if you have a loaded model, or *kernel.info* if you
-    have a model kernel prepared for evaluation.
-    """
-    ER = model_info.get('ER', None)
-    if ER is None:
-        return 1.0
-    else:
-        vol_pars = [get_weights(parameter, values)
-                    for parameter in model_info['parameters'].call_parameters
-                    if parameter.type == 'volume']
-        value, weight = dispersion_mesh(vol_pars)
-        individual_radii = ER(*value)
-        return np.sum(weight*individual_radii) / np.sum(weight)
-def call_VR(model_info, values):
-    """
-    Call the model VR function using *pars*.
-    *info* is either *model.info* if you have a loaded model, or *kernel.info*
-    if you have a model kernel prepared for evaluation.
-    """
-    VR = model_info.get('VR', None)
-    if VR is None:
-        return 1.0
-    else:
-        vol_pars = [get_weights(parameter, values)
-                    for parameter in model_info['parameters'].call_parameters
-                    if parameter.type == 'volume']
-        value, weight = dispersion_mesh(vol_pars)
-        whole, part = VR(*value)
-        return np.sum(weight*part)/np.sum(weight*whole)
-# TODO: remove call_ER, call_VR

Note: See TracChangeset for help on using the changeset viewer.

SasView

Changeset 6d6508e in sasmodels for sasmodels/core.py

Legend:

sasmodels/core.py

Download in other formats: