Index: src/sas/sascalc/dataloader/manipulations.py
===================================================================
--- src/sas/sascalc/dataloader/manipulations.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
+++ src/sas/sascalc/dataloader/manipulations.py	(revision dd11014add466ed4ba0564fcf61e5880d53e6c8b)
@@ -14,5 +14,5 @@
 #TODO: copy the meta data from the 2D object to the resulting 1D object
 import math
-import numpy as np
+import numpy
 
 #from data_info import plottable_2D
@@ -82,6 +82,6 @@
     if data2d.data is None or data2d.x_bins is None or data2d.y_bins is None:
         raise ValueError, "Can't convert this data: data=None..."
-    new_x = np.tile(data2d.x_bins, (len(data2d.y_bins), 1))
-    new_y = np.tile(data2d.y_bins, (len(data2d.x_bins), 1))
+    new_x = numpy.tile(data2d.x_bins, (len(data2d.y_bins), 1))
+    new_y = numpy.tile(data2d.y_bins, (len(data2d.x_bins), 1))
     new_y = new_y.swapaxes(0, 1)
 
@@ -89,11 +89,10 @@
     qx_data = new_x.flatten()
     qy_data = new_y.flatten()
-    q_data = np.sqrt(qx_data * qx_data + qy_data * qy_data)
-    if data2d.err_data == None or np.any(data2d.err_data <= 0):
-        new_err_data = np.sqrt(np.abs(new_data))
-
+    q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data)
+    if data2d.err_data is None or numpy.any(data2d.err_data <= 0):
+        new_err_data = numpy.sqrt(numpy.abs(new_data))
     else:
         new_err_data = data2d.err_data.flatten()
-    mask = np.ones(len(new_data), dtype=bool)
+    mask = numpy.ones(len(new_data), dtype=bool)
 
     #TODO: make sense of the following two lines...
@@ -150,8 +149,8 @@
 
         # Get data
-        data = data2D.data[np.isfinite(data2D.data)]
-        err_data = data2D.err_data[np.isfinite(data2D.data)]
-        qx_data = data2D.qx_data[np.isfinite(data2D.data)]
-        qy_data = data2D.qy_data[np.isfinite(data2D.data)]
+        data = data2D.data[numpy.isfinite(data2D.data)]
+        err_data = data2D.err_data[numpy.isfinite(data2D.data)]
+        qx_data = data2D.qx_data[numpy.isfinite(data2D.data)]
+        qy_data = data2D.qy_data[numpy.isfinite(data2D.data)]
 
         # Build array of Q intervals
@@ -171,8 +170,8 @@
             raise RuntimeError, "_Slab._avg: unrecognized axis %s" % str(maj)
 
-        x = np.zeros(nbins)
-        y = np.zeros(nbins)
-        err_y = np.zeros(nbins)
-        y_counts = np.zeros(nbins)
+        x = numpy.zeros(nbins)
+        y = numpy.zeros(nbins)
+        err_y = numpy.zeros(nbins)
+        y_counts = numpy.zeros(nbins)
 
         # Average pixelsize in q space
@@ -226,5 +225,5 @@
         y = y / y_counts
         x = x / y_counts
-        idx = (np.isfinite(y) & np.isfinite(x))
+        idx = (numpy.isfinite(y) & numpy.isfinite(x))
 
         if not idx.any():
@@ -305,8 +304,8 @@
             raise RuntimeError, msg
         # Get data
-        data = data2D.data[np.isfinite(data2D.data)]
-        err_data = data2D.err_data[np.isfinite(data2D.data)]
-        qx_data = data2D.qx_data[np.isfinite(data2D.data)]
-        qy_data = data2D.qy_data[np.isfinite(data2D.data)]
+        data = data2D.data[numpy.isfinite(data2D.data)]
+        err_data = data2D.err_data[numpy.isfinite(data2D.data)]
+        qx_data = data2D.qx_data[numpy.isfinite(data2D.data)]
+        qy_data = data2D.qy_data[numpy.isfinite(data2D.data)]
 
         y = 0.0
@@ -415,8 +414,8 @@
         """
         # Get data W/ finite values
-        data = data2D.data[np.isfinite(data2D.data)]
-        q_data = data2D.q_data[np.isfinite(data2D.data)]
-        err_data = data2D.err_data[np.isfinite(data2D.data)]
-        mask_data = data2D.mask[np.isfinite(data2D.data)]
+        data = data2D.data[numpy.isfinite(data2D.data)]
+        q_data = data2D.q_data[numpy.isfinite(data2D.data)]
+        err_data = data2D.err_data[numpy.isfinite(data2D.data)]
+        mask_data = data2D.mask[numpy.isfinite(data2D.data)]
 
         dq_data = None
@@ -449,18 +448,18 @@
             dq_overlap_y *= dq_overlap_y
 
-            dq_overlap = np.sqrt((dq_overlap_x + dq_overlap_y) / 2.0)
+            dq_overlap = numpy.sqrt((dq_overlap_x + dq_overlap_y) / 2.0)
             # Final protection of dq
             if dq_overlap < 0:
                 dq_overlap = y_min
-            dqx_data = data2D.dqx_data[np.isfinite(data2D.data)]
-            dqy_data = data2D.dqy_data[np.isfinite(data2D.data)] - dq_overlap
+            dqx_data = data2D.dqx_data[numpy.isfinite(data2D.data)]
+            dqy_data = data2D.dqy_data[numpy.isfinite(data2D.data)] - dq_overlap
             # def; dqx_data = dq_r dqy_data = dq_phi
             # Convert dq 2D to 1D here
             dqx = dqx_data * dqx_data
             dqy = dqy_data * dqy_data
-            dq_data = np.add(dqx, dqy)
-            dq_data = np.sqrt(dq_data)
-
-        #q_data_max = np.max(q_data)
+            dq_data = numpy.add(dqx, dqy)
+            dq_data = numpy.sqrt(dq_data)
+
+        #q_data_max = numpy.max(q_data)
         if len(data2D.q_data) == None:
             msg = "Circular averaging: invalid q_data: %g" % data2D.q_data
@@ -470,9 +469,9 @@
         nbins = int(math.ceil((self.r_max - self.r_min) / self.bin_width))
 
-        x = np.zeros(nbins)
-        y = np.zeros(nbins)
-        err_y = np.zeros(nbins)
-        err_x = np.zeros(nbins)
-        y_counts = np.zeros(nbins)
+        x = numpy.zeros(nbins)
+        y = numpy.zeros(nbins)
+        err_y = numpy.zeros(nbins)
+        err_x = numpy.zeros(nbins)
+        y_counts = numpy.zeros(nbins)
 
         for npt in range(len(data)):
@@ -528,8 +527,8 @@
 
         err_y = err_y / y_counts
-        err_y[err_y == 0] = np.average(err_y)
+        err_y[err_y == 0] = numpy.average(err_y)
         y = y / y_counts
         x = x / y_counts
-        idx = (np.isfinite(y)) & (np.isfinite(x))
+        idx = (numpy.isfinite(y)) & (numpy.isfinite(x))
 
         if err_x != None:
@@ -586,15 +585,15 @@
 
         # Get data
-        data = data2D.data[np.isfinite(data2D.data)]
-        q_data = data2D.q_data[np.isfinite(data2D.data)]
-        err_data = data2D.err_data[np.isfinite(data2D.data)]
-        qx_data = data2D.qx_data[np.isfinite(data2D.data)]
-        qy_data = data2D.qy_data[np.isfinite(data2D.data)]
+        data = data2D.data[numpy.isfinite(data2D.data)]
+        q_data = data2D.q_data[numpy.isfinite(data2D.data)]
+        err_data = data2D.err_data[numpy.isfinite(data2D.data)]
+        qx_data = data2D.qx_data[numpy.isfinite(data2D.data)]
+        qy_data = data2D.qy_data[numpy.isfinite(data2D.data)]
 
         # Set space for 1d outputs
-        phi_bins = 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)
+        phi_bins = numpy.zeros(self.nbins_phi)
+        phi_counts = numpy.zeros(self.nbins_phi)
+        phi_values = numpy.zeros(self.nbins_phi)
+        phi_err = numpy.zeros(self.nbins_phi)
 
         # Shift to apply to calculated phi values in order
@@ -637,5 +636,5 @@
             phi_values[i] = 2.0 * math.pi / self.nbins_phi * (1.0 * i)
 
-        idx = (np.isfinite(phi_bins))
+        idx = (numpy.isfinite(phi_bins))
 
         if not idx.any():
@@ -770,9 +769,9 @@
 
         # Get the all data & info
-        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)]
+        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)]
         dq_data = None
 
@@ -804,22 +803,22 @@
             dq_overlap_y *= dq_overlap_y
 
-            dq_overlap = np.sqrt((dq_overlap_x + dq_overlap_y) / 2.0)
+            dq_overlap = numpy.sqrt((dq_overlap_x + dq_overlap_y) / 2.0)
             if dq_overlap < 0:
                 dq_overlap = y_min
-            dqx_data = data2D.dqx_data[np.isfinite(data2D.data)]
-            dqy_data = data2D.dqy_data[np.isfinite(data2D.data)] - dq_overlap
+            dqx_data = data2D.dqx_data[numpy.isfinite(data2D.data)]
+            dqy_data = data2D.dqy_data[numpy.isfinite(data2D.data)] - dq_overlap
             # def; dqx_data = dq_r dqy_data = dq_phi
             # Convert dq 2D to 1D here
             dqx = dqx_data * dqx_data
             dqy = dqy_data * dqy_data
-            dq_data = np.add(dqx, dqy)
-            dq_data = np.sqrt(dq_data)
+            dq_data = numpy.add(dqx, dqy)
+            dq_data = numpy.sqrt(dq_data)
 
         #set space for 1d outputs
-        x = np.zeros(self.nbins)
-        y = np.zeros(self.nbins)
-        y_err = np.zeros(self.nbins)
-        x_err = np.zeros(self.nbins)
-        y_counts = np.zeros(self.nbins)
+        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)
 
         # Get the min and max into the region: 0 <= phi < 2Pi
@@ -924,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] = np.average(y_err)
-        idx = (np.isfinite(y) & np.isfinite(y_err))
+        y_err[y_err == 0] = numpy.average(y_err)
+        idx = (numpy.isfinite(y) & numpy.isfinite(y_err))
         if x_err != None:
             d_x = x_err[idx] / y_counts[idx]
@@ -1013,5 +1012,5 @@
         qx_data = data2D.qx_data
         qy_data = data2D.qy_data
-        q_data = np.sqrt(qx_data * qx_data + qy_data * qy_data)
+        q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data)
 
         # check whether or not the data point is inside ROI
@@ -1114,5 +1113,5 @@
 
         # get phi from data
-        phi_data = np.arctan2(qy_data, qx_data)
+        phi_data = numpy.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 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
+++ src/sas/sascalc/dataloader/readers/IgorReader.py	(revision dd11014add466ed4ba0564fcf61e5880d53e6c8b)
@@ -14,11 +14,8 @@
 import os
 
-import numpy as np
-import math
-#import logging
-
 from sas.sascalc.dataloader.data_info import Data2D
 from sas.sascalc.dataloader.data_info import Detector
 from sas.sascalc.dataloader.manipulations import reader2D_converter
+import numpy as np
 
 # Look for unit converter
@@ -65,35 +62,4 @@
             data_conv_i(1.0, output.I_unit)
 
-        for line in lines:
-            
-            # Find setup info line
-            if isInfo:
-                isInfo = False
-                line_toks = line.split()
-                # Wavelength in Angstrom
-                try:
-                    wavelength = float(line_toks[1])
-                except:
-                    msg = "IgorReader: can't read this file, missing wavelength"
-                    raise ValueError, msg
-                
-            #Find # of bins in a row assuming the detector is square.
-            if dataStarted == True:
-                try:
-                    value = float(line)
-                except:
-                    # Found a non-float entry, skip it
-                    continue
-                
-                # Get total bin number
-                
-            i_tot_row += 1
-        i_tot_row = math.ceil(math.sqrt(i_tot_row)) - 1
-        #print "i_tot", i_tot_row
-        size_x = i_tot_row  # 192#128
-        size_y = i_tot_row  # 192#128
-        output.data = np.zeros([size_x, size_y])
-        output.err_data = np.zeros([size_x, size_y])
-  
         data_row = 0
         wavelength = distance = center_x = center_y = None
