Changeset d32de68 in sasmodels

Timestamp:

Aug 21, 2018 4:43:34 AM (6 years ago)

Author:

Torin Cooper-Bennun <torin.cooper-bennun@…>

Branches:

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

Children:

c11d09f

Parents:

d3ffeb7

Message:

put intermediate results into helper functions; tidy up; retain sasview 4.3 support in returning P(Q), S(Q)

Location:

sasmodels

Files:

• product.py (modified) (4 diffs)
• sasview_model.py (modified) (2 diffs)

sasmodels/product.py

@@ -13 +13 @@
 from __future__ import print_function, division
 
+from collections import OrderedDict
+
 from copy import copy
 import numpy as np  # type: ignore
@@ -22 +24 @@
 # pylint: disable=unused-import
 try:
-    from typing import Tuple
+    from typing import Tuple, Callable
 except ImportError:
     pass
@@ -145 +147 @@
     return par
 
+def _intermediates(P, S):
+    # type: (np.ndarray, np.ndarray) -> OrderedDict[str, np.ndarray]
+    """
+    Returns intermediate results for standard product (P(Q)*S(Q))
+    """
+    return OrderedDict((
+        ("P(Q)", P),
+        ("S(Q)", S),
+    ))
+
+def _intermediates_beta(F1, F2, S, scale, bg):
+    # type: (np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray) -> OrderedDict[str, np.ndarray]
+    """
+    Returns intermediate results for beta approximation-enabled product
+    """
+    # TODO: 1. include calculated Q vector
+    # TODO: 2. consider implications if there are intermediate results in P(Q)
+    return OrderedDict((
+        ("P(Q)", scale*F2),
+        ("S(Q)", S),
+        ("beta(Q)", F1**2 / F2),
+        ("S_eff(Q)", 1 + (F1**2 / F2)*(S-1)),
+        # ("I(Q)", scale*(F2 + (F1**2)*(S-1)) + bg),
+    ))
+
 class ProductModel(KernelModel):
     def __init__(self, model_info, P, S):
@@ -270 +297 @@
             F1, F2, volume_avg = self.p_kernel.beta(p_details, p_values, cutoff, magnetic)
             combined_scale = scale*volfrac/volume_avg
-            # Define lazy results based on intermediate values.
-            # The return value for the calculation should be an ordered
-            # dictionary containing any result the user might want to see
-            # at the end of the calculation, including scalars, strings,
-            # and plottable data.  Don't want to build this structure during
-            # fits, only when displaying the final result (or a one-off
-            # computation which asks for it).
-            # Do not use the current hack of storing the intermediate values
-            # in self.results since that leads to awkward threading issues.
-            # Instead return the function along with the bundle of inputs.
-            # P and Q may themselves have intermediate results they want to
-            # include, such as A and B if P = A + B.  Might use this mechanism
-            # to return the computed effective radius as well.
-            #def lazy_results(Q, S, F1, F2, scale):
-            #    """
-            #    beta = F1**2 / F2  # what about divide by zero errors?
-            #    return {
-            #        'P' : Data1D(Q, scale*F2),
-            #        'beta': Data1D(Q, beta),
-            #        'S' : Data1D(Q, S),
-            #        'Seff': Data1D(Q, 1 + beta*(S-1)),
-            #        'I' : Data1D(Q, scale*(F2 + (F1**2)*(S-1)) + background),
-            #    }
-            #lazy_pars = s_result, F1, F2, combined_scale
-
-            # self.results = [F2*volfrac/volume_avg, s_result]
+
+            self.results = lambda: _intermediates_beta(F1, F2, s_result, volfrac/volume_avg, background)
             final_result = combined_scale*(F2 + (F1**2)*(s_result - 1)) + background
-
-            # TODO: 1. include calculated Q vector
-            # TODO: 2. consider implications if there are intermediate results in P(Q)
-            # def lazy(F1, F2, S, scale, bg):
-            def lazy(F1, F2, S, scale):
-                return {
-                    "P(Q)": lambda: scale*F2,
-                    "S(Q)": lambda: S,
-                    "beta(Q)": lambda: F1**2 / F2,
-                    "S_eff(Q)": lambda: 1 + (F1**2 / F2)*(S-1),
-                    # "I(Q)":  lambda: scale*(F2 + (F1**2)*(S-1)) + bg,
-                }
-
-            self.results = lazy(F1, F2, s_result, volfrac/volume_avg)
 
         else:
             p_result = self.p_kernel.Iq(p_details, p_values, cutoff, magnetic)
-            # remember the parts for plotting later
-            # self.results = [p_result, s_result]
+
+            self.results = lambda: _intermediates(p_result, s_result)
             final_result = scale*(p_result*s_result) + background
-
-            def lazy(P, S):
-                return {
-                    "P(Q)": lambda: P,
-                    "S(Q)": lambda: S,
-                }
-
-            self.results = lazy(p_result, s_result)
 
         #call_details.show(values)

sasmodels/sasview_model.py

@@ -616 +616 @@
         # 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,
@@ -638 +638 @@
             with calculation_lock:
                 self._calculate_Iq(qx)
-                return self._intermediate_results
+                # for compatibility with sasview 4.3
+                results = self._intermediate_results()
+                return results["P(Q)"], results["S(Q)"]
         else:
             return None