Changeset fb5914f in sasmodels

Timestamp:

Mar 30, 2016 1:34:16 AM (8 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:

7a1143b, 3a45c2c

Parents:

ce896fd

Message:

bind sasview to new parameter table definition

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]
-    values, weights = zip(*vw_pairs)
-
+
+    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 kernel(details, weights, values, cutoff)
+    return details, weights, values
+
 
 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):
+    def user_parameters(self, pars={}, is2d=True):
         """
         Return the list of parameters for the given data type.
@@ -493 +493 @@
                 if table:
                     # look up length from incoming parameters
-                    table_length = int(pars[p.length_control])
+                    table_length = int(pars.get(p.length_control, p.length))
                     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 generate
+from . import weights
 
 def standard_models():
@@ -52 +52 @@
     """
     def __init__(self):
-        self._kernel = None
+        self._model = None
         model_info = self._model_info
         parameters = model_info['parameters']
@@ -75 +75 @@
         self.params = collections.OrderedDict()
         self.dispersion = dict()
-        partype = model_info['partype']
-
-        for p in model_info['parameters']:
+
+        self.orientation_params = []
+        self.magnetic_params = []
+        self.fixed = []
+        for p in parameters.user_parameters():
             self.params[p.name] = p.default
             self.details[p.name] = [p.units] + p.limits
-
-        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']]
+            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")
+
         self.non_fittable = []
 
@@ -113 +116 @@
     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
@@ -122 +124 @@
     def __set_state__(self, state):
         self.__dict__ = state
-        self._kernel = None
+        self._model = None
 
     def __str__(self):
@@ -211 +213 @@
     def getDispParamList(self):
         """
-        Return a list of all available parameters for the model
+        Return a list of polydispersity parameters for the model
         """
         # TODO: fix test so that parameter order doesn't matter
-        ret = ['%s.%s' % (d.lower(), p)
-               for d in self._model_info['partype']['pd-2d']
-               for p in ('npts', 'nsigmas', 'width')]
+        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]
         #print(ret)
         return ret
@@ -289 +292 @@
             # Check whether we have a list of ndarrays [qx,qy]
             qx, qy = qdist
-            partype = self._model_info['partype']
-            if not partype['orientation'] and not partype['magnetic']:
+            if not self._model_info['parameters'].has_2d:
                 return self.calculate_Iq(np.sqrt(qx ** 2 + qy ** 2))
             else:
@@ -312 +314 @@
         to the card for each evaluation.
         """
-        if self._kernel is None:
-            self._kernel = core.build_model(self._model_info)
+        if self._model is None:
+            self._model = core.build_model(self._model_info, platform='dll')
         q_vectors = [np.asarray(q) for q in args]
-        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()
+        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()
         return result
 
@@ -393 +396 @@
     def _get_weights(self, par):
         """
-            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)
-
+        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())