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 b2b3693291d8e49fd33718753161206c1964548c)
+++ 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 == None or data2d.x_bins == None or data2d.y_bins == 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,10 @@
     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 == 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 +149,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 +170,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 +225,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 +304,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 +414,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 +448,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 +469,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 +527,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 +585,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 +636,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 +769,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 +803,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 +923,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 +1012,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 +1113,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 b699768550de9d4b35b087234ec1d2a461922bab)
+++ src/sas/sascalc/dataloader/readers/IgorReader.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -13,5 +13,5 @@
 #############################################################################
 import os
-import numpy
+import numpy as np
 import math
 #import logging
@@ -118,6 +118,6 @@
         size_x = i_tot_row  # 192#128
         size_y = i_tot_row  # 192#128
-        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])
      
         #Read Header and 2D data
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
