Index: src/sas/sascalc/pr/fit/AbstractFitEngine.py
===================================================================
--- src/sas/sascalc/pr/fit/AbstractFitEngine.py	(revision fc18690cd84cc4dd6e33a9d344f47b08cef71290)
+++ src/sas/sascalc/pr/fit/AbstractFitEngine.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -4,5 +4,5 @@
 import sys
 import math
-import numpy
+import numpy as np
 
 from sas.sascalc.dataloader.data_info import Data1D
@@ -162,12 +162,12 @@
         # constant, or dy data
         if dy is None or dy == [] or dy.all() == 0:
-            self.dy = numpy.ones(len(y))
+            self.dy = np.ones(len(y))
         else:
-            self.dy = numpy.asarray(dy).copy()
+            self.dy = np.asarray(dy).copy()
 
         ## Min Q-value
         #Skip the Q=0 point, especially when y(q=0)=None at x[0].
         if min(self.x) == 0.0 and self.x[0] == 0 and\
-                     not numpy.isfinite(self.y[0]):
+                     not np.isfinite(self.y[0]):
             self.qmin = min(self.x[self.x != 0])
         else:
@@ -188,5 +188,5 @@
         # Skip Q=0 point, (especially for y(q=0)=None at x[0]).
         # ToDo: Find better way to do it.
-        if qmin == 0.0 and not numpy.isfinite(self.y[qmin]):
+        if qmin == 0.0 and not np.isfinite(self.y[qmin]):
             self.qmin = min(self.x[self.x != 0])
         elif qmin != None:
@@ -239,5 +239,5 @@
         """
         # Compute theory data f(x)
-        fx = numpy.zeros(len(self.x))
+        fx = np.zeros(len(self.x))
         fx[self.idx_unsmeared] = fn(self.x[self.idx_unsmeared])
        
@@ -247,7 +247,7 @@
                               self._last_unsmeared_bin)
         ## Sanity check
-        if numpy.size(self.dy) != numpy.size(fx):
+        if np.size(self.dy) != np.size(fx):
             msg = "FitData1D: invalid error array "
-            msg += "%d <> %d" % (numpy.shape(self.dy), numpy.size(fx))
+            msg += "%d <> %d" % (np.shape(self.dy), np.size(fx))
             raise RuntimeError, msg
         return (self.y[self.idx] - fx[self.idx]) / self.dy[self.idx], fx[self.idx]
@@ -300,10 +300,10 @@
         ## new error image for fitting purpose
         if self.err_data == None or self.err_data == []:
-            self.res_err_data = numpy.ones(len(self.data))
+            self.res_err_data = np.ones(len(self.data))
         else:
             self.res_err_data = copy.deepcopy(self.err_data)
         #self.res_err_data[self.res_err_data==0]=1
         
-        self.radius = numpy.sqrt(self.qx_data**2 + self.qy_data**2)
+        self.radius = np.sqrt(self.qx_data**2 + self.qy_data**2)
         
         # Note: mask = True: for MASK while mask = False for NOT to mask
@@ -311,6 +311,6 @@
                             (self.radius <= self.qmax))
         self.idx = (self.idx) & (self.mask)
-        self.idx = (self.idx) & (numpy.isfinite(self.data))
-        self.num_points = numpy.sum(self.idx)
+        self.idx = (self.idx) & (np.isfinite(self.data))
+        self.num_points = np.sum(self.idx)
 
     def set_smearer(self, smearer):
@@ -334,9 +334,9 @@
         if qmax != None:
             self.qmax = qmax
-        self.radius = numpy.sqrt(self.qx_data**2 + self.qy_data**2)
+        self.radius = np.sqrt(self.qx_data**2 + self.qy_data**2)
         self.idx = ((self.qmin <= self.radius) &\
                             (self.radius <= self.qmax))
         self.idx = (self.idx) & (self.mask)
-        self.idx = (self.idx) & (numpy.isfinite(self.data))
+        self.idx = (self.idx) & (np.isfinite(self.data))
         self.idx = (self.idx) & (self.res_err_data != 0)
 
@@ -351,5 +351,5 @@
         Number of measurement points in data set after masking, etc.
         """
-        return numpy.sum(self.idx)
+        return np.sum(self.idx)
 
     def residuals(self, fn):
Index: src/sas/sascalc/pr/fit/BumpsFitting.py
===================================================================
--- src/sas/sascalc/pr/fit/BumpsFitting.py	(revision b699768550de9d4b35b087234ec1d2a461922bab)
+++ src/sas/sascalc/pr/fit/BumpsFitting.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -5,5 +5,5 @@
 from datetime import timedelta, datetime
 
-import numpy
+import numpy as np
 
 from bumps import fitters
@@ -96,5 +96,5 @@
         try:
             p = history.population_values[0]
-            n,p = len(p), numpy.sort(p)
+            n,p = len(p), np.sort(p)
             QI,Qmid, = int(0.2*n),int(0.5*n)
             self.convergence.append((best, p[0],p[QI],p[Qmid],p[-1-QI],p[-1]))
@@ -193,8 +193,8 @@
 
     def numpoints(self):
-        return numpy.sum(self.data.idx) # number of fitted points
+        return np.sum(self.data.idx) # number of fitted points
 
     def nllf(self):
-        return 0.5*numpy.sum(self.residuals()**2)
+        return 0.5*np.sum(self.residuals()**2)
 
     def theory(self):
@@ -293,13 +293,13 @@
             R.success = result['success']
             if R.success:
-                R.stderr = numpy.hstack((result['stderr'][fitted_index],
-                                         numpy.NaN*numpy.ones(len(fitness.computed_pars))))
-                R.pvec = numpy.hstack((result['value'][fitted_index],
+                R.stderr = np.hstack((result['stderr'][fitted_index],
+                                      np.NaN*np.ones(len(fitness.computed_pars))))
+                R.pvec = np.hstack((result['value'][fitted_index],
                                       [p.value for p in fitness.computed_pars]))
-                R.fitness = numpy.sum(R.residuals**2)/(fitness.numpoints() - len(fitted_index))
+                R.fitness = np.sum(R.residuals**2)/(fitness.numpoints() - len(fitted_index))
             else:
-                R.stderr = numpy.NaN*numpy.ones(len(param_list))
-                R.pvec = numpy.asarray( [p.value for p in fitness.fitted_pars+fitness.computed_pars])
-                R.fitness = numpy.NaN
+                R.stderr = np.NaN*np.ones(len(param_list))
+                R.pvec = np.asarray( [p.value for p in fitness.fitted_pars+fitness.computed_pars])
+                R.fitness = np.NaN
             R.convergence = result['convergence']
             if result['uncertainty'] is not None:
@@ -331,5 +331,5 @@
     max_step = steps + options.get('burn', 0)
     pars = [p.name for p in problem._parameters]
-    #x0 = numpy.asarray([p.value for p in problem._parameters])
+    #x0 = np.asarray([p.value for p in problem._parameters])
     options['monitors'] = [
         BumpsMonitor(handler, max_step, pars, problem.dof),
@@ -352,6 +352,6 @@
 
     convergence_list = options['monitors'][-1].convergence
-    convergence = (2*numpy.asarray(convergence_list)/problem.dof
-                   if convergence_list else numpy.empty((0,1),'d'))
+    convergence = (2*np.asarray(convergence_list)/problem.dof
+                   if convergence_list else np.empty((0,1),'d'))
 
     success = best is not None
Index: src/sas/sascalc/pr/fit/Loader.py
===================================================================
--- src/sas/sascalc/pr/fit/Loader.py	(revision b699768550de9d4b35b087234ec1d2a461922bab)
+++ src/sas/sascalc/pr/fit/Loader.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -2,5 +2,5 @@
 #import wx
 #import string
-import numpy
+import numpy as np
 
 class Load:
@@ -52,5 +52,5 @@
                     self.y.append(y)
                     self.dy.append(dy)
-                    self.dx = numpy.zeros(len(self.x))
+                    self.dx = np.zeros(len(self.x))
                 except:
                     print "READ ERROR", line
Index: src/sas/sascalc/pr/fit/expression.py
===================================================================
--- src/sas/sascalc/pr/fit/expression.py	(revision b699768550de9d4b35b087234ec1d2a461922bab)
+++ src/sas/sascalc/pr/fit/expression.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -271,5 +271,5 @@
 
 def test_deps():
-    import numpy
+    import numpy as np
 
     # Null case
@@ -279,5 +279,5 @@
     _check("test1",[(2,7),(1,5),(1,4),(2,1),(3,1),(5,6)])
     _check("test1 renumbered",[(6,1),(7,3),(7,4),(6,7),(5,7),(3,2)])
-    _check("test1 numpy",numpy.array([(2,7),(1,5),(1,4),(2,1),(3,1),(5,6)]))
+    _check("test1 numpy",np.array([(2,7),(1,5),(1,4),(2,1),(3,1),(5,6)]))
 
     # No dependencies
@@ -291,5 +291,5 @@
 
     # large test for gross speed check
-    A = numpy.random.randint(4000,size=(1000,2))
+    A = np.random.randint(4000,size=(1000,2))
     A[:,1] += 4000  # Avoid cycles
     _check("test-large",A)
@@ -297,8 +297,8 @@
     # depth tests
     k = 200
-    A = numpy.array([range(0,k),range(1,k+1)]).T
+    A = np.array([range(0,k),range(1,k+1)]).T
     _check("depth-1",A)
 
-    A = numpy.array([range(1,k+1),range(0,k)]).T
+    A = np.array([range(1,k+1),range(0,k)]).T
     _check("depth-2",A)
 
Index: src/sas/sascalc/pr/invertor.py
===================================================================
--- src/sas/sascalc/pr/invertor.py	(revision 463e7ffce130ae386f93cd18b87a1120743e88b5)
+++ src/sas/sascalc/pr/invertor.py	(revision 463e7ffce130ae386f93cd18b87a1120743e88b5)
@@ -7,5 +7,5 @@
 """
 
-import numpy
+import numpy as np
 import sys
 import math
@@ -191,13 +191,13 @@
         #import numpy
         if name == 'x':
-            out = numpy.ones(self.get_nx())
+            out = np.ones(self.get_nx())
             self.get_x(out)
             return out
         elif name == 'y':
-            out = numpy.ones(self.get_ny())
+            out = np.ones(self.get_ny())
             self.get_y(out)
             return out
         elif name == 'err':
-            out = numpy.ones(self.get_nerr())
+            out = np.ones(self.get_nerr())
             self.get_err(out)
             return out
@@ -327,5 +327,5 @@
             raise RuntimeError, msg
 
-        p = numpy.ones(nfunc)
+        p = np.ones(nfunc)
         t_0 = time.time()
         out, cov_x, _, _, _ = optimize.leastsq(self.residuals, p, full_output=1)
@@ -343,5 +343,5 @@
 
         if cov_x is None:
-            cov_x = numpy.ones([nfunc, nfunc])
+            cov_x = np.ones([nfunc, nfunc])
             cov_x *= math.fabs(chisqr)
         return out, cov_x
@@ -360,5 +360,5 @@
             raise RuntimeError, msg
 
-        p = numpy.ones(nfunc)
+        p = np.ones(nfunc)
         t_0 = time.time()
         out, cov_x, _, _, _ = optimize.leastsq(self.pr_residuals, p, full_output=1)
@@ -437,5 +437,5 @@
         """
         # Note: To make sure an array is contiguous:
-        # blah = numpy.ascontiguousarray(blah_original)
+        # blah = np.ascontiguousarray(blah_original)
         # ... before passing it to C
 
@@ -458,7 +458,7 @@
             nfunc += 1
 
-        a = numpy.zeros([npts + nq, nfunc])
-        b = numpy.zeros(npts + nq)
-        err = numpy.zeros([nfunc, nfunc])
+        a = np.zeros([npts + nq, nfunc])
+        b = np.zeros(npts + nq)
+        err = np.zeros([nfunc, nfunc])
 
         # Construct the a matrix and b vector that represent the problem
@@ -478,5 +478,5 @@
         self.chi2 = chi2
 
-        inv_cov = numpy.zeros([nfunc, nfunc])
+        inv_cov = np.zeros([nfunc, nfunc])
         # Get the covariance matrix, defined as inv_cov = a_transposed * a
         self._get_invcov_matrix(nfunc, nr, a, inv_cov)
@@ -492,5 +492,5 @@
 
         try:
-            cov = numpy.linalg.pinv(inv_cov)
+            cov = np.linalg.pinv(inv_cov)
             err = math.fabs(chi2 / float(npts - nfunc)) * cov
         except:
@@ -507,6 +507,6 @@
             self.background = c[0]
 
-            err_0 = numpy.zeros([nfunc, nfunc])
-            c_0 = numpy.zeros(nfunc)
+            err_0 = np.zeros([nfunc, nfunc])
+            c_0 = np.zeros(nfunc)
 
             for i in range(nfunc_0):
@@ -664,5 +664,5 @@
                                                    str(self.cov[i][i])))
         file.write("<r>  <Pr>  <dPr>\n")
-        r = numpy.arange(0.0, self.d_max, self.d_max / npts)
+        r = np.arange(0.0, self.d_max, self.d_max / npts)
 
         for r_i in r:
@@ -696,6 +696,6 @@
                         toks = line.split('=')
                         self.nfunc = int(toks[1])
-                        self.out = numpy.zeros(self.nfunc)
-                        self.cov = numpy.zeros([self.nfunc, self.nfunc])
+                        self.out = np.zeros(self.nfunc)
+                        self.cov = np.zeros([self.nfunc, self.nfunc])
                     elif line.startswith('#alpha='):
                         toks = line.split('=')
Index: src/sas/sascalc/pr/num_term.py
===================================================================
--- src/sas/sascalc/pr/num_term.py	(revision 463e7ffce130ae386f93cd18b87a1120743e88b5)
+++ src/sas/sascalc/pr/num_term.py	(revision 463e7ffce130ae386f93cd18b87a1120743e88b5)
@@ -1,4 +1,4 @@
 import math
-import numpy
+import numpy as np
 import copy
 import sys
@@ -154,7 +154,7 @@
 def load(path):
     # Read the data from the data file
-    data_x = numpy.zeros(0)
-    data_y = numpy.zeros(0)
-    data_err = numpy.zeros(0)
+    data_x = np.zeros(0)
+    data_y = np.zeros(0)
+    data_err = np.zeros(0)
     scale = None
     min_err = 0.0
@@ -178,7 +178,7 @@
                     #err = 0
 
-                data_x = numpy.append(data_x, test_x)
-                data_y = numpy.append(data_y, test_y)
-                data_err = numpy.append(data_err, err)
+                data_x = np.append(data_x, test_x)
+                data_y = np.append(data_y, test_y)
+                data_err = np.append(data_err, err)
             except:
                 logger.error(sys.exc_value)
