Diff [e3f1fed2bbde53b5b41f464ccc43303bd69bc8f5:43345ab66cde34ce38fa5c0a8d7c55f589895aaf] for / – SasView

check_packages.py

-                      r235f514
+                      r3e1f417
     for package_name, test_vals in win_required_package_list.items():
         try:
+            if package_name == "pywin":
+                import win32api
+                fixed_file_info = win32api.GetFileVersionInfo(win32api.__file__, '\\')
+                print("%s Version Installed: %s"% (package_name, fixed_file_info['FileVersionLS'] >> 16))
+            else:
+                i = __import__(test_vals['import_name'], fromlist=[''])
+                print("%s Version Installed: %s"% (package_name, getattr(i, test_vals['test'])))
+            i = __import__(test_vals['import_name'], fromlist=[''])
+            print("%s Version Installed: %s"% (package_name, getattr(i, test_vals['test'], "unknown")))
         except ImportError:
             print('%s NOT INSTALLED'% package_name)

docs/sphinx-docs/build_sphinx.py

-                      r01f1e17
+                      r4abc05d8
 #/sasview-local-trunk/docs/sphinx-docs/build_sphinx.py
 SASMODELS_SOURCE_PROLOG = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc")
 SASMODELS_SOURCE_GPU = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc", "ref", "gpu")
 SASMODELS_SOURCE_SESANS = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc", "ref", "sesans")
 SASMODELS_SOURCE_SESANSIMG = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc", "ref", "sesans", "sesans_img")
 SASMODELS_SOURCE_MAGNETISM = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc", "ref", "magnetism")
 SASMODELS_SOURCE_MAGIMG = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc", "ref", "magnetism", "mag_img")
 SASMODELS_SOURCE_REF_MODELS = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc", "ref", "models")
+SASMODELS_SOURCE_GPU = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc", "guide", "gpu")
+SASMODELS_SOURCE_SESANS = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc", "guide", "sesans")
+SASMODELS_SOURCE_SESANSIMG = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc", "guide", "sesans", "sesans_img")
+SASMODELS_SOURCE_MAGNETISM = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc", "guide", "magnetism")
+SASMODELS_SOURCE_MAGIMG = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc", "guide", "magnetism", "mag_img")
+SASMODELS_SOURCE_REF_MODELS = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc", "guide", "models")
 SASMODELS_SOURCE_MODELS = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc", "model")
 SASMODELS_SOURCE_IMG = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc", "model", "img")

run.py

rf36e01f	rf94a935
51	51	def import_package(modname, path):
52	52	"""Import a package into a particular point in the python namespace"""
	53	#logger.debug("Dynamicly importing: %s", path)
53	54	mod = imp.load_source(modname, abspath(joinpath(path, '__init__.py')))
54	55	sys.modules[modname] = mod

sasview/test/sesans_data/sphere2micron.ses

-                      r2a2b43a
+                      rd3bce8c
+DataFileTitle   "Polystyrene of Markus Strobl,  Full Sine, ++ only "
+Sample  "Polystyrene 2 um in 53% H2O, 47% D2O "
+Settings        "D1=D2=20x8 mm,Ds = 16x10 mm (WxH), GF1 =scanning, GF2 = 2.5 A. 2 um polystyrene in 53% H2O, 47% D2O; 8.55% contrast "
+Operator        CPD
+Date    do 10 jul 2014 16:37:30
+ScanType        sine one element scan
+Thickness [cm]  2.00E-01
+Q_zmax [\A^-1]  0.05
+Q_ymax [\A^-1]  0.05
+spin echo length [A]     Depolarisation [A-2 cm-1]       error depol [A-2 cm-1]          error SEL [A]   wavelength [A]          error wavelength [A]    polarisation    error pol
+.56  0.0041929       0.0036894       19.578  2.11    0.1055  1.0037  0.0032974
+    -0.0046571      0.0038185       78.2    2.11    0.1055  0.99586 0.003386
+.6  -0.017007       0.0038132       136.78  2.11    0.1055  0.98497 0.0033444
+.9  -0.033462       0.0035068       195.39  2.11    0.1055  0.97064 0.0030309
+.2  -0.047483       0.0038208       254.01  2.11    0.1055  0.9586  0.0032613
+.8  -0.070375       0.00376 312.59  2.11    0.1055  0.93926 0.0031446
+.2  -0.092217       0.0037927       371.16  2.11    0.1055  0.92117 0.0031108
+.5  -0.10238        0.004006        429.77  2.11    0.1055  0.91287 0.0032562
+.7  -0.12672        0.0038534       488.39  2.11    0.1055  0.8933  0.0030651
+   -0.1374 0.004243        546.98  2.11    0.1055  0.88484 0.003343
+   -0.16072        0.0045837       605.58  2.11    0.1055  0.86666 0.0035372
+   -0.16623        0.0045613       664.2   2.11    0.1055  0.86242 0.0035027
+   -0.18468        0.0044918       722.79  2.11    0.1055  0.84837 0.0033931
+   -0.19143        0.0048967       781.38  2.11    0.1055  0.84328 0.0036768
+   -0.20029        0.0045421       840.02  2.11    0.1055  0.83666 0.0033837
+   -0.19798        0.0046642       898.56  2.11    0.1055  0.83838 0.0034819
+   -0.21442        0.0047052       957.17  2.11    0.1055  0.82619 0.0034614
+   -0.20885        0.0044931       1015.8  2.11    0.1055  0.8303  0.0033218
+   -0.21393        0.0049186       1074.4  2.11    0.1055  0.82655 0.00362
+   -0.20685        0.004423        1133    2.11    0.1055  0.83179 0.0032758
+   -0.20802        0.0046979       1191.6  2.11    0.1055  0.83092 0.0034758
+   -0.19848        0.0045953       1250.2  2.11    0.1055  0.838   0.0034289
+   -0.21117        0.0044567       1308.8  2.11    0.1055  0.82859 0.0032881
+   -0.21283        0.004137        1367.4  2.11    0.1055  0.82736 0.0030477
+   -0.2042 0.0044587       1426    2.11    0.1055  0.83375 0.0033101
+   -0.2112 0.0042852       1484.6  2.11    0.1055  0.82857 0.0031615
+   -0.20319        0.0043483       1543.2  2.11    0.1055  0.8345  0.003231
+   -0.20752        0.0044297       1601.8  2.11    0.1055  0.83129 0.0032788
+   -0.20654        0.0043188       1660.4  2.11    0.1055  0.83201 0.0031995
+   -0.20126        0.0046375       1719    2.11    0.1055  0.83593 0.0034518
+   -0.20924        0.0042871       1777.6  2.11    0.1055  0.83001 0.0031684
+   -0.21323        0.0045471       1836.2  2.11    0.1055  0.82707 0.0033487
+   -0.21324        0.0045354       1894.7  2.11    0.1055  0.82706 0.00334
+   -0.19905        0.0044141       1953.4  2.11    0.1055  0.83758 0.003292
+   -0.1991 0.0047441       2012    2.11    0.1055  0.83754 0.003538
+   -0.20359        0.0050136       2070.5  2.11    0.1055  0.8342  0.003724
+   -0.21032        0.0049474       2129.1  2.11    0.1055  0.82922 0.0036529
+   -0.20689        0.0048203       2187.8  2.11    0.1055  0.83176 0.00357
+   -0.21075        0.0052337       2246.4  2.11    0.1055  0.8289  0.0038628
+   -0.19956        0.0047827       2304.9  2.11    0.1055  0.8372  0.0035653
+FileFormatVersion       1.0
+DataFileTitle           Polystyrene of Markus Strobl,  Full Sine, ++ only
+Sample                  Polystyrene 2 um in 53% H2O, 47% D2O
+Settings                D1=D2=20x8 mm,Ds = 16x10 mm (WxH), GF1 =scanning, GF2 = 2.5 A. 2 um polystyrene in 53% H2O, 47% D2O; 8.55% contrast
+Operator                CPD
+Date                    do 10 jul 2014 16:37:30
+ScanType                sine one element scan
+Thickness               2.00E-01
+Thickness_unit          cm
+Theta_zmax              0.0168
+Theta_zmax_unit         radians
+Theta_ymax              0.0168
+Theta_ymax_unit         radians
+Orientation             Z
+SpinEchoLength_unit     A
+Depolarisation_unit     A-2 cm-1
+Wavelength_unit         A
+BEGIN_DATA
+SpinEchoLength Depolarisation Depolarisation_error SpinEchoLength_error Wavelength Wavelength_error Polarisation  Polarisation_error
+.56 0.0041929 0.0036894 19.578 2.11 0.1055 1.0037 0.0032974
+-0.0046571 0.0038185 78.2 2.11 0.1055 0.99586 0.003386
+.6 -0.017007 0.0038132 136.78 2.11 0.1055 0.98497 0.0033444
+.9 -0.033462 0.0035068 195.39 2.11 0.1055 0.97064 0.0030309
+.2 -0.047483 0.0038208 254.01 2.11 0.1055 0.9586 0.0032613
+.8 -0.070375 0.00376 312.59 2.11 0.1055 0.93926 0.0031446
+.2 -0.092217 0.0037927 371.16 2.11 0.1055 0.92117 0.0031108
+.5 -0.10238 0.004006 429.77 2.11 0.1055 0.91287 0.0032562
+.7 -0.12672 0.0038534 488.39 2.11 0.1055 0.8933 0.0030651
+-0.1374 0.004243 546.98 2.11 0.1055 0.88484 0.003343
+-0.16072 0.0045837 605.58 2.11 0.1055 0.86666 0.0035372
+-0.16623 0.0045613 664.2 2.11 0.1055 0.86242 0.0035027
+-0.18468 0.0044918 722.79 2.11 0.1055 0.84837 0.0033931
+-0.19143 0.0048967 781.38 2.11 0.1055 0.84328 0.0036768
+-0.20029 0.0045421 840.02 2.11 0.1055 0.83666 0.0033837
+-0.19798 0.0046642 898.56 2.11 0.1055 0.83838 0.0034819
+-0.21442 0.0047052 957.17 2.11 0.1055 0.82619 0.0034614
+-0.20885 0.0044931 1015.8 2.11 0.1055 0.8303 0.0033218
+-0.21393 0.0049186 1074.4 2.11 0.1055 0.82655 0.00362
+-0.20685 0.004423 1133 2.11 0.1055 0.83179 0.0032758
+-0.20802 0.0046979 1191.6 2.11 0.1055 0.83092 0.0034758
+-0.19848 0.0045953 1250.2 2.11 0.1055 0.838 0.0034289
+-0.21117 0.0044567 1308.8 2.11 0.1055 0.82859 0.0032881
+-0.21283 0.004137 1367.4 2.11 0.1055 0.82736 0.0030477
+-0.2042 0.0044587 1426 2.11 0.1055 0.83375 0.0033101
+-0.2112 0.0042852 1484.6 2.11 0.1055 0.82857 0.0031615
+-0.20319 0.0043483 1543.2 2.11 0.1055 0.8345 0.003231
+-0.20752 0.0044297 1601.8 2.11 0.1055 0.83129 0.0032788
+-0.20654 0.0043188 1660.4 2.11 0.1055 0.83201 0.0031995
+-0.20126 0.0046375 1719 2.11 0.1055 0.83593 0.0034518
+-0.20924 0.0042871 1777.6 2.11 0.1055 0.83001 0.0031684
+-0.21323 0.0045471 1836.2 2.11 0.1055 0.82707 0.0033487
+-0.21324 0.0045354 1894.7 2.11 0.1055 0.82706 0.00334
+-0.19905 0.0044141 1953.4 2.11 0.1055 0.83758 0.003292
+-0.1991 0.0047441 2012 2.11 0.1055 0.83754 0.003538
+-0.20359 0.0050136 2070.5 2.11 0.1055 0.8342 0.003724
+-0.21032 0.0049474 2129.1 2.11 0.1055 0.82922 0.0036529
+-0.20689 0.0048203 2187.8 2.11 0.1055 0.83176 0.00357
+-0.21075 0.0052337 2246.4 2.11 0.1055 0.8289 0.0038628
+-0.19956 0.0047827 2304.9 2.11 0.1055 0.8372 0.0035653

src/sas/sascalc/data_util/nxsunit.py

-                      rb699768
+                      r8e9536f
     sld = { '10^-6 Angstrom^-2': 1e-6, 'Angstrom^-2': 1 }
     Q = { 'invA': 1, 'invAng': 1, 'invAngstroms': 1, '1/A': 1,
           '10^-3 Angstrom^-1': 1e-3, '1/cm': 1e-8,
+          '10^-3 Angstrom^-1': 1e-3, '1/cm': 1e-8, '1/m': 1e-10,
           'nm^-1': 0.1, '1/nm': 0.1, 'n_m^-1': 0.1 }
 …
     _check(1,Converter('n_m^-1')(10,'invA')) # 10 nm^-1 = 1 inv Angstroms
     _check(2,Converter('mm')(2000,'m')) # 2000 mm -> 2 m
+    _check(2.011e10,Converter('1/A')(2.011,"1/m")) # 2.011 1/A -> 2.011 * 10^10 1/m
     _check(0.003,Converter('microseconds')(3,units='ms')) # 3 us -> 0.003 ms
     _check(45,Converter('nanokelvin')(45))  # 45 nK -> 45 nK

src/sas/sascalc/data_util/qsmearing.py

                       r235f514
             raise ValueError('one or more of your dx values are negative, please check the data file!')
+    if _found_sesans == True:
+        #Pre-compute the Hankel matrix (H)
+        qmax, qunits = data.sample.zacceptance
+    if _found_sesans:
+        # Pre-compute the Hankel matrix (H)
         SElength = Converter(data._xunit)(data.x, "A")
+        zaccept = Converter(qunits)(qmax, "1/A"),
+        theta_max = Converter("radians")(data.sample.zacceptance)[0]
+        q_max = 2 * np.pi / np.max(data.source.wavelength) * np.sin(theta_max)
+        zaccept = Converter("1/A")(q_max, "1/" + data.source.wavelength_unit),
         Rmax = 10000000
+        hankel = SesansTransform(data.x, SElength, zaccept, Rmax)
+        hankel = SesansTransform(data.x, SElength,
+                                 data.source.wavelength,
+                                 zaccept, Rmax)
         # Then return the actual transform, as if it were a smearing function
         return PySmear(hankel, model, offset=0)

src/sas/sascalc/dataloader/manipulations.py

-                      r7432acb
+                      r324e0bf
+from __future__ import division
 """
 Data manipulations for 2D data sets.
 Using the meta data information, various types of averaging
 are performed in Q-space
+To test this module use:
+```
+cd test
+PYTHONPATH=../src/ python2  -m sasdataloader.test.utest_averaging DataInfoTests.test_sectorphi_quarter
+```
 """
 #####################################################################
 #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
 ######################################################################
+#TODO: copy the meta data from the 2D object to the resulting 1D object
+# TODO: copy the meta data from the 2D object to the resulting 1D object
 import math
+import numpy
+import numpy as np
+import sys
 #from data_info import plottable_2D
 …
     return phi_out
-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
-    """
-    if data2d.data is None or data2d.x_bins is None or data2d.y_bins is None:
-        raise ValueError, "Can't convert this data: data=None..."
-    new_x = numpy.tile(data2d.x_bins, (len(data2d.y_bins), 1))
-    new_y = numpy.tile(data2d.y_bins, (len(data2d.x_bins), 1))
-    new_y = new_y.swapaxes(0, 1)
-    new_data = data2d.data.flatten()
-    qx_data = new_x.flatten()
-    qy_data = new_y.flatten()
-    q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data)
-    if data2d.err_data is None or numpy.any(data2d.err_data <= 0):
-        new_err_data = numpy.sqrt(numpy.abs(new_data))
-    else:
-        new_err_data = data2d.err_data.flatten()
-    mask = numpy.ones(len(new_data), dtype=bool)
-    #TODO: make sense of the following two lines...
-    #from sas.sascalc.dataloader.data_info import Data2D
-    #output = Data2D()
-    output = data2d
-    output.data = new_data
-    output.err_data = new_err_data
-    output.qx_data = qx_data
-    output.qy_data = qy_data
-    output.q_data = q_data
-    output.mask = mask
-    return output
-class _Slab(object):
-    """
-    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):
-        # Minimum Qx value [A-1]
-        self.x_min = x_min
-        # Maximum Qx value [A-1]
-        self.x_max = x_max
-        # Minimum Qy value [A-1]
-        self.y_min = y_min
-        # Maximum Qy value [A-1]
-        self.y_max = y_max
-        # Bin width (step size) [A-1]
-        self.bin_width = bin_width
-        # If True, I(|Q|) will be return, otherwise,
-        # negative q-values are allowed
-        self.fold = False
-    def __call__(self, data2D):
-        return NotImplemented
-    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
-        """
-        if len(data2D.detector) > 1:
-            msg = "_Slab._avg: invalid number of "
-            msg += " detectors: %g" % len(data2D.detector)
-            raise RuntimeError, msg
-        # Get data
-        data = data2D.data[numpy.isfinite(data2D.data)]
-        err_data = data2D.err_data[numpy.isfinite(data2D.data)]
-        qx_data = data2D.qx_data[numpy.isfinite(data2D.data)]
-        qy_data = data2D.qy_data[numpy.isfinite(data2D.data)]
-        # Build array of Q intervals
-        if maj == 'x':
-            if self.fold:
-                x_min = 0
-            else:
-                x_min = self.x_min
-            nbins = int(math.ceil((self.x_max - x_min) / self.bin_width))
-        elif maj == 'y':
-            if self.fold:
-                y_min = 0
-            else:
-                y_min = self.y_min
-            nbins = int(math.ceil((self.y_max - y_min) / self.bin_width))
-        else:
-            raise RuntimeError, "_Slab._avg: unrecognized axis %s" % str(maj)
-        x = numpy.zeros(nbins)
-        y = numpy.zeros(nbins)
-        err_y = numpy.zeros(nbins)
-        y_counts = numpy.zeros(nbins)
-        # Average pixelsize in q space
-        for npts in range(len(data)):
-            # default frac
-            frac_x = 0
-            frac_y = 0
-            # get ROI
-            if self.x_min <= qx_data[npts] and self.x_max > qx_data[npts]:
-                frac_x = 1
-            if self.y_min <= qy_data[npts] and self.y_max > qy_data[npts]:
-                frac_y = 1
-            frac = frac_x * frac_y
-            if frac == 0:
-                continue
-            # binning: find axis of q
-            if maj == 'x':
-                q_value = qx_data[npts]
-                min_value = x_min
-            if maj == 'y':
-                q_value = qy_data[npts]
-                min_value = y_min
-            if self.fold and q_value < 0:
-                q_value = -q_value
-            # bin
-            i_q = int(math.ceil((q_value - min_value) / self.bin_width)) - 1
-            # skip outside of max bins
-            if i_q < 0 or i_q >= nbins:
-                continue
-            #TODO: find better definition of x[i_q] based on q_data
-            # min_value + (i_q + 1) * self.bin_width / 2.0
-            x[i_q] += frac * q_value
-            y[i_q] += frac * data[npts]
-            if err_data is None or err_data[npts] == 0.0:
-                if data[npts] < 0:
-                    data[npts] = -data[npts]
-                err_y[i_q] += frac * frac * data[npts]
-            else:
-                err_y[i_q] += frac * frac * err_data[npts] * err_data[npts]
-            y_counts[i_q] += frac
-        # Average the sums
-        for n in range(nbins):
-            err_y[n] = math.sqrt(err_y[n])
-        err_y = err_y / y_counts
-        y = y / y_counts
-        x = x / y_counts
-        idx = (numpy.isfinite(y) & numpy.isfinite(x))
-        if not idx.any():
-            msg = "Average Error: No points inside ROI to average..."
-            raise ValueError, msg
-        return Data1D(x=x[idx], y=y[idx], dy=err_y[idx])
-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(Qx) for a region of interest
-        :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.
-    """
-    def __init__(self, x_min=0.0, x_max=0.0, y_min=0.0, y_max=0.0):
-        # Minimum Qx value [A-1]
-        self.x_min = x_min
-        # Maximum Qx value [A-1]
-        self.x_max = x_max
-        # Minimum Qy value [A-1]
-        self.y_min = y_min
-        # Maximum Qy value [A-1]
-        self.y_max = y_max
-    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,
-            number of points summed
-        """
-        y, err_y, y_counts = self._sum(data2D)
-        # Average the sums
-        counts = 0 if y_counts == 0 else y
-        error = 0 if y_counts == 0 else math.sqrt(err_y)
-        # Added y_counts to return, SMK & PDB, 04/03/2013
-        return counts, error, y_counts
-    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
-        """
-        if len(data2D.detector) > 1:
-            msg = "Circular averaging: invalid number "
-            msg += "of detectors: %g" % len(data2D.detector)
-            raise RuntimeError, msg
-        # Get data
-        data = data2D.data[numpy.isfinite(data2D.data)]
-        err_data = data2D.err_data[numpy.isfinite(data2D.data)]
-        qx_data = data2D.qx_data[numpy.isfinite(data2D.data)]
-        qy_data = data2D.qy_data[numpy.isfinite(data2D.data)]
-        y = 0.0
-        err_y = 0.0
-        y_counts = 0.0
-        # Average pixelsize in q space
-        for npts in range(len(data)):
-            # default frac
-            frac_x = 0
-            frac_y = 0
-            # get min and max at each points
-            qx = qx_data[npts]
-            qy = qy_data[npts]
-            # get the ROI
-            if self.x_min <= qx and self.x_max > qx:
-                frac_x = 1
-            if self.y_min <= qy and self.y_max > qy:
-                frac_y = 1
-            #Find the fraction along each directions
-            frac = frac_x * frac_y
-            if frac == 0:
-                continue
-            y += frac * data[npts]
-            if err_data is None or err_data[npts] == 0.0:
-                if data[npts] < 0:
-                    data[npts] = -data[npts]
-                err_y += frac * frac * data[npts]
-            else:
-                err_y += frac * frac * err_data[npts] * err_data[npts]
-            y_counts += frac
-        return y, err_y, y_counts
-class Boxavg(Boxsum):
-    """
-    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):
-        super(Boxavg, self).__init__(x_min=x_min, x_max=x_max,
-                                     y_min=y_min, y_max=y_max)
-    def __call__(self, data2D):
-        """
-        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)
-        # Average the sums
-        counts = 0 if y_counts == 0 else y / y_counts
-        error = 0 if y_counts == 0 else math.sqrt(err_y) / y_counts
-        return counts, error
 def get_pixel_fraction_square(x, xmin, xmax):
     """
 …
         return 1.0
+class CircularAverage(object):
+    """
+    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):
+        # Minimum radius included in the average [A-1]
+        self.r_min = r_min
+        # Maximum radius included in the average [A-1]
+        self.r_max = r_max
+        # Bin width (step size) [A-1]
+        self.bin_width = bin_width
+    def __call__(self, data2D, ismask=False):
+        """
+        Perform circular averaging on the data
+        :param data2D: Data2D object
+        :return: Data1D object
+        """
+        # Get data W/ finite values
+        data = data2D.data[numpy.isfinite(data2D.data)]
+        q_data = data2D.q_data[numpy.isfinite(data2D.data)]
+        err_data = data2D.err_data[numpy.isfinite(data2D.data)]
+        mask_data = data2D.mask[numpy.isfinite(data2D.data)]
+        dq_data = None
+        # Get the dq for resolution averaging
+        if data2D.dqx_data is not None and data2D.dqy_data is not None:
+            # The pinholes and det. pix contribution present
+            # in both direction of the 2D which must be subtracted when
+            # converting to 1D: dq_overlap should calculated ideally at
+            # q = 0. Note This method works on only pinhole geometry.
+            # Extrapolate dqx(r) and dqy(phi) at q = 0, and take an average.
+            z_max = max(data2D.q_data)
+            z_min = min(data2D.q_data)
+            x_max = data2D.dqx_data[data2D.q_data[z_max]]
+            x_min = data2D.dqx_data[data2D.q_data[z_min]]
+            y_max = data2D.dqy_data[data2D.q_data[z_max]]
+            y_min = data2D.dqy_data[data2D.q_data[z_min]]
+            # Find qdx at q = 0
+            dq_overlap_x = (x_min * z_max - x_max * z_min) / (z_max - z_min)
+            # when extrapolation goes wrong
+            if dq_overlap_x > min(data2D.dqx_data):
+                dq_overlap_x = min(data2D.dqx_data)
+            dq_overlap_x *= dq_overlap_x
+            # Find qdx at q = 0
+            dq_overlap_y = (y_min * z_max - y_max * z_min) / (z_max - z_min)
+            # when extrapolation goes wrong
+            if dq_overlap_y > min(data2D.dqy_data):
+                dq_overlap_y = min(data2D.dqy_data)
+            # get dq at q=0.
+            dq_overlap_y *= dq_overlap_y
+            dq_overlap = numpy.sqrt((dq_overlap_x + dq_overlap_y) / 2.0)
+            # Final protection of dq
+            if dq_overlap < 0:
+                dq_overlap = y_min
+            dqx_data = data2D.dqx_data[numpy.isfinite(data2D.data)]
+            dqy_data = data2D.dqy_data[numpy.isfinite(data2D.data)] - dq_overlap
+            # def; dqx_data = dq_r dqy_data = dq_phi
+            # Convert dq 2D to 1D here
+            dqx = dqx_data * dqx_data
+            dqy = dqy_data * dqy_data
+            dq_data = numpy.add(dqx, dqy)
+            dq_data = numpy.sqrt(dq_data)
+        #q_data_max = numpy.max(q_data)
+        if len(data2D.q_data) is None:
+            msg = "Circular averaging: invalid q_data: %g" % data2D.q_data
+            raise RuntimeError, msg
+        # Build array of Q intervals
+        nbins = int(math.ceil((self.r_max - self.r_min) / self.bin_width))
+        x = numpy.zeros(nbins)
+        y = numpy.zeros(nbins)
+        err_y = numpy.zeros(nbins)
+        err_x = numpy.zeros(nbins)
+        y_counts = numpy.zeros(nbins)
+        for npt in range(len(data)):
+            if ismask and not mask_data[npt]:
+                continue
+            frac = 0
+            # q-value at the pixel (j,i)
+            q_value = q_data[npt]
+            data_n = data[npt]
+            ## No need to calculate the frac when all data are within range
+            if self.r_min >= self.r_max:
+                raise ValueError, "Limit Error: min > max"
+            if self.r_min <= q_value and q_value <= self.r_max:
+                frac = 1
+            if frac == 0:
+                continue
+            i_q = int(math.floor((q_value - self.r_min) / self.bin_width))
+            # Take care of the edge case at phi = 2pi.
+            if i_q == nbins:
+                i_q = nbins - 1
+            y[i_q] += frac * data_n
+            # Take dqs from data to get the q_average
+            x[i_q] += frac * q_value
+            if err_data is None or err_data[npt] == 0.0:
+                if data_n < 0:
+                    data_n = -data_n
+                err_y[i_q] += frac * frac * data_n
+            else:
+                err_y[i_q] += frac * frac * err_data[npt] * err_data[npt]
+            if dq_data is not None:
+                # To be consistent with dq calculation in 1d reduction,
+                # we need just the averages (not quadratures) because
+                # it should not depend on the number of the q points
+                # in the qr bins.
+                err_x[i_q] += frac * dq_data[npt]
+            else:
+                err_x = None
+            y_counts[i_q] += frac
+        # Average the sums
+        for n in range(nbins):
+            if err_y[n] < 0:
+                err_y[n] = -err_y[n]
+            err_y[n] = math.sqrt(err_y[n])
+            #if err_x is not None:
+            #    err_x[n] = math.sqrt(err_x[n])
+        err_y = err_y / y_counts
+        err_y[err_y == 0] = numpy.average(err_y)
+        y = y / y_counts
+        x = x / y_counts
+        idx = (numpy.isfinite(y)) & (numpy.isfinite(x))
+        if err_x is not None:
+            d_x = err_x[idx] / y_counts[idx]
+        else:
+            d_x = None
+        if not idx.any():
+            msg = "Average Error: No points inside ROI to average..."
+            raise ValueError, msg
+        return Data1D(x=x[idx], y=y[idx], dy=err_y[idx], dx=d_x)
+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
+    """
+    #Todo: remove center.
+    def __init__(self, r_min=0, r_max=0, center_x=0, center_y=0, nbins=36):
+        # Minimum radius
+        self.r_min = r_min
+        # Maximum radius
+        self.r_max = r_max
+        # Center of the ring in x
+        self.center_x = center_x
+        # Center of the ring in y
+        self.center_y = center_y
+        # Number of angular bins
+        self.nbins_phi = nbins
+    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
+        """
+        if data2D.__class__.__name__ not in ["Data2D", "plottable_2D"]:
+            raise RuntimeError, "Ring averaging only take plottable_2D objects"
+        Pi = math.pi
+        # Get data
+        data = data2D.data[numpy.isfinite(data2D.data)]
+        q_data = data2D.q_data[numpy.isfinite(data2D.data)]
+        err_data = data2D.err_data[numpy.isfinite(data2D.data)]
+        qx_data = data2D.qx_data[numpy.isfinite(data2D.data)]
+        qy_data = data2D.qy_data[numpy.isfinite(data2D.data)]
+        # Set space for 1d outputs
+        phi_bins = numpy.zeros(self.nbins_phi)
+        phi_counts = numpy.zeros(self.nbins_phi)
+        phi_values = numpy.zeros(self.nbins_phi)
+        phi_err = numpy.zeros(self.nbins_phi)
+        # Shift to apply to calculated phi values in order
+        # to center first bin at zero
+        phi_shift = Pi / self.nbins_phi
+        for npt in range(len(data)):
+            frac = 0
+            # q-value at the point (npt)
+            q_value = q_data[npt]
+            data_n = data[npt]
+            # phi-value at the point (npt)
+            phi_value = math.atan2(qy_data[npt], qx_data[npt]) + Pi
+            if self.r_min <= q_value and q_value <= self.r_max:
+                frac = 1
+            if frac == 0:
+                continue
+            # binning
+            i_phi = int(math.floor((self.nbins_phi) * \
+                                   (phi_value + phi_shift) / (2 * Pi)))
+            # Take care of the edge case at phi = 2pi.
+            if i_phi >= self.nbins_phi:
+                i_phi = 0
+            phi_bins[i_phi] += frac * data[npt]
+            if err_data is None or err_data[npt] == 0.0:
+                if data_n < 0:
+                    data_n = -data_n
+                phi_err[i_phi] += frac * frac * math.fabs(data_n)
+            else:
+                phi_err[i_phi] += frac * frac * err_data[npt] * err_data[npt]
+            phi_counts[i_phi] += frac
+        for i in range(self.nbins_phi):
+            phi_bins[i] = phi_bins[i] / phi_counts[i]
+            phi_err[i] = math.sqrt(phi_err[i]) / phi_counts[i]
+            phi_values[i] = 2.0 * math.pi / self.nbins_phi * (1.0 * i)
+        idx = (numpy.isfinite(phi_bins))
+        if not idx.any():
+            msg = "Average Error: No points inside ROI to average..."
+            raise ValueError, msg
+        #elif len(phi_bins[idx])!= self.nbins_phi:
+        #    print "resulted",self.nbins_phi- len(phi_bins[idx])
+        #,"empty bin(s) due to tight binning..."
+        return Data1D(x=phi_values[idx], y=phi_bins[idx], dy=phi_err[idx])
+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
+        +-----------+--------+    <--- 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
+    """
+    if q_1 > q_0:
+        if q > q_0 and q <= q_1:
+            return (q - q_0) / (q_1 - q_0)
+    else:
+        if q > q_1 and q <= q_0:
+            return (q - q_1) / (q_0 - q_1)
+    return None
 def get_pixel_fraction(qmax, q_00, q_01, q_10, q_11):
 …
     return frac_max
+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
+        +-----------+--------+    <--- 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
+    """
+    if q_1 > q_0:
+        if q > q_0 and q <= q_1:
+            return (q - q_0) / (q_1 - q_0)
+def get_dq_data(data2D):
+    '''
+    Get the dq for resolution averaging
+    The pinholes and det. pix contribution present
+    in both direction of the 2D which must be subtracted when
+    converting to 1D: dq_overlap should calculated ideally at
+    q = 0. Note This method works on only pinhole geometry.
+    Extrapolate dqx(r) and dqy(phi) at q = 0, and take an average.
+    '''
+    z_max = max(data2D.q_data)
+    z_min = min(data2D.q_data)
+    dqx_at_z_max = data2D.dqx_data[np.argmax(data2D.q_data)]
+    dqx_at_z_min = data2D.dqx_data[np.argmin(data2D.q_data)]
+    dqy_at_z_max = data2D.dqy_data[np.argmax(data2D.q_data)]
+    dqy_at_z_min = data2D.dqy_data[np.argmin(data2D.q_data)]
+    # Find qdx at q = 0
+    dq_overlap_x = (dqx_at_z_min * z_max - dqx_at_z_max * z_min) / (z_max - z_min)
+    # when extrapolation goes wrong
+    if dq_overlap_x > min(data2D.dqx_data):
+        dq_overlap_x = min(data2D.dqx_data)
+    dq_overlap_x *= dq_overlap_x
+    # Find qdx at q = 0
+    dq_overlap_y = (dqy_at_z_min * z_max - dqy_at_z_max * z_min) / (z_max - z_min)
+    # when extrapolation goes wrong
+    if dq_overlap_y > min(data2D.dqy_data):
+        dq_overlap_y = min(data2D.dqy_data)
+    # get dq at q=0.
+    dq_overlap_y *= dq_overlap_y
+    dq_overlap = np.sqrt((dq_overlap_x + dq_overlap_y) / 2.0)
+    # Final protection of dq
+    if dq_overlap < 0:
+        dq_overlap = dqy_at_z_min
+    dqx_data = data2D.dqx_data[np.isfinite(data2D.data)]
+    dqy_data = data2D.dqy_data[np.isfinite(
+        data2D.data)] - dq_overlap
+    # def; dqx_data = dq_r dqy_data = dq_phi
+    # Convert dq 2D to 1D here
+    dq_data = np.sqrt(dqx_data**2 + dqx_data**2)
+    return dq_data
+################################################################################
+def reader2D_converter(data2d=None):
+    """
+    convert old 2d format opened by IhorReader or danse_reader
+    to new Data2D format
+    This is mainly used by the Readers
+    :param data2d: 2d array of Data2D object
+    :return: 1d arrays of Data2D object
+    """
+    if data2d.data is None or data2d.x_bins is None or data2d.y_bins is None:
+        raise ValueError("Can't convert this data: data=None...")
+    new_x = np.tile(data2d.x_bins, (len(data2d.y_bins), 1))
+    new_y = np.tile(data2d.y_bins, (len(data2d.x_bins), 1))
+    new_y = new_y.swapaxes(0, 1)
+    new_data = data2d.data.flatten()
+    qx_data = new_x.flatten()
+    qy_data = new_y.flatten()
+    q_data = np.sqrt(qx_data * qx_data + qy_data * qy_data)
+    if data2d.err_data is None or np.any(data2d.err_data <= 0):
+        new_err_data = np.sqrt(np.abs(new_data))
     else:
+        if q > q_1 and q <= q_0:
+            return (q - q_1) / (q_0 - q_1)
+    return None
+        new_err_data = data2d.err_data.flatten()
+    mask = np.ones(len(new_data), dtype=bool)
+    # TODO: make sense of the following two lines...
+    #from sas.sascalc.dataloader.data_info import Data2D
+    #output = Data2D()
+    output = data2d
+    output.data = new_data
+    output.err_data = new_err_data
+    output.qx_data = qx_data
+    output.qy_data = qy_data
+    output.q_data = q_data
+    output.mask = mask
+    return output
+################################################################################
+class Binning(object):
+    '''
+    This class just creates a binning object
+    either linear or log
+    '''
+    def __init__(self, min_value, max_value, n_bins, base=None):
+        '''
+        if base is None: Linear binning
+        '''
+        self.min = min_value if min_value > 0 else 0.0001
+        self.max = max_value
+        self.n_bins = n_bins
+        self.base = base
+    def get_bin_index(self, value):
+        '''
+        The general formula logarithm binning is:
+        bin = floor(N * (log(x) - log(min)) / (log(max) - log(min)))
+        '''
+        if self.base:
+            temp_x = self.n_bins * (math.log(value, self.base) - math.log(self.min, self.base))
+            temp_y = math.log(self.max, self.base) - math.log(self.min, self.base)
+        else:
+            temp_x = self.n_bins * (value - self.min)
+            temp_y = self.max - self.min
+        # Bin index calulation
+        return int(math.floor(temp_x / temp_y))
+################################################################################
+class _Slab(object):
+    """
+    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):
+        # Minimum Qx value [A-1]
+        self.x_min = x_min
+        # Maximum Qx value [A-1]
+        self.x_max = x_max
+        # Minimum Qy value [A-1]
+        self.y_min = y_min
+        # Maximum Qy value [A-1]
+        self.y_max = y_max
+        # Bin width (step size) [A-1]
+        self.bin_width = bin_width
+        # If True, I(|Q|) will be return, otherwise,
+        # negative q-values are allowed
+        self.fold = False
+    def __call__(self, data2D):
+        return NotImplemented
+    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
+        """
+        if len(data2D.detector) > 1:
+            msg = "_Slab._avg: invalid number of "
+            msg += " detectors: %g" % len(data2D.detector)
+            raise RuntimeError(msg)
+        # Get data
+        data = data2D.data[np.isfinite(data2D.data)]
+        err_data = data2D.err_data[np.isfinite(data2D.data)]
+        qx_data = data2D.qx_data[np.isfinite(data2D.data)]
+        qy_data = data2D.qy_data[np.isfinite(data2D.data)]
+        # Build array of Q intervals
+        if maj == 'x':
+            if self.fold:
+                x_min = 0
+            else:
+                x_min = self.x_min
+            nbins = int(math.ceil((self.x_max - x_min) / self.bin_width))
+        elif maj == 'y':
+            if self.fold:
+                y_min = 0
+            else:
+                y_min = self.y_min
+            nbins = int(math.ceil((self.y_max - y_min) / self.bin_width))
+        else:
+            raise RuntimeError("_Slab._avg: unrecognized axis %s" % str(maj))
+        x = np.zeros(nbins)
+        y = np.zeros(nbins)
+        err_y = np.zeros(nbins)
+        y_counts = np.zeros(nbins)
+        # Average pixelsize in q space
+        for npts in range(len(data)):
+            # default frac
+            frac_x = 0
+            frac_y = 0
+            # get ROI
+            if self.x_min <= qx_data[npts] and self.x_max > qx_data[npts]:
+                frac_x = 1
+            if self.y_min <= qy_data[npts] and self.y_max > qy_data[npts]:
+                frac_y = 1
+            frac = frac_x * frac_y
+            if frac == 0:
+                continue
+            # binning: find axis of q
+            if maj == 'x':
+                q_value = qx_data[npts]
+                min_value = x_min
+            if maj == 'y':
+                q_value = qy_data[npts]
+                min_value = y_min
+            if self.fold and q_value < 0:
+                q_value = -q_value
+            # bin
+            i_q = int(math.ceil((q_value - min_value) / self.bin_width)) - 1
+            # skip outside of max bins
+            if i_q < 0 or i_q >= nbins:
+                continue
+            # TODO: find better definition of x[i_q] based on q_data
+            # min_value + (i_q + 1) * self.bin_width / 2.0
+            x[i_q] += frac * q_value
+            y[i_q] += frac * data[npts]
+            if err_data is None or err_data[npts] == 0.0:
+                if data[npts] < 0:
+                    data[npts] = -data[npts]
+                err_y[i_q] += frac * frac * data[npts]
+            else:
+                err_y[i_q] += frac * frac * err_data[npts] * err_data[npts]
+            y_counts[i_q] += frac
+        # Average the sums
+        for n in range(nbins):
+            err_y[n] = math.sqrt(err_y[n])
+        err_y = err_y / y_counts
+        y = y / y_counts
+        x = x / y_counts
+        idx = (np.isfinite(y) & np.isfinite(x))
+        if not idx.any():
+            msg = "Average Error: No points inside ROI to average..."
+            raise ValueError(msg)
+        return Data1D(x=x[idx], y=y[idx], dy=err_y[idx])
+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(Qx) for a region of interest
+        :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.
+    """
+    def __init__(self, x_min=0.0, x_max=0.0, y_min=0.0, y_max=0.0):
+        # Minimum Qx value [A-1]
+        self.x_min = x_min
+        # Maximum Qx value [A-1]
+        self.x_max = x_max
+        # Minimum Qy value [A-1]
+        self.y_min = y_min
+        # Maximum Qy value [A-1]
+        self.y_max = y_max
+    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,
+            number of points summed
+        """
+        y, err_y, y_counts = self._sum(data2D)
+        # Average the sums
+        counts = 0 if y_counts == 0 else y
+        error = 0 if y_counts == 0 else math.sqrt(err_y)
+        # Added y_counts to return, SMK & PDB, 04/03/2013
+        return counts, error, y_counts
+    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
+        """
+        if len(data2D.detector) > 1:
+            msg = "Circular averaging: invalid number "
+            msg += "of detectors: %g" % len(data2D.detector)
+            raise RuntimeError(msg)
+        # Get data
+        data = data2D.data[np.isfinite(data2D.data)]
+        err_data = data2D.err_data[np.isfinite(data2D.data)]
+        qx_data = data2D.qx_data[np.isfinite(data2D.data)]
+        qy_data = data2D.qy_data[np.isfinite(data2D.data)]
+        y = 0.0
+        err_y = 0.0
+        y_counts = 0.0
+        # Average pixelsize in q space
+        for npts in range(len(data)):
+            # default frac
+            frac_x = 0
+            frac_y = 0
+            # get min and max at each points
+            qx = qx_data[npts]
+            qy = qy_data[npts]
+            # get the ROI
+            if self.x_min <= qx and self.x_max > qx:
+                frac_x = 1
+            if self.y_min <= qy and self.y_max > qy:
+                frac_y = 1
+            # Find the fraction along each directions
+            frac = frac_x * frac_y
+            if frac == 0:
+                continue
+            y += frac * data[npts]
+            if err_data is None or err_data[npts] == 0.0:
+                if data[npts] < 0:
+                    data[npts] = -data[npts]
+                err_y += frac * frac * data[npts]
+            else:
+                err_y += frac * frac * err_data[npts] * err_data[npts]
+            y_counts += frac
+        return y, err_y, y_counts
+class Boxavg(Boxsum):
+    """
+    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):
+        super(Boxavg, self).__init__(x_min=x_min, x_max=x_max,
+                                     y_min=y_min, y_max=y_max)
+    def __call__(self, data2D):
+        """
+        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)
+        # Average the sums
+        counts = 0 if y_counts == 0 else y / y_counts
+        error = 0 if y_counts == 0 else math.sqrt(err_y) / y_counts
+        return counts, error
+################################################################################
+class CircularAverage(object):
+    """
+    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):
+        # Minimum radius included in the average [A-1]
+        self.r_min = r_min
+        # Maximum radius included in the average [A-1]
+        self.r_max = r_max
+        # Bin width (step size) [A-1]
+        self.bin_width = bin_width
+    def __call__(self, data2D, ismask=False):
+        """
+        Perform circular averaging on the data
+        :param data2D: Data2D object
+        :return: Data1D object
+        """
+        # Get data W/ finite values
+        data = data2D.data[np.isfinite(data2D.data)]
+        q_data = data2D.q_data[np.isfinite(data2D.data)]
+        err_data = data2D.err_data[np.isfinite(data2D.data)]
+        mask_data = data2D.mask[np.isfinite(data2D.data)]
+        dq_data = None
+        if data2D.dqx_data is not None and data2D.dqy_data is not None:
+            dq_data = get_dq_data(data2D)
+        if len(q_data) == 0:
+            msg = "Circular averaging: invalid q_data: %g" % data2D.q_data
+            raise RuntimeError(msg)
+        # Build array of Q intervals
+        nbins = int(math.ceil((self.r_max - self.r_min) / self.bin_width))
+        x = np.zeros(nbins)
+        y = np.zeros(nbins)
+        err_y = np.zeros(nbins)
+        err_x = np.zeros(nbins)
+        y_counts = np.zeros(nbins)
+        for npt in range(len(data)):
+            if ismask and not mask_data[npt]:
+                continue
+            frac = 0
+            # q-value at the pixel (j,i)
+            q_value = q_data[npt]
+            data_n = data[npt]
+            # No need to calculate the frac when all data are within range
+            if self.r_min >= self.r_max:
+                raise ValueError("Limit Error: min > max")
+            if self.r_min <= q_value and q_value <= self.r_max:
+                frac = 1
+            if frac == 0:
+                continue
+            i_q = int(math.floor((q_value - self.r_min) / self.bin_width))
+            # Take care of the edge case at phi = 2pi.
+            if i_q == nbins:
+                i_q = nbins - 1
+            y[i_q] += frac * data_n
+            # Take dqs from data to get the q_average
+            x[i_q] += frac * q_value
+            if err_data is None or err_data[npt] == 0.0:
+                if data_n < 0:
+                    data_n = -data_n
+                err_y[i_q] += frac * frac * data_n
+            else:
+                err_y[i_q] += frac * frac * err_data[npt] * err_data[npt]
+            if dq_data is not None:
+                # To be consistent with dq calculation in 1d reduction,
+                # we need just the averages (not quadratures) because
+                # it should not depend on the number of the q points
+                # in the qr bins.
+                err_x[i_q] += frac * dq_data[npt]
+            else:
+                err_x = None
+            y_counts[i_q] += frac
+        # Average the sums
+        for n in range(nbins):
+            if err_y[n] < 0:
+                err_y[n] = -err_y[n]
+            err_y[n] = math.sqrt(err_y[n])
+            # if err_x is not None:
+            #    err_x[n] = math.sqrt(err_x[n])
+        err_y = err_y / y_counts
+        err_y[err_y == 0] = np.average(err_y)
+        y = y / y_counts
+        x = x / y_counts
+        idx = (np.isfinite(y)) & (np.isfinite(x))
+        if err_x is not None:
+            d_x = err_x[idx] / y_counts[idx]
+        else:
+            d_x = None
+        if not idx.any():
+            msg = "Average Error: No points inside ROI to average..."
+            raise ValueError(msg)
+        return Data1D(x=x[idx], y=y[idx], dy=err_y[idx], dx=d_x)
+################################################################################
+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
+    """
+    # Todo: remove center.
+    def __init__(self, r_min=0, r_max=0, center_x=0, center_y=0, nbins=36):
+        # Minimum radius
+        self.r_min = r_min
+        # Maximum radius
+        self.r_max = r_max
+        # Center of the ring in x
+        self.center_x = center_x
+        # Center of the ring in y
+        self.center_y = center_y
+        # Number of angular bins
+        self.nbins_phi = nbins
+    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
+        """
+        if data2D.__class__.__name__ not in ["Data2D", "plottable_2D"]:
+            raise RuntimeError("Ring averaging only take plottable_2D objects")
+        Pi = math.pi
+        # Get data
+        data = data2D.data[np.isfinite(data2D.data)]
+        q_data = data2D.q_data[np.isfinite(data2D.data)]
+        err_data = data2D.err_data[np.isfinite(data2D.data)]
+        qx_data = data2D.qx_data[np.isfinite(data2D.data)]
+        qy_data = data2D.qy_data[np.isfinite(data2D.data)]
+        # Set space for 1d outputs
+        phi_bins = np.zeros(self.nbins_phi)
+        phi_counts = np.zeros(self.nbins_phi)
+        phi_values = np.zeros(self.nbins_phi)
+        phi_err = np.zeros(self.nbins_phi)
+        # Shift to apply to calculated phi values in order
+        # to center first bin at zero
+        phi_shift = Pi / self.nbins_phi
+        for npt in range(len(data)):
+            frac = 0
+            # q-value at the point (npt)
+            q_value = q_data[npt]
+            data_n = data[npt]
+            # phi-value at the point (npt)
+            phi_value = math.atan2(qy_data[npt], qx_data[npt]) + Pi
+            if self.r_min <= q_value and q_value <= self.r_max:
+                frac = 1
+            if frac == 0:
+                continue
+            # binning
+            i_phi = int(math.floor((self.nbins_phi) *
+                                   (phi_value + phi_shift) / (2 * Pi)))
+            # Take care of the edge case at phi = 2pi.
+            if i_phi >= self.nbins_phi:
+                i_phi = 0
+            phi_bins[i_phi] += frac * data[npt]
+            if err_data is None or err_data[npt] == 0.0:
+                if data_n < 0:
+                    data_n = -data_n
+                phi_err[i_phi] += frac * frac * math.fabs(data_n)
+            else:
+                phi_err[i_phi] += frac * frac * err_data[npt] * err_data[npt]
+            phi_counts[i_phi] += frac
+        for i in range(self.nbins_phi):
+            phi_bins[i] = phi_bins[i] / phi_counts[i]
+            phi_err[i] = math.sqrt(phi_err[i]) / phi_counts[i]
+            phi_values[i] = 2.0 * math.pi / self.nbins_phi * (1.0 * i)
+        idx = (np.isfinite(phi_bins))
+        if not idx.any():
+            msg = "Average Error: No points inside ROI to average..."
+            raise ValueError(msg)
+        # elif len(phi_bins[idx])!= self.nbins_phi:
+        #    print "resulted",self.nbins_phi- len(phi_bins[idx])
+        #,"empty bin(s) due to tight binning..."
+        return Data1D(x=phi_values[idx], y=phi_bins[idx], dy=phi_err[idx])
 …
     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 __init__(self, r_min, r_max, phi_min=0, phi_max=2 * math.pi, nbins=20,
+                 base=None):
+        '''
+        :param base: must be a valid base for an algorithm, i.e.,
+        a positive number
+        '''
         self.r_min = r_min
         self.r_max = r_max
 …
         self.phi_max = phi_max
         self.nbins = nbins
+        self.base = base
     def _agv(self, data2D, run='phi'):
 …
         """
         if data2D.__class__.__name__ not in ["Data2D", "plottable_2D"]:
+            raise RuntimeError, "Ring averaging only take plottable_2D objects"
+        Pi = math.pi
+            raise RuntimeError("Ring averaging only take plottable_2D objects")
         # Get the all data & info
+        data = data2D.data[numpy.isfinite(data2D.data)]
+        q_data = data2D.q_data[numpy.isfinite(data2D.data)]
+        err_data = data2D.err_data[numpy.isfinite(data2D.data)]
+        qx_data = data2D.qx_data[numpy.isfinite(data2D.data)]
+        qy_data = data2D.qy_data[numpy.isfinite(data2D.data)]
+        data = data2D.data[np.isfinite(data2D.data)]
+        q_data = data2D.q_data[np.isfinite(data2D.data)]
+        err_data = data2D.err_data[np.isfinite(data2D.data)]
+        qx_data = data2D.qx_data[np.isfinite(data2D.data)]
+        qy_data = data2D.qy_data[np.isfinite(data2D.data)]
         dq_data = None
-        # Get the dq for resolution averaging
         if data2D.dqx_data is not None and data2D.dqy_data is not None:
+            # The pinholes and det. pix contribution present
+            # in both direction of the 2D which must be subtracted when
+            # converting to 1D: dq_overlap should calculated ideally at
+            # q = 0.
+            # Extrapolate dqy(perp) at q = 0
+            z_max = max(data2D.q_data)
+            z_min = min(data2D.q_data)
+            x_max = data2D.dqx_data[data2D.q_data[z_max]]
+            x_min = data2D.dqx_data[data2D.q_data[z_min]]
+            y_max = data2D.dqy_data[data2D.q_data[z_max]]
+            y_min = data2D.dqy_data[data2D.q_data[z_min]]
+            # Find qdx at q = 0
+            dq_overlap_x = (x_min * z_max - x_max * z_min) / (z_max - z_min)
+            # when extrapolation goes wrong
+            if dq_overlap_x > min(data2D.dqx_data):
+                dq_overlap_x = min(data2D.dqx_data)
+            dq_overlap_x *= dq_overlap_x
+            # Find qdx at q = 0
+            dq_overlap_y = (y_min * z_max - y_max * z_min) / (z_max - z_min)
+            # when extrapolation goes wrong
+            if dq_overlap_y > min(data2D.dqy_data):
+                dq_overlap_y = min(data2D.dqy_data)
+            # get dq at q=0.
+            dq_overlap_y *= dq_overlap_y
+            dq_overlap = numpy.sqrt((dq_overlap_x + dq_overlap_y) / 2.0)
+            if dq_overlap < 0:
+                dq_overlap = y_min
+            dqx_data = data2D.dqx_data[numpy.isfinite(data2D.data)]
+            dqy_data = data2D.dqy_data[numpy.isfinite(data2D.data)] - dq_overlap
+            # def; dqx_data = dq_r dqy_data = dq_phi
+            # Convert dq 2D to 1D here
+            dqx = dqx_data * dqx_data
+            dqy = dqy_data * dqy_data
+            dq_data = numpy.add(dqx, dqy)
+            dq_data = numpy.sqrt(dq_data)
+        #set space for 1d outputs
+        x = numpy.zeros(self.nbins)
+        y = numpy.zeros(self.nbins)
+        y_err = numpy.zeros(self.nbins)
+        x_err = numpy.zeros(self.nbins)
+        y_counts = numpy.zeros(self.nbins)
+            dq_data = get_dq_data(data2D)
+        # set space for 1d outputs
+        x = np.zeros(self.nbins)
+        y = np.zeros(self.nbins)
+        y_err = np.zeros(self.nbins)
+        x_err = np.zeros(self.nbins)
+        y_counts = np.zeros(self.nbins)  # Cycle counts (for the mean)
         # Get the min and max into the region: 0 <= phi < 2Pi
 …
         phi_max = flip_phi(self.phi_max)
+        #  binning object
+        if run.lower() == 'phi':
+            binning = Binning(self.phi_min, self.phi_max, self.nbins, self.base)
+        else:
+            binning = Binning(self.r_min, self.r_max, self.nbins, self.base)
         for n in range(len(data)):
-            frac = 0
             # q-value at the pixel (j,i)
 …
             # phi-value of the pixel (j,i)
+            phi_value = math.atan2(qy_data[n], qx_data[n]) + Pi
+            ## No need to calculate the frac when all data are within range
+            if self.r_min <= q_value and q_value <= self.r_max:
+                frac = 1
+            if frac == 0:
+            phi_value = math.atan2(qy_data[n], qx_data[n]) + math.pi
+            # No need to calculate: data outside of the radius
+            if self.r_min > q_value or q_value > self.r_max:
                 continue
+            #In case of two ROIs (symmetric major and minor regions)(for 'q2')
+            # In case of two ROIs (symmetric major and minor regions)(for 'q2')
             if run.lower() == 'q2':
                 ## For minor sector wing
+                # For minor sector wing
                 # Calculate the minor wing phis
                 phi_min_minor = flip_phi(phi_min - Pi)
                 phi_max_minor = flip_phi(phi_max - Pi)
+                phi_min_minor = flip_phi(phi_min - math.pi)
+                phi_max_minor = flip_phi(phi_max - math.pi)
                 # Check if phis of the minor ring is within 0 to 2pi
                 if phi_min_minor > phi_max_minor:
                     is_in = (phi_value > phi_min_minor or \
                               phi_value < phi_max_minor)
+                    is_in = (phi_value > phi_min_minor or
+                             phi_value < phi_max_minor)
                 else:
                     is_in = (phi_value > phi_min_minor and \
                               phi_value < phi_max_minor)
             #For all cases(i.e.,for 'q', 'q2', and 'phi')
             #Find pixels within ROI
+                    is_in = (phi_value > phi_min_minor and
+                             phi_value < phi_max_minor)
+            # For all cases(i.e.,for 'q', 'q2', and 'phi')
+            # Find pixels within ROI
             if phi_min > phi_max:
                 is_in = is_in or (phi_value > phi_min or \
                                    phi_value < phi_max)
+                is_in = is_in or (phi_value > phi_min or
+                                  phi_value < phi_max)
             else:
+                is_in = is_in or (phi_value >= phi_min  and \
+                                    phi_value < phi_max)
+                is_in = is_in or (phi_value >= phi_min and
+                                  phi_value < phi_max)
+            # data oustide of the phi range
             if not is_in:
-                frac = 0
-            if frac == 0:
                 continue
+            # Check which type of averaging we need
+            # Get the binning index
             if run.lower() == 'phi':
+                temp_x = (self.nbins) * (phi_value - self.phi_min)
+                temp_y = (self.phi_max - self.phi_min)
+                i_bin = int(math.floor(temp_x / temp_y))
+                i_bin = binning.get_bin_index(phi_value)
             else:
+                temp_x = (self.nbins) * (q_value - self.r_min)
+                temp_y = (self.r_max - self.r_min)
+                i_bin = int(math.floor(temp_x / temp_y))
+                i_bin = binning.get_bin_index(q_value)
             # Take care of the edge case at phi = 2pi.
 …
                 i_bin = self.nbins - 1
             ## Get the total y
             y[i_bin] += frac * data_n
             x[i_bin] += frac * q_value
+            # Get the total y
+            y[i_bin] += data_n
+            x[i_bin] += q_value
             if err_data[n] is None or err_data[n] == 0.0:
                 if data_n < 0:
                     data_n = -data_n
                 y_err[i_bin] += frac * frac * data_n
+                y_err[i_bin] += data_n
             else:
                 y_err[i_bin] += frac * frac * err_data[n] * err_data[n]
+                y_err[i_bin] += err_data[n]**2
             if dq_data is not None:
 …
                 # it should not depend on the number of the q points
                 # in the qr bins.
                 x_err[i_bin] += frac * dq_data[n]
+                x_err[i_bin] += dq_data[n]
             else:
                 x_err = None
             y_counts[i_bin] += frac
+            y_counts[i_bin] += 1
         # Organize the results
 …
                 # We take the center of ring area, not radius.
                 # This is more accurate than taking the radial center of ring.
                 #delta_r = (self.r_max - self.r_min) / self.nbins
                 #r_inner = self.r_min + delta_r * i
                 #r_outer = r_inner + delta_r
                 #x[i] = math.sqrt((r_inner * r_inner + r_outer * r_outer) / 2)
+                # delta_r = (self.r_max - self.r_min) / self.nbins
+                # r_inner = self.r_min + delta_r * i
+                # r_outer = r_inner + delta_r
+                # x[i] = math.sqrt((r_inner * r_inner + r_outer * r_outer) / 2)
                 x[i] = x[i] / y_counts[i]
         y_err[y_err == 0] = numpy.average(y_err)
         idx = (numpy.isfinite(y) & numpy.isfinite(y_err))
+        y_err[y_err == 0] = np.average(y_err)
+        idx = (np.isfinite(y) & np.isfinite(y_err))
         if x_err is not None:
             d_x = x_err[idx] / y_counts[idx]
 …
         if not idx.any():
             msg = "Average Error: No points inside sector of ROI to average..."
             raise ValueError, msg
         #elif len(y[idx])!= self.nbins:
+            raise ValueError(msg)
+        # elif len(y[idx])!= self.nbins:
         #    print "resulted",self.nbins- len(y[idx]),
         #"empty bin(s) due to tight binning..."
+        # "empty bin(s) due to tight binning..."
         return Data1D(x=x[idx], y=y[idx], dy=y_err[idx], dx=d_x)
 …
     The number of bin in phi also has to be defined.
     """
     def __call__(self, data2D):
         """
 …
     The number of bin in Q also has to be defined.
     """
     def __call__(self, data2D):
         """
 …
         return self._agv(data2D, 'q2')
+################################################################################
 class Ringcut(object):
 …
     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):
         # Minimum radius
 …
         """
         if data2D.__class__.__name__ not in ["Data2D", "plottable_2D"]:
             raise RuntimeError, "Ring cut only take plottable_2D objects"
+            raise RuntimeError("Ring cut only take plottable_2D objects")
         # Get data
         qx_data = data2D.qx_data
         qy_data = data2D.qy_data
         q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data)
+        q_data = np.sqrt(qx_data * qx_data + qy_data * qy_data)
         # check whether or not the data point is inside ROI
 …
         return out
+################################################################################
 class Boxcut(object):
 …
     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):
         # Minimum Qx value [A-1]
 …
         """
         if data2D.__class__.__name__ not in ["Data2D", "plottable_2D"]:
             raise RuntimeError, "Boxcut take only plottable_2D objects"
+            raise RuntimeError("Boxcut take only plottable_2D objects")
         # Get qx_ and qy_data
         qx_data = data2D.qx_data
 …
         return outx & outy
+################################################################################
 class Sectorcut(object):
 …
     and (phi_max-phi_min) should not be larger than pi
     """
     def __init__(self, phi_min=0, phi_max=math.pi):
         self.phi_min = phi_min
 …
         """
         if data2D.__class__.__name__ not in ["Data2D", "plottable_2D"]:
             raise RuntimeError, "Sectorcut take only plottable_2D objects"
+            raise RuntimeError("Sectorcut take only plottable_2D objects")
         Pi = math.pi
         # Get data
 …
         # get phi from data
         phi_data = numpy.arctan2(qy_data, qx_data)
+        phi_data = np.arctan2(qy_data, qx_data)
         # Get the min and max into the region: -pi <= phi < Pi
 …
         # check for major sector
         if phi_min_major > phi_max_major:
+            out_major = (phi_min_major <= phi_data) + (phi_max_major > phi_data)
+            out_major = (phi_min_major <= phi_data) + \
+                (phi_max_major > phi_data)
         else:
+            out_major = (phi_min_major <= phi_data) & (phi_max_major > phi_data)
+            out_major = (phi_min_major <= phi_data) & (
+                phi_max_major > phi_data)
         # minor sector
 …
         if phi_min_minor > phi_max_minor:
             out_minor = (phi_min_minor <= phi_data) + \
                             (phi_max_minor >= phi_data)
+                (phi_max_minor >= phi_data)
         else:
             out_minor = (phi_min_minor <= phi_data) & \
                             (phi_max_minor >= phi_data)
+                (phi_max_minor >= phi_data)
         out = out_major + out_minor

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

-                      r9a5097c
+                      r149b8f6
 """
     SESANS reader (based on ASCII reader)
     Reader for .ses or .sesans file format
     Jurrian Bakker
+    Jurrian Bakker
 """
 import numpy as np
 …
 _ZERO = 1e-16
 class Reader:
     """
     Class to load sesans files (6 columns).
     """
     ## File type
+    # File type
     type_name = "SESANS"
     ## Wildcards
+    # Wildcards
     type = ["SESANS files (*.ses)|*.ses",
             "SESANS files (*..sesans)|*.sesans"]
     ## List of allowed extensions
+    # List of allowed extensions
     ext = ['.ses', '.SES', '.sesans', '.SESANS']
     ## Flag to bypass extension check
+    # Flag to bypass extension check
     allow_all = True
     def read(self, path):
-#        print "reader triggered"
         """
         Load data file
         :param path: file path
         :return: SESANSData1D object, or None
         :raise RuntimeError: when the file can't be opened
         :raise ValueError: when the length of the data vectors are inconsistent
 …
             basename = os.path.basename(path)
             _, extension = os.path.splitext(basename)
+            if self.allow_all or extension.lower() in self.ext:
+                try:
+                    # Read in binary mode since GRASP frequently has no-ascii
+                    # characters that brakes the open operation
+                    input_f = open(path,'rb')
+                except:
+                    raise  RuntimeError, "sesans_reader: cannot open %s" % path
+                buff = input_f.read()
+                lines = buff.splitlines()
+                x  = np.zeros(0)
+                y  = np.zeros(0)
+                dy = np.zeros(0)
+                lam  = np.zeros(0)
+                dlam = np.zeros(0)
+                dx = np.zeros(0)
+               #temp. space to sort data
+                tx  = np.zeros(0)
+                ty  = np.zeros(0)
+                tdy = np.zeros(0)
+                tlam  = np.zeros(0)
+                tdlam = np.zeros(0)
+                tdx = np.zeros(0)
+                output = Data1D(x=x, y=y, lam=lam, dy=dy, dx=dx, dlam=dlam, isSesans=True)
+                self.filename = output.filename = basename
+            if not (self.allow_all or extension.lower() in self.ext):
+                raise RuntimeError(
+                    "{} has an unrecognized file extension".format(path))
+        else:
+            raise RuntimeError("{} is not a file".format(path))
+        with open(path, 'r') as input_f:
+            line = input_f.readline()
+            params = {}
+            while not line.startswith("BEGIN_DATA"):
+                terms = line.split()
+                if len(terms) >= 2:
+                    params[terms[0]] = " ".join(terms[1:])
+                line = input_f.readline()
+            self.params = params
+                paramnames=[]
+                paramvals=[]
+                zvals=[]
+                dzvals=[]
+                lamvals=[]
+                dlamvals=[]
+                Pvals=[]
+                dPvals=[]
+            if "FileFormatVersion" not in self.params:
+                raise RuntimeError("SES file missing FileFormatVersion")
+            if float(self.params["FileFormatVersion"]) >= 2.0:
+                raise RuntimeError("SASView only supports SES version 1")
+                for line in lines:
+                    # Initial try for CSV (split on ,)
+                    line=line.strip()
+                    toks = line.split('\t')
+                    if len(toks)==2:
+                        paramnames.append(toks[0])
+                        paramvals.append(toks[1])
+                    if len(toks)>5:
+                        zvals.append(toks[0])
+                        dzvals.append(toks[3])
+                        lamvals.append(toks[4])
+                        dlamvals.append(toks[5])
+                        Pvals.append(toks[1])
+                        dPvals.append(toks[2])
+                    else:
+                        continue
+            if "SpinEchoLength_unit" not in self.params:
+                raise RuntimeError("SpinEchoLength has no units")
+            if "Wavelength_unit" not in self.params:
+                raise RuntimeError("Wavelength has no units")
+            if params["SpinEchoLength_unit"] != params["Wavelength_unit"]:
+                raise RuntimeError("The spin echo data has rudely used "
+                                   "different units for the spin echo length "
+                                   "and the wavelength.  While sasview could "
+                                   "handle this instance, it is a violation "
+                                   "of the file format and will not be "
+                                   "handled by other software.")
+                x=[]
+                y=[]
+                lam=[]
+                dx=[]
+                dy=[]
+                dlam=[]
+                lam_header = lamvals[0].split()
+                data_conv_z = None
+                default_z_unit = "A"
+                data_conv_P = None
+                default_p_unit = " " # Adjust unit for axis (L^-3)
+                lam_unit = lam_header[1].replace("[","").replace("]","")
+                if lam_unit == 'AA':
+                    lam_unit = 'A'
+                varheader=[zvals[0],dzvals[0],lamvals[0],dlamvals[0],Pvals[0],dPvals[0]]
+                valrange=range(1, len(zvals))
+                for i in valrange:
+                    x.append(float(zvals[i]))
+                    y.append(float(Pvals[i]))
+                    lam.append(float(lamvals[i]))
+                    dy.append(float(dPvals[i]))
+                    dx.append(float(dzvals[i]))
+                    dlam.append(float(dlamvals[i]))
+            headers = input_f.readline().split()
                 x,y,lam,dy,dx,dlam = [
                     np.asarray(v, 'double')
                    for v in (x,y,lam,dy,dx,dlam)
+                ]
+            self._insist_header(headers, "SpinEchoLength")
+            self._insist_header(headers, "Depolarisation")
+            self._insist_header(headers, "Depolarisation_error")
+            self._insist_header(headers, "Wavelength")
                 input_f.close()
+            data = np.loadtxt(input_f)
+                output.x, output.x_unit = self._unit_conversion(x, lam_unit, default_z_unit)
+                output.y = y
+                output.y_unit = r'\AA^{-2} cm^{-1}'  # output y_unit added
+                output.dx, output.dx_unit = self._unit_conversion(dx, lam_unit, default_z_unit)
+                output.dy = dy
+                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(r"\rm{z}", output.x_unit)
+                output.yaxis(r"\rm{ln(P)/(t \lambda^2)}", output.y_unit)  # Adjust label to ln P/(lam^2 t), remove lam column refs
+            if data.shape[1] != len(headers):
+                raise RuntimeError(
+                    "File has {} headers, but {} columns".format(
+                        len(headers),
+                        data.shape[1]))
+                # Store loading process information
+                output.meta_data['loader'] = self.type_name
+                #output.sample.thickness = float(paramvals[6])
+                output.sample.name = paramvals[1]
+                output.sample.ID = paramvals[0]
+                zaccept_unit_split = paramnames[7].split("[")
+                zaccept_unit = zaccept_unit_split[1].replace("]","")
+                if zaccept_unit.strip() == r'\AA^-1' or zaccept_unit.strip() == r'\A^-1':
+                    zaccept_unit = "1/A"
+                output.sample.zacceptance=(float(paramvals[7]),zaccept_unit)
+                output.vars = varheader
+            if not data.size:
+                raise RuntimeError("{} is empty".format(path))
+            x = data[:, headers.index("SpinEchoLength")]
+            if "SpinEchoLength_error" in headers:
+                dx = data[:, headers.index("SpinEchoLength_error")]
+            else:
+                dx = x * 0.05
+            lam = data[:, headers.index("Wavelength")]
+            if "Wavelength_error" in headers:
+                dlam = data[:, headers.index("Wavelength_error")]
+            else:
+                dlam = lam * 0.05
+            y = data[:, headers.index("Depolarisation")]
+            dy = data[:, headers.index("Depolarisation_error")]
+                if len(output.x) < 1:
+                    raise RuntimeError, "%s is empty" % path
+                return output
+            lam_unit = self._unit_fetch("Wavelength")
+            x, x_unit = self._unit_conversion(x, "A",
+                                              self._unit_fetch(
+                                                  "SpinEchoLength"))
+            dx, dx_unit = self._unit_conversion(
+                dx, lam_unit,
+                self._unit_fetch("SpinEchoLength"))
+            dlam, dlam_unit = self._unit_conversion(
+                dlam, lam_unit,
+                self._unit_fetch("Wavelength"))
+            y_unit = self._unit_fetch("Depolarisation")
+        else:
+            raise RuntimeError, "%s is not a file" % path
+        return None
+            output = Data1D(x=x, y=y, lam=lam, dy=dy, dx=dx, dlam=dlam,
+                            isSesans=True)
+    def _unit_conversion(self, value, value_unit, default_unit):
+        if has_converter == True and value_unit != default_unit:
+            data_conv_q = Converter(value_unit)
+            value = data_conv_q(value, units=default_unit)
+            output.y_unit = y_unit
+            output.x_unit = x_unit
+            output.source.wavelength_unit = lam_unit
+            output.source.wavelength = lam
+            self.filename = output.filename = basename
+            output.xaxis(r"\rm{z}", x_unit)
+            # Adjust label to ln P/(lam^2 t), remove lam column refs
+            output.yaxis(r"\rm{ln(P)/(t \lambda^2)}", y_unit)
+            # Store loading process information
+            output.meta_data['loader'] = self.type_name
+            output.sample.name = params["Sample"]
+            output.sample.ID = params["DataFileTitle"]
+            output.sample.thickness = self._unit_conversion(
+                float(params["Thickness"]), "cm",
+                self._unit_fetch("Thickness"))[0]
+            output.sample.zacceptance = (
+                float(params["Theta_zmax"]),
+                self._unit_fetch("Theta_zmax"))
+            output.sample.yacceptance = (
+                float(params["Theta_ymax"]),
+                self._unit_fetch("Theta_ymax"))
+            return output
+    @staticmethod
+    def _insist_header(headers, name):
+        if name not in headers:
+            raise RuntimeError(
+                "Missing {} column in spin echo data".format(name))
+    @staticmethod
+    def _unit_conversion(value, value_unit, default_unit):
+        """
+        Performs unit conversion on a measurement.
+        :param value: The magnitude of the measurement
+        :param value_unit: a string containing the final desired unit
+        :param default_unit: string with the units of the original measurement
+        :return: The magnitude of the measurement in the new units
+        """
+        # (float, string, string) -> float
+        if has_converter and value_unit != default_unit:
+            data_conv_q = Converter(default_unit)
+            value = data_conv_q(value, units=value_unit)
             new_unit = default_unit
         else:
             new_unit = value_unit
         return value, new_unit
+    def _unit_fetch(self, unit):
+        return self.params[unit+"_unit"]

src/sas/sascalc/pr/c_extensions/Cinvertor.c

-                      r959eb01
+                      rcb62bd5
+}
 const char set_has_bck_doc[] =
+const char set_est_bck_doc[] =
         "Sets background flag\n";
 …
  * Sets the maximum distance
  */
 static PyObject * set_has_bck(Cinvertor *self, PyObject *args) {
         int has_bck;
         if (!PyArg_ParseTuple(args, "i", &has_bck)) return NULL;
         self->params.has_bck = has_bck;
         return Py_BuildValue("i", self->params.has_bck);
+}
 const char get_has_bck_doc[] =
+static PyObject * set_est_bck(Cinvertor *self, PyObject *args) {
+        int est_bck;
+        if (!PyArg_ParseTuple(args, "i", &est_bck)) return NULL;
+        self->params.est_bck = est_bck;
+        return Py_BuildValue("i", self->params.est_bck);
+}
+const char get_est_bck_doc[] =
         "Gets background flag\n";
 …
  * Gets the maximum distance
  */
 static PyObject * get_has_bck(Cinvertor *self, PyObject *args) {
         return Py_BuildValue("i", self->params.has_bck);
+static PyObject * get_est_bck(Cinvertor *self, PyObject *args) {
+        return Py_BuildValue("i", self->params.est_bck);
+}
 …
         sqrt_alpha = sqrt(self->params.alpha);
         pi = acos(-1.0);
         offset = (self->params.has_bck==1) ? 0 : 1;
+        offset = (self->params.est_bck==1) ? 0 : 1;
     for (j=0; j<nfunc; j++) {
 …
+            }
             if (accept_q(self, self->params.x[i])){
                 if (self->params.has_bck==1 && j==0) {
+                if (self->params.est_bck==1 && j==0) {
                     a[i*nfunc+j] = 1.0/self->params.err[i];
                 } else {
 …
+        }
         for (i_r=0; i_r<nr; i_r++){
             if (self->params.has_bck==1 && j==0) {
+            if (self->params.est_bck==1 && j==0) {
                 a[(i_r+self->params.npoints)*nfunc+j] = 0.0;
             } else {
 …
                    {"set_slit_height", (PyCFunction)set_slit_height, METH_VARARGS, set_slit_height_doc},
                    {"get_slit_height", (PyCFunction)get_slit_height, METH_VARARGS, get_slit_height_doc},
                    {"set_has_bck", (PyCFunction)set_has_bck, METH_VARARGS, set_has_bck_doc},
                    {"get_has_bck", (PyCFunction)get_has_bck, METH_VARARGS, get_has_bck_doc},
+                   {"set_est_bck", (PyCFunction)set_est_bck, METH_VARARGS, set_est_bck_doc},
+                   {"get_est_bck", (PyCFunction)get_est_bck, METH_VARARGS, get_est_bck_doc},
                    {"get_nx", (PyCFunction)get_nx, METH_VARARGS, get_nx_doc},
                    {"get_ny", (PyCFunction)get_ny, METH_VARARGS, get_ny_doc},

src/sas/sascalc/pr/c_extensions/invertor.c

r959eb01	rcb62bd5
20	20	pars->q_min = -1.0;
21	21	pars->q_max = -1.0;
22		pars->~~has~~_bck = 0;
	22	pars->est_bck = 0;
23	23	}
24	24
…	…
313	313	return sqrt(sum_r2/(2.0*sum));
314	314	}
315

src/sas/sascalc/pr/c_extensions/invertor.h

r959eb01	rcb62bd5
27	27	double q_max;
28	28	/// Flag for whether or not to evalute a constant background while inverting
29		int ~~has~~_bck;
	29	int est_bck;
30	30	/// Slit height in units of q [A-1]
31	31	double slit_height;

src/sas/sascalc/pr/invertor.py

-                      r45dffa69
+                      rcb62bd5
          self.q_min, self.q_max,
          self.x, self.y,
          self.err, self.has_bck,
+         self.err, self.est_bck,
          self.slit_height, self.slit_width) = state
 …
                  self.q_min, self.q_max,
                  self.x, self.y,
                  self.err, self.has_bck,
+                 self.err, self.est_bck,
                  self.slit_height, self.slit_width,
+                )
 …
         elif name == 'slit_width':
             return self.set_slit_width(value)
         elif name == 'has_bck':
+        elif name == 'est_bck':
             if value == True:
                 return self.set_has_bck(1)
+                return self.set_est_bck(1)
             elif value == False:
                 return self.set_has_bck(0)
+                return self.set_est_bck(0)
             else:
                 raise ValueError, "Invertor: has_bck can only be True or False"
+                raise ValueError, "Invertor: est_bck can only be True or False"
         return Cinvertor.__setattr__(self, name, value)
 …
         elif name == 'slit_width':
             return self.get_slit_width()
         elif name == 'has_bck':
             value = self.get_has_bck()
+        elif name == 'est_bck':
+            value = self.get_est_bck()
             if value == 1:
                 return True
 …
         invertor.y = self.y
         invertor.err = self.err
+        invertor.has_bck = self.has_bck
+        invertor.est_bck = self.est_bck
+        invertor.background = self.background
         invertor.slit_height = self.slit_height
         invertor.slit_width = self.slit_width
 …
         """
         # Reset the background value before proceeding
+        self.background = 0.0
+        return self.lstsq(nfunc, nr=nr)
+        # self.background = 0.0
+        if not self.est_bck:
+            self.y -= self.background
+        out, cov = self.lstsq(nfunc, nr=nr)
+        if not self.est_bck:
+            self.y += self.background
+        return out, cov
     def iq(self, out, q):
 …
         # If we need to fit the background, add a term
         if self.has_bck == True:
+        if self.est_bck == True:
             nfunc_0 = nfunc
             nfunc += 1
 …
         # Keep a copy of the last output
+        if self.has_bck == False:
+            self.background = 0
+        if self.est_bck == False:
             self.out = c
             self.cov = err
 …
         file.write("#slit_width=%g\n" % self.slit_width)
         file.write("#background=%g\n" % self.background)
         if self.has_bck == True:
+        if self.est_bck == True:
             file.write("#has_bck=1\n")
         else:
 …
                         toks = line.split('=')
                         if int(toks[1]) == 1:
                             self.has_bck = True
+                            self.est_bck = True
                         else:
                             self.has_bck = False
+                            self.est_bck = False
                     # Now read in the parameters

src/sas/sasgui/guiframe/local_perspectives/plotting/Plotter2D.py

-                      r7432acb
+                      r3e5648b
                 if self.slicer.__class__.__name__ != "BoxSum":
                     wx_id = ids.next()
+                    slicerpop.Append(wx_id, '&Edit Slicer Parameters')
+                    name = '&Edit Slicer Parameters and Batch Slicing'
+                    slicerpop.Append(wx_id, name)
                     wx.EVT_MENU(self, wx_id, self._onEditSlicer)
             slicerpop.AppendSeparator()
 …
         """
         ## Clear current slicer
+        # Clear current slicer
         if self.slicer is not None:
             self.slicer.clear()
         ## Create a new slicer
+        # Create a new slicer
         self.slicer_z += 1
         self.slicer = slicer(self, self.subplot, zorder=self.slicer_z)
         self.subplot.set_ylim(self.data2D.ymin, self.data2D.ymax)
         self.subplot.set_xlim(self.data2D.xmin, self.data2D.xmax)
         ## Draw slicer
+        # Draw slicer
         self.update()
         self.slicer.update()
 …
         npt = math.floor(npt)
         from sas.sascalc.dataloader.manipulations import CircularAverage
         ## compute the maximum radius of data2D
+        # compute the maximum radius of data2D
         self.qmax = max(math.fabs(self.data2D.xmax),
                         math.fabs(self.data2D.xmin))
 …
                         math.fabs(self.data2D.ymin))
         self.radius = math.sqrt(math.pow(self.qmax, 2) + math.pow(self.ymax, 2))
         ##Compute beam width
+        # Compute beam width
         bin_width = (self.qmax + self.qmax) / npt
         ## Create data1D circular average of data2D
+        # Create data1D circular average of data2D
         Circle = CircularAverage(r_min=0, r_max=self.radius,
                                  bin_width=bin_width)
 …
         new_plot.name = "Circ avg " + self.data2D.name
         new_plot.source = self.data2D.source
         #new_plot.info = self.data2D.info
+        # new_plot.info = self.data2D.info
         new_plot.interactive = True
         new_plot.detector = self.data2D.detector
         ## If the data file does not tell us what the axes are, just assume...
+        # If the data file does not tell us what the axes are, just assume...
         new_plot.xaxis("\\rm{Q}", "A^{-1}")
         if hasattr(self.data2D, "scale") and \
 …
         new_plot.id = "Circ avg " + self.data2D.name
         new_plot.is_data = True
+        self.parent.update_theory(data_id=self.data2D.id, \
+                                       theory=new_plot)
+        self.parent.update_theory(data_id=self.data2D.id, theory=new_plot)
         wx.PostEvent(self.parent,
                      NewPlotEvent(plot=new_plot, title=new_plot.name))
 …
         """
         if self.slicer is not None:
             from SlicerParameters import SlicerParameterPanel
+            from parameters_panel_slicer import SlicerParameterPanel
             dialog = SlicerParameterPanel(self, -1, "Slicer Parameters")
             dialog.set_slicer(self.slicer.__class__.__name__,
 …
         params = self.slicer.get_params()
         ## Create a new panel to display results of summation of Data2D
         from slicerpanel import SlicerPanel
+        from parameters_panel_boxsum import SlicerPanel
         win = MDIFrame(self.parent, None, 'None', (100, 200))
         new_panel = SlicerPanel(parent=win, id=-1,
 …
         if default_name.count('.') > 0:
             default_name = default_name.split('.')[0]
-        #default_name += "_out"
         if self.parent is not None:
             self.parent.show_data2d(data, default_name)
     def modifyGraphAppearance(self, e):
+        self.graphApp = graphAppearance(self, 'Modify graph appearance', legend=False)
+        self.graphApp = graphAppearance(self, 'Modify graph appearance',
+                                        legend=False)
         self.graphApp.setDefaults(self.grid_on, self.legend_on,
                                   self.xaxis_label, self.yaxis_label,

src/sas/sasgui/guiframe/local_perspectives/plotting/SectorSlicer.py

-                      r7432acb
+                      r8de66b6
         ## Absolute value of the Angle between the middle line and any side line
         self.phi = math.pi / 12
+        # Binning base for log/lin binning
+        self.bin_base = 0
         ## Middle line
         self.main_line = LineInteractor(self, self.base.subplot, color='blue',
 …
         phimin = -self.left_line.phi + self.main_line.theta
         phimax = self.left_line.phi + self.main_line.theta
+        bin_base = self.bin_base
         if nbins is None:
             nbins = 20
         sect = SectorQ(r_min=0.0, r_max=radius,
                        phi_min=phimin + math.pi,
                        phi_max=phimax + math.pi, nbins=nbins)
+                       phi_max=phimax + math.pi, nbins=nbins, base=bin_base)
         sector = sect(self.base.data2D)
 …
         params["Delta_Phi [deg]"] = math.fabs(self.left_line.phi * 180 / math.pi)
         params["nbins"] = self.nbins
+        params["binning base"] = self.bin_base
         return params
 …
         phi = math.fabs(params["Delta_Phi [deg]"] * math.pi / 180)
         self.nbins = int(params["nbins"])
+        self.bin_base = params["binning base"]
         self.main_line.theta = main
         ## Reset the slicer parameters

src/sas/sasgui/perspectives/calculator/model_editor.py

-                      ra1b8fee
+                      r07ec714
         self.name_hsizer = None
         self.name_tcl = None
+        self.overwrite_cb = None
         self.desc_sizer = None
         self.desc_tcl = None
 …
         self.warning = ""
         #This does not seem to be used anywhere so commenting out for now
         #    -- PDB 2/26/17
+        #    -- PDB 2/26/17
         #self._description = "New Plugin Model"
         self.function_tcl = None
 …
         #title name [string]
         name_txt = wx.StaticText(self, -1, 'Function Name : ')
         overwrite_cb = wx.CheckBox(self, -1, "Overwrite existing plugin model of this name?", (10, 10))
         overwrite_cb.SetValue(False)
         overwrite_cb.SetToolTipString("Overwrite it if already exists?")
         wx.EVT_CHECKBOX(self, overwrite_cb.GetId(), self.on_over_cb)
+        self.overwrite_cb = wx.CheckBox(self, -1, "Overwrite existing plugin model of this name?", (10, 10))
+        self.overwrite_cb.SetValue(False)
+        self.overwrite_cb.SetToolTipString("Overwrite it if already exists?")
+        wx.EVT_CHECKBOX(self, self.overwrite_cb.GetId(), self.on_over_cb)
         self.name_tcl = wx.TextCtrl(self, -1, size=(PANEL_WIDTH * 3 / 5, -1))
         self.name_tcl.Bind(wx.EVT_TEXT_ENTER, self.on_change_name)
 …
         self.name_tcl.SetToolTipString(hint_name)
         self.name_hsizer.AddMany([(self.name_tcl, 0, wx.LEFT | wx.TOP, 0),
                                   (overwrite_cb, 0, wx.LEFT, 20)])
+                                  (self.overwrite_cb, 0, wx.LEFT, 20)])
         self.name_sizer.AddMany([(name_txt, 0, wx.LEFT | wx.TOP, 10),
                                  (self.name_hsizer, 0,
 …
         self.param_sizer.AddMany([(param_txt, 0, wx.LEFT, 10),
                                   (self.param_tcl, 1, wx.EXPAND | wx.ALL, 10)])
         # Parameters with polydispersity
         pd_param_txt = wx.StaticText(self, -1, 'Fit Parameters requiring ' + \
 …
         self.pd_param_tcl.setDisplayLineNumbers(True)
         self.pd_param_tcl.SetToolTipString(pd_param_tip)
         self.param_sizer.AddMany([(pd_param_txt, 0, wx.LEFT, 10),
                                   (self.pd_param_tcl, 1, wx.EXPAND | wx.ALL, 10)])
 …
             info = 'Error'
             color = 'red'
+            self.overwrite_cb.SetValue(True)
+            self.overwrite_name = True
         else:
             self._notes = result
 …
         if has_scipy:
             lines.insert(0, 'import scipy')
         # Think about 2D later
+        # Think about 2D later
         #self.is_2d = func_str.count("#self.ndim = 2")
         #line_2d = ''
         #if self.is_2d:
         #    line_2d = CUSTOM_2D_TEMP.split('\n')
         # Also think about test later
+        # Also think about test later
         #line_test = TEST_TEMPLATE.split('\n')
         #local_params = ''
 …
         spaces4  = ' '*4
         spaces13 = ' '*13
         spaces16 = ' '*16
+        spaces16 = ' '*16
         param_names = []    # to store parameter names
         has_scipy = func_str.count("scipy.")
 …
             out_f.write(line + '\n')
             if line.count('#name'):
                 out_f.write('name = "%s" \n' % name)
+                out_f.write('name = "%s" \n' % name)
             elif line.count('#title'):
                 out_f.write('title = "User model for %s"\n' % name)
+                out_f.write('title = "User model for %s"\n' % name)
             elif line.count('#description'):
                 out_f.write('description = "%s"\n' % desc_str)
+                out_f.write('description = "%s"\n' % desc_str)
             elif line.count('#parameters'):
                 out_f.write('parameters = [ \n')
 …
                     p_line = param_line.lstrip().rstrip()
                     if p_line:
                         pname, pvalue = self.get_param_helper(p_line)
+                        pname, pvalue, desc = self.get_param_helper(p_line)
                         param_names.append(pname)
                         out_f.write("%s['%s', '', %s, [-numpy.inf, numpy.inf], '', ''],\n" % (spaces16, pname, pvalue))
+                        out_f.write("%s['%s', '', %s, [-numpy.inf, numpy.inf], '', '%s'],\n" % (spaces16, pname, pvalue, desc))
                 for param_line in pd_param_str.split('\n'):
                     p_line = param_line.lstrip().rstrip()
                     if p_line:
                         pname, pvalue = self.get_param_helper(p_line)
+                        pname, pvalue, desc = self.get_param_helper(p_line)
                         param_names.append(pname)
                         out_f.write("%s['%s', '', %s, [-numpy.inf, numpy.inf], 'volume', ''],\n" % (spaces16, pname, pvalue))
+                        out_f.write("%s['%s', '', %s, [-numpy.inf, numpy.inf], 'volume', '%s'],\n" % (spaces16, pname, pvalue, desc))
                 out_f.write('%s]\n' % spaces13)
         # No form_volume or ER available in simple model editor
         out_f.write('def form_volume(*arg): \n')
 …
         out_f.write('def ER(*arg): \n')
         out_f.write('    return 1.0 \n')
         # function to compute
         out_f.write('\n')
 …
         for func_line in func_str.split('\n'):
             out_f.write('%s%s\n' % (spaces4, func_line))
         Iqxy_string = 'return Iq(numpy.sqrt(x**2+y**2) '
         out_f.write('\n')
         out_f.write('def Iqxy(x, y ')
 …
         items = line.split(";")
         for item in items:
+            name = item.split("=")[0].lstrip().rstrip()
+            name = item.split("=")[0].strip()
+            description = ""
             try:
+                value = item.split("=")[1].lstrip().rstrip()
+                value = item.split("=")[1].strip()
+                if value.count("#"):
+                    # If line ends in a comment, remove it before parsing float
+                    index = value.index("#")
+                    description = value[(index + 1):].strip()
+                    value = value[:value.index("#")].strip()
                 float(value)
             except:
+            except ValueError:
                 value = 1.0 # default
         return name, value
+        return name, value, description
     def set_function_helper(self, line):
 …
 import numpy
 #name
+#name
 #title
 …
 #description
 #parameters
+#parameters
 """

src/sas/sasgui/perspectives/calculator/pyconsole.py

-                      r7432acb
+                      r4627657
     Iqxy = model.evalDistribution([qx, qy])
+    result = """
+    Iq(%s) = %s
+    Iqxy(%s, %s) = %s
+    """%(q, Iq, qx, qy, Iqxy)
+    # check the model's unit tests run
+    from sasmodels.model_test import run_one
+    result = run_one(path)
     return result
 …
         ok = wx.Button(self, wx.ID_OK, "OK")
         # Mysterious constraint layouts from
+        # Mysterious constraint layouts from
         # https://www.wxpython.org/docs/api/wx.lib.layoutf.Layoutf-class.html
         lc = layoutf.Layoutf('t=t5#1;b=t5#2;l=l5#1;r=r5#1', (self,ok))

src/sas/sasgui/perspectives/fitting/basepage.py

ra1b8fee	ra1b8fee
254	254	if not hasattr(self, "model_view"):
255	255	return
256		toggle_mode_on = self.model_view.IsEnabled()
	256	toggle_mode_on = self.model_view.IsEnabled() or self.data is None
257	257	if toggle_mode_on:
258	258	if self.enable2D and not check_data_validity(self.data):

src/sas/sasgui/perspectives/fitting/fitting.py

-                      ra1b8fee
+                      r489f53a
         toks = os.path.splitext(label)
         path = os.path.join(models.find_plugins_dir(), toks[0])
+        message = "Are you sure you want to delete the file {}?".format(path)
+        dlg = wx.MessageDialog(self.frame, message, '', wx.YES_NO | wx.ICON_QUESTION)
+        if not dlg.ShowModal() == wx.ID_YES:
+            return
         try:
             for ext in ['.py', '.pyc']:
                 p_path = path + ext
+                if ext == '.pyc' and not os.path.isfile(path + ext):
+                    # If model is invalid, .pyc file may not exist as model has
+                    # never been compiled. Don't try and delete it
+                    continue
                 os.remove(p_path)
             self.update_custom_combo()
 …
           '(Re)Load all models present in user plugin_models folder')
         wx.EVT_MENU(owner, wx_id, self.load_plugin_models)
     def set_edit_menu_helper(self, owner=None, menu=None):
         """
 …
             @param unsmeared_error: data error, rescaled to unsmeared model
         """
+        try:
+            np.nan_to_num(y)
+            new_plot = self.create_theory_1D(x, y, page_id, model, data, state,
+                                             data_description=model.name,
+                                             data_id=str(page_id) + " " + data.name)
+            if unsmeared_model is not None:
+                self.create_theory_1D(x, unsmeared_model, page_id, model, data, state,
+                                      data_description=model.name + " unsmeared",
+                                      data_id=str(page_id) + " " + data.name + " unsmeared")
+                if unsmeared_data is not None and unsmeared_error is not None:
+                    self.create_theory_1D(x, unsmeared_data, page_id, model, data, state,
+                                          data_description="Data unsmeared",
+                                          data_id="Data  " + data.name + " unsmeared",
+                                          dy=unsmeared_error)
+            if sq_model is not None and pq_model is not None:
+                self.create_theory_1D(x, sq_model, page_id, model, data, state,
+                                      data_description=model.name + " S(q)",
+                                      data_id=str(page_id) + " " + data.name + " S(q)")
+                self.create_theory_1D(x, pq_model, page_id, model, data, state,
+                                      data_description=model.name + " P(q)",
+                                      data_id=str(page_id) + " " + data.name + " P(q)")
+            current_pg = self.fit_panel.get_page_by_id(page_id)
+            title = new_plot.title
+            batch_on = self.fit_panel.get_page_by_id(page_id).batch_on
+            if not batch_on:
+                wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot,
+                                            title=str(title)))
+            elif plot_result:
+                top_data_id = self.fit_panel.get_page_by_id(page_id).data.id
+                if data.id == top_data_id:
+                    wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot,
+                                            title=str(title)))
+            caption = current_pg.window_caption
+            self.page_finder[page_id].set_fit_tab_caption(caption=caption)
+            self.page_finder[page_id].set_theory_data(data=new_plot,
+        number_finite = np.count_nonzero(np.isfinite(y))
+        np.nan_to_num(y)
+        new_plot = self.create_theory_1D(x, y, page_id, model, data, state,
+                                         data_description=model.name,
+                                         data_id=str(page_id) + " " + data.name)
+        if unsmeared_model is not None:
+            self.create_theory_1D(x, unsmeared_model, page_id, model, data, state,
+                                  data_description=model.name + " unsmeared",
+                                  data_id=str(page_id) + " " + data.name + " unsmeared")
+            if unsmeared_data is not None and unsmeared_error is not None:
+                self.create_theory_1D(x, unsmeared_data, page_id, model, data, state,
+                                      data_description="Data unsmeared",
+                                      data_id="Data  " + data.name + " unsmeared",
+                                      dy=unsmeared_error)
+        # Comment this out until we can get P*S models with correctly populated parameters
+        if sq_model is not None and pq_model is not None:
+            self.create_theory_1D(x, sq_model, page_id, model, data, state,
+                                  data_description=model.name + " S(q)",
+                                  data_id=str(page_id) + " " + data.name + " S(q)")
+            self.create_theory_1D(x, pq_model, page_id, model, data, state,
+                                  data_description=model.name + " P(q)",
+                                  data_id=str(page_id) + " " + data.name + " P(q)")
+        current_pg = self.fit_panel.get_page_by_id(page_id)
+        title = new_plot.title
+        batch_on = self.fit_panel.get_page_by_id(page_id).batch_on
+        if not batch_on:
+            wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot, title=str(title)))
+        elif plot_result:
+            top_data_id = self.fit_panel.get_page_by_id(page_id).data.id
+            if data.id == top_data_id:
+                wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot, title=str(title)))
+        caption = current_pg.window_caption
+        self.page_finder[page_id].set_fit_tab_caption(caption=caption)
+        self.page_finder[page_id].set_theory_data(data=new_plot,
                                                       fid=data.id)
             if toggle_mode_on:
                 wx.PostEvent(self.parent,
                              NewPlotEvent(group_id=str(page_id) + " Model2D",
+        if toggle_mode_on:
+            wx.PostEvent(self.parent,
+                         NewPlotEvent(group_id=str(page_id) + " Model2D",
                                           action="Hide"))
             else:
                 if update_chisqr:
                     wx.PostEvent(current_pg,
                                  Chi2UpdateEvent(output=self._cal_chisqr(
+        else:
+            if update_chisqr:
+                wx.PostEvent(current_pg,
+                             Chi2UpdateEvent(output=self._cal_chisqr(
                                                                 data=data,
                                                                 fid=fid,
                                                                 weight=weight,
+                                                            page_id=page_id,
+                                                            index=index)))
+                else:
+                    self._plot_residuals(page_id=page_id, data=data, fid=fid,
+                                         index=index, weight=weight)
+                                                                page_id=page_id,
+                                                                index=index)))
+            else:
+                self._plot_residuals(page_id=page_id, data=data, fid=fid,
+                                     index=index, weight=weight)
+        if not number_finite:
+            logger.error("Using the present parameters the model does not return any finite value. ")
+            msg = "Computing Error: Model did not return any finite value."
+            wx.PostEvent(self.parent, StatusEvent(status = msg, info="error"))
+        else:
             msg = "Computation  completed!"
+            if number_finite != y.size:
+                msg += ' PROBLEM: For some Q values the model returns non finite intensities!'
+                logger.error("For some Q values the model returns non finite intensities.")
             wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop"))
-        except:
-            raise
     def _calc_exception(self, etype, value, tb):
 …
         that can be plot.
         """
+        number_finite = np.count_nonzero(np.isfinite(image))
         np.nan_to_num(image)
         new_plot = Data2D(image=image, err_image=data.err_data)
 …
                 self._plot_residuals(page_id=page_id, data=data, fid=fid,
                                       index=index, weight=weight)
+        msg = "Computation  completed!"
+        wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop"))
+        if not number_finite:
+            logger.error("Using the present parameters the model does not return any finite value. ")
+            msg = "Computing Error: Model did not return any finite value."
+            wx.PostEvent(self.parent, StatusEvent(status = msg, info="error"))
+        else:
+            msg = "Computation  completed!"
+            if number_finite != image.size:
+                msg += ' PROBLEM: For some Qx,Qy values the model returns non finite intensities!'
+                logger.error("For some Qx,Qy values the model returns non finite intensities.")
+            wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop"))
     def _draw_model2D(self, model, page_id, qmin,

src/sas/sasgui/perspectives/fitting/models.py

-                      ra1b8fee
+                      rb1c2011
     try:
         import compileall
         compileall.compile_dir(dir=dir, ddir=dir, force=1,
+        compileall.compile_dir(dir=dir, ddir=dir, force=0,
                                quiet=report_problem)
     except:
 …
 def _findModels(dir):
+def _find_models():
     """
     Find custom models
     """
     # List of plugin objects
     dir = find_plugins_dir()
+    directory = find_plugins_dir()
     # Go through files in plug-in directory
     if not os.path.isdir(dir):
         msg = "SasView couldn't locate Model plugin folder %r." % dir
+    if not os.path.isdir(directory):
+        msg = "SasView couldn't locate Model plugin folder %r." % directory
         logger.warning(msg)
         return {}
     plugin_log("looking for models in: %s" % str(dir))
     #compile_file(dir)  #always recompile the folder plugin
     logger.info("plugin model dir: %s" % str(dir))
+    plugin_log("looking for models in: %s" % str(directory))
+    # compile_file(directory)  #always recompile the folder plugin
+    logger.info("plugin model dir: %s" % str(directory))
     plugins = {}
     for filename in os.listdir(dir):
+    for filename in os.listdir(directory):
         name, ext = os.path.splitext(filename)
         if ext == '.py' and not name == '__init__':
             path = os.path.abspath(os.path.join(dir, filename))
+            path = os.path.abspath(os.path.join(directory, filename))
             try:
                 model = load_custom_model(path)
+                model.name = PLUGIN_NAME_BASE + model.name
+                if not model.name.count(PLUGIN_NAME_BASE):
+                    model.name = PLUGIN_NAME_BASE + model.name
                 plugins[model.name] = model
             except Exception:
 …
                 plugin_log(msg)
                 logger.warning("Failed to load plugin %r. See %s for details"
                                 % (path, PLUGIN_LOG))
+                               % (path, PLUGIN_LOG))
     return plugins
 …
         temp = {}
         if self.is_changed():
             return  _findModels(dir)
+            return  _find_models()
         logger.info("plugin model : %s" % str(temp))
         return temp
 …
         for name, plug in self.stored_plugins.iteritems():
             self.model_dictionary[name] = plug
         self._get_multifunc_models()
 …
         """
         self.plugins = []
         new_plugins = _findModels(dir)
+        new_plugins = _find_models()
         for name, plug in  new_plugins.iteritems():
             for stored_name, stored_plug in self.stored_plugins.iteritems():

src/sas/sasgui/perspectives/pr/inversion_panel.py

-                      r7432acb
+                      rcb62bd5
         self.rg_ctl = None
         self.iq0_ctl = None
+        self.bck_chk = None
+        self.bck_value = None
+        self.bck_est_ctl = None
+        self.bck_man_ctl = None
+        self.est_bck = True
+        self.bck_input = None
         self.bck_ctl = None
 …
         # Read the panel's parameters
         flag, alpha, dmax, nfunc, qmin, \
         qmax, height, width = self._read_pars()
+        qmax, height, width, bck = self._read_pars()
         state.nfunc = nfunc
 …
         # Background evaluation checkbox
+        state.estimate_bck = self.bck_chk.IsChecked()
+        state.estimate_bck = self.est_bck
+        state.bck_value = bck
         # Estimates
 …
         self.plot_data.SetValue(str(state.file))
+        # Background evaluation checkbox
+        self.bck_chk.SetValue(state.estimate_bck)
+        # Background value
+        self.bck_est_ctl.SetValue(state.estimate_bck)
+        self.bck_man_ctl.SetValue(not state.estimate_bck)
+        if not state.estimate_bck:
+            self.bck_input.Enable()
+            self.bck_input.SetValue(str(state.bck_value))
+        self.est_bck = state.estimate_bck
+        self.bck_value = state.bck_value
         # Estimates
 …
                        wx.EXPAND | wx.LEFT | wx.RIGHT | wx.ADJUST_MINSIZE, 15)
+        self.bck_chk = wx.CheckBox(self, -1, "Estimate background level")
+        hint_msg = "Check box to let the fit estimate "
+        hint_msg += "the constant background level."
+        self.bck_chk.SetToolTipString(hint_msg)
+        self.bck_chk.Bind(wx.EVT_CHECKBOX, self._on_pars_changed)
+        radio_sizer = wx.GridBagSizer(5, 5)
+        self.bck_est_ctl = wx.RadioButton(self, -1, "Estimate background level",
+            name="estimate_bck", style=wx.RB_GROUP)
+        self.bck_man_ctl = wx.RadioButton(self, -1, "Input manual background level",
+            name="manual_bck")
+        self.bck_est_ctl.Bind(wx.EVT_RADIOBUTTON, self._on_bck_changed)
+        self.bck_man_ctl.Bind(wx.EVT_RADIOBUTTON, self._on_bck_changed)
+        radio_sizer.Add(self.bck_est_ctl, (0,0), (1,1), wx.LEFT | wx.EXPAND)
+        radio_sizer.Add(self.bck_man_ctl, (0,1), (1,1), wx.RIGHT | wx.EXPAND)
         iy += 1
         pars_sizer.Add(self.bck_chk, (iy, 0), (1, 2),
+        pars_sizer.Add(radio_sizer, (iy, 0), (1, 2),
                        wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15)
+        background_label = wx.StaticText(self, -1, "Background: ")
+        self.bck_input = PrTextCtrl(self, -1, style=wx.TE_PROCESS_ENTER,
+            size=(60, 20), value="0.0")
+        self.bck_input.Disable()
+        self.bck_input.Bind(wx.EVT_TEXT, self._read_pars)
+        background_units = wx.StaticText(self, -1, "[A^(-1)]", size=(55, 20))
+        iy += 1
+        background_sizer = wx.GridBagSizer(5, 5)
+        background_sizer.Add(background_label, (0, 0), (1,1),
+            wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 23)
+        background_sizer.Add(self.bck_input, (0, 1), (1,1),
+            wx.LEFT | wx.ADJUST_MINSIZE, 5)
+        background_sizer.Add(background_units, (0, 2), (1,1),
+            wx.LEFT | wx.ADJUST_MINSIZE, 5)
+        pars_sizer.Add(background_sizer, (iy, 0), (1, 2),
+            wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15)
         boxsizer1.Add(pars_sizer, 0, wx.EXPAND)
         vbox.Add(boxsizer1, (iy_vb, 0), (1, 1),
 …
         self._on_pars_changed()
+    def _on_bck_changed(self, evt=None):
+        self.est_bck = self.bck_est_ctl.GetValue()
+        if self.est_bck:
+            self.bck_input.Disable()
+        else:
+            self.bck_input.Enable()
     def _on_pars_changed(self, evt=None):
         """
 …
         scenes.
         """
+        flag, alpha, dmax, nfunc, qmin, qmax, height, width = self._read_pars()
+        has_bck = self.bck_chk.IsChecked()
+        flag, alpha, dmax, nfunc, qmin, qmax, height, width, bck = self._read_pars()
         # If the pars are valid, estimate alpha
 …
                                                       d_max=dmax,
                                                       q_min=qmin, q_max=qmax,
+                                                      bck=has_bck,
+                                                      est_bck=self.est_bck,
+                                                      bck_val=bck,
                                                       height=height,
                                                       width=width)
 …
         height = 0
         width = 0
+        background = 0
         flag = True
         # Read slit height
 …
             self.qmax_ctl.Refresh()
+        return flag, alpha, dmax, nfunc, qmin, qmax, height, width
+        # Read background
+        if not self.est_bck:
+            try:
+                bck_str = self.bck_input.GetValue()
+                if len(bck_str.strip()) == 0:
+                    background = 0.0
+                else:
+                    background = float(bck_str)
+                    self.bck_input.SetBackgroundColour(wx.WHITE)
+            except ValueError:
+                background = 0.0
+                self.bck_input.SetBackgroundColour("pink")
+            self.bck_input.Refresh()
+        return flag, alpha, dmax, nfunc, qmin, qmax, height, width, background
     def _on_explore(self, evt):
 …
         # Push it to the manager
+        flag, alpha, dmax, nfunc, qmin, qmax, height, width = self._read_pars()
+        has_bck = self.bck_chk.IsChecked()
+        flag, alpha, dmax, nfunc, qmin, qmax, height, width, bck = self._read_pars()
         if flag:
 …
                                                    d_max=dmax,
                                                    q_min=qmin, q_max=qmax,
+                                                   bck=has_bck,
+                                                   est_bck=self.est_bck,
+                                                   bck_val = bck,
                                                    height=height,
                                                    width=width)

src/sas/sasgui/perspectives/pr/inversion_state.py

-                      r7432acb
+                      ra0e6b1b
            ["qmin", "qmin"],
            ["qmax", "qmax"],
+           ["estimate_bck", "estimate_bck"]]
+           ["estimate_bck", "estimate_bck"],
+           ["bck_value", "bck_value"]]
 ## List of P(r) inversion outputs
 …
         self.estimate_bck = False
         self.timestamp = time.time()
+        self.bck_value = 0.0
         # Inversion parameters
 …
         state += "Timestamp:    %s\n" % self.timestamp
         state += "Estimate bck: %s\n" % str(self.estimate_bck)
+        state += "Bck Value:    %s\n" % str(self.bck_value)
         state += "No. terms:    %s\n" % str(self.nfunc)
         state += "D_max:        %s\n" % str(self.d_max)
 …
                             self.coefficients.append(float(c))
                         except:
                             # Bad data, skip. We will count the number of
                             # coefficients at the very end and deal with
+                            # Bad data, skip. We will count the number of
+                            # coefficients at the very end and deal with
                             # inconsistencies then.
                             pass
 …
                                 cov_row.append(float(c))
                             except:
                                 # Bad data, skip. We will count the number of
                                 # coefficients at the very end and deal with
+                                # Bad data, skip. We will count the number of
+                                # coefficients at the very end and deal with
                                 # inconsistencies then.
                                 pass
 …
                 tree = etree.parse(path, parser=etree.ETCompatXMLParser())
                 # Check the format version number
                 # Specifying the namespace will take care of the file
                 #format version
+                # Specifying the namespace will take care of the file
+                #format version
                 root = tree.getroot()

src/sas/sasgui/perspectives/pr/media/pr_help.rst

-                      r1221196
+                      r1abd19c
 P(r) inversion requires that the background be perfectly subtracted.  This is
 often difficult to do well and thus many data sets will include a background.
+For those cases, the user should check the "estimate background" box and the
+module will do its best to estimate it.
+For those cases, the user should check the "Estimate background level" option
+and the module will do its best to estimate it. If you know the background value
+for your data, select the "Input manual background level" option. Note that
+this value will be treated as having 0 error.
 The P(r) module is constantly computing in the background what the optimum

src/sas/sasgui/perspectives/pr/pr.py

-                      ra1b8fee
+                      rcb62bd5
         self.q_min = None
         self.q_max = None
+        self.has_bck = False
+        self.est_bck = False
+        self.bck_val = 0
         self.slit_height = 0
         self.slit_width = 0
 …
         self.control_panel.iq0 = pr.iq0(out)
         self.control_panel.bck = pr.background
+        self.control_panel.bck_input.SetValue("{:.2g}".format(pr.background))
         # Show I(q) fit
 …
     def setup_plot_inversion(self, alpha, nfunc, d_max, q_min=None, q_max=None,
                              bck=False, height=0, width=0):
+                             est_bck=False, bck_val=0, height=0, width=0):
         """
             Set up inversion from plotted data
 …
         self.q_min = q_min
         self.q_max = q_max
+        self.has_bck = bck
+        self.est_bck = est_bck
+        self.bck_val = bck_val
         self.slit_height = height
         self.slit_width = width
 …
     def estimate_plot_inversion(self, alpha, nfunc, d_max,
                                 q_min=None, q_max=None,
                                 bck=False, height=0, width=0):
+                                est_bck=False, bck_val=0, height=0, width=0):
         """
             Estimate parameters from plotted data
 …
         self.q_min = q_min
         self.q_max = q_max
+        self.has_bck = bck
+        self.est_bck = est_bck
+        self.bck_val = bck_val
         self.slit_height = height
         self.slit_width = width
 …
         pr.x = self.current_plottable.x
         pr.y = self.current_plottable.y
         pr.has_bck = self.has_bck
+        pr.est_bck = self.est_bck
         pr.slit_height = self.slit_height
         pr.slit_width = self.slit_width
+        pr.background = self.bck_val
         # Keep track of the plot window title to ensure that
 …
         self.q_min = q_min
         self.q_max = q_max
         self.has_bck = bck
+        self.est_bck = bck
         self.slit_height = height
         self.slit_width = width
 …
         self.q_min = q_min
         self.q_max = q_max
         self.has_bck = bck
+        self.est_bck = bck
         self.slit_height = height
         self.slit_width = width
 …
             pr.y = y
             pr.err = err
             pr.has_bck = self.has_bck
+            pr.est_bck = self.est_bck
             pr.slit_height = self.slit_height
             pr.slit_width = self.slit_width

test/pr_inversion/test/utest_invertor.py

-                      raaf5e49
+                      rcb62bd5
             self.x_in[i] = 1.0*(i+1)
     def test_has_bck_flag(self):
         """
             Tests the has_bck flag operations
         """
         self.assertEqual(self.invertor.has_bck, False)
         self.invertor.has_bck=True
         self.assertEqual(self.invertor.has_bck, True)
+    def test_est_bck_flag(self):
+        """
+            Tests the est_bck flag operations
+        """
+        self.assertEqual(self.invertor.est_bck, False)
+        self.invertor.est_bck=True
+        self.assertEqual(self.invertor.est_bck, True)
         def doit_float():
             self.invertor.has_bck  = 2.0
+            self.invertor.est_bck  = 2.0
         def doit_str():
             self.invertor.has_bck  = 'a'
+            self.invertor.est_bck  = 'a'
         self.assertRaises(ValueError, doit_float)

test/sasdataloader/test/utest_averaging.py

-                      r9a5097c
+                      re123eb9
+import math
+import os
 import unittest
+import math
+from sas.sascalc.dataloader.loader import  Loader
+from sas.sascalc.dataloader.manipulations import Ring, CircularAverage, SectorPhi, get_q,reader2D_converter
+from scipy.stats import binned_statistic_2d
 import numpy as np
 import sas.sascalc.dataloader.data_info as data_info
+from sas.sascalc.dataloader.loader import Loader
+from sas.sascalc.dataloader.manipulations import (Boxavg, Boxsum,
+                                                  CircularAverage, Ring,
+                                                  SectorPhi, SectorQ, SlabX,
+                                                  SlabY, get_q,
+                                                  reader2D_converter)
 class Averaging(unittest.TestCase):
 …
         Test averaging manipulations on a flat distribution
     """
     def setUp(self):
         """
 …
             should return the predefined height of the distribution (1.0).
         """
         x_0  = np.ones([100,100])
         dx_0 = np.ones([100,100])
+        x_0 = np.ones([100, 100])
+        dx_0 = np.ones([100, 100])
         self.data = data_info.Data2D(data=x_0, err_data=dx_0)
         detector = data_info.Detector()
         detector.distance = 1000.0  #mm
         detector.pixel_size.x = 1.0 #mm
         detector.pixel_size.y = 1.0 #mm
+        detector.distance = 1000.0  # mm
+        detector.pixel_size.x = 1.0  # mm
+        detector.pixel_size.y = 1.0  # mm
         # center in pixel position = (len(x_0)-1)/2
         detector.beam_center.x = (len(x_0)-1)/2 #pixel number
         detector.beam_center.y = (len(x_0)-1)/2 #pixel number
+        detector.beam_center.x = (len(x_0) - 1) / 2  # pixel number
+        detector.beam_center.y = (len(x_0) - 1) / 2  # pixel number
         self.data.detector.append(detector)
         source = data_info.Source()
         source.wavelength = 10.0 #A
+        source.wavelength = 10.0  # A
         self.data.source = source
+        # get_q(dx, dy, det_dist, wavelength) where units are mm,mm,mm,and A respectively.
+        # get_q(dx, dy, det_dist, wavelength) where units are mm,mm,mm,and A
+        # respectively.
         self.qmin = get_q(1.0, 1.0, detector.distance, source.wavelength)
         self.qmax = get_q(49.5, 49.5, detector.distance, source.wavelength)
         self.qstep = len(x_0)
         x=  np.linspace(start= -1*self.qmax,
                                stop= self.qmax,
                                num= self.qstep,
                                endpoint=True )
         y = np.linspace(start= -1*self.qmax,
                                stop= self.qmax,
                                num= self.qstep,
                                endpoint=True )
         self.data.x_bins=x
         self.data.y_bins=y
+        x = np.linspace(start=-1 * self.qmax,
+                        stop=self.qmax,
+                        num=self.qstep,
+                        endpoint=True)
+        y = np.linspace(start=-1 * self.qmax,
+                        stop=self.qmax,
+                        num=self.qstep,
+                        endpoint=True)
+        self.data.x_bins = x
+        self.data.y_bins = y
         self.data = reader2D_converter(self.data)
     def test_ring_flat_distribution(self):
         """
             Test ring averaging
         """
         r = Ring(r_min=2*self.qmin, r_max=5*self.qmin,
                  center_x=self.data.detector[0].beam_center.x,
+        r = Ring(r_min=2 * self.qmin, r_max=5 * self.qmin,
+                 center_x=self.data.detector[0].beam_center.x,
                  center_y=self.data.detector[0].beam_center.y)
         r.nbins_phi = 20
         o = r(self.data)
         for i in range(20):
             self.assertEqual(o.y[i], 1.0)
     def test_sectorphi_full(self):
         """
             Test sector averaging
         """
         r = SectorPhi(r_min=self.qmin, r_max=3*self.qmin,
                       phi_min=0, phi_max=math.pi*2.0)
+        r = SectorPhi(r_min=self.qmin, r_max=3 * self.qmin,
+                      phi_min=0, phi_max=math.pi * 2.0)
         r.nbins_phi = 20
         o = r(self.data)
         for i in range(7):
             self.assertEqual(o.y[i], 1.0)
     def test_sectorphi_partial(self):
         """
         """
         phi_max = math.pi * 1.5
         r = SectorPhi(r_min=self.qmin, r_max=3*self.qmin,
+        r = SectorPhi(r_min=self.qmin, r_max=3 * self.qmin,
                       phi_min=0, phi_max=phi_max)
         self.assertEqual(r.phi_max, phi_max)
 …
         for i in range(17):
             self.assertEqual(o.y[i], 1.0)
+class data_info_tests(unittest.TestCase):
+class DataInfoTests(unittest.TestCase):
     def setUp(self):
+        self.data = Loader().load('MAR07232_rest.ASC')
+        filepath = os.path.join(os.path.dirname(
+            os.path.realpath(__file__)), 'MAR07232_rest.ASC')
+        self.data = Loader().load(filepath)
     def test_ring(self):
         """
             Test ring averaging
         """
         r = Ring(r_min=.005, r_max=.01,
                  center_x=self.data.detector[0].beam_center.x,
+        r = Ring(r_min=.005, r_max=.01,
+                 center_x=self.data.detector[0].beam_center.x,
                  center_y=self.data.detector[0].beam_center.y,
                  nbins = 20)
+                 nbins=20)
         ##r.nbins_phi = 20
+        o = r(self.data)
+        answer = Loader().load('ring_testdata.txt')
+        o = r(self.data)
+        filepath = os.path.join(os.path.dirname(
+            os.path.realpath(__file__)), 'ring_testdata.txt')
+        answer = Loader().load(filepath)
         for i in range(r.nbins_phi - 1):
             self.assertAlmostEqual(o.x[i + 1], answer.x[i], 4)
             self.assertAlmostEqual(o.y[i + 1], answer.y[i], 4)
             self.assertAlmostEqual(o.dy[i + 1], answer.dy[i], 4)
     def test_circularavg(self):
         """
+        Test circular averaging
+        The test data was not generated by IGOR.
+        """
+        r = CircularAverage(r_min=.00, r_max=.025,
+                            bin_width=0.0003)
+        r.nbins_phi = 20
+        o = r(self.data)
+        filepath = os.path.join(os.path.dirname(
+            os.path.realpath(__file__)), 'avg_testdata.txt')
+        answer = Loader().load(filepath)
+        for i in range(r.nbins_phi):
+            self.assertAlmostEqual(o.x[i], answer.x[i], 4)
+            self.assertAlmostEqual(o.y[i], answer.y[i], 4)
+            self.assertAlmostEqual(o.dy[i], answer.dy[i], 4)
+    def test_box(self):
+        """
             Test circular averaging
             The test data was not generated by IGOR.
         """
+        r = CircularAverage(r_min=.00, r_max=.025,
+                 bin_width=0.0003)
+        r.nbins_phi = 20
+        o = r(self.data)
+        answer = Loader().load('avg_testdata.txt')
+        for i in range(r.nbins_phi):
+            self.assertAlmostEqual(o.x[i], answer.x[i], 4)
+            self.assertAlmostEqual(o.y[i], answer.y[i], 4)
+            self.assertAlmostEqual(o.dy[i], answer.dy[i], 4)
+    def test_box(self):
+        """
+            Test circular averaging
+            The test data was not generated by IGOR.
+        """
+        from sas.sascalc.dataloader.manipulations import Boxsum, Boxavg
         r = Boxsum(x_min=.01, x_max=.015, y_min=0.01, y_max=0.015)
         s, ds, npoints = r(self.data)
         self.assertAlmostEqual(s, 34.278990899999997, 4)
         self.assertAlmostEqual(ds, 7.8007981835194293, 4)
         self.assertAlmostEqual(npoints, 324.0000, 4)
+        self.assertAlmostEqual(npoints, 324.0000, 4)
         r = Boxavg(x_min=.01, x_max=.015, y_min=0.01, y_max=0.015)
         s, ds = r(self.data)
         self.assertAlmostEqual(s, 0.10579935462962962, 4)
         self.assertAlmostEqual(ds, 0.024076537603455028, 4)
     def test_slabX(self):
         """
 …
             The test data was not generated by IGOR.
         """
+        from sas.sascalc.dataloader.manipulations import SlabX
         r = SlabX(x_min=-.01, x_max=.01, y_min=-0.0002, y_max=0.0002, bin_width=0.0004)
+        r = SlabX(x_min=-.01, x_max=.01, y_min=-0.0002,
+                  y_max=0.0002, bin_width=0.0004)
         r.fold = False
         o = r(self.data)
+        answer = Loader().load('slabx_testdata.txt')
+        for i in range(len(o.x)):
+            self.assertAlmostEqual(o.x[i], answer.x[i], 4)
+            self.assertAlmostEqual(o.y[i], answer.y[i], 4)
+            self.assertAlmostEqual(o.dy[i], answer.dy[i], 4)
+        filepath = os.path.join(os.path.dirname(
+            os.path.realpath(__file__)), 'slabx_testdata.txt')
+        answer = Loader().load(filepath)
+        for i in range(len(o.x)):
+            self.assertAlmostEqual(o.x[i], answer.x[i], 4)
+            self.assertAlmostEqual(o.y[i], answer.y[i], 4)
+            self.assertAlmostEqual(o.dy[i], answer.dy[i], 4)
     def test_slabY(self):
         """
 …
             The test data was not generated by IGOR.
         """
+        from sas.sascalc.dataloader.manipulations import SlabY
         r = SlabY(x_min=.005, x_max=.01, y_min=-0.01, y_max=0.01, bin_width=0.0004)
+        r = SlabY(x_min=.005, x_max=.01, y_min=-
+.01, y_max=0.01, bin_width=0.0004)
         r.fold = False
         o = r(self.data)
+        answer = Loader().load('slaby_testdata.txt')
+        for i in range(len(o.x)):
+            self.assertAlmostEqual(o.x[i], answer.x[i], 4)
+            self.assertAlmostEqual(o.y[i], answer.y[i], 4)
+            self.assertAlmostEqual(o.dy[i], answer.dy[i], 4)
+        filepath = os.path.join(os.path.dirname(
+            os.path.realpath(__file__)), 'slaby_testdata.txt')
+        answer = Loader().load(filepath)
+        for i in range(len(o.x)):
+            self.assertAlmostEqual(o.x[i], answer.x[i], 4)
+            self.assertAlmostEqual(o.y[i], answer.y[i], 4)
+            self.assertAlmostEqual(o.dy[i], answer.dy[i], 4)
     def test_sectorphi_full(self):
         """
 …
             The test data was not generated by IGOR.
         """
+        from sas.sascalc.dataloader.manipulations import SectorPhi
+        import math
         nbins = 19
         phi_min = math.pi / (nbins + 1)
         phi_max = math.pi * 2 - phi_min
         r = SectorPhi(r_min=.005,
                       r_max=.01,
 …
         o = r(self.data)
+        answer = Loader().load('ring_testdata.txt')
+        for i in range(len(o.x)):
+            self.assertAlmostEqual(o.x[i], answer.x[i], 4)
+            self.assertAlmostEqual(o.y[i], answer.y[i], 4)
+            self.assertAlmostEqual(o.dy[i], answer.dy[i], 4)
+        filepath = os.path.join(os.path.dirname(
+            os.path.realpath(__file__)), 'ring_testdata.txt')
+        answer = Loader().load(filepath)
+        for i in range(len(o.x)):
+            self.assertAlmostEqual(o.x[i], answer.x[i], 4)
+            self.assertAlmostEqual(o.y[i], answer.y[i], 4)
+            self.assertAlmostEqual(o.dy[i], answer.dy[i], 4)
     def test_sectorphi_quarter(self):
         """
 …
             The test data was not generated by IGOR.
         """
+        from sas.sascalc.dataloader.manipulations import SectorPhi
         import math
         r = SectorPhi(r_min=.005, r_max=.01, phi_min=0, phi_max=math.pi/2.0)
+        r.nbins_phi = 20
         o = r(self.data)
         answer = Loader().load('sectorphi_testdata.txt')
         for i in range(len(o.x)):
             self.assertAlmostEqual(o.x[i], answer.x[i], 4)
             self.assertAlmostEqual(o.y[i], answer.y[i], 4)
             self.assertAlmostEqual(o.dy[i], answer.dy[i], 4)
+        r = SectorPhi(r_min=.005, r_max=.01, phi_min=0, phi_max=math.pi / 2.0)
+        r.nbins_phi = 20
+        o = r(self.data)
+        filepath = os.path.join(os.path.dirname(
+            os.path.realpath(__file__)), 'sectorphi_testdata.txt')
+        answer = Loader().load(filepath)
+        for i in range(len(o.x)):
+            self.assertAlmostEqual(o.x[i], answer.x[i], 4)
+            self.assertAlmostEqual(o.y[i], answer.y[i], 4)
+            self.assertAlmostEqual(o.dy[i], answer.dy[i], 4)
     def test_sectorq_full(self):
         """
 …
             The test data was not generated by IGOR.
         """
+        from sas.sascalc.dataloader.manipulations import SectorQ
+        import math
+        r = SectorQ(r_min=.005, r_max=.01, phi_min=0, phi_max=math.pi/2.0)
+        r.nbins_phi = 20
+        o = r(self.data)
+        answer = Loader().load('sectorq_testdata.txt')
+        for i in range(len(o.x)):
+            self.assertAlmostEqual(o.x[i], answer.x[i], 4)
+            self.assertAlmostEqual(o.y[i], answer.y[i], 4)
+            self.assertAlmostEqual(o.dy[i], answer.dy[i], 4)
+        r = SectorQ(r_min=.005, r_max=.01, phi_min=0, phi_max=math.pi / 2.0)
+        r.nbins_phi = 20
+        o = r(self.data)
+        filepath = os.path.join(os.path.dirname(
+            os.path.realpath(__file__)), 'sectorq_testdata.txt')
+        answer = Loader().load(filepath)
+        for i in range(len(o.x)):
+            self.assertAlmostEqual(o.x[i], answer.x[i], 4)
+            self.assertAlmostEqual(o.y[i], answer.y[i], 4)
+            self.assertAlmostEqual(o.dy[i], answer.dy[i], 4)
+    def test_sectorq_log(self):
+        """
+            Test sector averaging I(q)
+            The test data was not generated by IGOR.
+        """
+        r = SectorQ(r_min=.005, r_max=.01, phi_min=0, phi_max=math.pi / 2.0, base=10)
+        r.nbins_phi = 20
+        o = r(self.data)
+        expected_binning = np.logspace(np.log10(0.005), np.log10(0.01), 20, base=10)
+        for i in range(len(o.x)):
+            self.assertAlmostEqual(o.x[i], expected_binning[i], 3)
+        # TODO: Test for Y values (o.y)
+        # print len(self.data.x_bins)
+        # print len(self.data.y_bins)
+        # print self.data.q_data.shape
+        # data_to_bin = np.array(self.data.q_data)
+        # data_to_bin = data_to_bin.reshape(len(self.data.x_bins), len(self.data.y_bins))
+        # H, xedges, yedges, binnumber = binned_statistic_2d(self.data.x_bins, self.data.y_bins, data_to_bin,
+        #     bins=[[0, math.pi / 2.0], expected_binning], statistic='mean')
+        # xedges_width = (xedges[1] - xedges[0])
+        # xedges_center = xedges[1:] - xedges_width / 2
+        # yedges_width = (yedges[1] - yedges[0])
+        # yedges_center = yedges[1:] - yedges_width / 2
+        # print H.flatten().shape
+        # print o.y.shape
 if __name__ == '__main__':

test/sasguiframe/test/utest_manipulations.py

                       r959eb01
     Unit tests for data manipulations
 """
+#TODO: what happens if you add a Data1D to a Data2D?
+# TODO: what happens if you add a Data1D to a Data2D?
+import math
+import os.path
 import unittest
+import math
 import numpy as np
+from sas.sascalc.dataloader.loader import  Loader
 from sas.sasgui.guiframe.dataFitting import Data1D, Data2D
 from sas.sasgui.guiframe.dataFitting import Data1D as Theory1D
+import os.path
 class data_info_tests(unittest.TestCase):
+from sas.sascalc.dataloader.loader import Loader
+from sas.sasgui.guiframe.dataFitting import Data1D
+from sas.sasgui.guiframe.dataFitting import Data2D
+class DataInfoTests(unittest.TestCase):
     def setUp(self):
         data = Loader().load("cansas1d.xml")
         self.data = data[0]
     def test_clone1D(self):
         """
 …
         """
         clone = self.data.clone_without_data()
         for i in range(len(self.data.detector)):
+            self.assertEqual(self.data.detector[i].distance, clone.detector[i].distance)
+class theory1d_tests(unittest.TestCase):
+            self.assertEqual(
+                self.data.detector[i].distance, clone.detector[i].distance)
+class Theory1DTests(unittest.TestCase):
     def setUp(self):
         data = Loader().load("cansas1d.xml")
         self.data = data[0]
     def test_clone_theory1D(self):
         """
             Test basic cloning
         """
         theory = Theory1D(x=[], y=[], dy=None)
+        theory = Data1D(x=[], y=[], dy=None)
         theory.clone_without_data(clone=self.data)
         theory.copy_from_datainfo(data1d=self.data)
         for i in range(len(self.data.detector)):
+            self.assertEqual(self.data.detector[i].distance, theory.detector[i].distance)
+            self.assertEqual(
+                self.data.detector[i].distance, theory.detector[i].distance)
         for i in range(len(self.data.x)):
             self.assertEqual(self.data.x[i], theory.x[i])
 …
             self.assertEqual(self.data.dy[i], theory.dy[i])
+class manip_tests(unittest.TestCase):
+class ManipTests(unittest.TestCase):
     def setUp(self):
         # Create two data sets to play with
         x_0 = np.ones(5)
         for i in range(5):
             x_0[i] = x_0[i]*(i+1.0)
         y_0 = 2.0*np.ones(5)
         dy_0 = 0.5*np.ones(5)
+            x_0[i] = x_0[i] * (i + 1.0)
+        y_0 = 2.0 * np.ones(5)
+        dy_0 = 0.5 * np.ones(5)
         self.data = Data1D(x_0, y_0, dy=dy_0)
         x = self.data.x
         y = np.ones(5)
         dy = np.ones(5)
         self.data2 = Data1D(x, y, dy=dy)
     def test_load(self):
         """
 …
         # There should be 5 entries in the file
         self.assertEqual(len(self.data.x), 5)
         for i in range(5):
             # The x values should be from 1 to 5
             self.assertEqual(self.data.x[i], float(i+1))
+            self.assertEqual(self.data.x[i], float(i + 1))
             # All y-error values should be 0.5
             self.assertEqual(self.data.dy[i], 0.5)
+            self.assertEqual(self.data.dy[i], 0.5)
             # All y values should be 2.0
             self.assertEqual(self.data.y[i], 2.0)
+            self.assertEqual(self.data.y[i], 2.0)
     def test_add(self):
         result = self.data2+self.data
+        result = self.data2 + self.data
         for i in range(5):
             self.assertEqual(result.y[i], 3.0)
             self.assertEqual(result.dy[i], math.sqrt(0.5**2+1.0))
+            self.assertEqual(result.dy[i], math.sqrt(0.5**2 + 1.0))
     def test_sub(self):
         result = self.data2-self.data
+        result = self.data2 - self.data
         for i in range(5):
             self.assertEqual(result.y[i], -1.0)
             self.assertEqual(result.dy[i], math.sqrt(0.5**2+1.0))
+            self.assertEqual(result.dy[i], math.sqrt(0.5**2 + 1.0))
     def test_mul(self):
         result = self.data2*self.data
+        result = self.data2 * self.data
         for i in range(5):
             self.assertEqual(result.y[i], 2.0)
+            self.assertEqual(result.dy[i], math.sqrt((0.5*1.0)**2+(1.0*2.0)**2))
+            self.assertEqual(result.dy[i], math.sqrt(
+                (0.5 * 1.0)**2 + (1.0 * 2.0)**2))
     def test_div(self):
         result = self.data2/self.data
+        result = self.data2 / self.data
         for i in range(5):
             self.assertEqual(result.y[i], 0.5)
+            self.assertEqual(result.dy[i], math.sqrt((1.0/2.0)**2+(0.5*1.0/4.0)**2))
+            self.assertEqual(result.dy[i], math.sqrt(
+                (1.0 / 2.0)**2 + (0.5 * 1.0 / 4.0)**2))
     def test_radd(self):
         result = self.data+3.0
+        result = self.data + 3.0
         for i in range(5):
             self.assertEqual(result.y[i], 5.0)
             self.assertEqual(result.dy[i], 0.5)
         result = 3.0+self.data
+        result = 3.0 + self.data
         for i in range(5):
             self.assertEqual(result.y[i], 5.0)
             self.assertEqual(result.dy[i], 0.5)
     def test_rsub(self):
         result = self.data-3.0
+        result = self.data - 3.0
         for i in range(5):
             self.assertEqual(result.y[i], -1.0)
             self.assertEqual(result.dy[i], 0.5)
         result = 3.0-self.data
+        result = 3.0 - self.data
         for i in range(5):
             self.assertEqual(result.y[i], 1.0)
             self.assertEqual(result.dy[i], 0.5)
     def test_rmul(self):
         result = self.data*3.0
+        result = self.data * 3.0
         for i in range(5):
             self.assertEqual(result.y[i], 6.0)
             self.assertEqual(result.dy[i], 1.5)
         result = 3.0*self.data
+        result = 3.0 * self.data
         for i in range(5):
             self.assertEqual(result.y[i], 6.0)
             self.assertEqual(result.dy[i], 1.5)
     def test_rdiv(self):
         result = self.data/4.0
+        result = self.data / 4.0
         for i in range(5):
             self.assertEqual(result.y[i], 0.5)
             self.assertEqual(result.dy[i], 0.125)
         result = 6.0/self.data
+        result = 6.0 / self.data
         for i in range(5):
             self.assertEqual(result.y[i], 3.0)
+            self.assertEqual(result.dy[i], 6.0*0.5/4.0)
+class manip_2D(unittest.TestCase):
+            self.assertEqual(result.dy[i], 6.0 * 0.5 / 4.0)
+class Manin2DTests(unittest.TestCase):
     def setUp(self):
         # Create two data sets to play with
         x_0 = 2.0*np.ones(25)
         dx_0 = 0.5*np.ones(25)
+        x_0 = 2.0 * np.ones(25)
+        dx_0 = 0.5 * np.ones(25)
         qx_0 = np.arange(25)
         qy_0 = np.arange(25)
         mask_0 = np.zeros(25)
         dqx_0 = np.arange(25)/100
         dqy_0 = np.arange(25)/100
+        dqx_0 = np.arange(25) / 100
+        dqy_0 = np.arange(25) / 100
         q_0 = np.sqrt(qx_0 * qx_0 + qy_0 * qy_0)
         self.data = Data2D(image=x_0, err_image=dx_0, qx_data=qx_0,
                            qy_data=qy_0, q_data=q_0, mask=mask_0,
+        self.data = Data2D(image=x_0, err_image=dx_0, qx_data=qx_0,
+                           qy_data=qy_0, q_data=q_0, mask=mask_0,
                            dqx_data=dqx_0, dqy_data=dqy_0)
         y = np.ones(25)
         dy = np.ones(25)
 …
         mask = np.zeros(25)
         q = np.sqrt(qx * qx + qy * qy)
         self.data2 = Data2D(image=y, err_image=dy, qx_data=qx, qy_data=qy,
+        self.data2 = Data2D(image=y, err_image=dy, qx_data=qx, qy_data=qy,
                             q_data=q, mask=mask)
     def test_load(self):
         """
 …
         # There should be 5 entries in the file
         self.assertEqual(np.size(self.data.data), 25)
         for i in range(25):
             # All y-error values should be 0.5
             self.assertEqual(self.data.err_data[i], 0.5)
+            self.assertEqual(self.data.err_data[i], 0.5)
             # All y values should be 2.0
             self.assertEqual(self.data.data[i], 2.0)
+            self.assertEqual(self.data.data[i], 2.0)
     def test_add(self):
         result = self.data2+self.data
+        result = self.data2 + self.data
         for i in range(25):
             self.assertEqual(result.data[i], 3.0)
             self.assertEqual(result.err_data[i], math.sqrt(0.5**2+1.0))
+            self.assertEqual(result.err_data[i], math.sqrt(0.5**2 + 1.0))
     def test_sub(self):
         result = self.data2-self.data
         for i in range(25):
                 self.assertEqual(result.data[i], -1.0)
                 self.assertEqual(result.err_data[i], math.sqrt(0.5**2+1.0))
+        result = self.data2 - self.data
+        for i in range(25):
+            self.assertEqual(result.data[i], -1.0)
+            self.assertEqual(result.err_data[i], math.sqrt(0.5**2 + 1.0))
     def test_mul(self):
         result = self.data2*self.data
+        result = self.data2 * self.data
         for i in range(25):
             self.assertEqual(result.data[i], 2.0)
+            self.assertEqual(result.err_data[i], math.sqrt((0.5*1.0)**2+(1.0*2.0)**2))
+            self.assertEqual(result.err_data[i], math.sqrt(
+                (0.5 * 1.0)**2 + (1.0 * 2.0)**2))
     def test_div(self):
         result = self.data2/self.data
+        result = self.data2 / self.data
         for i in range(25):
             self.assertEqual(result.data[i], 0.5)
+            self.assertEqual(result.err_data[i], math.sqrt((1.0/2.0)**2+(0.5*1.0/4.0)**2))
+            self.assertEqual(result.err_data[i], math.sqrt(
+                (1.0 / 2.0)**2 + (0.5 * 1.0 / 4.0)**2))
     def test_radd(self):
         result = self.data+3.0
+        result = self.data + 3.0
         for i in range(25):
             self.assertEqual(result.data[i], 5.0)
             self.assertEqual(result.err_data[i], 0.5)
         result = 3.0+self.data
+        result = 3.0 + self.data
         for i in range(25):
             self.assertEqual(result.data[i], 5.0)
             self.assertEqual(result.err_data[i], 0.5)
     def test_rsub(self):
         result = self.data-3.0
+        result = self.data - 3.0
         for i in range(25):
             self.assertEqual(result.data[i], -1.0)
             self.assertEqual(result.err_data[i], 0.5)
         result = 3.0-self.data
+        result = 3.0 - self.data
         for i in range(25):
             self.assertEqual(result.data[i], 1.0)
             self.assertEqual(result.err_data[i], 0.5)
     def test_rmul(self):
         result = self.data*3.0
+        result = self.data * 3.0
         for i in range(25):
             self.assertEqual(result.data[i], 6.0)
             self.assertEqual(result.err_data[i], 1.5)
         result = 3.0*self.data
+        result = 3.0 * self.data
         for i in range(25):
             self.assertEqual(result.data[i], 6.0)
             self.assertEqual(result.err_data[i], 1.5)
     def test_rdiv(self):
         result = self.data/4.0
+        result = self.data / 4.0
         for i in range(25):
             self.assertEqual(result.data[i], 0.5)
             self.assertEqual(result.err_data[i], 0.125)
         result = 6.0/self.data
+        result = 6.0 / self.data
         for i in range(25):
             self.assertEqual(result.data[i], 3.0)
+            self.assertEqual(result.err_data[i], 6.0*0.5/4.0)
+class extra_manip_2D(unittest.TestCase):
+            self.assertEqual(result.err_data[i], 6.0 * 0.5 / 4.0)
+class ExtraManip2DTests(unittest.TestCase):
     def setUp(self):
         # Create two data sets to play with
         x_0 = 2.0*np.ones(25)
         dx_0 = 0.5*np.ones(25)
+        x_0 = 2.0 * np.ones(25)
+        dx_0 = 0.5 * np.ones(25)
         qx_0 = np.arange(25)
         qy_0 = np.arange(25)
         mask_0 = np.zeros(25)
         dqx_0 = np.arange(25)/100
         dqy_0 = np.arange(25)/100
+        dqx_0 = np.arange(25) / 100
+        dqy_0 = np.arange(25) / 100
         q_0 = np.sqrt(qx_0 * qx_0 + qy_0 * qy_0)
         self.data = Data2D(image=x_0, err_image=dx_0, qx_data=qx_0,
                            qy_data=qy_0, q_data=q_0, mask=mask_0,
+        self.data = Data2D(image=x_0, err_image=dx_0, qx_data=qx_0,
+                           qy_data=qy_0, q_data=q_0, mask=mask_0,
                            dqx_data=dqx_0, dqy_data=dqy_0)
         y = np.ones(25)
         dy = np.ones(25)
 …
         mask = np.zeros(25)
         q = np.sqrt(qx * qx + qy * qy)
         self.data2 = Data2D(image=y, err_image=dy, qx_data=qx, qy_data=qy,
+        self.data2 = Data2D(image=y, err_image=dy, qx_data=qx, qy_data=qy,
                             q_data=q, mask=mask)
     def test_load(self):
         """
 …
         # There should be 5 entries in the file
         self.assertEqual(np.size(self.data.data), 25)
         for i in range(25):
             # All y-error values should be 0.5
             self.assertEqual(self.data.err_data[i], 0.5)
+            self.assertEqual(self.data.err_data[i], 0.5)
             # All y values should be 2.0
             self.assertEqual(self.data.data[i], 2.0)
+            self.assertEqual(self.data.data[i], 2.0)
     def test_add(self):
         result = self.data2+self.data
+        result = self.data2 + self.data
         for i in range(25):
             self.assertEqual(result.data[i], 3.0)
             self.assertEqual(result.err_data[i], math.sqrt(0.5**2+1.0))
+            self.assertEqual(result.err_data[i], math.sqrt(0.5**2 + 1.0))
     def test_sub(self):
         result = self.data2-self.data
         for i in range(25):
                 self.assertEqual(result.data[i], -1.0)
                 self.assertEqual(result.err_data[i], math.sqrt(0.5**2+1.0))
+        result = self.data2 - self.data
+        for i in range(25):
+            self.assertEqual(result.data[i], -1.0)
+            self.assertEqual(result.err_data[i], math.sqrt(0.5**2 + 1.0))
     def test_mul(self):
         result = self.data2*self.data
+        result = self.data2 * self.data
         for i in range(25):
             self.assertEqual(result.data[i], 2.0)
+            self.assertEqual(result.err_data[i], math.sqrt((0.5*1.0)**2+(1.0*2.0)**2))
+            self.assertEqual(result.err_data[i], math.sqrt(
+                (0.5 * 1.0)**2 + (1.0 * 2.0)**2))
     def test_div(self):
         result = self.data2/self.data
+        result = self.data2 / self.data
         for i in range(25):
             self.assertEqual(result.data[i], 0.5)
+            self.assertEqual(result.err_data[i], math.sqrt((1.0/2.0)**2+(0.5*1.0/4.0)**2))
+            self.assertEqual(result.err_data[i], math.sqrt(
+                (1.0 / 2.0)**2 + (0.5 * 1.0 / 4.0)**2))
     def test_radd(self):
         result = self.data+3.0
+        result = self.data + 3.0
         for i in range(25):
             self.assertEqual(result.data[i], 5.0)
             self.assertEqual(result.err_data[i], 0.5)
         result = 3.0+self.data
+        result = 3.0 + self.data
         for i in range(25):
             self.assertEqual(result.data[i], 5.0)
             self.assertEqual(result.err_data[i], 0.5)
     def test_rsub(self):
         result = self.data-3.0
+        result = self.data - 3.0
         for i in range(25):
             self.assertEqual(result.data[i], -1.0)
             self.assertEqual(result.err_data[i], 0.5)
         result = 3.0-self.data
+        result = 3.0 - self.data
         for i in range(25):
             self.assertEqual(result.data[i], 1.0)
             self.assertEqual(result.err_data[i], 0.5)
     def test_rmul(self):
         result = self.data*3.0
+        result = self.data * 3.0
         for i in range(25):
             self.assertEqual(result.data[i], 6.0)
             self.assertEqual(result.err_data[i], 1.5)
         result = 3.0*self.data
+        result = 3.0 * self.data
         for i in range(25):
             self.assertEqual(result.data[i], 6.0)
             self.assertEqual(result.err_data[i], 1.5)
     def test_rdiv(self):
         result = self.data/4.0
+        result = self.data / 4.0
         for i in range(25):
             self.assertEqual(result.data[i], 0.5)
             self.assertEqual(result.err_data[i], 0.125)
         result = 6.0/self.data
+        result = 6.0 / self.data
         for i in range(25):
             self.assertEqual(result.data[i], 3.0)
+            self.assertEqual(result.err_data[i], 6.0*0.5/4.0)
+            self.assertEqual(result.err_data[i], 6.0 * 0.5 / 4.0)
 if __name__ == '__main__':
     unittest.main()

SasView

Changes in / [e3f1fed:43345ab] in sasview

Legend:

check_packages.py

docs/sphinx-docs/build_sphinx.py

run.py

sasview/test/sesans_data/sphere2micron.ses

src/sas/sascalc/data_util/nxsunit.py

src/sas/sascalc/data_util/qsmearing.py

src/sas/sascalc/dataloader/manipulations.py

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

src/sas/sascalc/pr/c_extensions/Cinvertor.c

src/sas/sascalc/pr/c_extensions/invertor.c

src/sas/sascalc/pr/c_extensions/invertor.h

src/sas/sascalc/pr/invertor.py

src/sas/sasgui/guiframe/local_perspectives/plotting/Plotter2D.py

src/sas/sasgui/guiframe/local_perspectives/plotting/SectorSlicer.py

src/sas/sasgui/perspectives/calculator/model_editor.py

src/sas/sasgui/perspectives/calculator/pyconsole.py

src/sas/sasgui/perspectives/fitting/basepage.py

src/sas/sasgui/perspectives/fitting/fitting.py

src/sas/sasgui/perspectives/fitting/models.py

src/sas/sasgui/perspectives/pr/inversion_panel.py

src/sas/sasgui/perspectives/pr/inversion_state.py

src/sas/sasgui/perspectives/pr/media/pr_help.rst

src/sas/sasgui/perspectives/pr/pr.py

test/pr_inversion/test/utest_invertor.py

test/sasdataloader/test/utest_averaging.py

test/sasguiframe/test/utest_manipulations.py

Download in other formats: