Changes in / [6e7ba14:aa44a6a] in sasmodels

Location:

sasmodels

Files:

• product.py (modified) (6 diffs)
• sasview_model.py (modified) (3 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, Union
 except ImportError:
     pass
@@ -40 +42 @@
     pars = []
     if p_info.have_Fq:
-        par = Parameter("structure_factor_mode", "", 0, [["P*S","P*(1+beta*(S-1))"]], "",
+        par = Parameter("structure_factor_mode", ["P*S","P*(1+beta*(S-1))"], 0, None, "",
                         "Structure factor calculation")
         pars.append(par)
     if p_info.effective_radius_type is not None:
-        par = Parameter("radius_effective_mode", "", 0,
-                        [["unconstrained"] + p_info.effective_radius_type],
-                        "", "Effective radius calculation")
+        par = Parameter("radius_effective_mode", ["unconstrained"] + p_info.effective_radius_type, 0, None, "",
+                        "Effective radius calculation")
         pars.append(par)
     return pars
@@ -157 +158 @@
     return par
 
+def _intermediates(P, S, effective_radius):
+    # type: (np.ndarray, np.ndarray, float) -> OrderedDict[str, np.ndarray]
+    """
+    Returns intermediate results for standard product (P(Q)*S(Q))
+    """
+    return OrderedDict((
+        ("P(Q)", P),
+        ("S(Q)", S),
+        ("effective_radius", effective_radius),
+    ))
+
+def _intermediates_beta(F1, F2, S, scale, bg, effective_radius):
+    # type: (np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, float) -> OrderedDict[str, Union[np.ndarray, float]]
+    """
+    Returns intermediate results for beta approximation-enabled product. The result may be an array or a float.
+    """
+    # 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)),
+        ("effective_radius", effective_radius),
+        # ("I(Q)", scale*(F2 + (F1**2)*(S-1)) + bg),
+    ))
+
 class ProductModel(KernelModel):
     def __init__(self, model_info, P, S):
@@ -276 +304 @@
             s_result = self.s_kernel.Iq(s_details, s_values, cutoff, False)
             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, effective_radius)
             final_result = combined_scale*(F2 + (F1**2)*(s_result - 1)) + background
+
         else:
             p_result, effective_radius = self.p_kernel.Pq_Reff(
@@ -309 +315 @@
             s_result = self.s_kernel.Iq(s_details, s_values, cutoff, False)
             # remember the parts for plotting later
-            self.results = [p_result, s_result]
+            self.results = lambda: _intermediates(p_result, s_result, effective_radius)
             final_result = scale*(p_result*s_result) + background
 

sasmodels/sasview_model.py

@@ -381 +381 @@
                 continue
             self.params[p.name] = p.default
-            self.details[p.id] = [p.units, p.limits[0], p.limits[1]]
+            if p.limits and type(p.limits) is list and len(p.limits) > 1:
+                self.details[p.id] = [p.units if not p.choices else p.choices, p.limits[0], p.limits[1]]
+            else:
+                self.details[p.id] = [p.units if not p.choices else p.choices, None, None]
             if p.polydisperse:
                 self.details[p.id+".width"] = [
@@ -616 +619 @@
         # 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 +641 @@
             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