Changeset 117c02a in sasmodels for sasmodels/product.py

Timestamp:

Sep 3, 2018 5:20:35 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:

c0131d44

Parents:

bad3093

Message:

cherry-picking lazy results implementation from beta_approx_lazy_results, beta_approx_new_R_eff branches

File:

• sasmodels/product.py (modified) (6 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
@@ -37 +39 @@
 ER_ID = "radius_effective"
 VF_ID = "volfraction"
-BETA_DEFINITION = ("beta_mode", "", 0, [["P*S"],["P*(1+beta*(S-1))"]], "",
+BETA_DEFINITION = ("beta_mode", ["P*S", "P*(1+beta*(S-1))"], 0, (None, None), "",
                    "Structure factor dispersion calculation mode")
+def make_extra_pars(p_info):
+    pars = []
+    if p_info.have_Fq:
+        par = Parameter("structure_factor_mode", ["P*S","P*(1+beta*(S-1))"], 0, (None, None), "",
+                        "Structure factor calculation")
+        pars.append(par)
+    return pars
 
 # TODO: core_shell_sphere model has suppressed the volume ratio calculation
@@ -76 +85 @@
     translate_name = dict((old.id, new.id) for old, new
                           in zip(s_pars.kernel_parameters[1:], s_list))
-    beta = [Parameter(*BETA_DEFINITION)] if p_info.have_Fq else []
-    combined_pars = p_pars.kernel_parameters + s_list + beta
+    combined_pars = p_pars.kernel_parameters + s_list + make_extra_pars(p_info)
     parameters = ParameterTable(combined_pars)
     parameters.max_pd = p_pars.max_pd + s_pars.max_pd
@@ -145 +153 @@
     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 +303 @@
             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
+
         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