Changes in / [a80e64c:997d4eb] in sasmodels

Files:

• example/se008731_01.ses (added)
• example/se008731_01_40pcorr.ses (added)
• example/se008731_01_40points.ses (added)
• example/twomicronsphere.ses (added)
• sasmodels/direct_model.py (modified) (2 diffs)
• sasmodels/resolution.py (modified) (3 diffs)
• sasmodels/sesans.py (modified) (5 diffs)

sasmodels/direct_model.py

@@ -31 +31 @@
 from . import resolution2d
 from .details import make_kernel_args, dispersion_mesh
+from sas.sasgui.perspectives.fitting.fitpage import FitPage
 
 try:
@@ -193 +194 @@
         # interpret data
         if hasattr(data, 'lam'):
+        #if not FitPage.no_transform.GetValue(): #if the no_transform radio button is not active DOES NOT WORK! not active before fitting
             self.data_type = 'sesans'
         elif hasattr(data, 'qx_data'):

sasmodels/resolution.py

@@ -9 +9 @@
 from numpy import sqrt, log, log10, exp, pi  # type: ignore
 import numpy as np  # type: ignore
+
+from sasmodels import sesans
 
 __all__ = ["Resolution", "Perfect1D", "Pinhole1D", "Slit1D",
@@ -43 +45 @@
         raise NotImplementedError("Subclass does not define the apply function")
 
-
 class Perfect1D(Resolution):
     """
@@ -56 +57 @@
         return theory
 
+
+class SESANS1D(Resolution):
+
+    def __init__(self, data, q_calc):
+        self.q = data.x
+        self.data = data
+        self.q_calc = q_calc
+
+    def apply(self, theory):
+        return sesans.transform(self.data, self.q_calc, theory, None, None)
 
 class Pinhole1D(Resolution):

sasmodels/sesans.py

@@ -15 +15 @@
 from numpy import pi, exp  # type: ignore
 from scipy.special import jv as besselj
+#from sas.sasgui.perspectives.fitting.fitpage import FitPage
 #import direct_model.DataMixin as model
         
@@ -59 +60 @@
     (2016-03-19: currently controlled from parameters script)
     nqmono is the number of q vectors to be used for the detector integration
-    """
-    nqmono = len(qmono)
-    if nqmono == 0:
+    qmono are the detector limits: can be a 1D or 2D array (depending on Q-limit or Qx,Qy limits)
+    """
+    if qmono == None:
         result = call_hankel(data, q_calc, Iq_calc)
-    elif nqmono == 1:
-        q = qmono[0]
-        result = call_HankelAccept(data, q_calc, Iq_calc, q, Iq_mono)
     else:
-        Qx, Qy = [qmono[0], qmono[1]]
-        Qx = np.reshape(Qx, nqx, nqy)
-        Qy = np.reshape(Qy, nqx, nqy)
-        Iq_mono = np.reshape(Iq_mono, nqx, nqy)
-        qx = Qx[0, :]
-        qy = Qy[:, 0]
-        result = call_Cosine2D(data, q_calc, Iq_calc, qx, qy, Iq_mono)
+         nqmono = len(qmono)
+         if nqmono == 0: # if radiobutton hankel is active
+        #if FitPage.hankel.GetValue():
+            result = call_hankel(data, q_calc, Iq_calc)
+         elif nqmono == 1:
+            q = qmono[0]
+            result = call_HankelAccept(data, q_calc, Iq_calc, q, Iq_mono)
+         else: #if radiobutton Cosine is active
+            Qx, Qy = [qmono[0], qmono[1]]
+            Qx = np.reshape(Qx, nqx, nqy)
+            Qy = np.reshape(Qy, nqx, nqy)
+            Iq_mono = np.reshape(Iq_mono, nqx, nqy)
+            qx = Qx[0, :]
+            qy = Qy[:, 0]
+            result = call_Cosine2D(data, q_calc, Iq_calc, qx, qy, Iq_mono)
 
     return result
 
 def call_hankel(data, q_calc, Iq_calc):
-    return hankel((data.x, data.x_unit),
-                  (data.lam, data.lam_unit),
-                  (data.sample.thickness,
-                   data.sample.thickness_unit),
-                  q_calc, Iq_calc)
+ #   data.lam_unit='nm'
+    #return hankel((data.x, data.x_unit),
+      #            (data.lam, data.lam_unit),
+       #           (data.sample.thickness,
+        #           data.sample.thickness_unit),
+         #         q_calc, Iq_calc)
+
+    return hankel((data.x, data._xunit), q_calc, Iq_calc)
   
 def call_HankelAccept(data, q_calc, Iq_calc, q_mono, Iq_mono):
@@ -166 +175 @@
     P = exp(thickness*wavelength**2/(4*pi**2)*(G-G[0]))
     
-def hankel(SElength, wavelength, thickness, q, Iq):
+#def hankel(SElength, wavelength, thickness, q, Iq):
+def hankel(SElength, q, Iq):
     r"""
     Compute the expected SESANS polarization for a given SANS pattern.
@@ -189 +199 @@
 
     from sas.sascalc.data_util.nxsunit import Converter
-    wavelength = Converter(wavelength[1])(wavelength[0],"A")
-    thickness = Converter(thickness[1])(thickness[0],"A")
-    Iq = Converter("1/cm")(Iq,"1/A") # All models default to inverse centimeters
+    #wavelength = Converter(wavelength[1])(wavelength[0],"A")
+    #thickness = Converter(thickness[1])(thickness[0],"A")
+    #Iq = Converter("1/cm")(Iq,"1/A") # All models default to inverse centimeters
     SElength = Converter(SElength[1])(SElength[0],"A")
 
     G = np.zeros_like(SElength, 'd')
-#==============================================================================
-#     Hankel Transform method if "wavelength" is a scalar; mono-chromatic SESANS
-#==============================================================================
     for i, SElength_i in enumerate(SElength):
         integral = besselj(0, q*SElength_i)*Iq*q
         G[i] = np.sum(integral)
-    G0 = np.sum(Iq*q)
+    G0 = np.sum(Iq*q) #relation to ksi? For generalization to all models
 
     # [m^-1] step size in q, needed for integration
@@ -210 +217 @@
     G0 = np.sum(Iq*q)*dq*2*np.pi
 
-    P = exp(thickness*wavelength**2/(4*pi**2)*(G-G0))
+    #P = exp(thickness*wavelength**2/(4*pi**2)*(G-G0))
+    P = (G-G0)/(4*pi**2)
+    #P=G-G0
 
     return P