Index: src/sas/sascalc/calculator/BaseComponent.py
===================================================================
--- src/sas/sascalc/calculator/BaseComponent.py	(revision deddda187cdcc3d47108e1271351238d33c2fd41)
+++ src/sas/sascalc/calculator/BaseComponent.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -9,5 +9,5 @@
 from collections import OrderedDict
 
-import numpy
+import numpy as np
 #TO DO: that about a way to make the parameter
 #is self return if it is fittable or not
@@ -119,5 +119,5 @@
         Then get ::
 
-            q = numpy.sqrt(qx_prime^2+qy_prime^2)
+            q = np.sqrt(qx_prime^2+qy_prime^2)
 
         that is a qr in 1D array; ::
@@ -150,7 +150,7 @@
 
             # calculate q_r component for 2D isotropic
-            q = numpy.sqrt(qx**2+qy**2)
+            q = np.sqrt(qx**2+qy**2)
             # vectorize the model function runXY
-            v_model = numpy.vectorize(self.runXY, otypes=[float])
+            v_model = np.vectorize(self.runXY, otypes=[float])
             # calculate the scattering
             iq_array = v_model(q)
@@ -160,5 +160,5 @@
         elif qdist.__class__.__name__ == 'ndarray':
             # We have a simple 1D distribution of q-values
-            v_model = numpy.vectorize(self.runXY, otypes=[float])
+            v_model = np.vectorize(self.runXY, otypes=[float])
             iq_array = v_model(qdist)
             return iq_array
Index: src/sas/sascalc/calculator/instrument.py
===================================================================
--- src/sas/sascalc/calculator/instrument.py	(revision b699768550de9d4b35b087234ec1d2a461922bab)
+++ src/sas/sascalc/calculator/instrument.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -3,5 +3,5 @@
 control instrumental parameters
 """
-import numpy
+import numpy as np
 
 # defaults in cgs unit
@@ -168,5 +168,5 @@
         self.spectrum = self.get_default_spectrum()
         # intensity in counts/sec
-        self.intensity = numpy.interp(self.wavelength,
+        self.intensity = np.interp(self.wavelength,
                                       self.spectrum[0],
                                       self.spectrum[1],
@@ -203,5 +203,5 @@
         """
         spectrum = self.spectrum
-        intensity = numpy.interp(self.wavelength,
+        intensity = np.interp(self.wavelength,
                                  spectrum[0],
                                  spectrum[1],
@@ -244,5 +244,5 @@
         self.wavelength = wavelength
         validate(wavelength)
-        self.intensity = numpy.interp(self.wavelength,
+        self.intensity = np.interp(self.wavelength,
                                       self.spectrum[0],
                                       self.spectrum[1],
@@ -305,5 +305,5 @@
         get default spectrum
         """
-        return numpy.array(_LAMBDA_ARRAY)
+        return np.array(_LAMBDA_ARRAY)
 
     def get_band(self):
@@ -345,5 +345,5 @@
         get list of the intensity wrt wavelength_list
         """
-        out = numpy.interp(self.wavelength_list,
+        out = np.interp(self.wavelength_list,
                            self.spectrum[0],
                            self.spectrum[1],
Index: src/sas/sascalc/calculator/resolution_calculator.py
===================================================================
--- src/sas/sascalc/calculator/resolution_calculator.py	(revision b699768550de9d4b35b087234ec1d2a461922bab)
+++ src/sas/sascalc/calculator/resolution_calculator.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -12,5 +12,5 @@
 from math import sqrt
 import math
-import numpy
+import numpy as np
 import sys
 import logging
@@ -393,7 +393,7 @@
         dx_size = (self.qx_max - self.qx_min) / (1000 - 1)
         dy_size = (self.qy_max - self.qy_min) / (1000 - 1)
-        x_val = numpy.arange(self.qx_min, self.qx_max, dx_size)
-        y_val = numpy.arange(self.qy_max, self.qy_min, -dy_size)
-        q_1, q_2 = numpy.meshgrid(x_val, y_val)
+        x_val = np.arange(self.qx_min, self.qx_max, dx_size)
+        y_val = np.arange(self.qy_max, self.qy_min, -dy_size)
+        q_1, q_2 = np.meshgrid(x_val, y_val)
         #q_phi = numpy.arctan(q_1,q_2)
         # check whether polar or cartesian
@@ -887,5 +887,5 @@
         x_value = x_val - x0_val
         y_value = y_val - y0_val
-        phi_i = numpy.arctan2(y_val, x_val)
+        phi_i = np.arctan2(y_val, x_val)
 
         # phi correction due to the gravity shift (in phi)
@@ -893,6 +893,6 @@
         phi_i = phi_i - phi_0 + self.gravity_phi
 
-        sin_phi = numpy.sin(self.gravity_phi)
-        cos_phi = numpy.cos(self.gravity_phi)
+        sin_phi = np.sin(self.gravity_phi)
+        cos_phi = np.cos(self.gravity_phi)
 
         x_p = x_value * cos_phi + y_value * sin_phi
@@ -908,5 +908,5 @@
         nu_value = -0.5 * (new_x * new_x + new_y * new_y)
 
-        gaussian = numpy.exp(nu_value)
+        gaussian = np.exp(nu_value)
         # normalizing factor correction
         gaussian /= gaussian.sum()
@@ -954,5 +954,5 @@
             nu_value *= nu_value
             nu_value *= -0.5
-            gaussian *= numpy.exp(nu_value)
+            gaussian *= np.exp(nu_value)
             gaussian /= sigma
             # normalize
@@ -1026,6 +1026,6 @@
                                                            offset_x, offset_y)
         # distance [cm] from the beam center on detector plane
-        detector_ind_x = numpy.arange(detector_pix_nums_x)
-        detector_ind_y = numpy.arange(detector_pix_nums_y)
+        detector_ind_x = np.arange(detector_pix_nums_x)
+        detector_ind_y = np.arange(detector_pix_nums_y)
 
         # shif 0.5 pixel so that pix position is at the center of the pixel
@@ -1041,6 +1041,6 @@
         detector_ind_y = detector_ind_y * pix_y_size
 
-        qx_value = numpy.zeros(len(detector_ind_x))
-        qy_value = numpy.zeros(len(detector_ind_y))
+        qx_value = np.zeros(len(detector_ind_x))
+        qy_value = np.zeros(len(detector_ind_y))
         i = 0
 
@@ -1061,8 +1061,8 @@
 
         # p min and max values among the center of pixels
-        self.qx_min = numpy.min(qx_value)
-        self.qx_max = numpy.max(qx_value)
-        self.qy_min = numpy.min(qy_value)
-        self.qy_max = numpy.max(qy_value)
+        self.qx_min = np.min(qx_value)
+        self.qx_max = np.max(qx_value)
+        self.qy_min = np.min(qy_value)
+        self.qy_max = np.max(qy_value)
 
         # Appr. min and max values of the detector display limits
@@ -1088,5 +1088,5 @@
             from sas.sascalc.dataloader.data_info import Data2D
             output = Data2D()
-            inten = numpy.zeros_like(qx_value)
+            inten = np.zeros_like(qx_value)
             output.data = inten
             output.qx_data = qx_value
@@ -1107,6 +1107,6 @@
         plane_dist = dx_size
         # full scattering angle on the x-axis
-        theta = numpy.arctan(plane_dist / det_dist)
-        qx_value = (2.0 * pi / wavelength) * numpy.sin(theta)
+        theta = np.arctan(plane_dist / det_dist)
+        qx_value = (2.0 * pi / wavelength) * np.sin(theta)
         return qx_value
 
Index: src/sas/sascalc/calculator/sas_gen.py
===================================================================
--- src/sas/sascalc/calculator/sas_gen.py	(revision d2fd8fc62a44e402ef17815b5b0bf932d5332ff0)
+++ src/sas/sascalc/calculator/sas_gen.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -7,5 +7,5 @@
 from periodictable import formula
 from periodictable import nsf
-import numpy
+import numpy as np
 import os
 import copy
@@ -80,11 +80,11 @@
         ## Parameter details [units, min, max]
         self.details = {}
-        self.details['scale'] = ['', 0.0, numpy.inf]
-        self.details['background'] = ['[1/cm]', 0.0, numpy.inf]
-        self.details['solvent_SLD'] = ['1/A^(2)', -numpy.inf, numpy.inf]
-        self.details['total_volume'] = ['A^(3)', 0.0, numpy.inf]
+        self.details['scale'] = ['', 0.0, np.inf]
+        self.details['background'] = ['[1/cm]', 0.0, np.inf]
+        self.details['solvent_SLD'] = ['1/A^(2)', -np.inf, np.inf]
+        self.details['total_volume'] = ['A^(3)', 0.0, np.inf]
         self.details['Up_frac_in'] = ['[u/(u+d)]', 0.0, 1.0]
         self.details['Up_frac_out'] = ['[u/(u+d)]', 0.0, 1.0]
-        self.details['Up_theta'] = ['[deg]', -numpy.inf, numpy.inf]
+        self.details['Up_theta'] = ['[deg]', -np.inf, np.inf]
         # fixed parameters
         self.fixed = []
@@ -171,5 +171,5 @@
                 msg = "Not a 1D."
                 raise ValueError, msg
-            i_out = numpy.zeros_like(x[0])
+            i_out = np.zeros_like(x[0])
             # 1D I is found at y =0 in the 2D pattern
             out = self._gen(x[0], [], i_out)
@@ -187,5 +187,5 @@
         """
         if x.__class__.__name__ == 'list':
-            i_out = numpy.zeros_like(x[0])
+            i_out = np.zeros_like(x[0])
             out = self._gen(x[0], x[1], i_out)
             return out
@@ -237,32 +237,32 @@
         self.omfdata = omfdata
         length = int(omfdata.xnodes * omfdata.ynodes * omfdata.znodes)
-        pos_x = numpy.arange(omfdata.xmin,
+        pos_x = np.arange(omfdata.xmin,
                              omfdata.xnodes*omfdata.xstepsize + omfdata.xmin,
                              omfdata.xstepsize)
-        pos_y = numpy.arange(omfdata.ymin,
+        pos_y = np.arange(omfdata.ymin,
                              omfdata.ynodes*omfdata.ystepsize + omfdata.ymin,
                              omfdata.ystepsize)
-        pos_z = numpy.arange(omfdata.zmin,
+        pos_z = np.arange(omfdata.zmin,
                              omfdata.znodes*omfdata.zstepsize + omfdata.zmin,
                              omfdata.zstepsize)
-        self.pos_x = numpy.tile(pos_x, int(omfdata.ynodes * omfdata.znodes))
+        self.pos_x = np.tile(pos_x, int(omfdata.ynodes * omfdata.znodes))
         self.pos_y = pos_y.repeat(int(omfdata.xnodes))
-        self.pos_y = numpy.tile(self.pos_y, int(omfdata.znodes))
+        self.pos_y = np.tile(self.pos_y, int(omfdata.znodes))
         self.pos_z = pos_z.repeat(int(omfdata.xnodes * omfdata.ynodes))
         self.mx = omfdata.mx
         self.my = omfdata.my
         self.mz = omfdata.mz
-        self.sld_n = numpy.zeros(length)
+        self.sld_n = np.zeros(length)
 
         if omfdata.mx == None:
-            self.mx = numpy.zeros(length)
+            self.mx = np.zeros(length)
         if omfdata.my == None:
-            self.my = numpy.zeros(length)
+            self.my = np.zeros(length)
         if omfdata.mz == None:
-            self.mz = numpy.zeros(length)
+            self.mz = np.zeros(length)
 
         self._check_data_length(length)
         self.remove_null_points(False, False)
-        mask = numpy.ones(len(self.sld_n), dtype=bool)
+        mask = np.ones(len(self.sld_n), dtype=bool)
         if shape.lower() == 'ellipsoid':
             try:
@@ -328,6 +328,6 @@
         """
         if remove:
-            is_nonzero = (numpy.fabs(self.mx) + numpy.fabs(self.my) +
-                          numpy.fabs(self.mz)).nonzero()
+            is_nonzero = (np.fabs(self.mx) + np.fabs(self.my) +
+                          np.fabs(self.mz)).nonzero()
             if len(is_nonzero[0]) > 0:
                 self.pos_x = self.pos_x[is_nonzero]
@@ -369,7 +369,7 @@
         """
         desc = ""
-        mx = numpy.zeros(0)
-        my = numpy.zeros(0)
-        mz = numpy.zeros(0)
+        mx = np.zeros(0)
+        my = np.zeros(0)
+        mz = np.zeros(0)
         try:
             input_f = open(path, 'rb')
@@ -389,7 +389,7 @@
                     _my = mag2sld(_my, valueunit)
                     _mz = mag2sld(_mz, valueunit)
-                    mx = numpy.append(mx, _mx)
-                    my = numpy.append(my, _my)
-                    mz = numpy.append(mz, _mz)
+                    mx = np.append(mx, _mx)
+                    my = np.append(my, _my)
+                    mz = np.append(mz, _mz)
                 except:
                     # Skip non-data lines
@@ -501,13 +501,13 @@
         :raise RuntimeError: when the file can't be opened
         """
-        pos_x = numpy.zeros(0)
-        pos_y = numpy.zeros(0)
-        pos_z = numpy.zeros(0)
-        sld_n = numpy.zeros(0)
-        sld_mx = numpy.zeros(0)
-        sld_my = numpy.zeros(0)
-        sld_mz = numpy.zeros(0)
-        vol_pix = numpy.zeros(0)
-        pix_symbol = numpy.zeros(0)
+        pos_x = np.zeros(0)
+        pos_y = np.zeros(0)
+        pos_z = np.zeros(0)
+        sld_n = np.zeros(0)
+        sld_mx = np.zeros(0)
+        sld_my = np.zeros(0)
+        sld_mz = np.zeros(0)
+        vol_pix = np.zeros(0)
+        pix_symbol = np.zeros(0)
         x_line = []
         y_line = []
@@ -543,23 +543,23 @@
                         _pos_y = float(line[38:46].strip())
                         _pos_z = float(line[46:54].strip())
-                        pos_x = numpy.append(pos_x, _pos_x)
-                        pos_y = numpy.append(pos_y, _pos_y)
-                        pos_z = numpy.append(pos_z, _pos_z)
+                        pos_x = np.append(pos_x, _pos_x)
+                        pos_y = np.append(pos_y, _pos_y)
+                        pos_z = np.append(pos_z, _pos_z)
                         try:
                             val = nsf.neutron_sld(atom_name)[0]
                             # sld in Ang^-2 unit
                             val *= 1.0e-6
-                            sld_n = numpy.append(sld_n, val)
+                            sld_n = np.append(sld_n, val)
                             atom = formula(atom_name)
                             # cm to A units
                             vol = 1.0e+24 * atom.mass / atom.density / NA
-                            vol_pix = numpy.append(vol_pix, vol)
+                            vol_pix = np.append(vol_pix, vol)
                         except:
                             print "Error: set the sld of %s to zero"% atom_name
-                            sld_n = numpy.append(sld_n, 0.0)
-                        sld_mx = numpy.append(sld_mx, 0)
-                        sld_my = numpy.append(sld_my, 0)
-                        sld_mz = numpy.append(sld_mz, 0)
-                        pix_symbol = numpy.append(pix_symbol, atom_name)
+                            sld_n = np.append(sld_n, 0.0)
+                        sld_mx = np.append(sld_mx, 0)
+                        sld_my = np.append(sld_my, 0)
+                        sld_mz = np.append(sld_mz, 0)
+                        pix_symbol = np.append(pix_symbol, atom_name)
                     elif line[0:6].strip().count('CONECT') > 0:
                         toks = line.split()
@@ -630,25 +630,25 @@
         """
         try:
-            pos_x = numpy.zeros(0)
-            pos_y = numpy.zeros(0)
-            pos_z = numpy.zeros(0)
-            sld_n = numpy.zeros(0)
-            sld_mx = numpy.zeros(0)
-            sld_my = numpy.zeros(0)
-            sld_mz = numpy.zeros(0)
+            pos_x = np.zeros(0)
+            pos_y = np.zeros(0)
+            pos_z = np.zeros(0)
+            sld_n = np.zeros(0)
+            sld_mx = np.zeros(0)
+            sld_my = np.zeros(0)
+            sld_mz = np.zeros(0)
             try:
                 # Use numpy to speed up loading
-                input_f = numpy.loadtxt(path, dtype='float', skiprows=1,
+                input_f = np.loadtxt(path, dtype='float', skiprows=1,
                                         ndmin=1, unpack=True)
-                pos_x = numpy.array(input_f[0])
-                pos_y = numpy.array(input_f[1])
-                pos_z = numpy.array(input_f[2])
-                sld_n = numpy.array(input_f[3])
-                sld_mx = numpy.array(input_f[4])
-                sld_my = numpy.array(input_f[5])
-                sld_mz = numpy.array(input_f[6])
+                pos_x = np.array(input_f[0])
+                pos_y = np.array(input_f[1])
+                pos_z = np.array(input_f[2])
+                sld_n = np.array(input_f[3])
+                sld_mx = np.array(input_f[4])
+                sld_my = np.array(input_f[5])
+                sld_mz = np.array(input_f[6])
                 ncols = len(input_f)
                 if ncols == 8:
-                    vol_pix = numpy.array(input_f[7])
+                    vol_pix = np.array(input_f[7])
                 elif ncols == 7:
                     vol_pix = None
@@ -669,14 +669,14 @@
                         _sld_my = float(toks[5])
                         _sld_mz = float(toks[6])
-                        pos_x = numpy.append(pos_x, _pos_x)
-                        pos_y = numpy.append(pos_y, _pos_y)
-                        pos_z = numpy.append(pos_z, _pos_z)
-                        sld_n = numpy.append(sld_n, _sld_n)
-                        sld_mx = numpy.append(sld_mx, _sld_mx)
-                        sld_my = numpy.append(sld_my, _sld_my)
-                        sld_mz = numpy.append(sld_mz, _sld_mz)
+                        pos_x = np.append(pos_x, _pos_x)
+                        pos_y = np.append(pos_y, _pos_y)
+                        pos_z = np.append(pos_z, _pos_z)
+                        sld_n = np.append(sld_n, _sld_n)
+                        sld_mx = np.append(sld_mx, _sld_mx)
+                        sld_my = np.append(sld_my, _sld_my)
+                        sld_mz = np.append(sld_mz, _sld_mz)
                         try:
                             _vol_pix = float(toks[7])
-                            vol_pix = numpy.append(vol_pix, _vol_pix)
+                            vol_pix = np.append(vol_pix, _vol_pix)
                         except:
                             vol_pix = None
@@ -712,10 +712,10 @@
         sld_n = data.sld_n
         if sld_n == None:
-            sld_n = numpy.zeros(length)
+            sld_n = np.zeros(length)
         sld_mx = data.sld_mx
         if sld_mx == None:
-            sld_mx = numpy.zeros(length)
-            sld_my = numpy.zeros(length)
-            sld_mz = numpy.zeros(length)
+            sld_mx = np.zeros(length)
+            sld_my = np.zeros(length)
+            sld_mz = np.zeros(length)
         else:
             sld_my = data.sld_my
@@ -893,8 +893,8 @@
             if self.is_data:
                 # For data, put the value to only the pixels w non-zero M
-                is_nonzero = (numpy.fabs(self.sld_mx) +
-                              numpy.fabs(self.sld_my) +
-                              numpy.fabs(self.sld_mz)).nonzero()
-                self.sld_n = numpy.zeros(len(self.pos_x))
+                is_nonzero = (np.fabs(self.sld_mx) +
+                              np.fabs(self.sld_my) +
+                              np.fabs(self.sld_mz)).nonzero()
+                self.sld_n = np.zeros(len(self.pos_x))
                 if len(self.sld_n[is_nonzero]) > 0:
                     self.sld_n[is_nonzero] = sld_n
@@ -903,5 +903,5 @@
             else:
                 # For non-data, put the value to all the pixels
-                self.sld_n = numpy.ones(len(self.pos_x)) * sld_n
+                self.sld_n = np.ones(len(self.pos_x)) * sld_n
         else:
             self.sld_n = sld_n
@@ -912,17 +912,17 @@
         """
         if sld_mx.__class__.__name__ == 'float':
-            self.sld_mx = numpy.ones(len(self.pos_x)) * sld_mx
+            self.sld_mx = np.ones(len(self.pos_x)) * sld_mx
         else:
             self.sld_mx = sld_mx
         if sld_my.__class__.__name__ == 'float':
-            self.sld_my = numpy.ones(len(self.pos_x)) * sld_my
+            self.sld_my = np.ones(len(self.pos_x)) * sld_my
         else:
             self.sld_my = sld_my
         if sld_mz.__class__.__name__ == 'float':
-            self.sld_mz = numpy.ones(len(self.pos_x)) * sld_mz
+            self.sld_mz = np.ones(len(self.pos_x)) * sld_mz
         else:
             self.sld_mz = sld_mz
 
-        sld_m = numpy.sqrt(sld_mx * sld_mx + sld_my * sld_my + \
+        sld_m = np.sqrt(sld_mx * sld_mx + sld_my * sld_my + \
                                 sld_mz * sld_mz)
         self.sld_m = sld_m
@@ -936,5 +936,5 @@
             return
         if symbol.__class__.__name__ == 'str':
-            self.pix_symbol = numpy.repeat(symbol, len(self.sld_n))
+            self.pix_symbol = np.repeat(symbol, len(self.sld_n))
         else:
             self.pix_symbol = symbol
@@ -950,5 +950,5 @@
             self.vol_pix = vol
         elif vol.__class__.__name__.count('float') > 0:
-            self.vol_pix = numpy.repeat(vol, len(self.sld_n))
+            self.vol_pix = np.repeat(vol, len(self.sld_n))
         else:
             self.vol_pix = None
@@ -993,16 +993,16 @@
                 for x_pos in self.pos_x:
                     if xpos_pre != x_pos:
-                        self.xstepsize = numpy.fabs(x_pos - xpos_pre)
+                        self.xstepsize = np.fabs(x_pos - xpos_pre)
                         break
                 for y_pos in self.pos_y:
                     if ypos_pre != y_pos:
-                        self.ystepsize = numpy.fabs(y_pos - ypos_pre)
+                        self.ystepsize = np.fabs(y_pos - ypos_pre)
                         break
                 for z_pos in self.pos_z:
                     if zpos_pre != z_pos:
-                        self.zstepsize = numpy.fabs(z_pos - zpos_pre)
+                        self.zstepsize = np.fabs(z_pos - zpos_pre)
                         break
                 #default pix volume
-                self.vol_pix = numpy.ones(len(self.pos_x))
+                self.vol_pix = np.ones(len(self.pos_x))
                 vol = self.xstepsize * self.ystepsize * self.zstepsize
                 self.set_pixel_volumes(vol)
@@ -1071,14 +1071,14 @@
     y2 = output.pos_y+output.sld_my/max_m * gap
     z2 = output.pos_z+output.sld_mz/max_m * gap
-    x_arrow = numpy.column_stack((output.pos_x, x2))
-    y_arrow = numpy.column_stack((output.pos_y, y2))
-    z_arrow = numpy.column_stack((output.pos_z, z2))
+    x_arrow = np.column_stack((output.pos_x, x2))
+    y_arrow = np.column_stack((output.pos_y, y2))
+    z_arrow = np.column_stack((output.pos_z, z2))
     unit_x2 = output.sld_mx / max_m
     unit_y2 = output.sld_my / max_m
     unit_z2 = output.sld_mz / max_m
-    color_x = numpy.fabs(unit_x2 * 0.8)
-    color_y = numpy.fabs(unit_y2 * 0.8)
-    color_z = numpy.fabs(unit_z2 * 0.8)
-    colors = numpy.column_stack((color_x, color_y, color_z))
+    color_x = np.fabs(unit_x2 * 0.8)
+    color_y = np.fabs(unit_y2 * 0.8)
+    color_z = np.fabs(unit_z2 * 0.8)
+    colors = np.column_stack((color_x, color_y, color_z))
     plt.show()
 
@@ -1103,7 +1103,7 @@
     model = GenSAS()
     model.set_sld_data(foutput.output)
-    x = numpy.arange(1000)/10000. + 1e-5
-    y = numpy.arange(1000)/10000. + 1e-5
-    i = numpy.zeros(1000)
+    x = np.arange(1000)/10000. + 1e-5
+    y = np.arange(1000)/10000. + 1e-5
+    i = np.zeros(1000)
     model.runXY([x, y, i])
 
Index: src/sas/sascalc/data_util/err1d.py
===================================================================
--- src/sas/sascalc/data_util/err1d.py	(revision b699768550de9d4b35b087234ec1d2a461922bab)
+++ src/sas/sascalc/data_util/err1d.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -8,5 +8,5 @@
 """
 from __future__ import division  # Get true division
-import numpy
+import numpy as np
 
 
@@ -59,5 +59,5 @@
 def exp(X, varX):
     """Exponentiation with error propagation"""
-    Z = numpy.exp(X)
+    Z = np.exp(X)
     varZ = varX * Z**2
     return Z, varZ
@@ -66,5 +66,5 @@
 def log(X, varX):
     """Logarithm with error propagation"""
-    Z = numpy.log(X)
+    Z = np.log(X)
     varZ = varX / X**2
     return Z, varZ
@@ -73,5 +73,5 @@
 # def pow(X,varX, Y,varY):
 #    Z = X**Y
-#    varZ = (Y**2 * varX/X**2 + varY * numpy.log(X)**2) * Z**2
+#    varZ = (Y**2 * varX/X**2 + varY * np.log(X)**2) * Z**2
 #    return Z,varZ
 #
Index: src/sas/sascalc/data_util/formatnum.py
===================================================================
--- src/sas/sascalc/data_util/formatnum.py	(revision b699768550de9d4b35b087234ec1d2a461922bab)
+++ src/sas/sascalc/data_util/formatnum.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -40,5 +40,5 @@
 
 import math
-import numpy
+import numpy as np
 __all__ = ['format_uncertainty', 'format_uncertainty_pm',
            'format_uncertainty_compact']
@@ -102,13 +102,13 @@
     """
     # Handle indefinite value
-    if numpy.isinf(value):
+    if np.isinf(value):
         return "inf" if value > 0 else "-inf"
-    if numpy.isnan(value):
+    if np.isnan(value):
         return "NaN"
 
     # Handle indefinite uncertainty
-    if uncertainty is None or uncertainty <= 0 or numpy.isnan(uncertainty):
+    if uncertainty is None or uncertainty <= 0 or np.isnan(uncertainty):
         return "%g" % value
-    if numpy.isinf(uncertainty):
+    if np.isinf(uncertainty):
         if compact:
             return "%.2g(inf)" % value
@@ -279,15 +279,15 @@
 
     # non-finite values
-    assert value_str(-numpy.inf,None) == "-inf"
-    assert value_str(numpy.inf,None) == "inf"
-    assert value_str(numpy.NaN,None) == "NaN"
+    assert value_str(-np.inf,None) == "-inf"
+    assert value_str(np.inf,None) == "inf"
+    assert value_str(np.NaN,None) == "NaN"
     
     # bad or missing uncertainty
-    assert value_str(-1.23567,numpy.NaN) == "-1.23567"
-    assert value_str(-1.23567,-numpy.inf) == "-1.23567"
+    assert value_str(-1.23567,np.NaN) == "-1.23567"
+    assert value_str(-1.23567,-np.inf) == "-1.23567"
     assert value_str(-1.23567,-0.1) == "-1.23567"
     assert value_str(-1.23567,0) == "-1.23567"
     assert value_str(-1.23567,None) == "-1.23567"
-    assert value_str(-1.23567,numpy.inf) == "-1.2(inf)"
+    assert value_str(-1.23567,np.inf) == "-1.2(inf)"
 
 def test_pm():
@@ -410,15 +410,15 @@
 
     # non-finite values
-    assert value_str(-numpy.inf,None) == "-inf"
-    assert value_str(numpy.inf,None) == "inf"
-    assert value_str(numpy.NaN,None) == "NaN"
+    assert value_str(-np.inf,None) == "-inf"
+    assert value_str(np.inf,None) == "inf"
+    assert value_str(np.NaN,None) == "NaN"
     
     # bad or missing uncertainty
-    assert value_str(-1.23567,numpy.NaN) == "-1.23567"
-    assert value_str(-1.23567,-numpy.inf) == "-1.23567"
+    assert value_str(-1.23567,np.NaN) == "-1.23567"
+    assert value_str(-1.23567,-np.inf) == "-1.23567"
     assert value_str(-1.23567,-0.1) == "-1.23567"
     assert value_str(-1.23567,0) == "-1.23567"
     assert value_str(-1.23567,None) == "-1.23567"
-    assert value_str(-1.23567,numpy.inf) == "-1.2 +/- inf"
+    assert value_str(-1.23567,np.inf) == "-1.2 +/- inf"
 
 def test_default():
Index: src/sas/sascalc/data_util/qsmearing.py
===================================================================
--- src/sas/sascalc/data_util/qsmearing.py	(revision 775e0b725267ddb2b166c5d860205f56659906ad)
+++ src/sas/sascalc/data_util/qsmearing.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -9,5 +9,4 @@
 #copyright 2008, University of Tennessee
 ######################################################################
-import numpy
 import math
 import logging
@@ -60,8 +59,8 @@
     if data.dx is not None and data.isSesans:
         #if data.dx[0] > 0.0:
-        if numpy.size(data.dx[data.dx <= 0]) == 0:
+        if np.size(data.dx[data.dx <= 0]) == 0:
             _found_sesans = True
         # if data.dx[0] <= 0.0:
-        if numpy.size(data.dx[data.dx <= 0]) > 0:
+        if np.size(data.dx[data.dx <= 0]) > 0:
             raise ValueError('one or more of your dx values are negative, please check the data file!')
 
@@ -121,5 +120,5 @@
         self.resolution = resolution
         if offset is None:
-            offset = numpy.searchsorted(self.resolution.q_calc, self.resolution.q[0])
+            offset = np.searchsorted(self.resolution.q_calc, self.resolution.q[0])
         self.offset = offset
 
@@ -137,5 +136,5 @@
         start, end = first_bin + self.offset, last_bin + self.offset
         q_calc = self.resolution.q_calc
-        iq_calc = numpy.empty_like(q_calc)
+        iq_calc = np.empty_like(q_calc)
         if start > 0:
             iq_calc[:start] = self.model.evalDistribution(q_calc[:start])
@@ -157,6 +156,6 @@
         """
         q = self.resolution.q
-        first = numpy.searchsorted(q, q_min)
-        last = numpy.searchsorted(q, q_max)
+        first = np.searchsorted(q, q_min)
+        last = np.searchsorted(q, q_max)
         return first, min(last,len(q)-1)
 
Index: src/sas/sascalc/data_util/uncertainty.py
===================================================================
--- src/sas/sascalc/data_util/uncertainty.py	(revision b699768550de9d4b35b087234ec1d2a461922bab)
+++ src/sas/sascalc/data_util/uncertainty.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -17,5 +17,5 @@
 from __future__ import division
 
-import numpy
+import numpy as np
 import err1d
 from formatnum import format_uncertainty
@@ -27,5 +27,5 @@
 class Uncertainty(object):
     # Make standard deviation available
-    def _getdx(self): return numpy.sqrt(self.variance)
+    def _getdx(self): return np.sqrt(self.variance)
     def _setdx(self,dx): 
         # Direct operation
@@ -144,13 +144,13 @@
         return self
     def __abs__(self):
-        return Uncertainty(numpy.abs(self.x),self.variance)
+        return Uncertainty(np.abs(self.x),self.variance)
 
     def __str__(self):
-        #return str(self.x)+" +/- "+str(numpy.sqrt(self.variance))
-        if numpy.isscalar(self.x):
-            return format_uncertainty(self.x,numpy.sqrt(self.variance))
+        #return str(self.x)+" +/- "+str(np.sqrt(self.variance))
+        if np.isscalar(self.x):
+            return format_uncertainty(self.x,np.sqrt(self.variance))
         else:
             return [format_uncertainty(v,dv) 
-                    for v,dv in zip(self.x,numpy.sqrt(self.variance))]
+                    for v,dv in zip(self.x,np.sqrt(self.variance))]
     def __repr__(self):
         return "Uncertainty(%s,%s)"%(str(self.x),str(self.variance))
@@ -287,12 +287,12 @@
     # =============== vector operations ================
     # Slicing
-    z = Uncertainty(numpy.array([1,2,3,4,5]),numpy.array([2,1,2,3,2]))
+    z = Uncertainty(np.array([1,2,3,4,5]),np.array([2,1,2,3,2]))
     assert z[2].x == 3 and z[2].variance == 2
     assert (z[2:4].x == [3,4]).all()
     assert (z[2:4].variance == [2,3]).all()
-    z[2:4] = Uncertainty(numpy.array([8,7]),numpy.array([4,5]))
+    z[2:4] = Uncertainty(np.array([8,7]),np.array([4,5]))
     assert z[2].x == 8 and z[2].variance == 4
-    A = Uncertainty(numpy.array([a.x]*2),numpy.array([a.variance]*2))
-    B = Uncertainty(numpy.array([b.x]*2),numpy.array([b.variance]*2))
+    A = Uncertainty(np.array([a.x]*2),np.array([a.variance]*2))
+    B = Uncertainty(np.array([b.x]*2),np.array([b.variance]*2))
 
     # TODO complete tests of copy and inplace operations for vectors and slices.
Index: src/sas/sascalc/dataloader/data_info.py
===================================================================
--- src/sas/sascalc/dataloader/data_info.py	(revision 2ffe241a82548f1c3017267ebe33cb91ce512e31)
+++ src/sas/sascalc/dataloader/data_info.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -23,5 +23,5 @@
 #from sas.guitools.plottables import Data1D as plottable_1D
 from sas.sascalc.data_util.uncertainty import Uncertainty
-import numpy
+import numpy as np
 import math
 
@@ -51,18 +51,18 @@
 
     def __init__(self, x, y, dx=None, dy=None, dxl=None, dxw=None, lam=None, dlam=None):
-        self.x = numpy.asarray(x)
-        self.y = numpy.asarray(y)
+        self.x = np.asarray(x)
+        self.y = np.asarray(y)
         if dx is not None:
-            self.dx = numpy.asarray(dx)
+            self.dx = np.asarray(dx)
         if dy is not None:
-            self.dy = numpy.asarray(dy)
+            self.dy = np.asarray(dy)
         if dxl is not None:
-            self.dxl = numpy.asarray(dxl)
+            self.dxl = np.asarray(dxl)
         if dxw is not None:
-            self.dxw = numpy.asarray(dxw)
+            self.dxw = np.asarray(dxw)
         if lam is not None:
-            self.lam = numpy.asarray(lam)
+            self.lam = np.asarray(lam)
         if dlam is not None:
-            self.dlam = numpy.asarray(dlam)
+            self.dlam = np.asarray(dlam)
 
     def xaxis(self, label, unit):
@@ -109,14 +109,14 @@
                  qy_data=None, q_data=None, mask=None,
                  dqx_data=None, dqy_data=None):
-        self.data = numpy.asarray(data)
-        self.qx_data = numpy.asarray(qx_data)
-        self.qy_data = numpy.asarray(qy_data)
-        self.q_data = numpy.asarray(q_data)
-        self.mask = numpy.asarray(mask)
-        self.err_data = numpy.asarray(err_data)
+        self.data = np.asarray(data)
+        self.qx_data = np.asarray(qx_data)
+        self.qy_data = np.asarray(qy_data)
+        self.q_data = np.asarray(q_data)
+        self.mask = np.asarray(mask)
+        self.err_data = np.asarray(err_data)
         if dqx_data is not None:
-            self.dqx_data = numpy.asarray(dqx_data)
+            self.dqx_data = np.asarray(dqx_data)
         if dqy_data is not None:
-            self.dqy_data = numpy.asarray(dqy_data)
+            self.dqy_data = np.asarray(dqy_data)
 
     def xaxis(self, label, unit):
@@ -734,5 +734,5 @@
         """
         def _check(v):
-            if (v.__class__ == list or v.__class__ == numpy.ndarray) \
+            if (v.__class__ == list or v.__class__ == np.ndarray) \
                 and len(v) > 0 and min(v) > 0:
                 return True
@@ -752,10 +752,10 @@
 
         if clone is None or not issubclass(clone.__class__, Data1D):
-            x = numpy.zeros(length)
-            dx = numpy.zeros(length)
-            y = numpy.zeros(length)
-            dy = numpy.zeros(length)
-            lam = numpy.zeros(length)
-            dlam = numpy.zeros(length)
+            x = np.zeros(length)
+            dx = np.zeros(length)
+            y = np.zeros(length)
+            dy = np.zeros(length)
+            lam = np.zeros(length)
+            dlam = np.zeros(length)
             clone = Data1D(x, y, lam=lam, dx=dx, dy=dy, dlam=dlam)
 
@@ -806,10 +806,10 @@
             dy_other = other.dy
             if other.dy == None or (len(other.dy) != len(other.y)):
-                dy_other = numpy.zeros(len(other.y))
+                dy_other = np.zeros(len(other.y))
 
         # Check that we have errors, otherwise create zero vector
         dy = self.dy
         if self.dy == None or (len(self.dy) != len(self.y)):
-            dy = numpy.zeros(len(self.y))
+            dy = np.zeros(len(self.y))
 
         return dy, dy_other
@@ -824,9 +824,9 @@
             result.dxw = None
         else:
-            result.dxw = numpy.zeros(len(self.x))
+            result.dxw = np.zeros(len(self.x))
         if self.dxl == None:
             result.dxl = None
         else:
-            result.dxl = numpy.zeros(len(self.x))
+            result.dxl = np.zeros(len(self.x))
 
         for i in range(len(self.x)):
@@ -886,35 +886,35 @@
             result.dy = None
         else:
-            result.dy = numpy.zeros(len(self.x) + len(other.x))
+            result.dy = np.zeros(len(self.x) + len(other.x))
         if self.dx == None or other.dx is None:
             result.dx = None
         else:
-            result.dx = numpy.zeros(len(self.x) + len(other.x))
+            result.dx = np.zeros(len(self.x) + len(other.x))
         if self.dxw == None or other.dxw is None:
             result.dxw = None
         else:
-            result.dxw = numpy.zeros(len(self.x) + len(other.x))
+            result.dxw = np.zeros(len(self.x) + len(other.x))
         if self.dxl == None or other.dxl is None:
             result.dxl = None
         else:
-            result.dxl = numpy.zeros(len(self.x) + len(other.x))
-
-        result.x = numpy.append(self.x, other.x)
+            result.dxl = np.zeros(len(self.x) + len(other.x))
+
+        result.x = np.append(self.x, other.x)
         #argsorting
-        ind = numpy.argsort(result.x)
+        ind = np.argsort(result.x)
         result.x = result.x[ind]
-        result.y = numpy.append(self.y, other.y)
+        result.y = np.append(self.y, other.y)
         result.y = result.y[ind]
         if result.dy != None:
-            result.dy = numpy.append(self.dy, other.dy)
+            result.dy = np.append(self.dy, other.dy)
             result.dy = result.dy[ind]
         if result.dx is not None:
-            result.dx = numpy.append(self.dx, other.dx)
+            result.dx = np.append(self.dx, other.dx)
             result.dx = result.dx[ind]
         if result.dxw is not None:
-            result.dxw = numpy.append(self.dxw, other.dxw)
+            result.dxw = np.append(self.dxw, other.dxw)
             result.dxw = result.dxw[ind]
         if result.dxl is not None:
-            result.dxl = numpy.append(self.dxl, other.dxl)
+            result.dxl = np.append(self.dxl, other.dxl)
             result.dxl = result.dxl[ind]
         return result
@@ -970,10 +970,10 @@
 
         if clone is None or not issubclass(clone.__class__, Data2D):
-            data = numpy.zeros(length)
-            err_data = numpy.zeros(length)
-            qx_data = numpy.zeros(length)
-            qy_data = numpy.zeros(length)
-            q_data = numpy.zeros(length)
-            mask = numpy.zeros(length)
+            data = np.zeros(length)
+            err_data = np.zeros(length)
+            qx_data = np.zeros(length)
+            qy_data = np.zeros(length)
+            q_data = np.zeros(length)
+            mask = np.zeros(length)
             dqx_data = None
             dqy_data = None
@@ -1031,5 +1031,5 @@
             if other.err_data == None or \
                 (len(other.err_data) != len(other.data)):
-                err_other = numpy.zeros(len(other.data))
+                err_other = np.zeros(len(other.data))
 
         # Check that we have errors, otherwise create zero vector
@@ -1037,5 +1037,5 @@
         if self.err_data == None or \
             (len(self.err_data) != len(self.data)):
-            err = numpy.zeros(len(other.data))
+            err = np.zeros(len(other.data))
         return err, err_other
 
@@ -1049,15 +1049,15 @@
         # First, check the data compatibility
         dy, dy_other = self._validity_check(other)
-        result = self.clone_without_data(numpy.size(self.data))
+        result = self.clone_without_data(np.size(self.data))
         if self.dqx_data == None or self.dqy_data == None:
             result.dqx_data = None
             result.dqy_data = None
         else:
-            result.dqx_data = numpy.zeros(len(self.data))
-            result.dqy_data = numpy.zeros(len(self.data))
-        for i in range(numpy.size(self.data)):
+            result.dqx_data = np.zeros(len(self.data))
+            result.dqy_data = np.zeros(len(self.data))
+        for i in range(np.size(self.data)):
             result.data[i] = self.data[i]
             if self.err_data is not None and \
-                numpy.size(self.data) == numpy.size(self.err_data):
+                            np.size(self.data) == np.size(self.err_data):
                 result.err_data[i] = self.err_data[i]
             if self.dqx_data is not None:
@@ -1118,6 +1118,6 @@
         # First, check the data compatibility
         self._validity_check_union(other)
-        result = self.clone_without_data(numpy.size(self.data) + \
-                                         numpy.size(other.data))
+        result = self.clone_without_data(np.size(self.data) + \
+                                         np.size(other.data))
         result.xmin = self.xmin
         result.xmax = self.xmax
@@ -1129,20 +1129,20 @@
             result.dqy_data = None
         else:
-            result.dqx_data = numpy.zeros(len(self.data) + \
-                                         numpy.size(other.data))
-            result.dqy_data = numpy.zeros(len(self.data) + \
-                                         numpy.size(other.data))
-
-        result.data = numpy.append(self.data, other.data)
-        result.qx_data = numpy.append(self.qx_data, other.qx_data)
-        result.qy_data = numpy.append(self.qy_data, other.qy_data)
-        result.q_data = numpy.append(self.q_data, other.q_data)
-        result.mask = numpy.append(self.mask, other.mask)
+            result.dqx_data = np.zeros(len(self.data) + \
+                                       np.size(other.data))
+            result.dqy_data = np.zeros(len(self.data) + \
+                                       np.size(other.data))
+
+        result.data = np.append(self.data, other.data)
+        result.qx_data = np.append(self.qx_data, other.qx_data)
+        result.qy_data = np.append(self.qy_data, other.qy_data)
+        result.q_data = np.append(self.q_data, other.q_data)
+        result.mask = np.append(self.mask, other.mask)
         if result.err_data is not None:
-            result.err_data = numpy.append(self.err_data, other.err_data)
+            result.err_data = np.append(self.err_data, other.err_data)
         if self.dqx_data is not None:
-            result.dqx_data = numpy.append(self.dqx_data, other.dqx_data)
+            result.dqx_data = np.append(self.dqx_data, other.dqx_data)
         if self.dqy_data is not None:
-            result.dqy_data = numpy.append(self.dqy_data, other.dqy_data)
+            result.dqy_data = np.append(self.dqy_data, other.dqy_data)
 
         return result
Index: src/sas/sascalc/dataloader/manipulations.py
===================================================================
--- src/sas/sascalc/dataloader/manipulations.py	(revision 36d69e1ba7246dedeb4f530e6542511304379c86)
+++ src/sas/sascalc/dataloader/manipulations.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -14,5 +14,5 @@
 #TODO: copy the meta data from the 2D object to the resulting 1D object
 import math
-import numpy
+import numpy as np
 
 #from data_info import plottable_2D
@@ -82,6 +82,6 @@
     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_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)
 
@@ -89,10 +89,11 @@
     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))
+    q_data = np.sqrt(qx_data * qx_data + qy_data * qy_data)
+    if data2d.err_data == None or np.any(data2d.err_data <= 0):
+        new_err_data = np.sqrt(np.abs(new_data))
+
     else:
         new_err_data = data2d.err_data.flatten()
-    mask = numpy.ones(len(new_data), dtype=bool)
+    mask = np.ones(len(new_data), dtype=bool)
 
     #TODO: make sense of the following two lines...
@@ -149,8 +150,8 @@
 
         # 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)]
+        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
@@ -170,8 +171,8 @@
             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)
+        x = np.zeros(nbins)
+        y = np.zeros(nbins)
+        err_y = np.zeros(nbins)
+        y_counts = np.zeros(nbins)
 
         # Average pixelsize in q space
@@ -225,5 +226,5 @@
         y = y / y_counts
         x = x / y_counts
-        idx = (numpy.isfinite(y) & numpy.isfinite(x))
+        idx = (np.isfinite(y) & np.isfinite(x))
 
         if not idx.any():
@@ -304,8 +305,8 @@
             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)]
+        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
@@ -414,8 +415,8 @@
         """
         # 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)]
+        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
@@ -448,18 +449,18 @@
             dq_overlap_y *= dq_overlap_y
 
-            dq_overlap = numpy.sqrt((dq_overlap_x + dq_overlap_y) / 2.0)
+            dq_overlap = np.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
+            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
             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)
+            dq_data = np.add(dqx, dqy)
+            dq_data = np.sqrt(dq_data)
+
+        #q_data_max = np.max(q_data)
         if len(data2D.q_data) == None:
             msg = "Circular averaging: invalid q_data: %g" % data2D.q_data
@@ -469,9 +470,9 @@
         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)
+        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)):
@@ -527,8 +528,8 @@
 
         err_y = err_y / y_counts
-        err_y[err_y == 0] = numpy.average(err_y)
+        err_y[err_y == 0] = np.average(err_y)
         y = y / y_counts
         x = x / y_counts
-        idx = (numpy.isfinite(y)) & (numpy.isfinite(x))
+        idx = (np.isfinite(y)) & (np.isfinite(x))
 
         if err_x != None:
@@ -585,15 +586,15 @@
 
         # 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)]
+        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 = 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)
+        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
@@ -636,5 +637,5 @@
             phi_values[i] = 2.0 * math.pi / self.nbins_phi * (1.0 * i)
 
-        idx = (numpy.isfinite(phi_bins))
+        idx = (np.isfinite(phi_bins))
 
         if not idx.any():
@@ -769,9 +770,9 @@
 
         # 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
 
@@ -803,22 +804,22 @@
             dq_overlap_y *= dq_overlap_y
 
-            dq_overlap = numpy.sqrt((dq_overlap_x + dq_overlap_y) / 2.0)
+            dq_overlap = np.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
+            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
             dqx = dqx_data * dqx_data
             dqy = dqy_data * dqy_data
-            dq_data = numpy.add(dqx, dqy)
-            dq_data = numpy.sqrt(dq_data)
+            dq_data = np.add(dqx, dqy)
+            dq_data = np.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)
+        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)
 
         # Get the min and max into the region: 0 <= phi < 2Pi
@@ -923,6 +924,6 @@
                 #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 != None:
             d_x = x_err[idx] / y_counts[idx]
@@ -1012,5 +1013,5 @@
         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
@@ -1113,5 +1114,5 @@
 
         # 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
Index: src/sas/sascalc/dataloader/readers/IgorReader.py
===================================================================
--- src/sas/sascalc/dataloader/readers/IgorReader.py	(revision 36d69e1ba7246dedeb4f530e6542511304379c86)
+++ src/sas/sascalc/dataloader/readers/IgorReader.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -14,8 +14,11 @@
 import os
 
+import numpy as np
+import math
+#import logging
+
 from sas.sascalc.dataloader.data_info import Data2D
 from sas.sascalc.dataloader.data_info import Detector
 from sas.sascalc.dataloader.manipulations import reader2D_converter
-import numpy as np
 
 # Look for unit converter
@@ -62,4 +65,35 @@
             data_conv_i(1.0, output.I_unit)
 
+        for line in lines:
+            
+            # Find setup info line
+            if isInfo:
+                isInfo = False
+                line_toks = line.split()
+                # Wavelength in Angstrom
+                try:
+                    wavelength = float(line_toks[1])
+                except:
+                    msg = "IgorReader: can't read this file, missing wavelength"
+                    raise ValueError, msg
+                
+            #Find # of bins in a row assuming the detector is square.
+            if dataStarted == True:
+                try:
+                    value = float(line)
+                except:
+                    # Found a non-float entry, skip it
+                    continue
+                
+                # Get total bin number
+                
+            i_tot_row += 1
+        i_tot_row = math.ceil(math.sqrt(i_tot_row)) - 1
+        #print "i_tot", i_tot_row
+        size_x = i_tot_row  # 192#128
+        size_y = i_tot_row  # 192#128
+        output.data = np.zeros([size_x, size_y])
+        output.err_data = np.zeros([size_x, size_y])
+  
         data_row = 0
         wavelength = distance = center_x = center_y = None
Index: src/sas/sascalc/dataloader/readers/abs_reader.py
===================================================================
--- src/sas/sascalc/dataloader/readers/abs_reader.py	(revision b699768550de9d4b35b087234ec1d2a461922bab)
+++ src/sas/sascalc/dataloader/readers/abs_reader.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -9,5 +9,5 @@
 ######################################################################
 
-import numpy
+import numpy as np
 import os
 from sas.sascalc.dataloader.data_info import Data1D
@@ -53,8 +53,8 @@
                 buff = input_f.read()
                 lines = buff.split('\n')
-                x  = numpy.zeros(0)
-                y  = numpy.zeros(0)
-                dy = numpy.zeros(0)
-                dx = numpy.zeros(0)
+                x  = np.zeros(0)
+                y  = np.zeros(0)
+                dy = np.zeros(0)
+                dx = np.zeros(0)
                 output = Data1D(x, y, dy=dy, dx=dx)
                 detector = Detector()
@@ -204,8 +204,8 @@
                                 _dy = data_conv_i(_dy, units=output.y_unit)
                            
-                            x = numpy.append(x, _x)
-                            y = numpy.append(y, _y)
-                            dy = numpy.append(dy, _dy)
-                            dx = numpy.append(dx, _dx)
+                            x = np.append(x, _x)
+                            y = np.append(y, _y)
+                            dy = np.append(dy, _dy)
+                            dx = np.append(dx, _dx)
                             
                         except:
Index: src/sas/sascalc/dataloader/readers/ascii_reader.py
===================================================================
--- src/sas/sascalc/dataloader/readers/ascii_reader.py	(revision d2471870e414a3166a1caa621a5cf27a07cacb6d)
+++ src/sas/sascalc/dataloader/readers/ascii_reader.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -14,5 +14,5 @@
 
 
-import numpy
+import numpy as np
 import os
 from sas.sascalc.dataloader.data_info import Data1D
@@ -69,8 +69,8 @@
 
                 # Arrays for data storage
-                tx = numpy.zeros(0)
-                ty = numpy.zeros(0)
-                tdy = numpy.zeros(0)
-                tdx = numpy.zeros(0)
+                tx = np.zeros(0)
+                ty = np.zeros(0)
+                tdy = np.zeros(0)
+                tdx = np.zeros(0)
 
                 # The first good line of data will define whether
@@ -140,17 +140,17 @@
                             is_data == False:
                             try:
-                                tx = numpy.zeros(0)
-                                ty = numpy.zeros(0)
-                                tdy = numpy.zeros(0)
-                                tdx = numpy.zeros(0)
+                                tx = np.zeros(0)
+                                ty = np.zeros(0)
+                                tdy = np.zeros(0)
+                                tdx = np.zeros(0)
                             except:
                                 pass
 
                         if has_error_dy == True:
-                            tdy = numpy.append(tdy, _dy)
+                            tdy = np.append(tdy, _dy)
                         if has_error_dx == True:
-                            tdx = numpy.append(tdx, _dx)
-                        tx = numpy.append(tx, _x)
-                        ty = numpy.append(ty, _y)
+                            tdx = np.append(tdx, _dx)
+                        tx = np.append(tx, _x)
+                        ty = np.append(ty, _y)
 
                         #To remember the # of columns on the current line
@@ -188,9 +188,9 @@
                 #Let's re-order the data to make cal.
                 # curve look better some cases
-                ind = numpy.lexsort((ty, tx))
-                x = numpy.zeros(len(tx))
-                y = numpy.zeros(len(ty))
-                dy = numpy.zeros(len(tdy))
-                dx = numpy.zeros(len(tdx))
+                ind = np.lexsort((ty, tx))
+                x = np.zeros(len(tx))
+                y = np.zeros(len(ty))
+                dy = np.zeros(len(tdy))
+                dx = np.zeros(len(tdx))
                 output = Data1D(x, y, dy=dy, dx=dx)
                 self.filename = output.filename = basename
@@ -212,7 +212,7 @@
                 output.y = y[x != 0]
                 output.dy = dy[x != 0] if has_error_dy == True\
-                    else numpy.zeros(len(output.y))
+                    else np.zeros(len(output.y))
                 output.dx = dx[x != 0] if has_error_dx == True\
-                    else numpy.zeros(len(output.x))
+                    else np.zeros(len(output.x))
 
                 output.xaxis("\\rm{Q}", 'A^{-1}')
Index: src/sas/sascalc/dataloader/readers/danse_reader.py
===================================================================
--- src/sas/sascalc/dataloader/readers/danse_reader.py	(revision b699768550de9d4b35b087234ec1d2a461922bab)
+++ src/sas/sascalc/dataloader/readers/danse_reader.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -15,5 +15,5 @@
 import os
 import sys
-import numpy
+import numpy as np
 import logging
 from sas.sascalc.dataloader.data_info import Data2D, Detector
@@ -79,6 +79,6 @@
             output.detector.append(detector)
             
-            output.data = numpy.zeros([size_x,size_y])
-            output.err_data = numpy.zeros([size_x, size_y])
+            output.data = np.zeros([size_x,size_y])
+            output.err_data = np.zeros([size_x, size_y])
             
             data_conv_q = None
Index: src/sas/sascalc/dataloader/readers/hfir1d_reader.py
===================================================================
--- src/sas/sascalc/dataloader/readers/hfir1d_reader.py	(revision b699768550de9d4b35b087234ec1d2a461922bab)
+++ src/sas/sascalc/dataloader/readers/hfir1d_reader.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -9,5 +9,5 @@
 #copyright 2008, University of Tennessee
 ######################################################################
-import numpy
+import numpy as np
 import os
 from sas.sascalc.dataloader.data_info import Data1D
@@ -52,8 +52,8 @@
                 buff = input_f.read()
                 lines = buff.split('\n')
-                x = numpy.zeros(0)
-                y = numpy.zeros(0)
-                dx = numpy.zeros(0)
-                dy = numpy.zeros(0)
+                x = np.zeros(0)
+                y = np.zeros(0)
+                dx = np.zeros(0)
+                dy = np.zeros(0)
                 output = Data1D(x, y, dx=dx, dy=dy)
                 self.filename = output.filename = basename
@@ -88,8 +88,8 @@
                             _dy = data_conv_i(_dy, units=output.y_unit)
                                                     
-                        x = numpy.append(x, _x)
-                        y = numpy.append(y, _y)
-                        dx = numpy.append(dx, _dx)
-                        dy = numpy.append(dy, _dy)
+                        x = np.append(x, _x)
+                        y = np.append(y, _y)
+                        dx = np.append(dx, _dx)
+                        dy = np.append(dy, _dy)
                     except:
                         # Couldn't parse this line, skip it 
Index: src/sas/sascalc/dataloader/readers/red2d_reader.py
===================================================================
--- src/sas/sascalc/dataloader/readers/red2d_reader.py	(revision b699768550de9d4b35b087234ec1d2a461922bab)
+++ src/sas/sascalc/dataloader/readers/red2d_reader.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -10,5 +10,5 @@
 ######################################################################
 import os
-import numpy
+import numpy as np
 import math
 from sas.sascalc.dataloader.data_info import Data2D, Detector
@@ -198,8 +198,8 @@
                 break
         # Make numpy array to remove header lines using index
-        lines_array = numpy.array(lines)
+        lines_array = np.array(lines)
 
         # index for lines_array
-        lines_index = numpy.arange(len(lines))
+        lines_index = np.arange(len(lines))
         
         # get the data lines
@@ -225,5 +225,5 @@
 
         # numpy array form
-        data_array = numpy.array(data_list1)
+        data_array = np.array(data_list1)
         # Redimesion based on the row_num and col_num,
         #otherwise raise an error.
@@ -235,9 +235,9 @@
         ## Get the all data: Let's HARDcoding; Todo find better way
         # Defaults
-        dqx_data = numpy.zeros(0)
-        dqy_data = numpy.zeros(0)
-        err_data = numpy.ones(row_num)
-        qz_data = numpy.zeros(row_num)
-        mask = numpy.ones(row_num, dtype=bool)
+        dqx_data = np.zeros(0)
+        dqy_data = np.zeros(0)
+        err_data = np.ones(row_num)
+        qz_data = np.zeros(row_num)
+        mask = np.ones(row_num, dtype=bool)
         # Get from the array
         qx_data = data_point[0]
@@ -254,5 +254,5 @@
             dqy_data = data_point[(5 + ver)]
         #if col_num > (6 + ver): mask[data_point[(6 + ver)] < 1] = False
-        q_data = numpy.sqrt(qx_data*qx_data+qy_data*qy_data+qz_data*qz_data)
+        q_data = np.sqrt(qx_data*qx_data+qy_data*qy_data+qz_data*qz_data)
            
         # Extra protection(it is needed for some data files): 
@@ -262,8 +262,8 @@
   
         # Store limits of the image in q space
-        xmin = numpy.min(qx_data)
-        xmax = numpy.max(qx_data)
-        ymin = numpy.min(qy_data)
-        ymax = numpy.max(qy_data)
+        xmin = np.min(qx_data)
+        xmax = np.max(qx_data)
+        ymin = np.min(qy_data)
+        ymax = np.max(qy_data)
 
         # units
@@ -287,6 +287,6 @@
         
         # store x and y axis bin centers in q space
-        x_bins = numpy.arange(xmin, xmax + xstep, xstep)
-        y_bins = numpy.arange(ymin, ymax + ystep, ystep)
+        x_bins = np.arange(xmin, xmax + xstep, xstep)
+        y_bins = np.arange(ymin, ymax + ystep, ystep)
        
         # get the limits of q values
@@ -300,5 +300,5 @@
         output.data = data
         if (err_data == 1).all():
-            output.err_data = numpy.sqrt(numpy.abs(data))
+            output.err_data = np.sqrt(np.abs(data))
             output.err_data[output.err_data == 0.0] = 1.0
         else:
@@ -335,12 +335,12 @@
                 # tranfer the comp. to cartesian coord. for newer version.
                 if ver != 1:
-                    diag = numpy.sqrt(qx_data * qx_data + qy_data * qy_data)
+                    diag = np.sqrt(qx_data * qx_data + qy_data * qy_data)
                     cos_th = qx_data / diag
                     sin_th = qy_data / diag
-                    output.dqx_data = numpy.sqrt((dqx_data * cos_th) * \
+                    output.dqx_data = np.sqrt((dqx_data * cos_th) * \
                                                  (dqx_data * cos_th) \
                                                  + (dqy_data * sin_th) * \
                                                   (dqy_data * sin_th))
-                    output.dqy_data = numpy.sqrt((dqx_data * sin_th) * \
+                    output.dqy_data = np.sqrt((dqx_data * sin_th) * \
                                                  (dqx_data * sin_th) \
                                                  + (dqy_data * cos_th) * \
Index: src/sas/sascalc/dataloader/readers/sesans_reader.py
===================================================================
--- src/sas/sascalc/dataloader/readers/sesans_reader.py	(revision 95253581a7278bcefffb1c4770afed962b126cd7)
+++ src/sas/sascalc/dataloader/readers/sesans_reader.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -6,5 +6,5 @@
     Jurrian Bakker 
 """
-import numpy
+import numpy as np
 import os
 from sas.sascalc.dataloader.data_info import Data1D
@@ -60,18 +60,18 @@
                 buff = input_f.read()
                 lines = buff.splitlines()
-                x  = numpy.zeros(0)
-                y  = numpy.zeros(0)
-                dy = numpy.zeros(0)
-                lam  = numpy.zeros(0)
-                dlam = numpy.zeros(0)
-                dx = numpy.zeros(0)
+                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  = numpy.zeros(0)
-                ty  = numpy.zeros(0)
-                tdy = numpy.zeros(0)
-                tlam  = numpy.zeros(0)
-                tdlam = numpy.zeros(0)
-                tdx = numpy.zeros(0)
+                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
@@ -128,5 +128,5 @@
 
                 x,y,lam,dy,dx,dlam = [
-                   numpy.asarray(v, 'double')
+                    np.asarray(v, 'double')
                    for v in (x,y,lam,dy,dx,dlam)
                 ]
Index: src/sas/sascalc/dataloader/readers/tiff_reader.py
===================================================================
--- src/sas/sascalc/dataloader/readers/tiff_reader.py	(revision b699768550de9d4b35b087234ec1d2a461922bab)
+++ src/sas/sascalc/dataloader/readers/tiff_reader.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -13,5 +13,5 @@
 import logging
 import os
-import numpy
+import numpy as np
 from sas.sascalc.dataloader.data_info import Data2D
 from sas.sascalc.dataloader.manipulations import reader2D_converter
@@ -56,7 +56,7 @@
 
         # Initiazed the output data object
-        output.data = numpy.zeros([im.size[0], im.size[1]])
-        output.err_data = numpy.zeros([im.size[0], im.size[1]])
-        output.mask = numpy.ones([im.size[0], im.size[1]], dtype=bool)
+        output.data = np.zeros([im.size[0], im.size[1]])
+        output.err_data = np.zeros([im.size[0], im.size[1]])
+        output.mask = np.ones([im.size[0], im.size[1]], dtype=bool)
         
         # Initialize
@@ -94,6 +94,6 @@
         output.x_bins = x_vals
         output.y_bins = y_vals
-        output.qx_data = numpy.array(x_vals)
-        output.qy_data = numpy.array(y_vals)
+        output.qx_data = np.array(x_vals)
+        output.qy_data = np.array(y_vals)
         output.xmin = 0
         output.xmax = im.size[0] - 1
Index: src/sas/sascalc/fit/AbstractFitEngine.py
===================================================================
--- src/sas/sascalc/fit/AbstractFitEngine.py	(revision a9f579c8400c480f42c42445e1ff4dab09a6baa4)
+++ src/sas/sascalc/fit/AbstractFitEngine.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -4,5 +4,5 @@
 import sys
 import math
-import numpy
+import numpy as np
 
 from sas.sascalc.dataloader.data_info import Data1D
@@ -162,12 +162,12 @@
         # constant, or dy data
         if dy is None or dy == [] or dy.all() == 0:
-            self.dy = numpy.ones(len(y))
+            self.dy = np.ones(len(y))
         else:
-            self.dy = numpy.asarray(dy).copy()
+            self.dy = np.asarray(dy).copy()
 
         ## Min Q-value
         #Skip the Q=0 point, especially when y(q=0)=None at x[0].
         if min(self.x) == 0.0 and self.x[0] == 0 and\
-                     not numpy.isfinite(self.y[0]):
+                     not np.isfinite(self.y[0]):
             self.qmin = min(self.x[self.x != 0])
         else:
@@ -188,5 +188,5 @@
         # Skip Q=0 point, (especially for y(q=0)=None at x[0]).
         # ToDo: Find better way to do it.
-        if qmin == 0.0 and not numpy.isfinite(self.y[qmin]):
+        if qmin == 0.0 and not np.isfinite(self.y[qmin]):
             self.qmin = min(self.x[self.x != 0])
         elif qmin != None:
@@ -239,5 +239,5 @@
         """
         # Compute theory data f(x)
-        fx = numpy.zeros(len(self.x))
+        fx = np.zeros(len(self.x))
         fx[self.idx_unsmeared] = fn(self.x[self.idx_unsmeared])
        
@@ -247,7 +247,7 @@
                               self._last_unsmeared_bin)
         ## Sanity check
-        if numpy.size(self.dy) != numpy.size(fx):
+        if np.size(self.dy) != np.size(fx):
             msg = "FitData1D: invalid error array "
-            msg += "%d <> %d" % (numpy.shape(self.dy), numpy.size(fx))
+            msg += "%d <> %d" % (np.shape(self.dy), np.size(fx))
             raise RuntimeError, msg
         return (self.y[self.idx] - fx[self.idx]) / self.dy[self.idx], fx[self.idx]
@@ -300,10 +300,10 @@
         ## new error image for fitting purpose
         if self.err_data == None or self.err_data == []:
-            self.res_err_data = numpy.ones(len(self.data))
+            self.res_err_data = np.ones(len(self.data))
         else:
             self.res_err_data = copy.deepcopy(self.err_data)
         #self.res_err_data[self.res_err_data==0]=1
         
-        self.radius = numpy.sqrt(self.qx_data**2 + self.qy_data**2)
+        self.radius = np.sqrt(self.qx_data**2 + self.qy_data**2)
         
         # Note: mask = True: for MASK while mask = False for NOT to mask
@@ -311,6 +311,6 @@
                             (self.radius <= self.qmax))
         self.idx = (self.idx) & (self.mask)
-        self.idx = (self.idx) & (numpy.isfinite(self.data))
-        self.num_points = numpy.sum(self.idx)
+        self.idx = (self.idx) & (np.isfinite(self.data))
+        self.num_points = np.sum(self.idx)
 
     def set_smearer(self, smearer):
@@ -334,9 +334,9 @@
         if qmax != None:
             self.qmax = qmax
-        self.radius = numpy.sqrt(self.qx_data**2 + self.qy_data**2)
+        self.radius = np.sqrt(self.qx_data**2 + self.qy_data**2)
         self.idx = ((self.qmin <= self.radius) &\
                             (self.radius <= self.qmax))
         self.idx = (self.idx) & (self.mask)
-        self.idx = (self.idx) & (numpy.isfinite(self.data))
+        self.idx = (self.idx) & (np.isfinite(self.data))
         self.idx = (self.idx) & (self.res_err_data != 0)
 
@@ -351,5 +351,5 @@
         Number of measurement points in data set after masking, etc.
         """
-        return numpy.sum(self.idx)
+        return np.sum(self.idx)
 
     def residuals(self, fn):
Index: src/sas/sascalc/fit/BumpsFitting.py
===================================================================
--- src/sas/sascalc/fit/BumpsFitting.py	(revision 1a3072063148c066e9a1b64becf8ca13927ad656)
+++ src/sas/sascalc/fit/BumpsFitting.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -6,5 +6,5 @@
 import traceback
 
-import numpy
+import numpy as np
 
 from bumps import fitters
@@ -97,5 +97,5 @@
         try:
             p = history.population_values[0]
-            n,p = len(p), numpy.sort(p)
+            n,p = len(p), np.sort(p)
             QI,Qmid, = int(0.2*n),int(0.5*n)
             self.convergence.append((best, p[0],p[QI],p[Qmid],p[-1-QI],p[-1]))
@@ -194,8 +194,8 @@
 
     def numpoints(self):
-        return numpy.sum(self.data.idx) # number of fitted points
+        return np.sum(self.data.idx) # number of fitted points
 
     def nllf(self):
-        return 0.5*numpy.sum(self.residuals()**2)
+        return 0.5*np.sum(self.residuals()**2)
 
     def theory(self):
@@ -295,15 +295,15 @@
             if R.success:
                 if result['stderr'] is None:
-                    R.stderr = numpy.NaN*numpy.ones(len(param_list))
+                    R.stderr = np.NaN*np.ones(len(param_list))
                 else:
-                    R.stderr = numpy.hstack((result['stderr'][fitted_index],
-                                             numpy.NaN*numpy.ones(len(fitness.computed_pars))))
-                R.pvec = numpy.hstack((result['value'][fitted_index],
+                    R.stderr = np.hstack((result['stderr'][fitted_index],
+                                          np.NaN*np.ones(len(fitness.computed_pars))))
+                R.pvec = np.hstack((result['value'][fitted_index],
                                       [p.value for p in fitness.computed_pars]))
-                R.fitness = numpy.sum(R.residuals**2)/(fitness.numpoints() - len(fitted_index))
+                R.fitness = np.sum(R.residuals**2)/(fitness.numpoints() - len(fitted_index))
             else:
-                R.stderr = numpy.NaN*numpy.ones(len(param_list))
-                R.pvec = numpy.asarray( [p.value for p in fitness.fitted_pars+fitness.computed_pars])
-                R.fitness = numpy.NaN
+                R.stderr = np.NaN*np.ones(len(param_list))
+                R.pvec = np.asarray( [p.value for p in fitness.fitted_pars+fitness.computed_pars])
+                R.fitness = np.NaN
             R.convergence = result['convergence']
             if result['uncertainty'] is not None:
@@ -336,5 +336,5 @@
     max_step = steps + options.get('burn', 0)
     pars = [p.name for p in problem._parameters]
-    #x0 = numpy.asarray([p.value for p in problem._parameters])
+    #x0 = np.asarray([p.value for p in problem._parameters])
     options['monitors'] = [
         BumpsMonitor(handler, max_step, pars, problem.dof),
@@ -351,5 +351,5 @@
         errors = []
     except Exception as exc:
-        best, fbest = None, numpy.NaN
+        best, fbest = None, np.NaN
         errors = [str(exc), traceback.format_exc()]
     finally:
@@ -358,6 +358,6 @@
 
     convergence_list = options['monitors'][-1].convergence
-    convergence = (2*numpy.asarray(convergence_list)/problem.dof
-                   if convergence_list else numpy.empty((0,1),'d'))
+    convergence = (2*np.asarray(convergence_list)/problem.dof
+                   if convergence_list else np.empty((0,1),'d'))
 
     success = best is not None
Index: src/sas/sascalc/fit/Loader.py
===================================================================
--- src/sas/sascalc/fit/Loader.py	(revision b699768550de9d4b35b087234ec1d2a461922bab)
+++ src/sas/sascalc/fit/Loader.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -2,5 +2,5 @@
 #import wx
 #import string
-import numpy
+import numpy as np
 
 class Load:
@@ -52,5 +52,5 @@
                     self.y.append(y)
                     self.dy.append(dy)
-                    self.dx = numpy.zeros(len(self.x))
+                    self.dx = np.zeros(len(self.x))
                 except:
                     print "READ ERROR", line
Index: src/sas/sascalc/fit/MultiplicationModel.py
===================================================================
--- src/sas/sascalc/fit/MultiplicationModel.py	(revision 68669da9154d53fe949cb741efa850cd516ce157)
+++ src/sas/sascalc/fit/MultiplicationModel.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -1,5 +1,5 @@
 import copy
 
-import numpy
+import numpy as np
 
 from sas.sascalc.calculator.BaseComponent import BaseComponent
@@ -52,6 +52,6 @@
         ## Parameter details [units, min, max]
         self._set_details()
-        self.details['scale_factor'] = ['', 0.0, numpy.inf]
-        self.details['background'] = ['',-numpy.inf,numpy.inf]
+        self.details['scale_factor'] = ['', 0.0, np.inf]
+        self.details['background'] = ['',-np.inf,np.inf]
 
         #list of parameter that can be fitted
Index: src/sas/sascalc/fit/expression.py
===================================================================
--- src/sas/sascalc/fit/expression.py	(revision b699768550de9d4b35b087234ec1d2a461922bab)
+++ src/sas/sascalc/fit/expression.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -271,5 +271,5 @@
 
 def test_deps():
-    import numpy
+    import numpy as np
 
     # Null case
@@ -279,5 +279,5 @@
     _check("test1",[(2,7),(1,5),(1,4),(2,1),(3,1),(5,6)])
     _check("test1 renumbered",[(6,1),(7,3),(7,4),(6,7),(5,7),(3,2)])
-    _check("test1 numpy",numpy.array([(2,7),(1,5),(1,4),(2,1),(3,1),(5,6)]))
+    _check("test1 numpy",np.array([(2,7),(1,5),(1,4),(2,1),(3,1),(5,6)]))
 
     # No dependencies
@@ -291,5 +291,5 @@
 
     # large test for gross speed check
-    A = numpy.random.randint(4000,size=(1000,2))
+    A = np.random.randint(4000,size=(1000,2))
     A[:,1] += 4000  # Avoid cycles
     _check("test-large",A)
@@ -297,8 +297,8 @@
     # depth tests
     k = 200
-    A = numpy.array([range(0,k),range(1,k+1)]).T
+    A = np.array([range(0,k),range(1,k+1)]).T
     _check("depth-1",A)
 
-    A = numpy.array([range(1,k+1),range(0,k)]).T
+    A = np.array([range(1,k+1),range(0,k)]).T
     _check("depth-2",A)
 
Index: src/sas/sascalc/invariant/invariant.py
===================================================================
--- src/sas/sascalc/invariant/invariant.py	(revision b699768550de9d4b35b087234ec1d2a461922bab)
+++ src/sas/sascalc/invariant/invariant.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -17,5 +17,5 @@
 """
 import math
-import numpy
+import numpy as np
 
 from sas.sascalc.dataloader.data_info import Data1D as LoaderData1D
@@ -50,5 +50,5 @@
             dy = data.dy
         else:
-            dy = numpy.ones(len(data.y))
+            dy = np.ones(len(data.y))
 
         # Transform the data
@@ -63,7 +63,7 @@
 
         # Create Data1D object
-        x_out = numpy.asarray(x_out)
-        y_out = numpy.asarray(y_out)
-        dy_out = numpy.asarray(dy_out)
+        x_out = np.asarray(x_out)
+        y_out = np.asarray(y_out)
+        dy_out = np.asarray(dy_out)
         linear_data = LoaderData1D(x=x_out, y=y_out, dy=dy_out)
 
@@ -158,10 +158,10 @@
         :param x: array of q-values
         """
-        p1 = numpy.array([self.dscale * math.exp(-((self.radius * q) ** 2 / 3)) \
+        p1 = np.array([self.dscale * math.exp(-((self.radius * q) ** 2 / 3)) \
                           for q in x])
-        p2 = numpy.array([self.scale * math.exp(-((self.radius * q) ** 2 / 3))\
+        p2 = np.array([self.scale * math.exp(-((self.radius * q) ** 2 / 3))\
                      * (-(q ** 2 / 3)) * 2 * self.radius * self.dradius for q in x])
         diq2 = p1 * p1 + p2 * p2
-        return numpy.array([math.sqrt(err) for err in diq2])
+        return np.array([math.sqrt(err) for err in diq2])
 
     def _guinier(self, x):
@@ -182,5 +182,5 @@
             msg = "Rg expected positive value, but got %s" % self.radius
             raise ValueError(msg)
-        value = numpy.array([math.exp(-((self.radius * i) ** 2 / 3)) for i in x])
+        value = np.array([math.exp(-((self.radius * i) ** 2 / 3)) for i in x])
         return self.scale * value
 
@@ -232,9 +232,9 @@
         :param x: array of q-values
         """
-        p1 = numpy.array([self.dscale * math.pow(q, -self.power) for q in x])
-        p2 = numpy.array([self.scale * self.power * math.pow(q, -self.power - 1)\
+        p1 = np.array([self.dscale * math.pow(q, -self.power) for q in x])
+        p2 = np.array([self.scale * self.power * math.pow(q, -self.power - 1)\
                            * self.dpower for q in x])
         diq2 = p1 * p1 + p2 * p2
-        return numpy.array([math.sqrt(err) for err in diq2])
+        return np.array([math.sqrt(err) for err in diq2])
 
     def _power_law(self, x):
@@ -259,5 +259,5 @@
             raise ValueError(msg)
 
-        value = numpy.array([math.pow(i, -self.power) for i in x])
+        value = np.array([math.pow(i, -self.power) for i in x])
         return self.scale * value
 
@@ -304,13 +304,13 @@
         idx = (self.data.x >= qmin) & (self.data.x <= qmax)
 
-        fx = numpy.zeros(len(self.data.x))
+        fx = np.zeros(len(self.data.x))
 
         # Uncertainty
-        if type(self.data.dy) == numpy.ndarray and \
+        if type(self.data.dy) == np.ndarray and \
             len(self.data.dy) == len(self.data.x) and \
-            numpy.all(self.data.dy > 0):
+                np.all(self.data.dy > 0):
             sigma = self.data.dy
         else:
-            sigma = numpy.ones(len(self.data.x))
+            sigma = np.ones(len(self.data.x))
 
         # Compute theory data f(x)
@@ -332,23 +332,23 @@
             sigma2 = linearized_data.dy * linearized_data.dy
             a = -(power)
-            b = (numpy.sum(linearized_data.y / sigma2) \
-                 - a * numpy.sum(linearized_data.x / sigma2)) / numpy.sum(1.0 / sigma2)
+            b = (np.sum(linearized_data.y / sigma2) \
+                 - a * np.sum(linearized_data.x / sigma2)) / np.sum(1.0 / sigma2)
 
 
             deltas = linearized_data.x * a + \
-                    numpy.ones(len(linearized_data.x)) * b - linearized_data.y
-            residuals = numpy.sum(deltas * deltas / sigma2)
-
-            err = math.fabs(residuals) / numpy.sum(1.0 / sigma2)
+                     np.ones(len(linearized_data.x)) * b - linearized_data.y
+            residuals = np.sum(deltas * deltas / sigma2)
+
+            err = math.fabs(residuals) / np.sum(1.0 / sigma2)
             return [a, b], [0, math.sqrt(err)]
         else:
-            A = numpy.vstack([linearized_data.x / linearized_data.dy, 1.0 / linearized_data.dy]).T
-            (p, residuals, _, _) = numpy.linalg.lstsq(A, linearized_data.y / linearized_data.dy)
+            A = np.vstack([linearized_data.x / linearized_data.dy, 1.0 / linearized_data.dy]).T
+            (p, residuals, _, _) = np.linalg.lstsq(A, linearized_data.y / linearized_data.dy)
 
             # Get the covariance matrix, defined as inv_cov = a_transposed * a
-            err = numpy.zeros(2)
+            err = np.zeros(2)
             try:
-                inv_cov = numpy.dot(A.transpose(), A)
-                cov = numpy.linalg.pinv(inv_cov)
+                inv_cov = np.dot(A.transpose(), A)
+                cov = np.linalg.pinv(inv_cov)
                 err_matrix = math.fabs(residuals) * cov
                 err = [math.sqrt(err_matrix[0][0]), math.sqrt(err_matrix[1][1])]
@@ -434,5 +434,5 @@
         if new_data.dy is None or len(new_data.x) != len(new_data.dy) or \
             (min(new_data.dy) == 0 and max(new_data.dy) == 0):
-            new_data.dy = numpy.ones(len(new_data.x))
+            new_data.dy = np.ones(len(new_data.x))
         return  new_data
 
@@ -571,5 +571,5 @@
         """
         #create new Data1D to compute the invariant
-        q = numpy.linspace(start=q_start,
+        q = np.linspace(start=q_start,
                            stop=q_end,
                            num=npts,
@@ -580,5 +580,5 @@
         result_data = LoaderData1D(x=q, y=iq, dy=diq)
         if self._smeared != None:
-            result_data.dxl = self._smeared * numpy.ones(len(q))
+            result_data.dxl = self._smeared * np.ones(len(q))
         return result_data
 
@@ -691,5 +691,5 @@
 
         if q_start >= q_end:
-            return numpy.zeros(0), numpy.zeros(0)
+            return np.zeros(0), np.zeros(0)
 
         return self._get_extrapolated_data(\
@@ -719,5 +719,5 @@
 
         if q_start >= q_end:
-            return numpy.zeros(0), numpy.zeros(0)
+            return np.zeros(0), np.zeros(0)
 
         return self._get_extrapolated_data(\
Index: src/sas/sascalc/pr/fit/AbstractFitEngine.py
===================================================================
--- src/sas/sascalc/pr/fit/AbstractFitEngine.py	(revision fc18690cd84cc4dd6e33a9d344f47b08cef71290)
+++ src/sas/sascalc/pr/fit/AbstractFitEngine.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -4,5 +4,5 @@
 import sys
 import math
-import numpy
+import numpy as np
 
 from sas.sascalc.dataloader.data_info import Data1D
@@ -162,12 +162,12 @@
         # constant, or dy data
         if dy is None or dy == [] or dy.all() == 0:
-            self.dy = numpy.ones(len(y))
+            self.dy = np.ones(len(y))
         else:
-            self.dy = numpy.asarray(dy).copy()
+            self.dy = np.asarray(dy).copy()
 
         ## Min Q-value
         #Skip the Q=0 point, especially when y(q=0)=None at x[0].
         if min(self.x) == 0.0 and self.x[0] == 0 and\
-                     not numpy.isfinite(self.y[0]):
+                     not np.isfinite(self.y[0]):
             self.qmin = min(self.x[self.x != 0])
         else:
@@ -188,5 +188,5 @@
         # Skip Q=0 point, (especially for y(q=0)=None at x[0]).
         # ToDo: Find better way to do it.
-        if qmin == 0.0 and not numpy.isfinite(self.y[qmin]):
+        if qmin == 0.0 and not np.isfinite(self.y[qmin]):
             self.qmin = min(self.x[self.x != 0])
         elif qmin != None:
@@ -239,5 +239,5 @@
         """
         # Compute theory data f(x)
-        fx = numpy.zeros(len(self.x))
+        fx = np.zeros(len(self.x))
         fx[self.idx_unsmeared] = fn(self.x[self.idx_unsmeared])
        
@@ -247,7 +247,7 @@
                               self._last_unsmeared_bin)
         ## Sanity check
-        if numpy.size(self.dy) != numpy.size(fx):
+        if np.size(self.dy) != np.size(fx):
             msg = "FitData1D: invalid error array "
-            msg += "%d <> %d" % (numpy.shape(self.dy), numpy.size(fx))
+            msg += "%d <> %d" % (np.shape(self.dy), np.size(fx))
             raise RuntimeError, msg
         return (self.y[self.idx] - fx[self.idx]) / self.dy[self.idx], fx[self.idx]
@@ -300,10 +300,10 @@
         ## new error image for fitting purpose
         if self.err_data == None or self.err_data == []:
-            self.res_err_data = numpy.ones(len(self.data))
+            self.res_err_data = np.ones(len(self.data))
         else:
             self.res_err_data = copy.deepcopy(self.err_data)
         #self.res_err_data[self.res_err_data==0]=1
         
-        self.radius = numpy.sqrt(self.qx_data**2 + self.qy_data**2)
+        self.radius = np.sqrt(self.qx_data**2 + self.qy_data**2)
         
         # Note: mask = True: for MASK while mask = False for NOT to mask
@@ -311,6 +311,6 @@
                             (self.radius <= self.qmax))
         self.idx = (self.idx) & (self.mask)
-        self.idx = (self.idx) & (numpy.isfinite(self.data))
-        self.num_points = numpy.sum(self.idx)
+        self.idx = (self.idx) & (np.isfinite(self.data))
+        self.num_points = np.sum(self.idx)
 
     def set_smearer(self, smearer):
@@ -334,9 +334,9 @@
         if qmax != None:
             self.qmax = qmax
-        self.radius = numpy.sqrt(self.qx_data**2 + self.qy_data**2)
+        self.radius = np.sqrt(self.qx_data**2 + self.qy_data**2)
         self.idx = ((self.qmin <= self.radius) &\
                             (self.radius <= self.qmax))
         self.idx = (self.idx) & (self.mask)
-        self.idx = (self.idx) & (numpy.isfinite(self.data))
+        self.idx = (self.idx) & (np.isfinite(self.data))
         self.idx = (self.idx) & (self.res_err_data != 0)
 
@@ -351,5 +351,5 @@
         Number of measurement points in data set after masking, etc.
         """
-        return numpy.sum(self.idx)
+        return np.sum(self.idx)
 
     def residuals(self, fn):
Index: src/sas/sascalc/pr/fit/BumpsFitting.py
===================================================================
--- src/sas/sascalc/pr/fit/BumpsFitting.py	(revision b699768550de9d4b35b087234ec1d2a461922bab)
+++ src/sas/sascalc/pr/fit/BumpsFitting.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -5,5 +5,5 @@
 from datetime import timedelta, datetime
 
-import numpy
+import numpy as np
 
 from bumps import fitters
@@ -96,5 +96,5 @@
         try:
             p = history.population_values[0]
-            n,p = len(p), numpy.sort(p)
+            n,p = len(p), np.sort(p)
             QI,Qmid, = int(0.2*n),int(0.5*n)
             self.convergence.append((best, p[0],p[QI],p[Qmid],p[-1-QI],p[-1]))
@@ -193,8 +193,8 @@
 
     def numpoints(self):
-        return numpy.sum(self.data.idx) # number of fitted points
+        return np.sum(self.data.idx) # number of fitted points
 
     def nllf(self):
-        return 0.5*numpy.sum(self.residuals()**2)
+        return 0.5*np.sum(self.residuals()**2)
 
     def theory(self):
@@ -293,13 +293,13 @@
             R.success = result['success']
             if R.success:
-                R.stderr = numpy.hstack((result['stderr'][fitted_index],
-                                         numpy.NaN*numpy.ones(len(fitness.computed_pars))))
-                R.pvec = numpy.hstack((result['value'][fitted_index],
+                R.stderr = np.hstack((result['stderr'][fitted_index],
+                                      np.NaN*np.ones(len(fitness.computed_pars))))
+                R.pvec = np.hstack((result['value'][fitted_index],
                                       [p.value for p in fitness.computed_pars]))
-                R.fitness = numpy.sum(R.residuals**2)/(fitness.numpoints() - len(fitted_index))
+                R.fitness = np.sum(R.residuals**2)/(fitness.numpoints() - len(fitted_index))
             else:
-                R.stderr = numpy.NaN*numpy.ones(len(param_list))
-                R.pvec = numpy.asarray( [p.value for p in fitness.fitted_pars+fitness.computed_pars])
-                R.fitness = numpy.NaN
+                R.stderr = np.NaN*np.ones(len(param_list))
+                R.pvec = np.asarray( [p.value for p in fitness.fitted_pars+fitness.computed_pars])
+                R.fitness = np.NaN
             R.convergence = result['convergence']
             if result['uncertainty'] is not None:
@@ -331,5 +331,5 @@
     max_step = steps + options.get('burn', 0)
     pars = [p.name for p in problem._parameters]
-    #x0 = numpy.asarray([p.value for p in problem._parameters])
+    #x0 = np.asarray([p.value for p in problem._parameters])
     options['monitors'] = [
         BumpsMonitor(handler, max_step, pars, problem.dof),
@@ -352,6 +352,6 @@
 
     convergence_list = options['monitors'][-1].convergence
-    convergence = (2*numpy.asarray(convergence_list)/problem.dof
-                   if convergence_list else numpy.empty((0,1),'d'))
+    convergence = (2*np.asarray(convergence_list)/problem.dof
+                   if convergence_list else np.empty((0,1),'d'))
 
     success = best is not None
Index: src/sas/sascalc/pr/fit/Loader.py
===================================================================
--- src/sas/sascalc/pr/fit/Loader.py	(revision b699768550de9d4b35b087234ec1d2a461922bab)
+++ src/sas/sascalc/pr/fit/Loader.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -2,5 +2,5 @@
 #import wx
 #import string
-import numpy
+import numpy as np
 
 class Load:
@@ -52,5 +52,5 @@
                     self.y.append(y)
                     self.dy.append(dy)
-                    self.dx = numpy.zeros(len(self.x))
+                    self.dx = np.zeros(len(self.x))
                 except:
                     print "READ ERROR", line
Index: src/sas/sascalc/pr/fit/expression.py
===================================================================
--- src/sas/sascalc/pr/fit/expression.py	(revision b699768550de9d4b35b087234ec1d2a461922bab)
+++ src/sas/sascalc/pr/fit/expression.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -271,5 +271,5 @@
 
 def test_deps():
-    import numpy
+    import numpy as np
 
     # Null case
@@ -279,5 +279,5 @@
     _check("test1",[(2,7),(1,5),(1,4),(2,1),(3,1),(5,6)])
     _check("test1 renumbered",[(6,1),(7,3),(7,4),(6,7),(5,7),(3,2)])
-    _check("test1 numpy",numpy.array([(2,7),(1,5),(1,4),(2,1),(3,1),(5,6)]))
+    _check("test1 numpy",np.array([(2,7),(1,5),(1,4),(2,1),(3,1),(5,6)]))
 
     # No dependencies
@@ -291,5 +291,5 @@
 
     # large test for gross speed check
-    A = numpy.random.randint(4000,size=(1000,2))
+    A = np.random.randint(4000,size=(1000,2))
     A[:,1] += 4000  # Avoid cycles
     _check("test-large",A)
@@ -297,8 +297,8 @@
     # depth tests
     k = 200
-    A = numpy.array([range(0,k),range(1,k+1)]).T
+    A = np.array([range(0,k),range(1,k+1)]).T
     _check("depth-1",A)
 
-    A = numpy.array([range(1,k+1),range(0,k)]).T
+    A = np.array([range(1,k+1),range(0,k)]).T
     _check("depth-2",A)
 
Index: src/sas/sascalc/pr/invertor.py
===================================================================
--- src/sas/sascalc/pr/invertor.py	(revision 2c60f30436c786afaf7a16a8d82389832d5c6637)
+++ src/sas/sascalc/pr/invertor.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -7,5 +7,5 @@
 """
 
-import numpy
+import numpy as np
 import sys
 import math
@@ -189,13 +189,13 @@
         #import numpy
         if name == 'x':
-            out = numpy.ones(self.get_nx())
+            out = np.ones(self.get_nx())
             self.get_x(out)
             return out
         elif name == 'y':
-            out = numpy.ones(self.get_ny())
+            out = np.ones(self.get_ny())
             self.get_y(out)
             return out
         elif name == 'err':
-            out = numpy.ones(self.get_nerr())
+            out = np.ones(self.get_nerr())
             self.get_err(out)
             return out
@@ -325,5 +325,5 @@
             raise RuntimeError, msg
 
-        p = numpy.ones(nfunc)
+        p = np.ones(nfunc)
         t_0 = time.time()
         out, cov_x, _, _, _ = optimize.leastsq(self.residuals, p, full_output=1)
@@ -341,5 +341,5 @@
 
         if cov_x is None:
-            cov_x = numpy.ones([nfunc, nfunc])
+            cov_x = np.ones([nfunc, nfunc])
             cov_x *= math.fabs(chisqr)
         return out, cov_x
@@ -358,5 +358,5 @@
             raise RuntimeError, msg
 
-        p = numpy.ones(nfunc)
+        p = np.ones(nfunc)
         t_0 = time.time()
         out, cov_x, _, _, _ = optimize.leastsq(self.pr_residuals, p, full_output=1)
@@ -435,5 +435,5 @@
         """
         # Note: To make sure an array is contiguous:
-        # blah = numpy.ascontiguousarray(blah_original)
+        # blah = np.ascontiguousarray(blah_original)
         # ... before passing it to C
 
@@ -456,7 +456,7 @@
             nfunc += 1
 
-        a = numpy.zeros([npts + nq, nfunc])
-        b = numpy.zeros(npts + nq)
-        err = numpy.zeros([nfunc, nfunc])
+        a = np.zeros([npts + nq, nfunc])
+        b = np.zeros(npts + nq)
+        err = np.zeros([nfunc, nfunc])
 
         # Construct the a matrix and b vector that represent the problem
@@ -476,5 +476,5 @@
         self.chi2 = chi2
 
-        inv_cov = numpy.zeros([nfunc, nfunc])
+        inv_cov = np.zeros([nfunc, nfunc])
         # Get the covariance matrix, defined as inv_cov = a_transposed * a
         self._get_invcov_matrix(nfunc, nr, a, inv_cov)
@@ -490,5 +490,5 @@
 
         try:
-            cov = numpy.linalg.pinv(inv_cov)
+            cov = np.linalg.pinv(inv_cov)
             err = math.fabs(chi2 / float(npts - nfunc)) * cov
         except:
@@ -505,6 +505,6 @@
             self.background = c[0]
 
-            err_0 = numpy.zeros([nfunc, nfunc])
-            c_0 = numpy.zeros(nfunc)
+            err_0 = np.zeros([nfunc, nfunc])
+            c_0 = np.zeros(nfunc)
 
             for i in range(nfunc_0):
@@ -662,5 +662,5 @@
                                                    str(self.cov[i][i])))
         file.write("<r>  <Pr>  <dPr>\n")
-        r = numpy.arange(0.0, self.d_max, self.d_max / npts)
+        r = np.arange(0.0, self.d_max, self.d_max / npts)
 
         for r_i in r:
@@ -694,6 +694,6 @@
                         toks = line.split('=')
                         self.nfunc = int(toks[1])
-                        self.out = numpy.zeros(self.nfunc)
-                        self.cov = numpy.zeros([self.nfunc, self.nfunc])
+                        self.out = np.zeros(self.nfunc)
+                        self.cov = np.zeros([self.nfunc, self.nfunc])
                     elif line.startswith('#alpha='):
                         toks = line.split('=')
Index: src/sas/sascalc/pr/num_term.py
===================================================================
--- src/sas/sascalc/pr/num_term.py	(revision b699768550de9d4b35b087234ec1d2a461922bab)
+++ src/sas/sascalc/pr/num_term.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -1,4 +1,4 @@
 import math
-import numpy
+import numpy as np
 import copy
 import sys
@@ -152,7 +152,7 @@
 def load(path):
     # Read the data from the data file
-    data_x = numpy.zeros(0)
-    data_y = numpy.zeros(0)
-    data_err = numpy.zeros(0)
+    data_x = np.zeros(0)
+    data_y = np.zeros(0)
+    data_err = np.zeros(0)
     scale = None
     min_err = 0.0
@@ -176,7 +176,7 @@
                     #err = 0
 
-                data_x = numpy.append(data_x, test_x)
-                data_y = numpy.append(data_y, test_y)
-                data_err = numpy.append(data_err, err)
+                data_x = np.append(data_x, test_x)
+                data_y = np.append(data_y, test_y)
+                data_err = np.append(data_err, err)
             except:
                 logging.error(sys.exc_value)
