Changeset c1799d3 in sasmodels for sasmodels/sasview_model.py

Timestamp:

Nov 9, 2018 12:16:05 PM (5 years ago)

Author:

Paul Kienzle <pkienzle@…>

Branches:

master, core_shell_microgels, magnetic_model, ticket-1257-vesicle-product, ticket_1156, ticket_1265_superball, ticket_822_more_unit_tests

Children:

c11d09f

Parents:

17695aa (diff), cf3d0ce (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'beta_approx' into ticket-1157

File:

• sasmodels/sasview_model.py (modified) (13 diffs)

sasmodels/sasview_model.py

@@ -283 +283 @@
     attrs['category'] = model_info.category
     attrs['is_structure_factor'] = model_info.structure_factor
-    attrs['is_form_factor'] = model_info.ER is not None
+    attrs['is_form_factor'] = model_info.effective_radius_type is not None
     attrs['is_multiplicity_model'] = variants[0] > 1
     attrs['multiplicity_info'] = variants
@@ -556 +556 @@
             # pylint: disable=unpacking-non-sequence
             q, phi = x
-            return self.calculate_Iq([q*math.cos(phi)], [q*math.sin(phi)])[0]
+            result, _ = self.calculate_Iq([q*math.cos(phi)], [q*math.sin(phi)])
+            return result[0]
         else:
-            return self.calculate_Iq([x])[0]
+            result, _ = self.calculate_Iq([x])
+            return result[0]
 
 
@@ -573 +575 @@
         """
         if isinstance(x, (list, tuple)):
-            return self.calculate_Iq([x[0]], [x[1]])[0]
+            result, _ = self.calculate_Iq([x[0]], [x[1]])
+            return result[0]
         else:
-            return self.calculate_Iq([x])[0]
+            result, _ = self.calculate_Iq([x])
+            return result[0]
 
     def evalDistribution(self, qdist):
@@ -609 +613 @@
             # Check whether we have a list of ndarrays [qx,qy]
             qx, qy = qdist
-            return self.calculate_Iq(qx, qy)
+            result, _ = self.calculate_Iq(qx, qy)
+            return result
 
         elif isinstance(qdist, np.ndarray):
             # We have a simple 1D distribution of q-values
-            return self.calculate_Iq(qdist)
+            result, _ = self.calculate_Iq(qdist)
+            return result
 
         else:
@@ -632 +638 @@
         # so that it returns a results object containing all the bits:
         #     the A, B, C, ... of the composition model (and any subcomponents?)
-        #     the P and S of the product model,
+        #     the P and S of the product model
         #     the combined model before resolution smearing,
         #     the sasmodel before sesans conversion,
@@ -653 +659 @@
         if composition and composition[0] == 'product': # only P*S for now
             with calculation_lock:
-                self._calculate_Iq(qx)
-                return self._intermediate_results
+                _, lazy_results = self._calculate_Iq(qx)
+                # for compatibility with sasview 4.x
+                results = lazy_results()
+                pq_data = results.get("P(Q)")
+                sq_data = results.get("S(Q)")
+                return pq_data, sq_data
         else:
             return None
 
-    def calculate_Iq(self, qx, qy=None):
-        # type: (Sequence[float], Optional[Sequence[float]]) -> np.ndarray
+    def calculate_Iq(self,
+                     qx,     # type: Sequence[float]
+                     qy=None # type: Optional[Sequence[float]]
+                     ):
+        # type: (...) -> Tuple[np.ndarray, Callable[[], collections.OrderedDict[str, np.ndarray]]]
         """
         Calculate Iq for one set of q with the current parameters.
@@ -667 +680 @@
         This should NOT be used for fitting since it copies the *q* vectors
         to the card for each evaluation.
+
+        The returned tuple contains the scattering intensity followed by a
+        callable which returns a dictionary of intermediate data from
+        ProductKernel.
         """
         ## uncomment the following when trying to debug the uncoordinated calls
@@ -677 +694 @@
             return self._calculate_Iq(qx, qy)
 
-    def _calculate_Iq(self, qx, qy=None):
+    def _calculate_Iq(self, qx, qy=None, Fq=False, effective_radius_type=1):
         if self._model is None:
             self._model = core.build_model(self._model_info)
@@ -697 +714 @@
         #print("values", values)
         #print("is_mag", is_magnetic)
+        if Fq:
+            result = calculator.Fq(call_details, values, cutoff=self.cutoff,
+                                   magnetic=is_magnetic,
+                                   effective_radius_type=effective_radius_type)
         result = calculator(call_details, values, cutoff=self.cutoff,
                             magnetic=is_magnetic)
+        lazy_results = getattr(calculator, 'results',
+                               lambda: collections.OrderedDict())
         #print("result", result)
-        self._intermediate_results = getattr(calculator, 'results', None)
+
         calculator.release()
         #self._model.release()
-        return result
-
-    def calculate_ER(self):
+
+        return result, lazy_results
+
+
+    def calculate_ER(self, mode=1):
         # type: () -> float
         """
@@ -712 +737 @@
         :return: the value of the effective radius
         """
-        if self._model_info.ER is None:
-            return 1.0
-        else:
-            value, weight = self._dispersion_mesh()
-            fv = self._model_info.ER(*value)
-            #print(values[0].shape, weights.shape, fv.shape)
-            return np.sum(weight * fv) / np.sum(weight)
+        Fq = self._calculate_Iq([0.1], True, mode)
+        return Fq[2]
 
     def calculate_VR(self):
@@ -725 +745 @@
         Calculate the volf ratio for P(q)*S(q)
 
-        :return: the value of the volf ratio
-        """
-        if self._model_info.VR is None:
-            return 1.0
-        else:
-            value, weight = self._dispersion_mesh()
-            whole, part = self._model_info.VR(*value)
-            return np.sum(weight * part) / np.sum(weight * whole)
+        :return: the value of the form:shell volume ratio
+        """
+        Fq = self._calculate_Iq([0.1], True, mode)
+        return Fq[4]
 
     def set_dispersion(self, parameter, dispersion):
@@ -842 +858 @@
     P = _make_standard_model('cylinder')()
     model = MultiplicationModel(P, S)
+    model.setParam(product.RADIUS_MODE_ID, 1.0)
     value = model.evalDistribution([0.1, 0.1])
     if np.isnan(value):
@@ -930 +947 @@
     q = np.linspace(-0.35, 0.35, 500)
     qx, qy = np.meshgrid(q, q)
-    result = model.calculate_Iq(qx.flatten(), qy.flatten())
+    result, _ = model.calculate_Iq(qx.flatten(), qy.flatten())
     result = result.reshape(qx.shape)