Changeset 7e923c2 in sasmodels for sasmodels/product.py

Timestamp:

Aug 7, 2018 8:45:52 PM (6 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:

1a7ddc9

Parents:

c036ddb (diff), e9b17b18 (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 'master' into beta_approx

File:

• sasmodels/product.py (modified) (8 diffs)

sasmodels/product.py

@@ -16 +16 @@
 import numpy as np  # type: ignore
 
-from .modelinfo import ParameterTable, ModelInfo
+from .modelinfo import ParameterTable, ModelInfo, Parameter
 from .kernel import KernelModel, Kernel
 from .details import make_details, dispersion_mesh
@@ -37 +37 @@
 ER_ID = "radius_effective"
 VF_ID = "volfraction"
+BETA_DEFINITION = ("beta_mode", "", 0, [["P*S"],["P*(1+beta*(S-1))"]], "",
+                   "Structure factor dispersion calculation mode")
 
 # TODO: core_shell_sphere model has suppressed the volume ratio calculation
@@ -74 +76 @@
     translate_name = dict((old.id, new.id) for old, new
                           in zip(s_pars.kernel_parameters[1:], s_list))
-    combined_pars = p_pars.kernel_parameters + s_list
+    beta = [Parameter(*BETA_DEFINITION)] if p_info.have_Fq else []
+    combined_pars = p_pars.kernel_parameters + s_list + beta
     parameters = ParameterTable(combined_pars)
     parameters.max_pd = p_pars.max_pd + s_pars.max_pd
@@ -151 +154 @@
         #: Structure factor modelling interaction between particles.
         self.S = S
+
         #: Model precision. This is not really relevant, since it is the
         #: individual P and S models that control the effective dtype,
@@ -168 +172 @@
         # in opencl; or both in opencl, but one in single precision and the
         # other in double precision).
+
         p_kernel = self.P.make_kernel(q_vectors)
         s_kernel = self.S.make_kernel(q_vectors)
@@ -211 +216 @@
         p_offset = call_details.offset[:p_npars]
         p_details = make_details(p_info, p_length, p_offset, nweights)
+
         # Set p scale to the volume fraction in s, which is the first of the
         # 'S' parameters in the parameter list, or 2+np in 0-origin.
@@ -254 +260 @@
         s_values = np.hstack(s_values).astype(self.s_kernel.dtype)
 
+        # beta mode is the first parameter after the structure factor pars
+        beta_index = 2+p_npars+s_npars
+        beta_mode = values[beta_index]
+
         # Call the kernels
-        p_result = self.p_kernel(p_details, p_values, cutoff, magnetic)
-        s_result = self.s_kernel(s_details, s_values, cutoff, False)
-
-        #print("p_npars",p_npars,s_npars,p_er,s_vr,values[2+p_npars+1:2+p_npars+s_npars])
+        s_result = self.s_kernel.Iq(s_details, s_values, cutoff, False)
+        scale, background = values[0], values[1]
+        if beta_mode:
+            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, s_result]
+            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]
+            final_result = scale*(p_result*s_result) + background
+
         #call_details.show(values)
         #print("values", values)
@@ -265 +308 @@
         #s_details.show(s_values)
         #print("=>", s_result)
-
-        # remember the parts for plotting later
-        self.results = [p_result, s_result]
-
         #import pylab as plt
         #plt.subplot(211); plt.loglog(self.p_kernel.q_input.q, p_result, '-')
         #plt.subplot(212); plt.loglog(self.s_kernel.q_input.q, s_result, '-')
         #plt.figure()
-
-        return values[0]*(p_result*s_result) + values[1]
+        return final_result
 
     def release(self):