-                      r7ae2b7f
+                      r04dc697
 """
+import warnings
+from __future__ import print_function
+__all__ = [ "Model", "Experiment" ]
 import numpy as np  # type: ignore
 …
 from .direct_model import DataMixin
+__all__ = [
+    "Model", "Experiment",
+    ]
+# CRUFT: old style bumps wrapper which doesn't separate data and model
+# pylint: disable=invalid-name
+def BumpsModel(data, model, cutoff=1e-5, **kw):
+    r"""
+    Bind a model to data, along with a polydispersity cutoff.
+    *data* is a :class:`data.Data1D`, :class:`data.Data2D` or
+    :class:`data.Sesans` object.  Use :func:`data.empty_data1D` or
+    :func:`data.empty_data2D` to define $q, \Delta q$ calculation
+    points for displaying the SANS curve when there is no measured data.
+    *model* is a runnable module as returned from :func:`core.load_model`.
+    *cutoff* is the polydispersity weight cutoff.
+    Any additional *key=value* pairs are model dependent parameters.
+    Returns an :class:`Experiment` object.
+    Note that the usual Bumps semantics is not fully supported, since
+    assigning *M.name = parameter* on the returned experiment object
+    does not set that parameter in the model.  Range setting will still
+    work as expected though.
+    .. deprecated:: 0.1
+        Use :class:`Experiment` instead.
+    """
+    warnings.warn("Use of BumpsModel is deprecated.  Use bumps_model.Experiment instead.")
+    # Create the model and experiment
+    model = Model(model, **kw)
+    experiment = Experiment(data=data, model=model, cutoff=cutoff)
+    # Copy the model parameters up to the experiment object.
+    for k, v in model.parameters().items():
+        setattr(experiment, k, v)
+    return experiment
+try:
+    from typing import Dict, Union, Tuple, Any
+    from .data import Data1D, Data2D
+    from .kernel import KernelModel
+    from .modelinfo import ModelInfo
+    Data = Union[Data1D, Data2D]
+except ImportError:
+    pass
+try:
+    # Optional import. This allows the doc builder and nosetests to run even
+    # when bumps is not on the path.
+    from bumps.names import Parameter # type: ignore
+except ImportError:
+    pass
 def create_parameters(model_info, **kwargs):
+    # type: (ModelInfo, **Union[float, str, Parameter]) -> Tuple[Dict[str, Parameter], Dict[str, str]]
     """
     Generate Bumps parameters from the model info.
 …
     Any additional *key=value* pairs are initial values for the parameters
     to the models.  Uninitialized parameters will use the model default
+    value.
+    value.  The value can be a float, a bumps parameter, or in the case
+    of the distribution type parameter, a string.
     Returns a dictionary of *{name: Parameter}* containing the bumps
 …
     *{name: str}* containing the polydispersity distribution types.
     """
+    # lazy import; this allows the doc builder and nosetests to run even
+    # when bumps is not on the path.
+    from bumps.names import Parameter  # type: ignore
+    pars = {}     # floating point parameters
+    pd_types = {} # distribution names
+    pars = {}     # type: Dict[str, Parameter]
+    pd_types = {} # type: Dict[str, str]
     for p in model_info.parameters.call_parameters:
         value = kwargs.pop(p.name, p.default)
 …
                 pars[name] = Parameter.default(value, name=name, limits=limits)
             name = p.name + '_pd_type'
             pd_types[name] = kwargs.pop(name, 'gaussian')
+            pd_types[name] = str(kwargs.pop(name, 'gaussian'))
     if kwargs:  # args not corresponding to parameters
 …
     """
     def __init__(self, model, **kwargs):
+        self._sasmodel = model
+        # type: (KernelModel, **Dict[str, Union[float, Parameter]]) -> None
+        self.sasmodel = model
         pars, pd_types = create_parameters(model.info, **kwargs)
         for k, v in pars.items():
 …
     def parameters(self):
+        # type: () -> Dict[str, Parameter]
         """
         Return a dictionary of parameters objects for the parameters,
 …
     def state(self):
+        # type: () -> Dict[str, Union[Parameter, str]]
         """
         Return a dictionary of current values for all the parameters,
 …
     The resulting model can be used directly in a Bumps FitProblem call.
     """
+    _cache = None # type: Dict[str, np.ndarray]
     def __init__(self, data, model, cutoff=1e-5):
+        # type: (Data, Model, float) -> None
         # remember inputs so we can inspect from outside
         self.model = model
         self.cutoff = cutoff
         self._interpret_data(data, model._sasmodel)
         self.update()
+        self._interpret_data(data, model.sasmodel)
+        self._cache = {}
     def update(self):
+        # type: () -> None
         """
         Call when model parameters have changed and theory needs to be
         recalculated.
         """
         self._cache = {}
+        self._cache.clear()
     def numpoints(self):
+        # type: () -> float
         """
         Return the number of data points
 …
     def parameters(self):
+        # type: () -> Dict[str, Parameter]
         """
         Return a dictionary of parameters
 …
     def theory(self):
+        # type: () -> np.ndarray
         """
         Return the theory corresponding to the model parameters.
 …
     def residuals(self):
+        # type: () -> np.ndarray
         """
         Return theory minus data normalized by uncertainty.
 …
     def nllf(self):
+        # type: () -> float
         """
         Return the negative log likelihood of seeing data given the model
 …
         delta = self.residuals()
         #if np.any(np.isnan(R)): print("NaN in residuals")
         return 0.5 * np.sum(delta ** 2)
+        return 0.5 * np.sum(delta**2)
     #def __call__(self):
 …
     def plot(self, view='log'):
+        # type: (str) -> None
         """
         Plot the data and residuals.
 …
     def simulate_data(self, noise=None):
+        # type: (float) -> None
         """
         Generate simulated data.
 …
     def save(self, basename):
+        # type: (str) -> None
         """
         Save the model parameters and data into a file.
 …
     def __getstate__(self):
+        # type: () -> Dict[str, Any]
         # Can't pickle gpu functions, so instead make them lazy
         state = self.__dict__.copy()
 …
     def __setstate__(self, state):
+        # type: (Dict[str, Any]) -> None
         # pylint: disable=attribute-defined-outside-init
         self.__dict__ = state

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

SasView

Changeset 04dc697 in sasmodels for sasmodels/bumps_model.py

Legend:

sasmodels/bumps_model.py

Download in other formats: