Changes in / [d0876c9d:d1c4760] in sasmodels

Location:

sasmodels

Files:

• core.py (modified) (1 diff)
• modelinfo.py (modified) (2 diffs)
• sasview_model.py (modified) (9 diffs)

sasmodels/core.py

@@ -241 +241 @@
                  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)
+    values, weights = zip(*vw_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
-
+    return kernel(details, weights, values, cutoff)
 
 def call_ER_VR(model_info, vol_pars):

sasmodels/modelinfo.py

@@ -432 +432 @@
                          if p.polydisperse and p.type != 'magnetic')
 
-    def user_parameters(self, pars={}, is2d=True):
+    def user_parameters(self, pars, is2d):
         """
         Return the list of parameters for the given data type.
@@ -493 +493 @@
                 if table:
                     # look up length from incoming parameters
-                    table_length = int(pars.get(p.length_control, p.length))
+                    table_length = int(pars[p.length_control])
                     del dependent[p.length_control] # first entry seen
                     for k in range(1, table_length+1):

sasmodels/sasview_model.py

@@ -21 +21 @@
 
 from . import core
-from . import weights
+from . import generate
 
 def standard_models():
@@ -52 +52 @@
     """
     def __init__(self):
-        self._model = None
+        self._kernel = None
         model_info = self._model_info
         parameters = model_info['parameters']
@@ -75 +75 @@
         self.params = collections.OrderedDict()
         self.dispersion = dict()
-
-        self.orientation_params = []
-        self.magnetic_params = []
-        self.fixed = []
-        for p in parameters.user_parameters():
+        partype = model_info['partype']
+
+        for p in model_info['parameters']:
             self.params[p.name] = p.default
             self.details[p.name] = [p.units] + p.limits
-            if p.polydisperse:
-                self.dispersion[p.name] = {
-                    'width': 0,
-                    'npts': 35,
-                    'nsigmas': 3,
-                    'type': 'gaussian',
-                }
-            if p.type == 'orientation':
-                self.orientation_params.append(p.name)
-                self.orientation_params.append(p.name+".width")
-                self.fixed.append(p.name+".width")
-            if p.type == 'magnetic':
-                self.orientation_params.append(p.name)
-                self.magnetic_params.append(p.name)
-                self.fixed.append(p.name+".width")
-
+
+        for name in partype['pd-2d']:
+            self.dispersion[name] = {
+                'width': 0,
+                'npts': 35,
+                'nsigmas': 3,
+                'type': 'gaussian',
+            }
+
+        self.orientation_params = (
+            partype['orientation']
+            + [n + '.width' for n in partype['orientation']]
+            + partype['magnetic'])
+        self.magnetic_params = partype['magnetic']
+        self.fixed = [n + '.width' for n in partype['pd-2d']]
         self.non_fittable = []
 
@@ -116 +113 @@
     def __get_state__(self):
         state = self.__dict__.copy()
+        model_id = self._model_info['id']
         state.pop('_kernel')
         # May need to reload model info on set state since it has pointers
@@ -124 +122 @@
     def __set_state__(self, state):
         self.__dict__ = state
-        self._model = None
+        self._kernel = None
 
     def __str__(self):
@@ -213 +211 @@
     def getDispParamList(self):
         """
-        Return a list of polydispersity parameters for the model
+        Return a list of all available parameters for the model
         """
         # TODO: fix test so that parameter order doesn't matter
-        ret = ['%s.%s' % (p.name.lower(), ext)
-               for p in self._model_info['parameters'].user_parameters()
-               for ext in ('npts', 'nsigmas', 'width')
-               if p.polydisperse]
+        ret = ['%s.%s' % (d.lower(), p)
+               for d in self._model_info['partype']['pd-2d']
+               for p in ('npts', 'nsigmas', 'width')]
         #print(ret)
         return ret
@@ -292 +289 @@
             # Check whether we have a list of ndarrays [qx,qy]
             qx, qy = qdist
-            if not self._model_info['parameters'].has_2d:
+            partype = self._model_info['partype']
+            if not partype['orientation'] and not partype['magnetic']:
                 return self.calculate_Iq(np.sqrt(qx ** 2 + qy ** 2))
             else:
@@ -314 +312 @@
         to the card for each evaluation.
         """
-        if self._model is None:
-            self._model = core.build_model(self._model_info, platform='dll')
+        if self._kernel is None:
+            self._kernel = core.build_model(self._model_info)
         q_vectors = [np.asarray(q) for q in args]
-        kernel = self._model.make_kernel(q_vectors)
-        pairs = [self._get_weights(p)
-                 for p in self._model_info['parameters'].call_parameters]
-        details, weights, values = core.build_details(kernel, pairs)
-        return kernel(details, weights, values, cutoff=self.cutoff)
-        kernel.q_input.release()
-        kernel.release()
+        fn = self._kernel(q_vectors)
+        pars = [self.params[v] for v in fn.fixed_pars]
+        pd_pars = [self._get_weights(p) for p in fn.pd_pars]
+        result = fn(pars, pd_pars, self.cutoff)
+        fn.q_input.release()
+        fn.release()
         return result
 
@@ -396 +393 @@
     def _get_weights(self, par):
         """
-        Return dispersion weights for parameter
-        """
-        if par.polydisperse:
-            dis = self.dispersion[par.name]
-            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:
-            return [self.params[par.name]], []
-
-def test_model():
-    Cylinder = make_class('cylinder')
-    cylinder = Cylinder()
-    return cylinder.evalDistribution([0.1,0.1])
-
-if __name__ == "__main__":
-    print("cylinder(0.1,0.1)=%g"%test_model())
+            Return dispersion weights
+            :param par parameter name
+        """
+        from . import weights
+
+        relative = self._model_info['partype']['pd-rel']
+        limits = self._model_info['limits']
+        dis = self.dispersion[par]
+        value, weight = weights.get_weights(
+            dis['type'], dis['npts'], dis['width'], dis['nsigmas'],
+            self.params[par], limits[par], par in relative)
+        return value, weight / np.sum(weight)
+