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 dd11014add466ed4ba0564fcf61e5880d53e6c8b)
@@ -80,5 +80,5 @@
 
     """
-    if data2d.data == None or data2d.x_bins == None or data2d.y_bins == None:
+    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))
@@ -90,5 +90,5 @@
     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):
+    if data2d.err_data is None or numpy.any(data2d.err_data <= 0):
         new_err_data = numpy.sqrt(numpy.abs(new_data))
     else:
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 dd11014add466ed4ba0564fcf61e5880d53e6c8b)
@@ -13,10 +13,9 @@
 #############################################################################
 import os
-import numpy
-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
@@ -40,205 +39,139 @@
         """ Read file """
         if not os.path.isfile(filename):
-            raise ValueError, \
-            "Specified file %s is not a regular file" % filename
-        
-        # Read file
-        f = open(filename, 'r')
-        buf = f.read()
-        
-        # Instantiate data object
+            raise ValueError("Specified file %s is not a regular "
+                             "file" % filename)
+        
         output = Data2D()
+
         output.filename = os.path.basename(filename)
         detector = Detector()
-        if len(output.detector) > 0:
-            print str(output.detector[0])
+        if len(output.detector):
+            print(str(output.detector[0]))
         output.detector.append(detector)
-                
-        # Get content
-        dataStarted = False
-        
-        lines = buf.split('\n')
-        itot = 0
-        x = []
-        y = []
-        
-        ncounts = 0
-        
-        xmin = None
-        xmax = None
-        ymin = None
-        ymax = None
-        
-        i_x = 0
-        i_y = -1
-        i_tot_row = 0
-        
-        isInfo = False
-        isCenter = False
-       
-        data_conv_q = None
-        data_conv_i = None
-        
-        if has_converter == True and output.Q_unit != '1/A':
+
+        data_conv_q = data_conv_i = None
+        
+        if has_converter and output.Q_unit != '1/A':
             data_conv_q = Converter('1/A')
             # Test it
             data_conv_q(1.0, output.Q_unit)
             
-        if has_converter == True and output.I_unit != '1/cm':
+        if has_converter and output.I_unit != '1/cm':
             data_conv_i = Converter('1/cm')
             # Test it
             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 = numpy.zeros([size_x, size_y])
-        output.err_data = numpy.zeros([size_x, size_y])
-     
-        #Read Header and 2D data
-        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
-                # Distance in meters
-                try:
-                    distance = float(line_toks[3])
-                except:
-                    msg = "IgorReader: can't read this file, missing distance"
-                    raise ValueError, msg
-                
-                # Distance in meters
-                try:
-                    transmission = float(line_toks[4])
-                except:
-                    msg = "IgorReader: can't read this file, "
-                    msg += "missing transmission"
-                    raise ValueError, msg
-                                            
-            if line.count("LAMBDA") > 0:
-                isInfo = True
-                
-            # Find center info line
-            if isCenter:
-                isCenter = False
-                line_toks = line.split()
-                
-                # Center in bin number: Must substrate 1 because
-                #the index starts from 1
-                center_x = float(line_toks[0]) - 1
-                center_y = float(line_toks[1]) - 1
-
-            if line.count("BCENT") > 0:
-                isCenter = True
-                
-            # Find data start
-            if line.count("***")>0:
-                dataStarted = True
-                
-                # Check that we have all the info
-                if wavelength == None \
-                    or distance == None \
-                    or center_x == None \
-                    or center_y == None:
-                    msg = "IgorReader:Missing information in data file"
-                    raise ValueError, msg
-                
-            if dataStarted == True:
-                try:
-                    value = float(line)
-                except:
-                    # Found a non-float entry, skip it
-                    continue
-                
-                # Get bin number
-                if math.fmod(itot, i_tot_row) == 0:
-                    i_x = 0
-                    i_y += 1
-                else:
-                    i_x += 1
-                    
-                output.data[i_y][i_x] = value
-                ncounts += 1
-                
-                # Det 640 x 640 mm
-                # Q = 4pi/lambda sin(theta/2)
-                # Bin size is 0.5 cm 
-                #REmoved +1 from theta = (i_x-center_x+1)*0.5 / distance
-                # / 100.0 and 
-                #REmoved +1 from theta = (i_y-center_y+1)*0.5 /
-                # distance / 100.0
-                #ToDo: Need  complete check if the following
-                # covert process is consistent with fitting.py.
-                theta = (i_x - center_x) * 0.5 / distance / 100.0
-                qx = 4.0 * math.pi / wavelength * math.sin(theta/2.0)
-
-                if has_converter == True and output.Q_unit != '1/A':
-                    qx = data_conv_q(qx, units=output.Q_unit)
-
-                if xmin == None or qx < xmin:
-                    xmin = qx
-                if xmax == None or qx > xmax:
-                    xmax = qx
-                
-                theta = (i_y - center_y) * 0.5 / distance / 100.0
-                qy = 4.0 * math.pi / wavelength * math.sin(theta / 2.0)
-
-                if has_converter == True and output.Q_unit != '1/A':
-                    qy = data_conv_q(qy, units=output.Q_unit)
-                
-                if ymin == None or qy < ymin:
-                    ymin = qy
-                if ymax == None or qy > ymax:
-                    ymax = qy
-                
-                if not qx in x:
-                    x.append(qx)
-                if not qy in y:
-                    y.append(qy)
-                
-                itot += 1
-                  
-                  
+
+        data_row = 0
+        wavelength = distance = center_x = center_y = None
+        dataStarted = isInfo = isCenter = False
+
+        with open(filename, 'r') as f:
+            for line in f:
+                data_row += 1
+                # Find setup info line
+                if isInfo:
+                    isInfo = False
+                    line_toks = line.split()
+                    # Wavelength in Angstrom
+                    try:
+                        wavelength = float(line_toks[1])
+                    except ValueError:
+                        msg = "IgorReader: can't read this file, missing wavelength"
+                        raise ValueError(msg)
+                    # Distance in meters
+                    try:
+                        distance = float(line_toks[3])
+                    except ValueError:
+                        msg = "IgorReader: can't read this file, missing distance"
+                        raise ValueError(msg)
+
+                    # Distance in meters
+                    try:
+                        transmission = float(line_toks[4])
+                    except:
+                        msg = "IgorReader: can't read this file, "
+                        msg += "missing transmission"
+                        raise ValueError(msg)
+
+                if line.count("LAMBDA"):
+                    isInfo = True
+
+                # Find center info line
+                if isCenter:
+                    isCenter = False
+                    line_toks = line.split()
+
+                    # Center in bin number: Must subtract 1 because
+                    # the index starts from 1
+                    center_x = float(line_toks[0]) - 1
+                    center_y = float(line_toks[1]) - 1
+
+                if line.count("BCENT"):
+                    isCenter = True
+
+                # Find data start
+                if line.count("***"):
+                    # now have to continue to blank line
+                    dataStarted = True
+
+                    # Check that we have all the info
+                    if (wavelength is None
+                            or distance is None
+                            or center_x is None
+                            or center_y is None):
+                        msg = "IgorReader:Missing information in data file"
+                        raise ValueError(msg)
+
+                if dataStarted:
+                    if len(line.rstrip()):
+                        continue
+                    else:
+                        break
+
+        # The data is loaded in row major order (last index changing most
+        # rapidly). However, the original data is in column major order (first
+        # index changing most rapidly). The swap to column major order is done
+        # in reader2D_converter at the end of this method.
+        data = np.loadtxt(filename, skiprows=data_row)
+        size_x = size_y = int(np.rint(np.sqrt(data.size)))
+        output.data = np.reshape(data, (size_x, size_y))
+        output.err_data = np.zeros_like(output.data)
+
+        # Det 640 x 640 mm
+        # Q = 4 * pi/lambda * sin(theta/2)
+        # Bin size is 0.5 cm
+        # Removed +1 from theta = (i_x - center_x + 1)*0.5 / distance
+        # / 100.0 and
+        # Removed +1 from theta = (i_y - center_y + 1)*0.5 /
+        # distance / 100.0
+        # ToDo: Need  complete check if the following
+        # convert process is consistent with fitting.py.
+
+        # calculate qx, qy bin centers of each pixel in the image
+        theta = (np.arange(size_x) - center_x) * 0.5 / distance / 100.
+        qx = 4 * np.pi / wavelength * np.sin(theta/2)
+
+        theta = (np.arange(size_y) - center_y) * 0.5 / distance / 100.
+        qy = 4 * np.pi / wavelength * np.sin(theta/2)
+
+        if has_converter and output.Q_unit != '1/A':
+            qx = data_conv_q(qx, units=output.Q_unit)
+            qy = data_conv_q(qx, units=output.Q_unit)
+
+        xmax = np.max(qx)
+        xmin = np.min(qx)
+        ymax = np.max(qy)
+        ymin = np.min(qy)
+
+        # calculate edge offset in q.
         theta = 0.25 / distance / 100.0
-        xstep = 4.0 * math.pi / wavelength * math.sin(theta / 2.0)
+        xstep = 4.0 * np.pi / wavelength * np.sin(theta / 2.0)
         
         theta = 0.25 / distance / 100.0
-        ystep = 4.0 * math.pi/ wavelength * math.sin(theta / 2.0)
+        ystep = 4.0 * np.pi/ wavelength * np.sin(theta / 2.0)
         
         # Store all data ######################################
         # Store wavelength
-        if has_converter == True and output.source.wavelength_unit != 'A':
+        if has_converter and output.source.wavelength_unit != 'A':
             conv = Converter('A')
             wavelength = conv(wavelength, units=output.source.wavelength_unit)
@@ -246,5 +179,5 @@
 
         # Store distance
-        if has_converter == True and detector.distance_unit != 'm':
+        if has_converter and detector.distance_unit != 'm':
             conv = Converter('m')
             distance = conv(distance, units=detector.distance_unit)
@@ -254,7 +187,7 @@
         output.sample.transmission = transmission
         
-        # Store pixel size
+        # Store pixel size (mm)
         pixel = 5.0
-        if has_converter == True and detector.pixel_size_unit != 'mm':
+        if has_converter and detector.pixel_size_unit != 'mm':
             conv = Converter('mm')
             pixel = conv(pixel, units=detector.pixel_size_unit)
@@ -267,9 +200,9 @@
         
         # Store limits of the image (2D array)
-        xmin = xmin - xstep / 2.0
-        xmax = xmax + xstep / 2.0
-        ymin = ymin - ystep / 2.0
-        ymax = ymax + ystep / 2.0
-        if has_converter == True and output.Q_unit != '1/A':
+        xmin -= xstep / 2.0
+        xmax += xstep / 2.0
+        ymin -= ystep / 2.0
+        ymax += ystep / 2.0
+        if has_converter and output.Q_unit != '1/A':
             xmin = data_conv_q(xmin, units=output.Q_unit)
             xmax = data_conv_q(xmax, units=output.Q_unit)
@@ -282,6 +215,6 @@
         
         # Store x and y axis bin centers
-        output.x_bins = x
-        output.y_bins = y
+        output.x_bins = qx.tolist()
+        output.y_bins = qy.tolist()
         
         # Units
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/cansas_reader.py
===================================================================
--- src/sas/sascalc/dataloader/readers/cansas_reader.py	(revision c221349bffb81e7d2d9ea29d4fc752f92190c7cc)
+++ src/sas/sascalc/dataloader/readers/cansas_reader.py	(revision 8434365120d0b226f06367f64c21b3bc835e1db5)
@@ -930,5 +930,6 @@
             self._write_data(datainfo, entry_node)
         # Transmission Spectrum Info
-        self._write_trans_spectrum(datainfo, entry_node)
+        # TODO: fix the writer to linearize all data, including T_spectrum
+        # self._write_trans_spectrum(datainfo, entry_node)
         # Sample info
         self._write_sample_info(datainfo, entry_node)
Index: src/sas/sascalc/dataloader/readers/cansas_reader_HDF5.py
===================================================================
--- src/sas/sascalc/dataloader/readers/cansas_reader_HDF5.py	(revision d0764bfab02091109657cd6607dbfb337e7542f3)
+++ src/sas/sascalc/dataloader/readers/cansas_reader_HDF5.py	(revision d0764bfab02091109657cd6607dbfb337e7542f3)
@@ -9,18 +9,20 @@
 import sys
 
-from sas.sascalc.dataloader.data_info import plottable_1D, plottable_2D, Data1D, Data2D, DataInfo, Process, Aperture
-from sas.sascalc.dataloader.data_info import Collimation, TransmissionSpectrum, Detector
+from sas.sascalc.dataloader.data_info import plottable_1D, plottable_2D,\
+    Data1D, Data2D, DataInfo, Process, Aperture, Collimation, \
+    TransmissionSpectrum, Detector
 from sas.sascalc.dataloader.data_info import combine_data_info_with_plottable
-
 
 
 class Reader():
     """
-    A class for reading in CanSAS v2.0 data files. The existing iteration opens Mantid generated HDF5 formatted files
-    with file extension .h5/.H5. Any number of data sets may be present within the file and any dimensionality of data
-    may be used. Currently 1D and 2D SAS data sets are supported, but future implementations will include 1D and 2D
-    SESANS data.
-
-    Any number of SASdata sets may be present in a SASentry and the data within can be either 1D I(Q) or 2D I(Qx, Qy).
+    A class for reading in CanSAS v2.0 data files. The existing iteration opens
+    Mantid generated HDF5 formatted files with file extension .h5/.H5. Any
+    number of data sets may be present within the file and any dimensionality
+    of data may be used. Currently 1D and 2D SAS data sets are supported, but
+    future implementations will include 1D and 2D SESANS data.
+
+    Any number of SASdata sets may be present in a SASentry and the data within
+    can be either 1D I(Q) or 2D I(Qx, Qy).
 
     Also supports reading NXcanSAS formatted HDF5 files
@@ -30,29 +32,29 @@
     """
 
-    ## CanSAS version
+    # CanSAS version
     cansas_version = 2.0
-    ## Logged warnings or messages
+    # Logged warnings or messages
     logging = None
-    ## List of errors for the current data set
+    # List of errors for the current data set
     errors = None
-    ## Raw file contents to be processed
+    # Raw file contents to be processed
     raw_data = None
-    ## Data info currently being read in
+    # Data info currently being read in
     current_datainfo = None
-    ## SASdata set currently being read in
+    # SASdata set currently being read in
     current_dataset = None
-    ## List of plottable1D objects that should be linked to the current_datainfo
+    # List of plottable1D objects that should be linked to the current_datainfo
     data1d = None
-    ## List of plottable2D objects that should be linked to the current_datainfo
+    # List of plottable2D objects that should be linked to the current_datainfo
     data2d = None
-    ## Data type name
+    # Data type name
     type_name = "CanSAS 2.0"
-    ## Wildcards
+    # Wildcards
     type = ["CanSAS 2.0 HDF5 Files (*.h5)|*.h5"]
-    ## List of allowed extensions
+    # List of allowed extensions
     ext = ['.h5', '.H5']
-    ## Flag to bypass extension check
+    # Flag to bypass extension check
     allow_all = True
-    ## List of files to return
+    # List of files to return
     output = None
 
@@ -64,7 +66,7 @@
         :return: List of Data1D/2D objects and/or a list of errors.
         """
-        ## Reinitialize the class when loading a new data file to reset all class variables
+        # Reinitialize when loading a new data file to reset all class variables
         self.reset_class_variables()
-        ## Check that the file exists
+        # Check that the file exists
         if os.path.isfile(filename):
             basename = os.path.basename(filename)
@@ -72,13 +74,13 @@
             # If the file type is not allowed, return empty list
             if extension in self.ext or self.allow_all:
-                ## Load the data file
+                # Load the data file
                 self.raw_data = h5py.File(filename, 'r')
-                ## Read in all child elements of top level SASroot
+                # Read in all child elements of top level SASroot
                 self.read_children(self.raw_data, [])
-                ## Add the last data set to the list of outputs
+                # Add the last data set to the list of outputs
                 self.add_data_set()
-                ## Close the data file
+                # Close the data file
                 self.raw_data.close()
-        ## Return data set(s)
+        # Return data set(s)
         return self.output
 
@@ -110,7 +112,7 @@
         """
 
-        ## Loop through each element of the parent and process accordingly
+        # Loop through each element of the parent and process accordingly
         for key in data.keys():
-            ## Get all information for the current key
+            # Get all information for the current key
             value = data.get(key)
             if value.attrs.get(u'canSAS_class') is not None:
@@ -126,10 +128,11 @@
                 self.parent_class = class_name
                 parent_list.append(key)
-                ## If this is a new sasentry, store the current data sets and create a fresh Data1D/2D object
+                # If a new sasentry, store the current data sets and create
+                # a fresh Data1D/2D object
                 if class_prog.match(u'SASentry'):
                     self.add_data_set(key)
                 elif class_prog.match(u'SASdata'):
                     self._initialize_new_data_set(parent_list)
-                ## Recursion step to access data within the group
+                # Recursion step to access data within the group
                 self.read_children(value, parent_list)
                 self.add_intermediate()
@@ -137,11 +140,11 @@
 
             elif isinstance(value, h5py.Dataset):
-                ## If this is a dataset, store the data appropriately
+                # If this is a dataset, store the data appropriately
                 data_set = data[key][:]
                 unit = self._get_unit(value)
 
-                ## I and Q Data
+                # I and Q Data
                 if key == u'I':
-                    if type(self.current_dataset) is plottable_2D:
+                    if isinstance(self.current_dataset, plottable_2D):
                         self.current_dataset.data = data_set
                         self.current_dataset.zaxis("Intensity", unit)
@@ -151,5 +154,5 @@
                     continue
                 elif key == u'Idev':
-                    if type(self.current_dataset) is plottable_2D:
+                    if isinstance(self.current_dataset, plottable_2D):
                         self.current_dataset.err_data = data_set.flatten()
                     else:
@@ -158,5 +161,5 @@
                 elif key == u'Q':
                     self.current_dataset.xaxis("Q", unit)
-                    if type(self.current_dataset) is plottable_2D:
+                    if isinstance(self.current_dataset, plottable_2D):
                         self.current_dataset.q = data_set.flatten()
                     else:
@@ -166,4 +169,10 @@
                     self.current_dataset.dx = data_set.flatten()
                     continue
+                elif key == u'dQw':
+                    self.current_dataset.dxw = data_set.flatten()
+                    continue
+                elif key == u'dQl':
+                    self.current_dataset.dxl = data_set.flatten()
+                    continue
                 elif key == u'Qy':
                     self.current_dataset.yaxis("Q_y", unit)
@@ -183,7 +192,21 @@
                     self.current_dataset.mask = data_set.flatten()
                     continue
+                # Transmission Spectrum
+                elif (key == u'T'
+                      and self.parent_class == u'SAStransmission_spectrum'):
+                    self.trans_spectrum.transmission = data_set.flatten()
+                    continue
+                elif (key == u'Tdev'
+                      and self.parent_class == u'SAStransmission_spectrum'):
+                    self.trans_spectrum.transmission_deviation = \
+                        data_set.flatten()
+                    continue
+                elif (key == u'lambda'
+                      and self.parent_class == u'SAStransmission_spectrum'):
+                    self.trans_spectrum.wavelength = data_set.flatten()
+                    continue
 
                 for data_point in data_set:
-                    ## Top Level Meta Data
+                    # Top Level Meta Data
                     if key == u'definition':
                         self.current_datainfo.meta_data['reader'] = data_point
@@ -201,28 +224,42 @@
                         self.current_datainfo.notes.append(data_point)
 
-                    ## Sample Information
-                    elif key == u'Title' and self.parent_class == u'SASsample': # CanSAS 2.0 format
+                    # Sample Information
+                    # CanSAS 2.0 format
+                    elif key == u'Title' and self.parent_class == u'SASsample':
                         self.current_datainfo.sample.name = data_point
-                    elif key == u'ID' and self.parent_class == u'SASsample': # NXcanSAS format
+                    # NXcanSAS format
+                    elif key == u'name' and self.parent_class == u'SASsample':
                         self.current_datainfo.sample.name = data_point
-                    elif key == u'thickness' and self.parent_class == u'SASsample':
+                    # NXcanSAS format
+                    elif key == u'ID' and self.parent_class == u'SASsample':
+                        self.current_datainfo.sample.name = data_point
+                    elif (key == u'thickness'
+                          and self.parent_class == u'SASsample'):
                         self.current_datainfo.sample.thickness = data_point
-                    elif key == u'temperature' and self.parent_class == u'SASsample':
+                    elif (key == u'temperature'
+                          and self.parent_class == u'SASsample'):
                         self.current_datainfo.sample.temperature = data_point
-                    elif key == u'transmission' and self.parent_class == u'SASsample':
+                    elif (key == u'transmission'
+                          and self.parent_class == u'SASsample'):
                         self.current_datainfo.sample.transmission = data_point
-                    elif key == u'x_position' and self.parent_class == u'SASsample':
+                    elif (key == u'x_position'
+                          and self.parent_class == u'SASsample'):
                         self.current_datainfo.sample.position.x = data_point
-                    elif key == u'y_position' and self.parent_class == u'SASsample':
+                    elif (key == u'y_position'
+                          and self.parent_class == u'SASsample'):
                         self.current_datainfo.sample.position.y = data_point
-                    elif key == u'polar_angle' and self.parent_class == u'SASsample':
+                    elif key == u'pitch' and self.parent_class == u'SASsample':
                         self.current_datainfo.sample.orientation.x = data_point
-                    elif key == u'azimuthal_angle' and self.parent_class == u'SASsample':
+                    elif key == u'yaw' and self.parent_class == u'SASsample':
+                        self.current_datainfo.sample.orientation.y = data_point
+                    elif key == u'roll' and self.parent_class == u'SASsample':
                         self.current_datainfo.sample.orientation.z = data_point
-                    elif key == u'details' and self.parent_class == u'SASsample':
+                    elif (key == u'details'
+                          and self.parent_class == u'SASsample'):
                         self.current_datainfo.sample.details.append(data_point)
 
-                    ## Instrumental Information
-                    elif key == u'name' and self.parent_class == u'SASinstrument':
+                    # Instrumental Information
+                    elif (key == u'name'
+                          and self.parent_class == u'SASinstrument'):
                         self.current_datainfo.instrument = data_point
                     elif key == u'name' and self.parent_class == u'SASdetector':
@@ -231,102 +268,134 @@
                         self.detector.distance = float(data_point)
                         self.detector.distance_unit = unit
-                    elif key == u'slit_length' and self.parent_class == u'SASdetector':
+                    elif (key == u'slit_length'
+                          and self.parent_class == u'SASdetector'):
                         self.detector.slit_length = float(data_point)
                         self.detector.slit_length_unit = unit
-                    elif key == u'x_position' and self.parent_class == u'SASdetector':
+                    elif (key == u'x_position'
+                          and self.parent_class == u'SASdetector'):
                         self.detector.offset.x = float(data_point)
                         self.detector.offset_unit = unit
-                    elif key == u'y_position' and self.parent_class == u'SASdetector':
+                    elif (key == u'y_position'
+                          and self.parent_class == u'SASdetector'):
                         self.detector.offset.y = float(data_point)
                         self.detector.offset_unit = unit
-                    elif key == u'polar_angle' and self.parent_class == u'SASdetector':
+                    elif (key == u'pitch'
+                          and self.parent_class == u'SASdetector'):
                         self.detector.orientation.x = float(data_point)
                         self.detector.orientation_unit = unit
-                    elif key == u'azimuthal_angle' and self.parent_class == u'SASdetector':
+                    elif key == u'roll' and self.parent_class == u'SASdetector':
                         self.detector.orientation.z = float(data_point)
                         self.detector.orientation_unit = unit
-                    elif key == u'beam_center_x' and self.parent_class == u'SASdetector':
+                    elif key == u'yaw' and self.parent_class == u'SASdetector':
+                        self.detector.orientation.y = float(data_point)
+                        self.detector.orientation_unit = unit
+                    elif (key == u'beam_center_x'
+                          and self.parent_class == u'SASdetector'):
                         self.detector.beam_center.x = float(data_point)
                         self.detector.beam_center_unit = unit
-                    elif key == u'beam_center_y' and self.parent_class == u'SASdetector':
+                    elif (key == u'beam_center_y'
+                          and self.parent_class == u'SASdetector'):
                         self.detector.beam_center.y = float(data_point)
                         self.detector.beam_center_unit = unit
-                    elif key == u'x_pixel_size' and self.parent_class == u'SASdetector':
+                    elif (key == u'x_pixel_size'
+                          and self.parent_class == u'SASdetector'):
                         self.detector.pixel_size.x = float(data_point)
                         self.detector.pixel_size_unit = unit
-                    elif key == u'y_pixel_size' and self.parent_class == u'SASdetector':
+                    elif (key == u'y_pixel_size'
+                          and self.parent_class == u'SASdetector'):
                         self.detector.pixel_size.y = float(data_point)
                         self.detector.pixel_size_unit = unit
-                    elif key == u'SSD' and self.parent_class == u'SAScollimation':
+                    elif (key == u'distance'
+                          and self.parent_class == u'SAScollimation'):
                         self.collimation.length = data_point
                         self.collimation.length_unit = unit
-                    elif key == u'name' and self.parent_class == u'SAScollimation':
+                    elif (key == u'name'
+                          and self.parent_class == u'SAScollimation'):
                         self.collimation.name = data_point
-
-                    ## Process Information
-                    elif key == u'name' and self.parent_class == u'SASprocess':
+                    elif (key == u'shape'
+                          and self.parent_class == u'SASaperture'):
+                        self.aperture.shape = data_point
+                    elif (key == u'x_gap'
+                          and self.parent_class == u'SASaperture'):
+                        self.aperture.size.x = data_point
+                    elif (key == u'y_gap'
+                          and self.parent_class == u'SASaperture'):
+                        self.aperture.size.y = data_point
+
+                    # Process Information
+                    elif (key == u'Title'
+                          and self.parent_class == u'SASprocess'): # CanSAS 2.0
                         self.process.name = data_point
-                    elif key == u'Title' and self.parent_class == u'SASprocess': # CanSAS 2.0 format
+                    elif (key == u'name'
+                          and self.parent_class == u'SASprocess'): # NXcanSAS
                         self.process.name = data_point
-                    elif key == u'name' and self.parent_class == u'SASprocess': # NXcanSAS format
-                        self.process.name = data_point
-                    elif key == u'description' and self.parent_class == u'SASprocess':
+                    elif (key == u'description'
+                          and self.parent_class == u'SASprocess'):
                         self.process.description = data_point
                     elif key == u'date' and self.parent_class == u'SASprocess':
                         self.process.date = data_point
+                    elif key == u'term' and self.parent_class == u'SASprocess':
+                        self.process.term = data_point
                     elif self.parent_class == u'SASprocess':
                         self.process.notes.append(data_point)
 
-                    ## Transmission Spectrum
-                    elif key == u'T' and self.parent_class == u'SAStransmission_spectrum':
-                        self.trans_spectrum.transmission.append(data_point)
-                    elif key == u'Tdev' and self.parent_class == u'SAStransmission_spectrum':
-                        self.trans_spectrum.transmission_deviation.append(data_point)
-                    elif key == u'lambda' and self.parent_class == u'SAStransmission_spectrum':
-                        self.trans_spectrum.wavelength.append(data_point)
-
-                    ## Source
-                    elif key == u'wavelength' and self.parent_class == u'SASdata':
+                    # Source
+                    elif (key == u'wavelength'
+                          and self.parent_class == u'SASdata'):
                         self.current_datainfo.source.wavelength = data_point
                         self.current_datainfo.source.wavelength_unit = unit
-                    elif key == u'incident_wavelength' and self.parent_class == u'SASsource':
+                    elif (key == u'incident_wavelength'
+                          and self.parent_class == 'SASsource'):
                         self.current_datainfo.source.wavelength = data_point
                         self.current_datainfo.source.wavelength_unit = unit
-                    elif key == u'wavelength_max' and self.parent_class == u'SASsource':
+                    elif (key == u'wavelength_max'
+                          and self.parent_class == u'SASsource'):
                         self.current_datainfo.source.wavelength_max = data_point
                         self.current_datainfo.source.wavelength_max_unit = unit
-                    elif key == u'wavelength_min' and self.parent_class == u'SASsource':
+                    elif (key == u'wavelength_min'
+                          and self.parent_class == u'SASsource'):
                         self.current_datainfo.source.wavelength_min = data_point
                         self.current_datainfo.source.wavelength_min_unit = unit
-                    elif key == u'wavelength_spread' and self.parent_class == u'SASsource':
-                        self.current_datainfo.source.wavelength_spread = data_point
-                        self.current_datainfo.source.wavelength_spread_unit = unit
-                    elif key == u'beam_size_x' and self.parent_class == u'SASsource':
+                    elif (key == u'incident_wavelength_spread'
+                          and self.parent_class == u'SASsource'):
+                        self.current_datainfo.source.wavelength_spread = \
+                            data_point
+                        self.current_datainfo.source.wavelength_spread_unit = \
+                            unit
+                    elif (key == u'beam_size_x'
+                          and self.parent_class == u'SASsource'):
                         self.current_datainfo.source.beam_size.x = data_point
                         self.current_datainfo.source.beam_size_unit = unit
-                    elif key == u'beam_size_y' and self.parent_class == u'SASsource':
+                    elif (key == u'beam_size_y'
+                          and self.parent_class == u'SASsource'):
                         self.current_datainfo.source.beam_size.y = data_point
                         self.current_datainfo.source.beam_size_unit = unit
-                    elif key == u'beam_shape' and self.parent_class == u'SASsource':
+                    elif (key == u'beam_shape'
+                          and self.parent_class == u'SASsource'):
                         self.current_datainfo.source.beam_shape = data_point
-                    elif key == u'radiation' and self.parent_class == u'SASsource':
+                    elif (key == u'radiation'
+                          and self.parent_class == u'SASsource'):
                         self.current_datainfo.source.radiation = data_point
-                    elif key == u'transmission' and self.parent_class == u'SASdata':
+                    elif (key == u'transmission'
+                          and self.parent_class == u'SASdata'):
                         self.current_datainfo.sample.transmission = data_point
 
-                    ## Everything else goes in meta_data
+                    # Everything else goes in meta_data
                     else:
-                        new_key = self._create_unique_key(self.current_datainfo.meta_data, key)
+                        new_key = self._create_unique_key(
+                            self.current_datainfo.meta_data, key)
                         self.current_datainfo.meta_data[new_key] = data_point
 
             else:
-                ## I don't know if this reachable code
+                # I don't know if this reachable code
                 self.errors.add("ShouldNeverHappenException")
 
     def add_intermediate(self):
         """
-        This method stores any intermediate objects within the final data set after fully reading the set.
-
-        :param parent: The NXclass name for the h5py Group object that just finished being processed
+        This method stores any intermediate objects within the final data set
+        after fully reading the set.
+
+        :param parent: The NXclass name for the h5py Group object that just
+                       finished being processed
         """
 
@@ -347,16 +416,17 @@
             self.aperture = Aperture()
         elif self.parent_class == u'SASdata':
-            if type(self.current_dataset) is plottable_2D:
+            if isinstance(self.current_dataset, plottable_2D):
                 self.data2d.append(self.current_dataset)
-            elif type(self.current_dataset) is plottable_1D:
+            elif isinstance(self.current_dataset, plottable_1D):
                 self.data1d.append(self.current_dataset)
 
     def final_data_cleanup(self):
         """
-        Does some final cleanup and formatting on self.current_datainfo and all data1D and data2D objects and then
-        combines the data and info into Data1D and Data2D objects
-        """
-
-        ## Type cast data arrays to float64
+        Does some final cleanup and formatting on self.current_datainfo and
+        all data1D and data2D objects and then combines the data and info into
+        Data1D and Data2D objects
+        """
+
+        # Type cast data arrays to float64
         if len(self.current_datainfo.trans_spectrum) > 0:
             spectrum_list = []
@@ -364,6 +434,8 @@
                 spectrum.transmission = np.delete(spectrum.transmission, [0])
                 spectrum.transmission = spectrum.transmission.astype(np.float64)
-                spectrum.transmission_deviation = np.delete(spectrum.transmission_deviation, [0])
-                spectrum.transmission_deviation = spectrum.transmission_deviation.astype(np.float64)
+                spectrum.transmission_deviation = np.delete(
+                    spectrum.transmission_deviation, [0])
+                spectrum.transmission_deviation = \
+                    spectrum.transmission_deviation.astype(np.float64)
                 spectrum.wavelength = np.delete(spectrum.wavelength, [0])
                 spectrum.wavelength = spectrum.wavelength.astype(np.float64)
@@ -372,10 +444,10 @@
             self.current_datainfo.trans_spectrum = spectrum_list
 
-        ## Append errors to dataset and reset class errors
+        # Append errors to dataset and reset class errors
         self.current_datainfo.errors = self.errors
         self.errors.clear()
 
-        ## Combine all plottables with datainfo and append each to output
-        ## Type cast data arrays to float64 and find min/max as appropriate
+        # Combine all plottables with datainfo and append each to output
+        # Type cast data arrays to float64 and find min/max as appropriate
         for dataset in self.data2d:
             dataset.data = dataset.data.astype(np.float64)
@@ -397,13 +469,16 @@
             zeros = np.ones(dataset.data.size, dtype=bool)
             try:
-                for i in range (0, dataset.mask.size - 1):
+                for i in range(0, dataset.mask.size - 1):
                     zeros[i] = dataset.mask[i]
             except:
                 self.errors.add(sys.exc_value)
             dataset.mask = zeros
-            ## Calculate the actual Q matrix
+            # Calculate the actual Q matrix
             try:
                 if dataset.q_data.size <= 1:
-                    dataset.q_data = np.sqrt(dataset.qx_data * dataset.qx_data + dataset.qy_data * dataset.qy_data)
+                    dataset.q_data = np.sqrt(dataset.qx_data
+                                             * dataset.qx_data
+                                             + dataset.qy_data
+                                             * dataset.qy_data)
             except:
                 dataset.q_data = None
@@ -415,5 +490,6 @@
                 dataset.data = dataset.data.flatten()
 
-            final_dataset = combine_data_info_with_plottable(dataset, self.current_datainfo)
+            final_dataset = combine_data_info_with_plottable(
+                dataset, self.current_datainfo)
             self.output.append(final_dataset)
 
@@ -435,11 +511,13 @@
             if dataset.dy is not None:
                 dataset.dy = dataset.dy.astype(np.float64)
-            final_dataset = combine_data_info_with_plottable(dataset, self.current_datainfo)
+            final_dataset = combine_data_info_with_plottable(
+                dataset, self.current_datainfo)
             self.output.append(final_dataset)
 
     def add_data_set(self, key=""):
         """
-        Adds the current_dataset to the list of outputs after preforming final processing on the data and then calls a
-        private method to generate a new data set.
+        Adds the current_dataset to the list of outputs after preforming final
+        processing on the data and then calls a private method to generate a
+        new data set.
 
         :param key: NeXus group name for current tree level
@@ -453,8 +531,9 @@
 
 
-    def _initialize_new_data_set(self, parent_list = None):
-        """
-        A private class method to generate a new 1D or 2D data object based on the type of data within the set.
-        Outside methods should call add_data_set() to be sure any existing data is stored properly.
+    def _initialize_new_data_set(self, parent_list=None):
+        """
+        A private class method to generate a new 1D or 2D data object based on
+        the type of data within the set. Outside methods should call
+        add_data_set() to be sure any existing data is stored properly.
 
         :param parent_list: List of names of parent elements
@@ -473,7 +552,8 @@
     def _find_intermediate(self, parent_list, basename=""):
         """
-        A private class used to find an entry by either using a direct key or knowing the approximate basename.
-
-        :param parent_list: List of parents to the current level in the HDF5 file
+        A private class used to find an entry by either using a direct key or
+        knowing the approximate basename.
+
+        :param parent_list: List of parents nodes in the HDF5 file
         :param basename: Approximate name of an entry to search for
         :return:
@@ -486,5 +566,5 @@
             top = top.get(parent)
         for key in top.keys():
-            if (key_prog.match(key)):
+            if key_prog.match(key):
                 entry = True
                 break
@@ -516,7 +596,7 @@
         """
         unit = value.attrs.get(u'units')
-        if unit == None:
+        if unit is None:
             unit = value.attrs.get(u'unit')
-        ## Convert the unit formats
+        # Convert the unit formats
         if unit == "1/A":
             unit = "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
