-                      r3cd95c8
+                      r0997158f
 """
+"""
+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.
+If you use DANSE applications to do scientific research that leads to
+publication, we ask that you acknowledge the use of the software with the
+following sentence:
+"This work benefited from DANSE software developed under NSF award DMR-0520547."
+copyright 2008, University of Tennessee
+"""
+#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.
+#If you use DANSE applications to do scientific research that leads to
+#publication, we ask that you acknowledge the use of the software with the
+#following sentence:
+#This work benefited from DANSE software developed under NSF award DMR-0520547.
+#copyright 2008, University of Tennessee
 #TODO: Keep track of data manipulation in the 'process' data structure.
 …
 class plottable_1D:
     """
         Data1D is a place holder for 1D plottables.
+    Data1D is a place holder for 1D plottables.
     """
     # The presence of these should be mutually exclusive with the presence of Qdev (dx)
 …
 class plottable_2D:
     """
         Data2D is a place holder for 2D plottables.
+    Data2D is a place holder for 2D plottables.
     """
     xmin = None
 …
 class Vector:
     """
         Vector class to hold multi-dimensional objects
+    Vector class to hold multi-dimensional objects
     """
     ## x component
 …
     def __init__(self, x=None, y=None, z=None):
         """
+            Initialization. Components that are not
+            set a set to None by default.
+            @param x: x component
+            @param y: y component
+            @param z: z component
+        Initialization. Components that are not
+        set a set to None by default.
+        :param x: x component
+        :param y: y component
+        :param z: z component
         """
         self.x = x
 …
 class Detector:
     """
         Class to hold detector information
+    Class to hold detector information
     """
     ## Name of the instrument [string]
 …
     def __init__(self):
         """
+            Initialize class attribute that are objects...
+        Initialize class attribute that are objects...
         """
         self.offset      = Vector()
 …
 class Collimation:
     """
         Class to hold collimation information
+    Class to hold collimation information
     """
     ## Name
 …
 class Source:
     """
         Class to hold source information
+    Class to hold source information
     """
     ## Name
 …
 """
     Definitions of radiation types
+Definitions of radiation types
 """
 NEUTRON  = 'neutron'
 …
 class Sample:
     """
         Class to hold the sample description
+    Class to hold the sample description
     """
     ## Short name for sample
 …
 class Process:
     """
         Class that holds information about the processes
         performed on the data.
+    Class that holds information about the processes
+    performed on the data.
     """
     name = ''
 …
 class DataInfo:
     """
         Class to hold the data read from a file.
         It includes four blocks of data for the
         instrument description, the sample description,
         the data itself and any other meta data.
+    Class to hold the data read from a file.
+    It includes four blocks of data for the
+    instrument description, the sample description,
+    the data itself and any other meta data.
     """
     ## Title
 …
     def __init__(self):
         """
             Initialization
+        Initialization
         """
         ## Title
 …
     def __str__(self):
         """
             Nice printout
+        Nice printout
         """
         _str =  "File:            %s\n" % self.filename
 …
     def __add__(self, other):
         """
             Add two data sets
             @param other: data set to add to the current one
             @return: new data set
             @raise ValueError: raised when two data sets are incompatible
+        Add two data sets
+        :param other: data set to add to the current one
+        :return: new data set
+        :raise ValueError: raised when two data sets are incompatible
         """
         def operation(a, b): return a+b
 …
     def __radd__(self, other):
         """
+            Add two data sets
+            @param other: data set to add to the current one
+            @return: new data set
+            @raise ValueError: raised when two data sets are incompatible
+        Add two data sets
+        :param other: data set to add to the current one
+        :return: new data set
+        :raise ValueError: raised when two data sets are incompatible
         """
         def operation(a, b): return b+a
 …
     def __sub__(self, other):
         """
+            Subtract two data sets
+            @param other: data set to subtract from the current one
+            @return: new data set
+            @raise ValueError: raised when two data sets are incompatible
+        Subtract two data sets
+        :param other: data set to subtract from the current one
+        :return: new data set
+        :raise ValueError: raised when two data sets are incompatible
         """
         def operation(a, b): return a-b
 …
     def __rsub__(self, other):
         """
+            Subtract two data sets
+            @param other: data set to subtract from the current one
+            @return: new data set
+            @raise ValueError: raised when two data sets are incompatible
+        Subtract two data sets
+        :param other: data set to subtract from the current one
+        :return: new data set
+        :raise ValueError: raised when two data sets are incompatible
         """
         def operation(a, b): return b-a
 …
     def __mul__(self, other):
         """
+            Multiply two data sets
+            @param other: data set to subtract from the current one
+            @return: new data set
+            @raise ValueError: raised when two data sets are incompatible
+        Multiply two data sets
+        :param other: data set to subtract from the current one
+        :return: new data set
+        :raise ValueError: raised when two data sets are incompatible
         """
         def operation(a, b): return a*b
 …
     def __rmul__(self, other):
         """
+            Multiply two data sets
+            @param other: data set to subtract from the current one
+            @return: new data set
+            @raise ValueError: raised when two data sets are incompatible
+        Multiply two data sets
+        :param other: data set to subtract from the current one
+        :return: new data set
+        :raise ValueError: raised when two data sets are incompatible
         """
         def operation(a, b): return b*a
 …
     def __div__(self, other):
         """
+            Divided a data set by another
+            @param other: data set that the current one is divided by
+            @return: new data set
+            @raise ValueError: raised when two data sets are incompatible
+        Divided a data set by another
+        :param other: data set that the current one is divided by
+        :return: new data set
+        :raise ValueError: raised when two data sets are incompatible
         """
         def operation(a, b): return a/b
 …
     def __rdiv__(self, other):
         """
+            Divided a data set by another
+            @param other: data set that the current one is divided by
+            @return: new data set
+            @raise ValueError: raised when two data sets are incompatible
+        Divided a data set by another
+        :param other: data set that the current one is divided by
+        :return: new data set
+        :raise ValueError: raised when two data sets are incompatible
         """
         def operation(a, b): return b/a
 …
 class Data1D(plottable_1D, DataInfo):
     """
 D data class
+D data class
     """
     x_unit = '1/A'
 …
     def __str__(self):
         """
             Nice printout
+        Nice printout
         """
         _str =  "%s\n" % DataInfo.__str__(self)
 …
     def is_slit_smeared(self):
         """
+            Check whether the data has slit smearing information
+            @return: True is slit smearing info is present, False otherwise
+        Check whether the data has slit smearing information
+        :return: True is slit smearing info is present, False otherwise
         """
         def _check(v):
 …
     def clone_without_data(self, length=0, clone=None):
         """
             Clone the current object, without copying the data (which
             will be filled out by a subsequent operation).
             The data arrays will be initialized to zero.
             @param length: length of the data array to be initialized
             @param clone: if provided, the data will be copied to clone
+        Clone the current object, without copying the data (which
+        will be filled out by a subsequent operation).
+        The data arrays will be initialized to zero.
+        :param length: length of the data array to be initialized
+        :param clone: if provided, the data will be copied to clone
         """
         from copy import deepcopy
 …
     def _validity_check(self, other):
         """
+            Checks that the data lengths are compatible.
+            Checks that the x vectors are compatible.
+            Returns errors vectors equal to original
+            errors vectors if they were present or vectors
+            of zeros when none was found.
+            @param other: other data set for operation
+            @return: dy for self, dy for other [numpy arrays]
+            @raise ValueError: when lengths are not compatible
+        Checks that the data lengths are compatible.
+        Checks that the x vectors are compatible.
+        Returns errors vectors equal to original
+        errors vectors if they were present or vectors
+        of zeros when none was found.
+        :param other: other data set for operation
+        :return: dy for self, dy for other [numpy arrays]
+        :raise ValueError: when lengths are not compatible
         """
         dy_other = None
 …
 class Data2D(plottable_2D, DataInfo):
     """
 D data class
+D data class
     """
     ## Units for Q-values
 …
     def clone_without_data(self, length=0, clone=None):
         """
             Clone the current object, without copying the data (which
             will be filled out by a subsequent operation).
             The data arrays will be initialized to zero.
             @param length: length of the data array to be initialized
             @param clone: if provided, the data will be copied to clone
+        Clone the current object, without copying the data (which
+        will be filled out by a subsequent operation).
+        The data arrays will be initialized to zero.
+        :param length: length of the data array to be initialized
+        :param clone: if provided, the data will be copied to clone
         """
         from copy import deepcopy
 …
     def _validity_check(self, other):
         """
+            Checks that the data lengths are compatible.
+            Checks that the x vectors are compatible.
+            Returns errors vectors equal to original
+            errors vectors if they were present or vectors
+            of zeros when none was found.
+            @param other: other data set for operation
+            @return: dy for self, dy for other [numpy arrays]
+            @raise ValueError: when lengths are not compatible
+        Checks that the data lengths are compatible.
+        Checks that the x vectors are compatible.
+        Returns errors vectors equal to original
+        errors vectors if they were present or vectors
+        of zeros when none was found.
+        :param other: other data set for operation
+        :return: dy for self, dy for other [numpy arrays]
+        :raise ValueError: when lengths are not compatible
         """
         err_other = None
 …
     def _perform_operation(self, other, operation):
         """
+            Perform 2D operations between data sets
+            @param other: other data set
+            @param operation: function defining the operation
+        Perform 2D operations between data sets
+        :param other: other data set
+        :param operation: function defining the operation
         """
         # First, check the data compatibility

DataLoader/loader.py

-                      rfd4b6f8
+                      r0997158f
+#####################################################################
+#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 2008, University of Tennessee
+######################################################################
 """
     File handler to support different file extensions.
 …
     a directory (for instance, a user plug-in directory) and
     look for new readers/writers.
-"""
-"""
-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 2008, University of Tennessee
 """
 …
 class Registry(ExtensionRegistry):
     """
         Registry class for file format extensions.
         Readers and writers are supported.
+    Registry class for file format extensions.
+    Readers and writers are supported.
     """
 …
     def load(self, path, format=None):
         """
             Call the loader for the file type of path.
             @param path: file path
             @param format: explicit extension, to force the use of a particular reader
             Defaults to the ascii (multi-column) reader
             if no reader was registered for the file's
             extension.
+        Call the loader for the file type of path.
+        :param path: file path
+        :param format: explicit extension, to force the use of a particular reader
+        Defaults to the ascii (multi-column) reader
+        if no reader was registered for the file's
+        extension.
         """
         try:
 …
     def find_plugins(self, dir):
         """
+            Find readers in a given directory. This method
+            can be used to inspect user plug-in directories to
+            find new readers/writers.
+            @param dir: directory to search into
+            @return: number of readers found
+        Find readers in a given directory. This method
+        can be used to inspect user plug-in directories to
+        find new readers/writers.
+        :param dir: directory to search into
+        :return: number of readers found
         """
         readers_found = 0
 …
     def associate_file_type(self, ext, module):
         """
             Look into a module to find whether it contains a
             Reader class. If so, APPEND it to readers and (potentially)
             to the list of writers for the given extension
             @param ext: file extension [string]
             @param module: module object
+        Look into a module to find whether it contains a
+        Reader class. If so, APPEND it to readers and (potentially)
+        to the list of writers for the given extension
+        :param ext: file extension [string]
+        :param module: module object
         """
         reader_found = False
 …
     def associate_file_reader(self, ext, loader):
         """
             Append a reader object to readers
             @param ext: file extension [string]
             @param module: reader object
+        Append a reader object to readers
+        :param ext: file extension [string]
+        :param module: reader object
         """
         reader_found = False
 …
     def _identify_plugin(self, module):
         """
+            Look into a module to find whether it contains a
+            Reader class. If so, add it to readers and (potentially)
+            to the list of writers.
+            @param module: module object
+        Look into a module to find whether it contains a
+        Reader class. If so, add it to readers and (potentially)
+        to the list of writers.
+        :param module: module object
         """
         reader_found = False
 …
     def lookup_writers(self, path):
         """
         Return the loader associated with the file type of path.
         Raises ValueError if file type is not known.
+        :return: the loader associated with the file type of path.
+        :Raises ValueError: if file type is not known.
         """
         # Find matching extensions
 …
         Raises ValueError if no writer is available.
         Raises KeyError if format is not available.
         May raise a writer-defined exception if writer fails.
         """
 …
 class Loader(object):
     """
         Utility class to use the Registry as a singleton.
+    Utility class to use the Registry as a singleton.
     """
     ## Registry instance
 …
     def associate_file_type(self, ext, module):
         """
             Look into a module to find whether it contains a
             Reader class. If so, append it to readers and (potentially)
             to the list of writers for the given extension
             @param ext: file extension [string]
             @param module: module object
+        Look into a module to find whether it contains a
+        Reader class. If so, append it to readers and (potentially)
+        to the list of writers for the given extension
+        :param ext: file extension [string]
+        :param module: module object
         """
         return self.__registry.associate_file_type(ext, module)
 …
     def associate_file_reader(self, ext, loader):
         """
             Append a reader object to readers
             @param ext: file extension [string]
             @param module: reader object
+        Append a reader object to readers
+        :param ext: file extension [string]
+        :param module: reader object
         """
         return self.__registry.associate_file_reader(ext, loader)
 …
     def load(self, file, format=None):
         """
             Load a file
             @param file: file name (path)
             @param format: specified format to use (optional)
             @return: DataInfo object
+        Load a file
+        :param file: file name (path)
+        :param format: specified format to use (optional)
+        :return: DataInfo object
         """
         return self.__registry.load(file, format)
 …
     def save(self, file, data, format):
         """
             Save a DataInfo object to file
             @param file: file name (path)
             @param data: DataInfo object
             @param format: format to write the data in
+        Save a DataInfo object to file
+        :param file: file name (path)
+        :param data: DataInfo object
+        :param format: format to write the data in
         """
         return self.__registry.save(file, data, format)
 …
     def _get_registry_creation_time(self):
         """
             Internal method used to test the uniqueness
             of the registry object
+        Internal method used to test the uniqueness
+        of the registry object
         """
         return self.__registry._created
 …
     def find_plugins(self, dir):
         """
+            Find plugins in a given directory
+            @param dir: directory to look into to find new readers/writers
+        Find plugins in a given directory
+        :param dir: directory to look into to find new readers/writers
         """
         return self.__registry.find_plugins(dir)

DataLoader/manipulations.py

-                      rf265927
+                      r0997158f
+#####################################################################
+#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 2008, University of Tennessee
+######################################################################
 """
     Data manipulations for 2D data sets.
 …
 """
+"""
+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 2008, University of Tennessee
+"""
 #TODO: copy the meta data from the 2D object to the resulting 1D object
 …
 def get_q(dx, dy, det_dist, wavelength):
     """
+        @param dx: x-distance from beam center [mm]
+        @param dy: y-distance from beam center [mm]
+        @return: q-value at the given position
+    :param dx: x-distance from beam center [mm]
+    :param dy: y-distance from beam center [mm]
+    :return: q-value at the given position
     """
     # Distance from beam center in the plane of detector
 …
 def get_q_compo(dx, dy, det_dist, wavelength,compo=None):
+    #This reduces tiny error at very large q.
+    #Implementation of this func is not started yet.<--ToDo
+    """
+    This reduces tiny error at very large q.
+    Implementation of this func is not started yet.<--ToDo
+    """
     if dy==0:
         if dx>=0:
 …
 def flip_phi(phi):
     """
+        Correct phi to within the 0 <= to <= 2pi range
+        @return: phi in >=0 and <=2Pi
+    Correct phi to within the 0 <= to <= 2pi range
+    :return: phi in >=0 and <=2Pi
     """
     Pi = math.pi
 …
 def reader2D_converter(data2d=None):
     """
+        convert old 2d format opened by IhorReader or danse_reader to new Data2D format
+        @param data2d: 2d array of Data2D object
+        @return: 1d arrays of Data2D object
+    convert old 2d format opened by IhorReader or danse_reader to new Data2D format
+    :param data2d: 2d array of Data2D object
+    :return: 1d arrays of Data2D object
     """
     if data2d.data==None or data2d.x_bins==None or data2d.y_bins==None:
 …
 class _Slab(object):
     """
         Compute average I(Q) for a region of interest
+    Compute average I(Q) for a region of interest
     """
     def __init__(self, x_min=0.0, x_max=0.0, y_min=0.0, y_max=0.0, bin_width=0.001):
 …
     def _avg(self, data2D, maj):
         """
+             Compute average I(Q_maj) for a region of interest.
+             The major axis is defined as the axis of Q_maj.
+             The minor axis is the axis that we average over.
+             @param data2D: Data2D object
+             @param maj_min: min value on the major axis
+             @return: Data1D object
+        Compute average I(Q_maj) for a region of interest.
+        The major axis is defined as the axis of Q_maj.
+        The minor axis is the axis that we average over.
+        :param data2D: Data2D object
+        :param maj_min: min value on the major axis
+        :return: Data1D object
         """
         if len(data2D.detector) != 1:
 …
 class SlabY(_Slab):
     """
+    Compute average I(Qy) for a region of interest
+    """
+    def __call__(self, data2D):
+        """
         Compute average I(Qy) for a region of interest
+        :param data2D: Data2D object
+        :return: Data1D object
+        """
+        return self._avg(data2D, 'y')
+class SlabX(_Slab):
+    """
+    Compute average I(Qx) for a region of interest
     """
     def __call__(self, data2D):
         """
-             Compute average I(Qy) for a region of interest
-             @param data2D: Data2D object
-             @return: Data1D object
-        """
-        return self._avg(data2D, 'y')
-class SlabX(_Slab):
-    """
         Compute average I(Qx) for a region of interest
+    """
+    def __call__(self, data2D):
+        """
+             Compute average I(Qx) for a region of interest
+             @param data2D: Data2D object
+             @return: Data1D object
+        :param data2D: Data2D object
+        :return: Data1D object
         """
         return self._avg(data2D, 'x')
 …
 class Boxsum(object):
     """
         Perform the sum of counts in a 2D region of interest.
+    Perform the sum of counts in a 2D region of interest.
     """
     def __init__(self, x_min=0.0, x_max=0.0, y_min=0.0, y_max=0.0):
 …
     def __call__(self, data2D):
         """
+             Perform the sum in the region of interest
+             @param data2D: Data2D object
+             @return: number of counts, error on number of counts
+        Perform the sum in the region of interest
+        :param data2D: Data2D object
+        :return: number of counts, error on number of counts
         """
         y, err_y, y_counts = self._sum(data2D)
 …
     def _sum(self, data2D):
         """
+             Perform the sum in the region of interest
+             @param data2D: Data2D object
+             @return: number of counts, error on number of counts, number of entries summed
+        Perform the sum in the region of interest
+        :param data2D: Data2D object
+        :return: number of counts, error on number of counts, number of entries summed
         """
         if len(data2D.detector) != 1:
 …
 class Boxavg(Boxsum):
     """
         Perform the average of counts in a 2D region of interest.
+    Perform the average of counts in a 2D region of interest.
     """
     def __init__(self, x_min=0.0, x_max=0.0, y_min=0.0, y_max=0.0):
 …
     def __call__(self, data2D):
         """
+             Perform the sum in the region of interest
+             @param data2D: Data2D object
+             @return: average counts, error on average counts
+        Perform the sum in the region of interest
+        :param data2D: Data2D object
+        :return: average counts, error on average counts
         """
         y, err_y, y_counts = self._sum(data2D)
 …
 def get_pixel_fraction_square(x, xmin, xmax):
     """
+         Return the fraction of the length
+         from xmin to x.
+             A            B
+         +-----------+---------+
+         xmin        x         xmax
+         @param x: x-value
+         @param xmin: minimum x for the length considered
+         @param xmax: minimum x for the length considered
+         @return: (x-xmin)/(xmax-xmin) when xmin < x < xmax
+    Return the fraction of the length
+    from xmin to x.::
+           A            B
+       +-----------+---------+
+       xmin        x         xmax
+    :param x: x-value
+    :param xmin: minimum x for the length considered
+    :param xmax: minimum x for the length considered
+    :return: (x-xmin)/(xmax-xmin) when xmin < x < xmax
     """
     if x<=xmin:
 …
 class CircularAverage(object):
     """
         Perform circular averaging on 2D data
         The data returned is the distribution of counts
         as a function of Q
+    Perform circular averaging on 2D data
+    The data returned is the distribution of counts
+    as a function of Q
     """
     def __init__(self, r_min=0.0, r_max=0.0, bin_width=0.0005):
 …
     def __call__(self, data2D):
         """
+            Perform circular averaging on the data
+            @param data2D: Data2D object
+            @return: Data1D object
+        Perform circular averaging on the data
+        :param data2D: Data2D object
+        :return: Data1D object
         """
         # Get data
 …
 class Ring(object):
     """
         Defines a ring on a 2D data set.
         The ring is defined by r_min, r_max, and
         the position of the center of the ring.
         The data returned is the distribution of counts
         around the ring as a function of phi.
         Phi_min and phi_max should be defined between 0 and 2*pi
         in anti-clockwise starting from the x- axis on the left-hand side
+    Defines a ring on a 2D data set.
+    The ring is defined by r_min, r_max, and
+    the position of the center of the ring.
+    The data returned is the distribution of counts
+    around the ring as a function of phi.
+    Phi_min and phi_max should be defined between 0 and 2*pi
+    in anti-clockwise starting from the x- axis on the left-hand side
     """
     #Todo: remove center.
 …
     def __call__(self, data2D):
         """
+            Apply the ring to the data set.
+            Returns the angular distribution for a given q range
+            @param data2D: Data2D object
+            @return: Data1D object
+        Apply the ring to the data set.
+        Returns the angular distribution for a given q range
+        :param data2D: Data2D object
+        :return: Data1D object
         """
         if data2D.__class__.__name__ not in ["Data2D", "plottable_2D"]:
 …
 def get_pixel_fraction(qmax, q_00, q_01, q_10, q_11):
     """
         Returns the fraction of the pixel defined by
         the four corners (q_00, q_01, q_10, q_11) that
         has q < qmax.
+    Returns the fraction of the pixel defined by
+    the four corners (q_00, q_01, q_10, q_11) that
+    has q < qmax.::
                 q_01                q_11
         y=1         +--------------+
 …
                     x=0            x=1
     """
 …
 def get_intercept(q, q_0, q_1):
     """
+        Returns the fraction of the side at which the
+        q-value intercept the pixel, None otherwise.
+        The values returned is the fraction ON THE SIDE
+        OF THE LOWEST Q.
+                A        B
+         +-----------+--------+
+                    1     <--- pixel size
+        Q_0 -------- Q ----- Q_1    <--- equivalent Q range
+    Returns the fraction of the side at which the
+    q-value intercept the pixel, None otherwise.
+    The values returned is the fraction ON THE SIDE
+    OF THE LOWEST Q. ::
+            A           B
+        +-----------+--------+    <--- pixel size
+                    1
+        Q_0 -------- Q ----- Q_1   <--- equivalent Q range
         if Q_1 > Q_0, A is returned
         if Q_1 < Q_0, B is returned
         if Q is outside the range of [Q_0, Q_1], None is returned
 …
 class _Sector:
     """
         Defines a sector region on a 2D data set.
         The sector is defined by r_min, r_max, phi_min, phi_max,
         and the position of the center of the ring
         where phi_min and phi_max are defined by the right and left lines wrt central line
         and phi_max could be less than phi_min.
         Phi is defined between 0 and 2*pi in anti-clockwise starting from the x- axis on the left-hand side
+    Defines a sector region on a 2D data set.
+    The sector is defined by r_min, r_max, phi_min, phi_max,
+    and the position of the center of the ring
+    where phi_min and phi_max are defined by the right and left lines wrt central line
+    and phi_max could be less than phi_min.
+    Phi is defined between 0 and 2*pi in anti-clockwise starting from the x- axis on the left-hand side
     """
     def __init__(self, r_min, r_max, phi_min=0, phi_max=2*math.pi,nbins=20):
 …
     def _agv(self, data2D, run='phi'):
         """
+            Perform sector averaging.
+            @param data2D: Data2D object
+            @param run:  define the varying parameter ('phi' , 'q' , or 'q2')
+            @return: Data1D object
+        Perform sector averaging.
+        :param data2D: Data2D object
+        :param run:  define the varying parameter ('phi' , 'q' , or 'q2')
+        :return: Data1D object
         """
         if data2D.__class__.__name__ not in ["Data2D", "plottable_2D"]:
 …
 class SectorPhi(_Sector):
     """
         Sector average as a function of phi.
         I(phi) is return and the data is averaged over Q.
         A sector is defined by r_min, r_max, phi_min, phi_max.
         The number of bin in phi also has to be defined.
+    Sector average as a function of phi.
+    I(phi) is return and the data is averaged over Q.
+    A sector is defined by r_min, r_max, phi_min, phi_max.
+    The number of bin in phi also has to be defined.
     """
     def __call__(self, data2D):
         """
             Perform sector average and return I(phi).
             @param data2D: Data2D object
             @return: Data1D object
+        Perform sector average and return I(phi).
+        :param data2D: Data2D object
+        :return: Data1D object
         """
 …
 class SectorQ(_Sector):
     """
         Sector average as a function of Q for both symatric wings.
         I(Q) is return and the data is averaged over phi.
         A sector is defined by r_min, r_max, phi_min, phi_max.
         r_min, r_max, phi_min, phi_max >0.
         The number of bin in Q also has to be defined.
+    Sector average as a function of Q for both symatric wings.
+    I(Q) is return and the data is averaged over phi.
+    A sector is defined by r_min, r_max, phi_min, phi_max.
+    r_min, r_max, phi_min, phi_max >0.
+    The number of bin in Q also has to be defined.
     """
     def __call__(self, data2D):
         """
+            Perform sector average and return I(Q).
+            @param data2D: Data2D object
+            @return: Data1D object
+        Perform sector average and return I(Q).
+        :param data2D: Data2D object
+        :return: Data1D object
         """
         return self._agv(data2D, 'q2')
 …
 class Ringcut(object):
     """
         Defines a ring on a 2D data set.
         The ring is defined by r_min, r_max, and
         the position of the center of the ring.
         The data returned is the region inside the ring
         Phi_min and phi_max should be defined between 0 and 2*pi
         in anti-clockwise starting from the x- axis on the left-hand side
+    Defines a ring on a 2D data set.
+    The ring is defined by r_min, r_max, and
+    the position of the center of the ring.
+    The data returned is the region inside the ring
+    Phi_min and phi_max should be defined between 0 and 2*pi
+    in anti-clockwise starting from the x- axis on the left-hand side
     """
     def __init__(self, r_min=0, r_max=0, center_x=0, center_y=0 ):
 …
     def __call__(self, data2D):
         """
+            Apply the ring to the data set.
+            Returns the angular distribution for a given q range
+            @param data2D: Data2D object
+            @return: index array in the range
+        Apply the ring to the data set.
+        Returns the angular distribution for a given q range
+        :param data2D: Data2D object
+        :return: index array in the range
         """
         if data2D.__class__.__name__ not in ["Data2D", "plottable_2D"]:
 …
 class Boxcut(object):
     """
         Find a rectangular 2D region of interest.
+    Find a rectangular 2D region of interest.
     """
     def __init__(self, x_min=0.0, x_max=0.0, y_min=0.0, y_max=0.0):
 …
     def __call__(self, data2D):
         """
            Find a rectangular 2D region of interest.
            @param data2D: Data2D object
            @return: mask, 1d array (len = len(data))
                with Trues where the data points are inside ROI, otherwise False
+       Find a rectangular 2D region of interest.
+       :param data2D: Data2D object
+       :return: mask, 1d array (len = len(data))
+           with Trues where the data points are inside ROI, otherwise False
         """
         mask = self._find(data2D)
 …
     def _find(self, data2D):
         """
+             Find a rectangular 2D region of interest.
+             @param data2D: Data2D object
+             @return: out, 1d array (length = len(data))
+               with Trues where the data points are inside ROI, otherwise Falses
+        Find a rectangular 2D region of interest.
+        :param data2D: Data2D object
+        :return: out, 1d array (length = len(data))
+           with Trues where the data points are inside ROI, otherwise Falses
         """
         if data2D.__class__.__name__ not in ["Data2D", "plottable_2D"]:
 …
 class Sectorcut(object):
     """
         Defines a sector (major + minor) region on a 2D data set.
         The sector is defined by phi_min, phi_max,
         where phi_min and phi_max are defined by the right and left lines wrt central line.
         Phi_min and phi_max are given in units of radian
         and (phi_max-phi_min) should not be larger than pi
+    Defines a sector (major + minor) region on a 2D data set.
+    The sector is defined by phi_min, phi_max,
+    where phi_min and phi_max are defined by the right and left lines wrt central line.
+    Phi_min and phi_max are given in units of radian
+    and (phi_max-phi_min) should not be larger than pi
     """
     def __init__(self,phi_min=0, phi_max=math.pi):
 …
     def __call__(self, data2D):
         """
+           Find a rectangular 2D region of interest.
+           @param data2D: Data2D object
+           @return: mask, 1d array (len = len(data))
+               with Trues where the data points are inside ROI, otherwise False
+        Find a rectangular 2D region of interest.
+        :param data2D: Data2D object
+        :return: mask, 1d array (len = len(data))
+        with Trues where the data points are inside ROI, otherwise False
         """
         mask = self._find(data2D)
 …
     def _find(self, data2D):
         """
+             Find a rectangular 2D region of interest.
+             @param data2D: Data2D object
+             @return: out, 1d array (length = len(data))
+               with Trues where the data points are inside ROI, otherwise Falses
+        Find a rectangular 2D region of interest.
+        :param data2D: Data2D object
+        :return: out, 1d array (length = len(data))
+        with Trues where the data points are inside ROI, otherwise Falses
         """
         if data2D.__class__.__name__ not in ["Data2D", "plottable_2D"]:

DataLoader/qsmearing.py

-                      rf72333f
+                      r0997158f
+"""
+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 2009, University of Tennessee
+"""
+#####################################################################
+#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 2008, University of Tennessee
+######################################################################
 import DataLoader.extensions.smearer as smearer
 …
 def smear_selection(data1D):
     """
         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.
         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
+    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.
+    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
 …
     def __deepcopy__(self, memo={}):
         """
             Return a valid copy of self.
             Avoid copying the _smearer C object and force a matrix recompute
             when the copy is used.
+        Return a valid copy of self.
+        Avoid copying the _smearer C object and force a matrix recompute
+        when the copy is used.
         """
         result = _BaseSmearer()
 …
     def get_bin_range(self, q_min=None, q_max=None):
         """
+            @param q_min: minimum q-value to smear
+            @param q_max: maximum q-value to smear
+        :param q_min: minimum q-value to smear
+        :param q_max: maximum q-value to smear
         """
         # If this is the first time we call for smearing,
 …
     def __call__(self, iq_in, first_bin=0, last_bin=None):
         """
             Perform smearing
+        Perform smearing
         """
         # If this is the first time we call for smearing,
 …
 class _SlitSmearer(_BaseSmearer):
     """
         Slit smearing for I(q) array
+    Slit smearing for I(q) array
     """
     def __init__(self, nbins=None, width=None, height=None, min=None, max=None):
         """
+            Initialization
+            @param iq: I(q) array [cm-1]
+            @param width: slit width [A-1]
+            @param height: slit height [A-1]
+            @param min: Q_min [A-1]
+            @param max: Q_max [A-1]
+        Initialization
+        :param iq: I(q) array [cm-1]
+        :param width: slit width [A-1]
+        :param height: slit height [A-1]
+        :param min: Q_min [A-1]
+        :param max: Q_max [A-1]
         """
         _BaseSmearer.__init__(self)
 …
     def _initialize_smearer(self):
         """
             Initialize the C++ smearer object.
             This method HAS to be called before smearing
+        Initialize the C++ smearer object.
+        This method HAS to be called before smearing
         """
         #self._smearer = smearer.new_slit_smearer(self.width, self.height, self.min, self.max, self.nbins)
 …
     def get_unsmeared_range(self, q_min, q_max):
         """
             Determine the range needed in unsmeared-Q to cover
             the smeared Q range
+        Determine the range needed in unsmeared-Q to cover
+        the smeared Q range
         """
         # Range used for input to smearing
 …
 class SlitSmearer(_SlitSmearer):
     """
         Adaptor for slit smearing class and SANS data
+    Adaptor for slit smearing class and SANS data
     """
     def __init__(self, data1D):
         """
             Assumption: equally spaced bins of increasing q-values.
             @param data1D: data used to set the smearing parameters
+        Assumption: equally spaced bins of increasing q-values.
+        :param data1D: data used to set the smearing parameters
         """
         # Initialization from parent class
 …
 class _QSmearer(_BaseSmearer):
     """
         Perform Gaussian Q smearing
+    Perform Gaussian Q smearing
     """
     def __init__(self, nbins=None, width=None, min=None, max=None):
         """
             Initialization
             @param nbins: number of Q bins
             @param width: array standard deviation in Q [A-1]
             @param min: Q_min [A-1]
             @param max: Q_max [A-1]
+        Initialization
+        :param nbins: number of Q bins
+        :param width: array standard deviation in Q [A-1]
+        :param min: Q_min [A-1]
+        :param max: Q_max [A-1]
         """
         _BaseSmearer.__init__(self)
 …
     def _initialize_smearer(self):
         """
             Initialize the C++ smearer object.
             This method HAS to be called before smearing
+        Initialize the C++ smearer object.
+        This method HAS to be called before smearing
         """
         #self._smearer = smearer.new_q_smearer(numpy.asarray(self.width), self.min, self.max, self.nbins)
 …
     def get_unsmeared_range(self, q_min, q_max):
         """
             Determine the range needed in unsmeared-Q to cover
             the smeared Q range
             Take 3 sigmas as the offset between smeared and unsmeared space
+        Determine the range needed in unsmeared-Q to cover
+        the smeared Q range
+        Take 3 sigmas as the offset between smeared and unsmeared space
         """
         # Range used for input to smearing
 …
         return _qmin_unsmeared, _qmax_unsmeared
 class QSmearer(_QSmearer):
     """
         Adaptor for Gaussian Q smearing class and SANS data
+    Adaptor for Gaussian Q smearing class and SANS data
     """
     def __init__(self, data1D):
         """
             Assumption: equally spaced bins of increasing q-values.
             @param data1D: data used to set the smearing parameters
+        Assumption: equally spaced bins of increasing q-values.
+        :param data1D: data used to set the smearing parameters
         """
         # Initialization from parent class

DataLoader/readers/IgorReader.py

-                      readf1f9
+                      r0997158f
+############################################################################
+#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.
+#If you use DANSE applications to do scientific research that leads to
+#publication, we ask that you acknowledge the use of the software with the
+#following sentence:
+#This work benefited from DANSE software developed under NSF award DMR-0520547.
+#copyright 2008, University of Tennessee
+#############################################################################
 """
     IGOR 2D reduced file reader
-"""
-"""
-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.
-If you use DANSE applications to do scientific research that leads to
-publication, we ask that you acknowledge the use of the software with the
-following sentence:
-"This work benefited from DANSE software developed under NSF award DMR-0520547."
-copyright 2008, University of Tennessee
 """

DataLoader/readers/abs_reader.py

-                      rfe78c7b
+                      r0997158f
+"""
+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 2008, University of Tennessee
+"""
+#####################################################################
+#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 2008, University of Tennessee
+######################################################################
 import numpy
 …
 class Reader:
     """
         Class to load IGOR reduced .ABS files
+    Class to load IGOR reduced .ABS files
     """
     ## File type
 …
     def read(self, path):
         """
+            Load data file
+            @param path: file path
+            @return: Data1D object, or None
+            @raise RuntimeError: when the file can't be opened
+            @raise ValueError: when the length of the data vectors are inconsistent
+        Load data file.
+        :param path: file path
+        :return: Data1D object, or None
+        :raise RuntimeError: when the file can't be opened
+        :raise ValueError: when the length of the data vectors are inconsistent
         """
         if os.path.isfile(path):

DataLoader/readers/ascii_reader.py

-                      rc7c5ef8
+                      r0997158f
+"""
+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 2008, University of Tennessee
+"""
+############################################################################
+#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.
+#If you use DANSE applications to do scientific research that leads to
+#publication, we ask that you acknowledge the use of the software with the
+#following sentence:
+#This work benefited from DANSE software developed under NSF award DMR-0520547.
+#copyright 2008, University of Tennessee
+#############################################################################
 import numpy
 …
 class Reader:
     """
         Class to load ascii files (2, 3 or 4 columns)
+    Class to load ascii files (2, 3 or 4 columns).
     """
     ## File type
 …
     def read(self, path):
         """
+            Load data file
+            @param path: file path
+            @return: Data1D object, or None
+            @raise RuntimeError: when the file can't be opened
+            @raise ValueError: when the length of the data vectors are inconsistent
+        Load data file
+        :param path: file path
+        :return: Data1D object, or None
+        :raise RuntimeError: when the file can't be opened
+        :raise ValueError: when the length of the data vectors are inconsistent
         """
         if os.path.isfile(path):

DataLoader/readers/associations.py

-                      rded62ce
+                      r0997158f
-"""
-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 2009, University of Tennessee
+"""
+############################################################################
+#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.
+#If you use DANSE applications to do scientific research that leads to
+#publication, we ask that you acknowledge the use of the software with the
+#following sentence:
+#This work benefited from DANSE software developed under NSF award DMR-0520547.
+#copyright 2009, University of Tennessee
+#############################################################################
 """
     Module to associate default readers to file extensions.
     The module reads an xml file to get the readers for each file extension.
     The readers are tried in order they appear when reading a file.
+Module to associate default readers to file extensions.
+The module reads an xml file to get the readers for each file extension.
+The readers are tried in order they appear when reading a file.
 """
 …
 def read_associations(loader, settings='defaults.xml'):
     """
         Read the specified settings file to associate
         default readers to file extension.
         @param loader: Loader object
         @param settings: path to the XML settings file [string]
+    Read the specified settings file to associate
+    default readers to file extension.
+    :param loader: Loader object
+    :param settings: path to the XML settings file [string]
     """
     reader_dir = os.path.dirname(__file__)
 …
 def register_readers(registry_function):
     """
+        Function called by the registry/loader object to register
+        all default readers using a call back function.
+        WARNING: this method is now obsolete
+    Function called by the registry/loader object to register
+    all default readers using a call back function.
+        @param registry_function: function to be called to register each reader
+    :WARNING: this method is now obsolete
+    :param registry_function: function to be called to register each reader
     """
     logging.info("register_readers is now obsolete: use read_associations()")

DataLoader/readers/cansas_reader.py

-                      rfe78c7b
+                      r0997158f
+"""
+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 2008, 2009, University of Tennessee
+"""
+############################################################################
+#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.
+#If you use DANSE applications to do scientific research that leads to
+#publication, we ask that you acknowledge the use of the software with the
+#following sentence:
+#This work benefited from DANSE software developed under NSF award DMR-0520547.
+#copyright 2008,2009 University of Tennessee
+#############################################################################
 # Known issue: reader not compatible with multiple SASdata entries
 # within a single SASentry. Will raise a runtime error.
 …
 def write_node(doc, parent, name, value, attr={}):
     """
+        @param doc: document DOM
+        @param parent: parent node
+        @param name: tag of the element
+        @param value: value of the child text node
+        @param attr: attribute dictionary
+        @return: True if something was appended, otherwise False
+    :param doc: document DOM
+    :param parent: parent node
+    :param name: tag of the element
+    :param value: value of the child text node
+    :param attr: attribute dictionary
+    :return: True if something was appended, otherwise False
     """
     if value is not None:
 …
 def get_content(location, node):
     """
+        Get the first instance of the content of a xpath location
+        @param location: xpath location
+        @param node: node to start at
+        @return: Element, or None
+    Get the first instance of the content of a xpath location.
+    :param location: xpath location
+    :param node: node to start at
+    :return: Element, or None
     """
     nodes = node.xpath(location, namespaces={'ns': CANSAS_NS})
 …
 def get_float(location, node):
     """
         Get the content of a node as a float
         @param location: xpath location
         @param node: node to start at
+    Get the content of a node as a float
+    :param location: xpath location
+    :param node: node to start at
     """
     nodes = node.xpath(location, namespaces={'ns': CANSAS_NS})
 …
 class Reader:
     """
         Class to load cansas 1D XML files
         Dependencies:
             The CanSas reader requires PyXML 0.8.4 or later.
+    Class to load cansas 1D XML files
+    :Dependencies:
+        The CanSas reader requires PyXML 0.8.4 or later.
     """
     ## CanSAS version
 …
     def read(self, path):
         """
+            Load data file
+            @param path: file path
+            @return: Data1D object if a single SASentry was found,
+                        or a list of Data1D objects if multiple entries were found,
+                        or None of nothing was found
+            @raise RuntimeError: when the file can't be opened
+            @raise ValueError: when the length of the data vectors are inconsistent
+        Load data file
+        :param path: file path
+        :return: Data1D object if a single SASentry was found,
+                    or a list of Data1D objects if multiple entries were found,
+                    or None of nothing was found
+        :raise RuntimeError: when the file can't be opened
+        :raise ValueError: when the length of the data vectors are inconsistent
         """
         output = []
 …
     def _parse_entry(self, dom):
         """
+            Parse a SASentry
+            @param node: SASentry node
+            @return: Data1D object
+        Parse a SASentry
+        :param node: SASentry node
+        :return: Data1D object
         """
         x = numpy.zeros(0)
 …
     def _to_xml_doc(self, datainfo):
         """
             Create an XML document to contain the content of a Data1D
             @param datainfo: Data1D object
+        Create an XML document to contain the content of a Data1D
+        :param datainfo: Data1D object
         """
 …
     def write(self, filename, datainfo):
         """
             Write the content of a Data1D as a CanSAS XML file
             @param filename: name of the file to write
             @param datainfo: Data1D object
+        Write the content of a Data1D as a CanSAS XML file
+        :param filename: name of the file to write
+        :param datainfo: Data1D object
         """
         # Create XML document
 …
     def _store_float(self, location, node, variable, storage, optional=True):
         """
             Get the content of a xpath location and store
             the result. Check that the units are compatible
             with the destination. The value is expected to
             be a float.
             The xpath location might or might not exist.
             If it does not exist, nothing is done
             @param location: xpath location to fetch
             @param node: node to read the data from
             @param variable: name of the data member to store it in [string]
             @param storage: data object that has the 'variable' data member
             @param optional: if True, no exception will be raised if unit conversion can't be done
             @raise ValueError: raised when the units are not recognized
+        Get the content of a xpath location and store
+        the result. Check that the units are compatible
+        with the destination. The value is expected to
+        be a float.
+        The xpath location might or might not exist.
+        If it does not exist, nothing is done
+        :param location: xpath location to fetch
+        :param node: node to read the data from
+        :param variable: name of the data member to store it in [string]
+        :param storage: data object that has the 'variable' data member
+        :param optional: if True, no exception will be raised if unit conversion can't be done
+        :raise ValueError: raised when the units are not recognized
         """
         entry = get_content(location, node)
 …
     def _store_content(self, location, node, variable, storage):
         """
+            Get the content of a xpath location and store
+            the result. The value is treated as a string.
+            The xpath location might or might not exist.
+            If it does not exist, nothing is done
+            @param location: xpath location to fetch
+            @param node: node to read the data from
+            @param variable: name of the data member to store it in [string]
+            @param storage: data object that has the 'variable' data member
+            @return: return a list of errors
+        Get the content of a xpath location and store
+        the result. The value is treated as a string.
+        The xpath location might or might not exist.
+        If it does not exist, nothing is done
+        :param location: xpath location to fetch
+        :param node: node to read the data from
+        :param variable: name of the data member to store it in [string]
+        :param storage: data object that has the 'variable' data member
+        :return: return a list of errors
         """
         entry = get_content(location, node)

DataLoader/readers/danse_reader.py

-                      readf1f9
+                      r0997158f
+############################################################################
+#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.
+#If you use DANSE applications to do scientific research that leads to
+#publication, we ask that you acknowledge the use of the software with the
+#following sentence:
+#This work benefited from DANSE software developed under NSF award DMR-0520547.
+#copyright 2008, University of Tennessee
+#############################################################################
 """
     DANSE/SANS file reader
-"""
-"""
-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.
-If you use DANSE applications to do scientific research that leads to
-publication, we ask that you acknowledge the use of the software with the
-following sentence:
-"This work benefited from DANSE software developed under NSF award DMR-0520547."
-copyright 2008, University of Tennessee
 """
 …
 class Reader:
     """
         Example data manipulation
+    Example data manipulation
     """
     ## File type
 …
     def read(self, filename=None):
         """
             Open and read the data in a file
             @param file: path of the file
+        Open and read the data in a file
+        @param file: path of the file
         """
 …
             # Store all data ######################################
+            # Store all data
             # Store wavelength
             if has_converter==True and output.source.wavelength_unit != 'A':

DataLoader/readers/hfir1d_reader.py

-                      rfe78c7b
+                      r0997158f
-"""
-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 2008, University of Tennessee
+"""
+#####################################################################
+#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 2008, University of Tennessee
+######################################################################
 import numpy
 …
 class Reader(object):
     """
         Class to load HFIR 1D 4-column files
+    Class to load HFIR 1D 4-column files
     """
     ## File type
 …
     def read(self, path):
         """
+            Load data file
+            @param path: file path
+            @return: Data1D object, or None
+            @raise RuntimeError: when the file can't be opened
+            @raise ValueError: when the length of the data vectors are inconsistent
+        Load data file
+        :param path: file path
+        :return: Data1D object, or None
+        :raise RuntimeError: when the file can't be opened
+        :raise ValueError: when the length of the data vectors are inconsistent
         """
         if os.path.isfile(path):

DataLoader/readers/red2d_reader.py

-                      r59a2dab
+                      r0997158f
+#####################################################################
+#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 2008, University of Tennessee
+######################################################################
 """
     TXT/IGOR 2D Q Map file reader
 """
-"""
-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.
-If you use DANSE applications to do scientific research that leads to
-publication, we ask that you acknowledge the use of the software with the
-following sentence:
-"This work benefited from DANSE software developed under NSF award DMR-0520547."
-copyright 2008, University of Tennessee
-"""
 import os, sys

DataLoader/readers/tiff_reader.py

-                      rfe78c7b
+                      r0997158f
+#####################################################################
+#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 2008, University of Tennessee
+######################################################################
 """
     Image reader. Untested.
 """
-"""
-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 2008, University of Tennessee
-"""
 #TODO: load and check data and orientation of the image (needs rendering)
 …
 class Reader:
     """
         Example data manipulation
+    Example data manipulation
     """
     ## File type
 …
     def read(self, filename=None):
         """
+            Open and read the data in a file
+            @param file: path of the file
+        Open and read the data in a file
+        :param file: path of the file
         """
         try:

DataLoader/smearing_2d.py

-                      rc6a48c27
+                      r0997158f
+"""
+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 2009, University of Tennessee
+"""
+#####################################################################
+#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 2008, University of Tennessee
+######################################################################
 ## TODO: Need test,and check Gaussian averaging
 import numpy, math,time
 …
 class Smearer2D:
     """
         Gaussian Q smearing class for SANS 2d data
+    Gaussian Q smearing class for SANS 2d data
     """
+    def __init__(self, data=None,model=None,index=None,limit=LIMIT,accuracy='Low'):
+        """
+            Assumption: equally spaced bins in dq_r, dq_phi space.
+            @param data: 2d data used to set the smearing parameters
+            @param model: model function
+            @param index: 1d array with len(data) to define the range of the calculation: elements are given as True or False
+            @param nr: number of bins in dq_r-axis
+            @param nphi: number of bins in dq_phi-axis
+    def __init__(self, data=None, model=None, index=None,
+                 limit=LIMIT, accuracy='Low'):
+        """
+        Assumption: equally spaced bins in dq_r, dq_phi space.
+        :param data: 2d data used to set the smearing parameters
+        :param model: model function
+        :param index: 1d array with len(data) to define the range of the calculation: elements are given as True or False
+        :param nr: number of bins in dq_r-axis
+        :param nphi: number of bins in dq_phi-axis
         """
         ## data
 …
     def get_data(self):
         """
             get qx_data, qy_data, dqx_data,dqy_data,and calculate phi_data=arctan(qx_data/qy_data)
+        get qx_data, qy_data, dqx_data,dqy_data,and calculate phi_data=arctan(qx_data/qy_data)
         """
         if self.data == None or self.data.__class__.__name__ == 'Data1D':
 …
         return True
+    def set_accuracy(self,accuracy='Low'):
+        """
+            Set accuracy:  string
+    def set_accuracy(self, accuracy='Low'):
+        """
+        Set accuracy.
+        :param accuracy:  string
         """
         self.accuracy = accuracy
+    def set_smearer(self,smearer = True):
+        """
+            Set whether or not smearer will be used
+    def set_smearer(self, smearer=True):
+        """
+        Set whether or not smearer will be used
+        :param smearer: smear object
         """
         self.smearer = smearer
+    def set_data(self,data=None):
+        """
+            Set data:  1d arrays
+    def set_data(self, data=None):
+        """
+        Set data.
+        :param data: DataLoader.Data_info type
         """
         self.data = data
+    def set_model(self,model=None):
+        """
+            Set model
+    def set_model(self, model=None):
+        """
+        Set model.
+        :param model: sans.models instance
         """
         self.model = model
+    def set_index(self,index=None):
+        """
+            Set index: 1d arrays
+        """
+    def set_index(self, index=None):
+        """
+        Set index.
+        :param index: 1d arrays
+        """
         self.index = index
     def get_value(self):
         """
+            Over sampling of r_nbins times phi_nbins, calculate Gaussian weights, then find smeared intensity
+            # For the default values, this is equivalent (but by using numpy array
+            # the speed optimized by a factor of ten)to the following:
+            =====================================================================================
+            ## Remove the singular points if exists
+        Over sampling of r_nbins times phi_nbins, calculate Gaussian weights, then find smeared intensity
+        For the default values, this is equivalent (but by using numpy array
+        the speed optimized by a factor of ten)to the following: ::
+            Remove the singular points if exists
             self.dqx_data[self.dqx_data==0]=SIGMA_ZERO
             self.dqy_data[self.dqy_data==0]=SIGMA_ZERO
             for phi in range(0,4):
                 for r in range(0,5):
 …
                     r = r+0.25
                     dphi = phi*2.0*math.pi/4.0 + numpy.arctan(self.qy_data[index_model]/self.dqy_data[index_model]/self.qx_data[index_model]*/self.dqx_data[index_model])
                     dq = r*numpy.sqrt( self.dqx_data[index_model]*self.dqx_data[index_model] \
+                    dq = r*sqrt( self.dqx_data[index_model]*self.dqx_data[index_model] \
                         + self.dqy_data[index_model]*self.dqy_data[index_model] )
+                    #integrant of math.exp(-0.5*r*r) r dr at each bins : The integration may not need.
+                    weight_res[n] = math.exp(-0.5*((r-0.25)*(r-0.25)))-math.exp(-0.5*((r-0.25)*(r-0.25)))
+                    #if phi !=0 and r != 0:
+                    qx_res=numpy.append(qx_res,self.qx_data[index_model]+ dq*math.cos(dphi))
+                    qy_res=numpy.append(qy_res,self.qy_data[index_model]+ dq*math.sin(dphi))
+            ## Then compute I(qx_res,qy_res) and do weighted averaging.
+            =====================================================================================
+                    #integrant of exp(-0.5*r*r) r dr at each bins : The integration may not need.
+                    weight_res[n] = e^{(-0.5*((r-0.25)*(r-0.25)))}- e^{(-0.5*((r-0.25)*(r-0.25)))}
+                    #if phi != 0 and r != 0:
+                    qx_res = numpy.append(qx_res,self.qx_data[index_model]+ dq * cos(dphi))
+                    qy_res = numpy.append(qy_res,self.qy_data[index_model]+ dq * sin(dphi))
+        Then compute I(qx_res,qy_res) and do weighted averaging.
         """
         valid = self.get_data()

Note: See TracChangeset for help on using the changeset viewer.

SasView

Changeset 0997158f in sasview for DataLoader

Legend:

DataLoader/data_info.py

DataLoader/loader.py

DataLoader/manipulations.py

DataLoader/qsmearing.py

DataLoader/readers/IgorReader.py

DataLoader/readers/abs_reader.py

DataLoader/readers/ascii_reader.py

DataLoader/readers/associations.py

DataLoader/readers/cansas_reader.py

DataLoader/readers/danse_reader.py

DataLoader/readers/hfir1d_reader.py

DataLoader/readers/red2d_reader.py

DataLoader/readers/tiff_reader.py

DataLoader/smearing_2d.py

Download in other formats: