Changeset 25427d9 in sasview for src/sas/sascalc

Timestamp:

Mar 21, 2016 8:32:15 AM (8 years ago)

Author:

awashington

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:

cf92b1f, 5757bbe

Parents:

1c0e3b0 (diff), bb0c836 (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' of github.com:SasView/sasview

Location:

src/sas/sascalc

Files:

• calculator/BaseComponent.py (moved) (moved from src/sas/models/BaseComponent.py) (9 diffs)
• calculator/c_extensions/__init__.py (added)
• calculator/c_extensions/libfunc.c (moved) (moved from src/sas/models/c_extension/c_models/libfunc.c) (1 diff)
• calculator/c_extensions/libfunc.h (moved) (moved from src/sas/models/include/libmultifunc/libfunc.h)
• calculator/c_extensions/librefl.c (moved) (moved from src/sas/models/c_extension/c_models/librefl.c) (1 diff)
• calculator/c_extensions/librefl.h (moved) (moved from src/sas/models/include/libmultifunc/librefl.h)
• calculator/c_extensions/sld2i.cpp (moved) (moved from src/sas/models/c_extension/c_gen/sld2i.cpp) (1 diff)
• calculator/c_extensions/sld2i.hh (moved) (moved from src/sas/models/c_extension/c_gen/sld2i.hh)
• calculator/c_extensions/sld2i_module.cpp (moved) (moved from src/sas/models/c_extension/c_gen/sld2i_module.cpp)
• calculator/c_extensions/winFuncs.c (moved) (moved from src/sas/models/c_extension/libigor/winFuncs.c)
• calculator/c_extensions/winFuncs.h (moved) (moved from src/sas/models/c_extension/libigor/winFuncs.h)
• calculator/sas_gen.py (modified) (1 diff)
• data_util/qsmearing.py (modified) (6 diffs, 1 prop)
• fit/pluginmodel.py (moved) (moved from src/sas/models/pluginmodel.py) (6 diffs)
• dataloader/readers/sesans_reader.py (modified) (3 diffs)

src/sas/sascalc/calculator/BaseComponent.py

@@ -1 +1 @@
 #!/usr/bin/env python
 
-""" 
+"""
 Provide base functionality for all model components
 """
 
-# imports   
+# imports
 import copy
 import numpy
 #TO DO: that about a way to make the parameter
-#is self return if it is fittable or not  
+#is self return if it is fittable or not
 
 class BaseComponent:
-    """ 
+    """
     Basic model component
-    
+
     Since version 0.5.0, basic operations are no longer supported.
     """
@@ -20 +20 @@
     def __init__(self):
         """ Initialization"""
-        
+
         ## Name of the model
         self.name = "BaseComponent"
-        
+
         ## Parameters to be accessed by client
         self.params = {}
@@ -49 +49 @@
         self.output_name = "Intensity"
         self.output_unit = "cm^{-1}"
-        
+
     def __str__(self):
-        """ 
+        """
         :return: string representatio
-
         """
         return self.name
-   
+
     def is_fittable(self, par_name):
         """
         Check if a given parameter is fittable or not
-        
-        :param par_name: the parameter name to check 
-        
+
+        :param par_name: the parameter name to check
+
         """
         return par_name.lower() in self.fixed
         #For the future
         #return self.params[str(par_name)].is_fittable()
-   
-    def run(self, x): 
+
+    def run(self, x):
         """
         run 1d
         """
         return NotImplemented
-    
-    def runXY(self, x): 
+
+    def runXY(self, x):
         """
         run 2d
         """
-        return NotImplemented  
-    
-    def calculate_ER(self): 
+        return NotImplemented
+
+    def calculate_ER(self):
         """
         Calculate effective radius
         """
-        return NotImplemented  
-    
-    def calculate_VR(self): 
+        return NotImplemented
+
+    def calculate_VR(self):
         """
         Calculate volume fraction ratio
         """
-        return NotImplemented 
-    
+        return NotImplemented
+
     def evalDistribution(self, qdist):
         """
         Evaluate a distribution of q-values.
-        
+
         * For 1D, a numpy array is expected as input: ::
-        
+
             evalDistribution(q)
-            
+
           where q is a numpy array.
-        
-        
+
+
         * For 2D, a list of numpy arrays are expected: [qx_prime,qy_prime],
           where 1D arrays, ::
-        
+
               qx_prime = [ qx[0], qx[1], qx[2], ....]
-
           and ::
-
-              qy_prime = [ qy[0], qy[1], qy[2], ....] 
-        
+              qy_prime = [ qy[0], qy[1], qy[2], ....]
+
         Then get ::
-
             q = numpy.sqrt(qx_prime^2+qy_prime^2)
-        
+
         that is a qr in 1D array; ::
-
-            q = [q[0], q[1], q[2], ....] 
-        
+            q = [q[0], q[1], q[2], ....]
+
         ..note::
-          Due to 2D speed issue, no anisotropic scattering 
+          Due to 2D speed issue, no anisotropic scattering
           is supported for python models, thus C-models should have
           their own evalDistribution methods.
-        
+
         The method is then called the following way: ::
-        
+
             evalDistribution(q)
-
         where q is a numpy array.
-        
+
         :param qdist: ndarray of scalar q-values or list [qx,qy] where qx,qy are 1D ndarrays
         """
@@ -140 +134 @@
                 msg = "evalDistribution expects a list of 2 ndarrays"
                 raise RuntimeError, msg
-                
+
             # Extract qx and qy for code clarity
             qx = qdist[0]
             qy = qdist[1]
-            
+
             # calculate q_r component for 2D isotropic
             q = numpy.sqrt(qx**2+qy**2)
@@ -153 +147 @@
 
             return iq_array
-                
+
         elif qdist.__class__.__name__ == 'ndarray':
             # We have a simple 1D distribution of q-values
@@ -159 +153 @@
             iq_array = v_model(qdist)
             return iq_array
-            
+
         else:
             mesg = "evalDistribution is expecting an ndarray of scalar q-values"
             mesg += " or a list [qx,qy] where qx,qy are 2D ndarrays."
             raise RuntimeError, mesg
-        
-    
-    
+
+
+
     def clone(self):
         """ Returns a new object identical to the current object """
         obj = copy.deepcopy(self)
         return self._clone(obj)
-    
+
     def _clone(self, obj):
         """
@@ -182 +176 @@
         obj._persistency_dict = copy.deepcopy( self._persistency_dict)
         return obj
-    
+
     def set_dispersion(self, parameter, dispersion):
         """
         model dispersions
-        """ 
+        """
         ##Not Implemented
         return None
-        
+
     def getProfile(self):
         """
-        Get SLD profile 
-        
+        Get SLD profile
+
         : return: (z, beta) where z is a list of depth of the transition points
-                beta is a list of the corresponding SLD values 
+                beta is a list of the corresponding SLD values
         """
         #Not Implemented
         return None, None
-            
+
     def setParam(self, name, value):
-        """ 
+        """
         Set the value of a model parameter
-    
+
         :param name: name of the parameter
         :param value: value of the parameter
-        
+
         """
         # Look for dispersion parameters
@@ -223 +217 @@
                     self.params[item] = value
                     return
-            
+
         raise ValueError, "Model does not contain parameter %s" % name
-        
+
     def getParam(self, name):
-        """ 
+        """
         Set the value of a model parameter
-
         :param name: name of the parameter
-        
+
         """
         # Look for dispersion parameters
@@ -246 +239 @@
                 if item.lower()==name.lower():
                     return self.params[item]
-            
+
         raise ValueError, "Model does not contain parameter %s" % name
-     
+
     def getParamList(self):
-        """ 
+        """
         Return a list of all available parameters for the model
-        """ 
+        """
         list = self.params.keys()
         # WARNING: Extending the list with the dispersion parameters
         list.extend(self.getDispParamList())
         return list
-    
+
     def getDispParamList(self):
-        """ 
+        """
         Return a list of all available parameters for the model
-        """ 
+        """
         list = []
-        
+
         for item in self.dispersion.keys():
             for p in self.dispersion[item].keys():
                 if p not in ['type']:
                     list.append('%s.%s' % (item.lower(), p.lower()))
-                    
+
         return list
-    
+
     # Old-style methods that are no longer used
-    def setParamWithToken(self, name, value, token, member): 
+    def setParamWithToken(self, name, value, token, member):
         """
         set Param With Token
         """
         return NotImplemented
-    def getParamWithToken(self, name, token, member): 
+    def getParamWithToken(self, name, token, member):
         """
         get Param With Token
         """
         return NotImplemented
-    
-    def getParamListWithToken(self, token, member): 
+
+    def getParamListWithToken(self, token, member):
         """
         get Param List With Token
         """
         return NotImplemented
-    def __add__(self, other): 
+    def __add__(self, other):
         """
         add
         """
         raise ValueError, "Model operation are no longer supported"
-    def __sub__(self, other): 
+    def __sub__(self, other):
         """
         sub
         """
         raise ValueError, "Model operation are no longer supported"
-    def __mul__(self, other): 
+    def __mul__(self, other):
         """
         mul
         """
         raise ValueError, "Model operation are no longer supported"
-    def __div__(self, other): 
+    def __div__(self, other):
         """
         div
         """
         raise ValueError, "Model operation are no longer supported"
-        

src/sas/sascalc/calculator/c_extensions/libfunc.c

@@ -3 +3 @@
 #include <math.h>
 
-#include "libmultifunc/libfunc.h"
+#include "libfunc.h"
 
 #include <stdio.h>

src/sas/sascalc/calculator/c_extensions/librefl.c

@@ -4 +4 @@
 
 #include <math.h>
-#include "libmultifunc/librefl.h"
+#include "librefl.h"
 #include <stdio.h>
 #include <stdlib.h>
 #if defined(_MSC_VER)
-#include "../libigor/winFuncs.h"
+#include "winFuncs.h"
 #endif
 

src/sas/sascalc/calculator/c_extensions/sld2i.cpp

@@ -7 +7 @@
 using namespace std;
 extern "C" {
-        #include "libmultifunc/libfunc.h"
-        #include "libmultifunc/librefl.h"
+        #include "libfunc.h"
+        #include "librefl.h"
 }
 /**

src/sas/sascalc/calculator/sas_gen.py

@@ -3 +3 @@
 SAS generic computation and sld file readers
 """
-from sas.models.BaseComponent import BaseComponent
-import sas.models.sas_extension.sld2i as mod
+from sas.sascalc.calculator.BaseComponent import BaseComponent
+import sas.sascalc.calculator.core.sld2i as mod
 from periodictable import formula
 from periodictable import nsf

src/sas/sascalc/data_util/qsmearing.py

@@ -19 +19 @@
 def smear_selection(data, model = None):
     """
-    Creates the right type of smearer according 
+    Creates the right type of smearer according
     to the data.
-
     The canSAS format has a rule that either
     slit smearing data OR resolution smearing data
-    is available. 
-    
+    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 
+    smearing arrays are filled with good data
     (which should not happen), then we choose the
-    resolution smearing data. 
-    
+    resolution smearing data.
+
     :param data: Data1D object
     :param model: sas.model instance
@@ -43 +42 @@
             return None
         return Pinhole2D(data)
-    
+
     if  not hasattr(data, "dx") and not hasattr(data, "dxl")\
          and not hasattr(data, "dxw"):
         return None
-    
+
     # Look for resolution smearing data
     _found_resolution = False
     if data.dx is not None and len(data.dx) == len(data.x):
-        
+
         # Check that we have non-zero data
         if data.dx[0] > 0.0:
@@ -65 +64 @@
     if data.dxl is not None and len(data.dxl) == len(data.x) \
         and data.dxw is not None and len(data.dxw) == len(data.x):
-        
+
         # Check that we have non-zero data
         if data.dxl[0] > 0.0 or data.dxw[0] > 0.0:
             _found_slit = True
-        
+
         # Sanity check: all data should be the same as a function of Q
         for item in data.dxl:
@@ -75 +74 @@
                 _found_resolution = False
                 break
-            
+
         for item in data.dxw:
             if data.dxw[0] != item:
@@ -98 +97 @@
         """
         Apply the resolution function to the data.
-
         Note that this is called with iq_in matching data.x, but with
         iq_in[first_bin:last_bin] set to theory values for these bins,
         and the remainder left undefined.  The first_bin, last_bin values
         should be those returned from get_bin_range.
-
         The returned value is of the same length as iq_in, with the range
         first_bin:last_bin set to the resolution smeared values.
@@ -123 +120 @@
         """
         For a given q_min, q_max, find the corresponding indices in the data.
-
         Returns first, last.
-
         Note that these are indexes into q from the data, not the q_calc
         needed by the resolution function.  Note also that these are the

src/sas/sascalc/fit/pluginmodel.py

@@ -1 @@
-
-from sas.models.BaseComponent import BaseComponent
+from sas.sascalc.calculator.BaseComponent import BaseComponent
 import math
 
 class Model1DPlugin(BaseComponent):
     ## Name of the model
-   
+
     def __init__(self , name="Plugin Model" ):
         """ Initialization """
@@ -13 +12 @@
         self.params  = {}
         self.description = 'plugin model'
-        
+
     def function(self, x):
         """
@@ -19 +18 @@
         """
         return x
-        
+
     def run(self, x = 0.0):
-        """ 
+        """
         Evaluate the model
-        
+
         :param x: input x, or [x, phi] [radian]
-        
+
         :return: function value
-        
+
         """
         if x.__class__.__name__ == 'list':
@@ -37 +36 @@
         else:
             return self.function(x)
-        
-   
+
+
     def runXY(self, x = 0.0):
-        """ 
+        """
         Evaluate the model
-        
-        :param x: input x, or [x, y] 
-        
+
+        :param x: input x, or [x, y]
+
         :return: function value
-        
+
         """
         if x.__class__.__name__ == 'list':
@@ -54 +53 @@
         else:
             return self.function(x)
-        
+
     def set_details(self):
         """
@@ -61 +60 @@
         if not self.params:
             return {}
-            
+
         for key in self.params.keys():
             self.details[key] = ['', None, None]

src/sas/sascalc/dataloader/readers/sesans_reader.py

@@ -142 +142 @@
                 default_p_unit = " "
                 lam_unit = lam_header[1].replace("[","").replace("]","")
-                for i,x_val in output.x:
-                    output.x[i], output.x_unit = self._unit_conversion(x_val, lam_unit, default_z_unit)
-                for i,y_val in output.y:
-                    output.y[i], output.y_unit = self._unit_conversion(y_val, " ", default_p_unit)
                 varheader=[zvals[0],dzvals[0],lamvals[0],dlamvals[0],Pvals[0],dPvals[0]]
                 valrange=range(1, len(zvals))
@@ -163 +159 @@
                 input_f.close()
 
-                #Data
-                output.x = x #[x != 0]
-                output.y = y #[x != 0]
+                output.x, output.x_unit = self._unit_conversion(x, lam_unit, default_z_unit)
+                output.y = y
+                output.dx, output.dx_unit = self._unit_conversion(dx, lam_unit, default_z_unit)
                 output.dy = dy
-                output.dx = dx
-                output.lam = lam
-                output.dlam = dlam
+                output.lam, output.lam_unit = self._unit_conversion(lam, lam_unit, default_z_unit)
+                output.dlam, output.dlam_unit = self._unit_conversion(dlam, lam_unit, default_z_unit)
 
                 output.xaxis("\rm{z}", output.x_unit)
@@ -182 +177 @@
                 if zaccept_unit.strip() == '\AA^-1':
                     zaccept_unit = "1/A"
-                output.sample.zacceptance=float(paramvals[7])
-                output.sample.zacceptance=self._unit_conversion(output.sample.zacceptance,
-                                                                zaccept_unit, "1/" + default_z_unit)
+                output.sample.zacceptance=(float(paramvals[7]),zaccept_unit)
                 output.vars=varheader