Changes in / [2f9f1ec:630156b] in sasmodels

Files:

• example/6pc SD.txt (deleted)
• example/Beise009798_01.ses (deleted)
• example/Beise009798_02.ses (deleted)
• example/Beise009798_03.ses (deleted)
• example/Gab_5pc_deb2p0.ses (deleted)
• example/Gab_5pc_deb2p0.txt (deleted)
• example/oriented_sesans.py (deleted)
• example/unoriented_sesans.py (deleted)
• sasmodels/direct_model.py (modified) (7 diffs)
• sasmodels/sesans.py (modified) (3 diffs)
• sasmodels/sesanscos.py (deleted)
• sasmodels/sesanscosine.py (deleted)

sasmodels/direct_model.py

@@ -202 +202 @@
 
         if self.data_type == 'sesans':
-            from sas.sascalc.data_util.nxsunit import Converter
-            qmax, qunits = data.sample.zacceptance
-            SElength = Converter(data._xunit)(data.x, "A")
-            zaccept = Converter(qunits)(qmax, "1/A"),
-            Rmax = 10000000
-            index = slice(None, None)  # equivalent to index [:]
-            Iq = data.y[index]
-            dIq = data.dy[index]
-            oriented = getattr(data, 'oriented', False)
-            if oriented:
-                res = sesans.OrientedSesansTransform(data.x[index], SElength, zaccept, Rmax)
-                # Oriented sesans transform produces q_calc = [qx, qy]
-                q_vectors = res.q_calc
+            q = sesans.make_q(data.sample.zacceptance, data.Rmax)
+            index = slice(None, None)
+            res = None
+            if data.y is not None:
+                Iq, dIq = data.y, data.dy
             else:
-                res = sesans.SesansTransform(data.x[index], SElength, zaccept, Rmax)
-                # Unoriented sesans transform produces q_calc = q
-                q_vectors = [res.q_calc]
+                Iq, dIq = None, None
+            #self._theory = np.zeros_like(q)
+            q_vectors = [q]
+            q_mono = sesans.make_all_q(data)
         elif self.data_type == 'Iqxy':
             #if not model.info.parameters.has_2d:
@@ -237 +230 @@
             #self._theory = np.zeros_like(self.Iq)
             q_vectors = res.q_calc
+            q_mono = []
         elif self.data_type == 'Iq':
             index = (data.x >= data.qmin) & (data.x <= data.qmax)
@@ -261 +255 @@
             #self._theory = np.zeros_like(self.Iq)
             q_vectors = [res.q_calc]
+            q_mono = []
         elif self.data_type == 'Iq-oriented':
             index = (data.x >= data.qmin) & (data.x <= data.qmax)
@@ -277 +272 @@
                                       qy_width=data.dxl[index])
             q_vectors = res.q_calc
+            q_mono = []
         else:
             raise ValueError("Unknown data type") # never gets here
@@ -283 +279 @@
         # so we can save/restore state
         self._kernel_inputs = q_vectors
+        self._kernel_mono_inputs = q_mono
         self._kernel = None
         self.Iq, self.dIq, self.index = Iq, dIq, index
@@ -309 +306 @@
         if self._kernel is None:
             self._kernel = self._model.make_kernel(self._kernel_inputs)
+            self._kernel_mono = (
+                self._model.make_kernel(self._kernel_mono_inputs)
+                if self._kernel_mono_inputs else None)
 
         Iq_calc = call_kernel(self._kernel, pars, cutoff=cutoff)
@@ -316 +316 @@
         # TODO: refactor so we don't store the result in the model
         self.Iq_calc = None
-        result = self.resolution.apply(Iq_calc)
-        if hasattr(self.resolution, 'nx'):
-            self.Iq_calc = (
-                self.resolution.qx_calc, self.resolution.qy_calc,
-                np.reshape(Iq_calc, (self.resolution.ny, self.resolution.nx))
-            )
+        if self.data_type == 'sesans':
+            Iq_mono = (call_kernel(self._kernel_mono, pars, mono=True)
+                       if self._kernel_mono_inputs else None)
+            result = sesans.transform(self._data,
+                                      self._kernel_inputs[0], Iq_calc,
+                                      self._kernel_mono_inputs, Iq_mono)
+        else:
+            result = self.resolution.apply(Iq_calc)
+            if hasattr(self.resolution, 'nx'):
+                self.Iq_calc = (
+                    self.resolution.qx_calc, self.resolution.qy_calc,
+                    np.reshape(Iq_calc, (self.resolution.ny, self.resolution.nx))
+                )
         return result
 

sasmodels/sesans.py

@@ -20 +20 @@
     Spin-Echo SANS transform calculator.  Similar to a resolution function,
     the SesansTransform object takes I(q) for the set of *q_calc* values and
-    produces a transformed dataset.
+    produces a transformed dataset
 
     *SElength* (A) is the set of spin-echo lengths in the measured data.
@@ -48 +48 @@
 
     def apply(self, Iq):
+        # tye: (np.ndarray) -> np.ndarray
         G0 = np.dot(self._H0, Iq)
         G = np.dot(self._H.T, Iq)
@@ -72 +73 @@
         self.q_calc = q
         self._H, self._H0 = H, H0
-
-class OrientedSesansTransform(object):
-    """
-    Oriented Spin-Echo SANS transform calculator.  Similar to a resolution
-    function, the OrientedSesansTransform object takes I(q) for the set
-    of *q_calc* values and produces a transformed dataset.
-
-    *SElength* (A) is the set of spin-echo lengths in the measured data.
-
-    *zaccept* (1/A) is the maximum acceptance of scattering vector in the spin
-    echo encoding dimension (for ToF: Q of min(R) and max(lam)).
-
-    *Rmax* (A) is the maximum size sensitivity; larger radius requires more
-    computation time.
-    """
-    #: SElength from the data in the original data units; not used by transform
-    #: but the GUI uses it, so make sure that it is present.
-    q = None  # type: np.ndarray
-
-    #: q values to calculate when computing transform
-    q_calc = None  # type: np.ndarray
-
-    # transform arrays
-    _cosmat = None  # type: np.ndarray
-    _cos0 = None # type: np.ndarray
-    _Iq_shape = None # type: Tuple[int, int]
-
-    def __init__(self, z, SElength, zaccept, Rmax):
-        # type: (np.ndarray, float, float) -> None
-        #import logging; logging.info("creating SESANS transform")
-        self.q = z
-        self._set_cosmat(SElength, zaccept, Rmax)
-
-    def apply(self, Iq):
-        dq = self.q_calc[0][0]
-        Iq = np.reshape(Iq, self._Iq_shape)
-        G0 = self._cos0 * np.sum(Iq) * dq
-        G = np.sum(np.dot(Iq, self._cosmat), axis=0) * dq
-        P = G - G0
-        return P
-
-    def _set_cosmat(self, SElength, zaccept, Rmax):
-        # type: (np.ndarray, float, float) -> None
-        # Force float32 arrays, otherwise run into memory problems on some machines
-        SElength = np.asarray(SElength, dtype='float32')
-
-        # Rmax = #value in text box somewhere in FitPage?
-        q_max = 2 * pi / (SElength[1] - SElength[0])
-        q_min = 0.1 * 2 * pi / (np.size(SElength) * SElength[-1])
-        q_min *= 100
-
-        q = np.arange(q_min, q_max, q_min, dtype='float32')
-        dq = q_min
-
-        cos0 = np.float32(dq / (2 * pi))
-        cosmat = np.float32(dq / (2 * pi)) * np.cos(q[:, None] * SElength[None, :])
-
-        qx, qy = np.meshgrid(q, q)
-        self._Iq_shape = qx.shape
-        self.q_calc = qx.flatten(), qy.flatten()
-        self._cosmat, self._cos0 = cosmat, cos0