Changeset 4fe4394 in sasview for DataLoader

Timestamp:

Oct 10, 2008 4:47:33 PM (16 years ago)

Author:

Mathieu Doucet <doucetm@…>

Branches:

master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, costrafo411, magnetic_scatt, release-4.1.1, release-4.1.2, release-4.2.2, release_4.0.1, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload

Children:

ae60f86

Parents:

2139c3f

Message:

implemented smearer selection

Location:

DataLoader

Files:

• qsmearing.py (modified) (4 diffs)
• readers/danse_reader.py (modified) (2 diffs)
• test/latex_smeared.xml (added)
• test/utest_smearing.py (modified) (2 diffs)

DataLoader/qsmearing.py

@@ -8 +8 @@
 copyright 2008, University of Tennessee
 """
+
+#TODO: improvement: allow for varying dQ as a function of Q
+
 import numpy
 import math
@@ -15 +18 @@
     """
         Creates the right type of smearer according 
-        to the data
-    """
-    pass
+        to the data.
+    
+        The canSAS format has a rule that either
+        slit smearing data OR resolution smearing data
+        is available. 
+        
+        For the present purpose, we choose the one that
+        has none-zero data. If both slit and resolution
+        smearing arrays are filled with good data 
+        (which should not happen), then we choose the
+        resolution smearing data. 
+        
+        @param data1D: Data1D object
+    """
+    # Sanity check. If we are not dealing with a SANS Data1D
+    # object, just return None
+    if data1D.__class__.__name__ != 'Data1D' \
+        or not hasattr(data1D, "dxl") or not hasattr(data1D, "dxw"):
+        return None
+    
+    # Look for resolution smearing data
+    _found_resolution = False
+    if data1D.dx is not None and len(data1D.dx)==len(data1D.x):
+        
+        # Check that we have non-zero data
+        if data1D.dx[0]>0.0:
+            _found_resolution = True
+        
+    # If we found resolution smearing data, return a QSmearer
+    if _found_resolution == True:
+        return QSmearer(data1D)
+
+    # Look for slit smearing data
+    _found_slit = False
+    if data1D.dxl is not None and len(data1D.dxl)==len(data1D.x) \
+        and data1D.dxw is not None and len(data1D.dxw)==len(data1D.x):
+        
+        # Check that we have non-zero data
+        if data1D.dxl[0]>0.0 or data1D.dxw[0]>0.0:
+            _found_slit = True
+        
+        # Sanity check: all data should be the same as a function of Q
+        for item in data1D.dxl:
+            if data1D.dxl[0] != item:
+                _found_resolution = False
+                break
+            
+        for item in data1D.dxw:
+            if data1D.dxw[0] != item:
+                _found_resolution = False
+                break
+            
+    # If we found slit smearing data, return a slit smearer
+    if _found_slit == True:
+        return SlitSmearer(data1D)
+    
+    return None
+            
 
 class _BaseSmearer(object):
@@ -213 +271 @@
                 # Compute the fraction of the Gaussian contributing
                 # to the q bin between q_min and q_max
-                value =  scipy.special.erf( (q_max-q_j)/(math.sqrt(2.0)*self.width) ) 
-                value -=scipy.special.erf( (q_min-q_j)/(math.sqrt(2.0)*self.width) ) 
+                value =  scipy.special.erf( (q_max-q_j)/(math.sqrt(2.0)*self.width[j]) ) 
+                value -=scipy.special.erf( (q_min-q_j)/(math.sqrt(2.0)*self.width[j]) ) 
 
                 weights[i][j] += value
@@ -235 +293 @@
         
         ## Slit width
-        self.width = 0
+        self.width = numpy.zeros(len(data1D.x))
         if data1D.dx is not None and len(data1D.dx)==len(data1D.x):
-            self.width = data1D.dx[0]
-            # Sanity check
-            for value in data1D.dx:
-                if value != self.width:
-                    raise RuntimeError, "dQ must be the same for all data"
+            self.width = data1D.dx
         
         ## Number of Q bins

DataLoader/readers/danse_reader.py

@@ -155 +155 @@
             
             # Qx and Qy vectors
+            theta = pixel / distance / 100.0
+            stepq = 4.0*math.pi/wavelength * math.sin(theta/2.0) 
             for i_x in range(size_x):
                 theta = (i_x-center_x+1)*pixel / distance / 100.0
@@ -235 +237 @@
             
             # Store limits of the image (2D array)
+            xmin    =xmin-stepq/2.0
+            xmax    =xmax+stepq/2.0
+            ymin    =ymin-stepq/2.0
+            ymax    =ymax+stepq/2.0
+            
             if has_converter == True and output.Q_unit != '1/A':
                 xmin = data_conv_q(xmin, units=output.Q_unit)

DataLoader/test/utest_smearing.py

@@ -8 +8 @@
 from DataLoader.loader import  Loader
 from DataLoader.data_info import Data1D, Data2D
-from DataLoader.qsmearing import SlitSmearer, QSmearer
+from DataLoader.qsmearing import SlitSmearer, QSmearer, smear_selection
  
 import os.path
@@ -21 +21 @@
         dxl = 0.00*numpy.ones(10)
         dxw = 0.00*numpy.ones(10)
+        dx = 0.00*numpy.ones(10)
         
+        self.data.dx = dx
         self.data.x = x
         self.data.y = y