Changeset 2e94cbde in sasview

Timestamp:

Mar 5, 2010 9:59:19 PM (15 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:

2661d8b

Parents:

f5fda87

Message:

invariant: improve methods to get low/high extrapolated data.

File:

• Invariant/invariant.py (modified) (8 diffs)

Invariant/invariant.py

@@ +1 @@
+"""
+This software was developed by the University of Tennessee as part of the
+Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
+project funded by the US National Science Foundation. 
+
+See the license text in license.txt
+
+copyright 2010, University of Tennessee
+"""
+
 """
     This module implements invariant and its related computations.
@@ -7 +17 @@
         - intro / documentation
         - add unit tests for sufrace/volume computation with and without extrapolation.
-        - replace the get_extra_data_* methods
 """
 import math 
@@ -357 +366 @@
         self._high_extrapolation_function = PowerLaw()
         self._high_extrapolation_power = None
+        
+        # Extrapolation range
+        self._low_q_limit = Q_MINIMUM
         
     def _get_data(self, data):
@@ -520 +532 @@
         
         # Distribution starting point
-        q_start = Q_MINIMUM
+        self._low_q_limit = Q_MINIMUM
         if Q_MINIMUM >= qmin:
-            q_start = qmin/10
+            self._low_q_limit = qmin/10
         
         data = self._get_extrapolated_data(model=self._low_extrapolation_function,
                                                npts=INTEGRATION_NSTEPS,
-                                               q_start=q_start, q_end=qmin)
+                                               q_start=self._low_q_limit, q_end=qmin)
         
         # Systematic error
@@ -532 +544 @@
         # may not be a Guinier or simple power law. The following is a conservative
         # estimation for the systematic error.
-        err = qmin*qmin*math.fabs((qmin-q_start)*(data.y[0] - data.y[INTEGRATION_NSTEPS-1]))
+        err = qmin*qmin*math.fabs((qmin-self._low_q_limit)*(data.y[0] - data.y[INTEGRATION_NSTEPS-1]))
         return self._get_qstar(data), self._get_qstar_uncertainty(data)+err
         
@@ -549 +561 @@
         qmin = self._data.x[x_len - (self._high_extrapolation_npts - 1)]
         qmax = self._data.x[x_len]
-        q_end = Q_MAXIMUM
         
         # fit the data with a model to get the appropriate parameters
@@ -560 +571 @@
         data = self._get_extrapolated_data(model=self._high_extrapolation_function,
                                            npts=INTEGRATION_NSTEPS,
-                                           q_start=qmax, q_end=q_end)        
+                                           q_start=qmax, q_end=Q_MAXIMUM)        
         
         return self._get_qstar(data), self._get_qstar_uncertainty(data)
     
-    def get_extra_data_low(self, npts_in=None, q_start=Q_MINIMUM, nsteps=INTEGRATION_NSTEPS):
-        """
-           This method generates 2 data sets , the first is a data created during 
-           low extrapolation . its y is generated from x in [ Q_MINIMUM - the minimum of
-           data.x] and the outputs of the extrapolator .
-            (data is the data used to compute invariant) 
-           the second is also data produced during the fit but the x range considered
-           is within the reel range of data x.
-           x uses is in [minimum of data.x up to npts_in points]
-           @param npts_in: the number of first points of data to consider  for computing
-           y's coming out of the fit.
-           @param q_start: is the minimum value to uses for extrapolated data
-           @param npts: the number of point used to create extrapolated data 
+    def get_extra_data_low(self, npts_in=None, q_start=None, nsteps=20):
+        """
+            Returns the extrapolated data used for the loew-Q invariant calculation.
+            By default, the distribution will cover the data points used for the 
+            extrapolation. The number of overlap points is a parameter (npts_in).
+            By default, the maximum q-value of the distribution will be  
+            the minimum q-value used when extrapolating for the purpose of the 
+            invariant calculation. 
+            
+            @param npts_in: number of data points for which the extrapolated data overlap
+            @param q_start: is the minimum value to uses for extrapolated data
+            @param npts: the number of points in the extrapolated distribution
            
         """
-        # Create a data from result of the fit for a range outside of the data
-        # at low q range
-        q_start = max(Q_MINIMUM, q_start)
-        qmin = min(self._data.x)
-        
-        if q_start < qmin:
-            data_out_range = self._get_extrapolated_data(model=self._low_extrapolation_function,
-                                                         npts=nsteps,
-                                                         q_start=q_start, q_end=qmin)
-        else:
-            data_out_range = LoaderData1D(x=numpy.zeros(0), y=numpy.zeros(0))
-            
-        # Create data from the result of the fit for a range inside data q range for
-        # low q
-        if npts_in is None :
+        # Get extrapolation range
+        if q_start is None:
+            q_start = self._low_q_limit
+            
+        if npts_in is None:
             npts_in = self._low_extrapolation_npts
-
-        x = self._data.x[:npts_in]
-        y = self._low_extrapolation_function.evaluate_model(x=x)
-        data_in_range = LoaderData1D(x=x, y=y)
-        
-        return data_out_range, data_in_range
+        q_end = self._data.x[max(0, npts_in-1)]
+        
+        if q_start >= q_end:
+            return numpy.zeros(0), numpy.zeros(0)
+
+        return self._get_extrapolated_data(model=self._low_extrapolation_function,
+                                           npts=nsteps,
+                                           q_start=q_start, q_end=q_end)
           
-    def get_extra_data_high(self, npts_in=None, q_end=Q_MAXIMUM, nsteps=INTEGRATION_NSTEPS ):
-        """
-           This method generates 2 data sets , the first is a data created during 
-           low extrapolation . its y is generated from x in [ the maximum of
-           data.x to  Q_MAXIMUM] and the outputs of the extrapolator .
-            (data is the data used to compute invariant) 
-           the second is also data produced during the fit but the x range considered
-           is within the reel range of data x.
-           x uses is from maximum of data.x up to npts_in points before data.x maximum.
-           @param npts_in: the number of first points of data to consider  for computing
-           y's coming out of the fit.
-           @param q_end: is the maximum value to uses for extrapolated data
-           @param npts: the number of point used to create extrapolated data 
-           
-        """
-        #Create a data from result of the fit for a range outside of the data
-        # at low q range
-        qmax = max(self._data.x)
-        if  q_end != Q_MAXIMUM or nsteps != INTEGRATION_NSTEPS:
-            if q_end > Q_MAXIMUM:
-               q_end = Q_MAXIMUM
-            elif q_end <= qmax:
-                q_end = qmax * 10
-                
-            #compute the new data with the proper result of the fit for different
-            #boundary and step, outside of data
-            data_out_range = self._get_extrapolated_data(model=self._high_extrapolation_function,
-                                               npts=nsteps,
-                                               q_start=qmax, q_end=q_end)
-        else:
-            data_out_range = LoaderData1D(x=numpy.zeros(0), y=numpy.zeros(0))
-        
-        #Create data from the result of the fit for a range inside data q range for
-        #high q
-        if npts_in is None :
+    def get_extra_data_high(self, npts_in=None, q_end=Q_MAXIMUM, npts=20):
+        """
+            Returns the extrapolated data used for the high-Q invariant calculation.
+            By default, the distribution will cover the data points used for the 
+            extrapolation. The number of overlap points is a parameter (npts_in).
+            By default, the maximum q-value of the distribution will be Q_MAXIMUM, 
+            the maximum q-value used when extrapolating for the purpose of the 
+            invariant calculation. 
+            
+            @param npts_in: number of data points for which the extrapolated data overlap
+            @param q_end: is the maximum value to uses for extrapolated data
+            @param npts: the number of points in the extrapolated distribution
+        """
+        # Get extrapolation range
+        if npts_in is None:
             npts_in = self._high_extrapolation_npts
-            
-        x_len = len(self._data.x)
-        x = self._data.x[(x_len-npts_in):]
-        y = self._high_extrapolation_function.evaluate_model(x=x)
-        data_in_range = LoaderData1D(x=x, y=y)
-        
-        return data_out_range, data_in_range
-          
+        npts = len(self._data.x)
+        q_start = self._data.x[min(npts, npts-npts_in+1)]
+        
+        if q_start >= q_end:
+            return numpy.zeros(0), numpy.zeros(0)
+        
+        return self._get_extrapolated_data(model=self._high_extrapolation_function,
+                                           npts=npts,
+                                           q_start=q_start, q_end=q_end)
      
     def set_extrapolation(self, range, npts=4, function=None, power=None):
@@ -716 +699 @@
     def get_surface(self, contrast, porod_const, extrapolation=None):
         """
-            Compute the surface of the data.
+            Compute the specific surface from the data.
             
             Implementation: