Changeset aaf75b6 in sasmodels for sasmodels/resolution.py

Timestamp:

Mar 30, 2016 2:39:42 PM (8 years ago)

Author:

Paul Kienzle <pkienzle@…>

Branches:

master, core_shell_microgels, costrafo411, magnetic_model, release_v0.94, release_v0.95, ticket-1257-vesicle-product, ticket_1156, ticket_1265_superball, ticket_822_more_unit_tests

Children:

885ee37

Parents:

d0876c9d (diff), 364d8f7 (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 polydisp

Conflicts:

sasmodels/direct_model.py

File:

• sasmodels/resolution.py (modified) (18 diffs)

sasmodels/resolution.py

@@ -82 +82 @@
         self.q_calc = (pinhole_extend_q(q, q_width, nsigma=nsigma)
                        if q_calc is None else np.sort(q_calc))
-        self.weight_matrix = pinhole_resolution(
-            self.q_calc, self.q, np.maximum(q_width, MINIMUM_RESOLUTION))
+        self.weight_matrix = pinhole_resolution(self.q_calc, self.q,
+                                np.maximum(q_width, MINIMUM_RESOLUTION))
 
     def apply(self, theory):
@@ -91 +91 @@
 class Slit1D(Resolution):
     """
-    Slit aperture with a complicated resolution function.
+    Slit aperture with resolution function.
 
     *q* points at which the data is measured.
 
-    *qx_width* slit width
-
-    *qy_height* slit height
+    *dqx* slit width in qx
+
+    *dqy* slit height in qy
 
     *q_calc* is the list of points to calculate, or None if this should
@@ -104 +104 @@
     The *weight_matrix* is computed by :func:`slit1d_resolution`
     """
-    def __init__(self, q, width, height=0., q_calc=None):
-        # Remember what width/height was used even though we won't need them
+    def __init__(self, q, qx_width, qy_width=0., q_calc=None):
+        # Remember what width/dqy was used even though we won't need them
         # after the weight matrix is constructed
-        self.width, self.height = width, height
+        self.qx_width, self.qy_width = qx_width, qy_width
 
         # Allow independent resolution on each point even though it is not
         # needed in practice.
-        if np.isscalar(width):
-            width = np.ones(len(q))*width
+        if np.isscalar(qx_width):
+            qx_width = np.ones(len(q))*qx_width
         else:
-            width = np.asarray(width)
-        if np.isscalar(height):
-            height = np.ones(len(q))*height
+            qx_width = np.asarray(qx_width)
+        if np.isscalar(qy_width):
+            qy_width = np.ones(len(q))*qy_width
         else:
-            height = np.asarray(height)
+            qy_width = np.asarray(qy_width)
 
         self.q = q.flatten()
-        self.q_calc = slit_extend_q(q, width, height) \
+        self.q_calc = slit_extend_q(q, qx_width, qy_width) \
             if q_calc is None else np.sort(q_calc)
         self.weight_matrix = \
-            slit_resolution(self.q_calc, self.q, width, height)
+            slit_resolution(self.q_calc, self.q, qx_width, qy_width)
 
     def apply(self, theory):
@@ -396 +396 @@
     """
     q = np.sort(q)
-    if q_min < q[0]:
+    if q_min + 2*MINIMUM_RESOLUTION < q[0]:
         if q_min <= 0: q_min = q_min*MIN_Q_SCALE_FOR_NEGATIVE_Q_EXTRAPOLATION
         n_low = np.ceil((q[0]-q_min) / (q[1]-q[0])) if q[1] > q[0] else 15
@@ -402 +402 @@
     else:
         q_low = []
-    if q_max > q[-1]:
+    if q_max - 2*MINIMUM_RESOLUTION > q[-1]:
         n_high = np.ceil((q_max-q[-1]) / (q[-1]-q[-2])) if q[-1] > q[-2] else 15
         q_high = np.linspace(q[-1], q_max, n_high+1)[1:]
@@ -596 +596 @@
         Slit smearing with perfect resolution.
         """
-        resolution = Slit1D(self.x, width=0, height=0, q_calc=self.x)
+        resolution = Slit1D(self.x, qx_width=0, qy_width=0, q_calc=self.x)
         theory = self.Iq(resolution.q_calc)
         output = resolution.apply(theory)
@@ -606 +606 @@
         Slit smearing with height 0.005
         """
-        resolution = Slit1D(self.x, width=0, height=0.005, q_calc=self.x)
+        resolution = Slit1D(self.x, qx_width=0, qy_width=0.005, q_calc=self.x)
         theory = self.Iq(resolution.q_calc)
         output = resolution.apply(theory)
@@ -621 +621 @@
         """
         q = np.logspace(-4, -1, 10)
-        resolution = Slit1D(q, width=0.2, height=np.inf)
+        resolution = Slit1D(q, qx_width=0.2, qy_width=np.inf)
         theory = 1000*self.Iq(resolution.q_calc**4)
         output = resolution.apply(theory)
@@ -635 +635 @@
         Slit smearing with width 0.0002
         """
-        resolution = Slit1D(self.x, width=0.0002, height=0, q_calc=self.x)
+        resolution = Slit1D(self.x, qx_width=0.0002, qy_width=0, q_calc=self.x)
         theory = self.Iq(resolution.q_calc)
         output = resolution.apply(theory)
@@ -648 +648 @@
         Slit smearing with width > 100*height.
         """
-        resolution = Slit1D(self.x, width=0.0002, height=0.000001,
+        resolution = Slit1D(self.x, qx_width=0.0002, qy_width=0.000001,
                             q_calc=self.x)
         theory = self.Iq(resolution.q_calc)
@@ -773 +773 @@
         data = np.loadtxt(data_string.split('\n')).T
         q, delta_qv, _, answer = data
-        resolution = Slit1D(q, width=delta_qv, height=0)
+        resolution = Slit1D(q, qx_width=delta_qv, qy_width=0)
         output = self._eval_sphere(pars, resolution)
         # TODO: eliminate Igor test since it is too inaccurate to be useful.
@@ -793 +793 @@
         q_calc = slit_extend_q(interpolate(q, 2*np.pi/radius/20),
                                delta_qv[0], 0.)
-        resolution = Slit1D(q, width=delta_qv, height=0, q_calc=q_calc)
+        resolution = Slit1D(q, qx_width=delta_qv, qy_width=0, q_calc=q_calc)
         output = self._eval_sphere(pars, resolution)
         # TODO: relative error should be lower
@@ -805 +805 @@
         pars = {
             'scale':0.05,
-            'rpolar':500, 'requatorial':15000,
-            'sld':6, 'solvent_sld': 1,
+            'r_polar':500, 'r_equatorial':15000,
+            'sld':6, 'sld_solvent': 1,
             }
         form = load_model('ellipsoid', dtype='double')
         q = np.logspace(log10(4e-5), log10(2.5e-2), 68)
         width, height = 0.117, 0.
-        resolution = Slit1D(q, width=width, height=height)
+        resolution = Slit1D(q, qx_width=width, qy_width=height)
         answer = romberg_slit_1d(q, width, height, form, pars)
         output = resolution.apply(eval_form(resolution.q_calc, form, pars))
@@ -837 +837 @@
 TEST_PARS_PINHOLE_SPHERE = {
     'scale': 1.0, 'background': 0.01,
-    'radius': 60.0, 'sld': 1, 'solvent_sld': 6.3,
+    'radius': 60.0, 'sld': 1, 'sld_solvent': 6.3,
     }
 # Q, dQ, I(Q) calculated by NIST Igor SANS package
@@ -946 +946 @@
 TEST_PARS_SLIT_SPHERE = {
     'scale': 0.01, 'background': 0.01,
-    'radius': 60000, 'sld': 1, 'solvent_sld': 4,
+    'radius': 60000, 'sld': 1, 'sld_solvent': 4,
     }
 # Q dQ I(Q) I_smeared(Q)
@@ -1047 +1047 @@
 
     if name == 'cylinder':
-        pars = {'length':210, 'radius':500}
+        pars = {'length':210, 'radius':500, 'background': 0}
     elif name == 'teubner_strey':
         pars = {'a2':0.003, 'c1':-1e4, 'c2':1e10, 'background':0.312643}
@@ -1054 +1054 @@
     elif name == 'ellipsoid':
         pars = {
-            'scale':0.05,
-            'rpolar':500, 'requatorial':15000,
-            'sld':6, 'solvent_sld': 1,
+            'scale':0.05, 'background': 0,
+            'r_polar':500, 'r_equatorial':15000,
+            'sld':6, 'sld_solvent': 1,
             }
     else:
@@ -1068 +1068 @@
 
     if isinstance(resolution, Slit1D):
-        width, height = resolution.width, resolution.height
+        width, height = resolution.dqx, resolution.dqy
         Iq_romb = romberg_slit_1d(resolution.q, width, height, model, pars)
     else: