Changes in / [9acade6:5fd684d] in sasmodels

Location:

sasmodels

Files:

• sasview_model.py (modified) (3 diffs)
• weights.py (modified) (7 diffs)

sasmodels/sasview_model.py

@@ -565 +565 @@
         parameters = self._model_info.parameters
         pairs = [self._get_weights(p) for p in parameters.call_parameters]
-        #weights.plot_weights(self._model_info, pairs)
         call_details, values, is_magnetic = make_kernel_args(calculator, pairs)
         #call_details.show()
@@ -619 +618 @@
             # remember them is kind of funky.
             # Note: can't seem to get disperser parameters from sasview
-            # (1) Could create a sasview model that has not yet been
+            # (1) Could create a sasview model that has not yet # been
             # converted, assign the disperser to one of its polydisperse
             # parameters, then retrieve the disperser parameters from the
-            # sasview model.
-            # (2) Could write a disperser parameter retriever in sasview.
-            # (3) Could modify sasview to use sasmodels.weights dispersers.
+            # sasview model.  (2) Could write a disperser parameter retriever
+            # in sasview.  (3) Could modify sasview to use sasmodels.weights
+            # dispersers.
             # For now, rely on the fact that the sasview only ever uses
             # new dispersers in the set_dispersion call and create a new
             # one instead of trying to assign parameters.
+            dispersion = weights.MODELS[dispersion.type]()
             self.dispersion[parameter] = dispersion.get_pars()
         else:
@@ -658 +658 @@
         elif par.polydisperse:
             dis = self.dispersion[par.name]
-            if dis['type'] == 'array':
-                value, weight = dis['values'], dis['weights']
-            else:
-                value, weight = weights.get_weights(
-                    dis['type'], dis['npts'], dis['width'], dis['nsigmas'],
-                    self.params[par.name], par.limits, par.relative_pd)
+            value, weight = weights.get_weights(
+                dis['type'], dis['npts'], dis['width'], dis['nsigmas'],
+                self.params[par.name], par.limits, par.relative_pd)
             return value, weight / np.sum(weight)
         else:

sasmodels/weights.py

@@ -3 +3 @@
 """
 # TODO: include dispersion docs with the disperser models
-from __future__ import division, print_function
-
 from math import sqrt  # type: ignore
-from collections import OrderedDict
-
 import numpy as np  # type: ignore
 from scipy.special import gammaln  # type: ignore
@@ -58 +54 @@
             else:
                 return np.array([], 'd'), np.array([], 'd')
-        x, px = self._weights(center, sigma, lb, ub)
-        return x, px
+        return self._weights(center, sigma, lb, ub)
 
     def _weights(self, center, sigma, lb, ub):
@@ -84 +79 @@
     default = dict(npts=35, width=0, nsigmas=3)
     def _weights(self, center, sigma, lb, ub):
-        # TODO: sample high probability regions more densely
-        # i.e., step uniformly in cumulative density rather than x value
-        # so weight = 1/Npts for all weights, but values are unevenly spaced
         x = self._linspace(center, sigma, lb, ub)
         px = np.exp((x-center)**2 / (-2.0 * sigma * sigma))
@@ -173 +165 @@
 
     def _weights(self, center, sigma, lb, ub):
-        # TODO: rebin the array dispersion using npts
-        # TODO: use a distribution that can be recentered and scaled
-        x = self.values
-        #x = center + self.values*sigma
+        # TODO: interpolate into the array dispersion using npts
+        x = center + self.values*sigma
         idx = (x >= lb) & (x <= ub)
         x = x[idx]
@@ -184 +174 @@
 
 # dispersion name -> disperser lookup table.
-# Maintain order since this is used by sasview GUI to order the options in
-# the dispersion type combobox.
-MODELS = OrderedDict((d.type, d) for d in (
-    RectangleDispersion,
-    ArrayDispersion,
-    LogNormalDispersion,
-    GaussianDispersion,
-    SchulzDispersion,
+MODELS = dict((d.type, d) for d in (
+    GaussianDispersion, RectangleDispersion,
+    ArrayDispersion, SchulzDispersion, LogNormalDispersion
 ))
 
@@ -209 +194 @@
     *value* is the value of the parameter in the model.
 
-    *limits* is [lb, ub], the lower and upper bound on the possible values.
+    *limits* is [lb, ub], the lower and upper bound of the weight value.
 
     *relative* is true if *width* is defined in proportion to the value
@@ -216 +201 @@
     Returns *(value, weight)*, where *value* and *weight* are vectors.
     """
-    if disperser == "array":
-        raise NotImplementedError("Don't handle arrays through get_weights; use values and weights directly")
     cls = MODELS[disperser]
     obj = cls(n, width, nsigmas)
     v, w = obj.get_weights(value, limits[0], limits[1], relative)
     return v, w
-
-
-def plot_weights(model_info, pairs):
-    # type: (ModelInfo, List[Tuple[np.ndarray, np.ndarray]]) -> None
-    """
-    Plot the weights returned by :func:`get_weights`.
-
-    *model_info* is
-    :param model_info:
-    :param pairs:
-    :return:
-    """
-    import pylab
-
-    if any(len(values)>1 for values, weights in pairs):
-        labels = [p.name for p in model_info.parameters.call_parameters]
-        pylab.interactive(True)
-        pylab.figure()
-        for (v,w), s in zip(pairs, labels):
-            if len(v) > 1:
-                #print("weights for", s, v, w)
-                pylab.plot(v, w, '-o', label=s)
-        pylab.grid(True)
-        pylab.legend()