Index: src/sas/sasgui/perspectives/calculator/data_operator.py
===================================================================
--- src/sas/sasgui/perspectives/calculator/data_operator.py	(revision 61780e3355265f8377c4d588db7b820d2c9989a7)
+++ src/sas/sasgui/perspectives/calculator/data_operator.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -5,5 +5,5 @@
 import sys
 import time
-import numpy
+import numpy as np
 from sas.sascalc.dataloader.data_info import Data1D
 from sas.sasgui.plottools.PlotPanel import PlotPanel
@@ -541,7 +541,7 @@
                     theory, _ = theory_list.values()[0]
                     dnames.append(theory.name)
-        ind = numpy.argsort(dnames)
+        ind = np.argsort(dnames)
         if len(ind) > 0:
-            val_list = numpy.array(self._data.values())[ind]
+            val_list = np.array(self._data.values())[ind]
             for datastate in val_list:
                 data = datastate.data
Index: src/sas/sasgui/perspectives/calculator/gen_scatter_panel.py
===================================================================
--- src/sas/sasgui/perspectives/calculator/gen_scatter_panel.py	(revision 0f7c930fc2c325971c76a60d39f2e3719b8143a3)
+++ src/sas/sasgui/perspectives/calculator/gen_scatter_panel.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -7,5 +7,5 @@
 import sys
 import os
-import numpy
+import numpy as np
 #import math
 import wx.aui as aui
@@ -741,6 +741,6 @@
             marker = 'o'
             m_size = 3.5
-        sld_tot = (numpy.fabs(sld_mx) + numpy.fabs(sld_my) + \
-                   numpy.fabs(sld_mz) + numpy.fabs(output.sld_n))
+        sld_tot = (np.fabs(sld_mx) + np.fabs(sld_my) + \
+                   np.fabs(sld_mz) + np.fabs(output.sld_n))
         is_nonzero = sld_tot > 0.0
         is_zero = sld_tot == 0.0
@@ -757,8 +757,8 @@
             pix_symbol = output.pix_symbol[is_nonzero]
         # II. Plot selective points in color
-        other_color = numpy.ones(len(pix_symbol), dtype='bool')
+        other_color = np.ones(len(pix_symbol), dtype='bool')
         for key in color_dic.keys():
             chosen_color = pix_symbol == key
-            if numpy.any(chosen_color):
+            if np.any(chosen_color):
                 other_color = other_color & (chosen_color != True)
                 color = color_dic[key]
@@ -767,5 +767,5 @@
                         markeredgecolor=color, markersize=m_size, label=key)
         # III. Plot All others        
-        if numpy.any(other_color):
+        if np.any(other_color):
             a_name = ''
             if output.pix_type == 'atom':
@@ -795,7 +795,7 @@
                 draw magnetic vectors w/arrow
                 """
-                max_mx = max(numpy.fabs(sld_mx))
-                max_my = max(numpy.fabs(sld_my))
-                max_mz = max(numpy.fabs(sld_mz))
+                max_mx = max(np.fabs(sld_mx))
+                max_my = max(np.fabs(sld_my))
+                max_mz = max(np.fabs(sld_mz))
                 max_m = max(max_mx, max_my, max_mz)
                 try:
@@ -812,14 +812,14 @@
                         unit_z2 = sld_mz / max_m
                         # 0.8 is for avoiding the color becomes white=(1,1,1))
-                        color_x = numpy.fabs(unit_x2 * 0.8)
-                        color_y = numpy.fabs(unit_y2 * 0.8)
-                        color_z = numpy.fabs(unit_z2 * 0.8)
+                        color_x = np.fabs(unit_x2 * 0.8)
+                        color_y = np.fabs(unit_y2 * 0.8)
+                        color_z = np.fabs(unit_z2 * 0.8)
                         x2 = pos_x + unit_x2 * max_step
                         y2 = pos_y + unit_y2 * max_step
                         z2 = pos_z + unit_z2 * max_step
-                        x_arrow = numpy.column_stack((pos_x, x2))
-                        y_arrow = numpy.column_stack((pos_y, y2))
-                        z_arrow = numpy.column_stack((pos_z, z2))
-                        colors = numpy.column_stack((color_x, color_y, color_z))
+                        x_arrow = np.column_stack((pos_x, x2))
+                        y_arrow = np.column_stack((pos_y, y2))
+                        z_arrow = np.column_stack((pos_z, z2))
+                        colors = np.column_stack((color_x, color_y, color_z))
                         arrows = Arrow3D(panel, x_arrow, z_arrow, y_arrow,
                                         colors, mutation_scale=10, lw=1,
@@ -880,9 +880,9 @@
             if self.is_avg or self.is_avg == None:
                 self._create_default_1d_data()
-                i_out = numpy.zeros(len(self.data.y))
+                i_out = np.zeros(len(self.data.y))
                 inputs = [self.data.x, [], i_out]
             else:
                 self._create_default_2d_data()
-                i_out = numpy.zeros(len(self.data.data))
+                i_out = np.zeros(len(self.data.data))
                 inputs = [self.data.qx_data, self.data.qy_data, i_out]
 
@@ -989,5 +989,5 @@
         :Param input: input list [qx_data, qy_data, i_out]
         """
-        out = numpy.empty(0)
+        out = np.empty(0)
         #s = time.time()
         for ind in range(len(input[0])):
@@ -998,5 +998,5 @@
                 inputi = [input[0][ind:ind + 1], [], input[2][ind:ind + 1]]
                 outi = self.model.run(inputi)
-                out = numpy.append(out, outi)
+                out = np.append(out, outi)
             else:
                 if ind % 50 == 0  and update != None:
@@ -1006,5 +1006,5 @@
                           input[2][ind:ind + 1]]
                 outi = self.model.runXY(inputi)
-                out = numpy.append(out, outi)
+                out = np.append(out, outi)
         #print time.time() - s
         if self.is_avg or self.is_avg == None:
@@ -1027,5 +1027,5 @@
         self.npts_x = int(float(self.npt_ctl.GetValue()))
         self.data = Data2D()
-        qmax = self.qmax_x #/ numpy.sqrt(2)
+        qmax = self.qmax_x #/ np.sqrt(2)
         self.data.xaxis('\\rm{Q_{x}}', '\AA^{-1}')
         self.data.yaxis('\\rm{Q_{y}}', '\AA^{-1}')
@@ -1048,22 +1048,22 @@
         qstep = self.npts_x
 
-        x = numpy.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True)
-        y = numpy.linspace(start=ymin, stop=ymax, num=qstep, endpoint=True)
+        x = np.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True)
+        y = np.linspace(start=ymin, stop=ymax, num=qstep, endpoint=True)
         ## use data info instead
-        new_x = numpy.tile(x, (len(y), 1))
-        new_y = numpy.tile(y, (len(x), 1))
+        new_x = np.tile(x, (len(y), 1))
+        new_y = np.tile(y, (len(x), 1))
         new_y = new_y.swapaxes(0, 1)
         # all data reuire now in 1d array
         qx_data = new_x.flatten()
         qy_data = new_y.flatten()
-        q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data)
+        q_data = np.sqrt(qx_data * qx_data + qy_data * qy_data)
         # set all True (standing for unmasked) as default
-        mask = numpy.ones(len(qx_data), dtype=bool)
+        mask = np.ones(len(qx_data), dtype=bool)
         # store x and y bin centers in q space
         x_bins = x
         y_bins = y
         self.data.source = Source()
-        self.data.data = numpy.ones(len(mask))
-        self.data.err_data = numpy.ones(len(mask))
+        self.data.data = np.ones(len(mask))
+        self.data.err_data = np.ones(len(mask))
         self.data.qx_data = qx_data
         self.data.qy_data = qy_data
@@ -1084,5 +1084,5 @@
         :warning: This data is never plotted.
                     residuals.x = data_copy.x[index]
-            residuals.dy = numpy.ones(len(residuals.y))
+            residuals.dy = np.ones(len(residuals.y))
             residuals.dx = None
             residuals.dxl = None
@@ -1091,15 +1091,15 @@
         self.qmax_x = float(self.qmax_ctl.GetValue())
         self.npts_x = int(float(self.npt_ctl.GetValue()))
-        qmax = self.qmax_x #/ numpy.sqrt(2)
+        qmax = self.qmax_x #/ np.sqrt(2)
         ## Default values
         xmax = qmax
         xmin = qmax * _Q1D_MIN
         qstep = self.npts_x
-        x = numpy.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True)
+        x = np.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True)
         # store x and y bin centers in q space
         #self.data.source = Source()
-        y = numpy.ones(len(x))
-        dy = numpy.zeros(len(x))
-        dx = numpy.zeros(len(x))
+        y = np.ones(len(x))
+        dy = np.zeros(len(x))
+        dx = np.zeros(len(x))
         self.data = Data1D(x=x, y=y)
         self.data.dx = dx
@@ -1171,5 +1171,5 @@
         state = None
 
-        numpy.nan_to_num(image)
+        np.nan_to_num(image)
         new_plot = Data2D(image=image, err_image=data.err_data)
         new_plot.name = model.name + '2d'
@@ -1640,7 +1640,7 @@
             for key in sld_list.keys():
                 if ctr_list[0] == key:
-                    min_val = numpy.min(sld_list[key])
-                    max_val = numpy.max(sld_list[key])
-                    mean_val = numpy.mean(sld_list[key])
+                    min_val = np.min(sld_list[key])
+                    max_val = np.max(sld_list[key])
+                    mean_val = np.mean(sld_list[key])
                     enable = (min_val == max_val) and \
                              sld_data.pix_type == 'pixel'
@@ -1733,5 +1733,5 @@
                     npts = -1
                     break
-                if numpy.isfinite(n_val):
+                if np.isfinite(n_val):
                     npts *= int(n_val)
             if npts > 0:
@@ -1770,5 +1770,5 @@
                         ctl.Refresh()
                         return
-                    if numpy.isfinite(s_val):
+                    if np.isfinite(s_val):
                         s_size *= s_val
                 self.sld_data.set_pixel_volumes(s_size)
@@ -1787,5 +1787,5 @@
         try:
             sld_data = self.parent.get_sld_from_omf()
-            #nop = (nop * numpy.pi) / 6
+            #nop = (nop * np.pi) / 6
             nop = len(sld_data.sld_n)
         except:
Index: src/sas/sasgui/perspectives/fitting/basepage.py
===================================================================
--- src/sas/sasgui/perspectives/fitting/basepage.py	(revision b301db9771a6b47f4e6cab8b5e980f14f16dc65a)
+++ src/sas/sasgui/perspectives/fitting/basepage.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -5,5 +5,5 @@
 import os
 import wx
-import numpy
+import numpy as np
 import time
 import copy
@@ -100,5 +100,5 @@
         self.graph_id = None
         # Q range for data set
-        self.qmin_data_set = numpy.inf
+        self.qmin_data_set = np.inf
         self.qmax_data_set = None
         self.npts_data_set = 0
@@ -278,5 +278,5 @@
 
         """
-        x = numpy.linspace(start=self.qmin_x, stop=self.qmax_x,
+        x = np.linspace(start=self.qmin_x, stop=self.qmax_x,
                            num=self.npts_x, endpoint=True)
         self.data = Data1D(x=x)
@@ -295,14 +295,14 @@
         """
         if self.qmin_x >= 1.e-10:
-            qmin = numpy.log10(self.qmin_x)
+            qmin = np.log10(self.qmin_x)
         else:
             qmin = -10.
 
         if self.qmax_x <= 1.e10:
-            qmax = numpy.log10(self.qmax_x)
+            qmax = np.log10(self.qmax_x)
         else:
             qmax = 10.
 
-        x = numpy.logspace(start=qmin, stop=qmax,
+        x = np.logspace(start=qmin, stop=qmax,
                            num=self.npts_x, endpoint=True, base=10.0)
         self.data = Data1D(x=x)
@@ -341,16 +341,16 @@
         qstep = self.npts_x
 
-        x = numpy.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True)
-        y = numpy.linspace(start=ymin, stop=ymax, num=qstep, endpoint=True)
+        x = np.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True)
+        y = np.linspace(start=ymin, stop=ymax, num=qstep, endpoint=True)
         # use data info instead
-        new_x = numpy.tile(x, (len(y), 1))
-        new_y = numpy.tile(y, (len(x), 1))
+        new_x = np.tile(x, (len(y), 1))
+        new_y = np.tile(y, (len(x), 1))
         new_y = new_y.swapaxes(0, 1)
         # all data reuire now in 1d array
         qx_data = new_x.flatten()
         qy_data = new_y.flatten()
-        q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data)
+        q_data = np.sqrt(qx_data * qx_data + qy_data * qy_data)
         # set all True (standing for unmasked) as default
-        mask = numpy.ones(len(qx_data), dtype=bool)
+        mask = np.ones(len(qx_data), dtype=bool)
         # store x and y bin centers in q space
         x_bins = x
@@ -358,6 +358,6 @@
 
         self.data.source = Source()
-        self.data.data = numpy.ones(len(mask))
-        self.data.err_data = numpy.ones(len(mask))
+        self.data.data = np.ones(len(mask))
+        self.data.err_data = np.ones(len(mask))
         self.data.qx_data = qx_data
         self.data.qy_data = qy_data
@@ -783,5 +783,5 @@
                     # Skip non-data lines
                     logging.error(traceback.format_exc())
-            return numpy.array(angles), numpy.array(weights)
+            return np.array(angles), np.array(weights)
         except:
             raise
@@ -2107,5 +2107,5 @@
         for data in self.data_list:
             # q value from qx and qy
-            radius = numpy.sqrt(data.qx_data * data.qx_data +
+            radius = np.sqrt(data.qx_data * data.qx_data +
                                 data.qy_data * data.qy_data)
             # get unmasked index
@@ -2113,5 +2113,5 @@
                          (radius <= float(self.qmax.GetValue()))
             index_data = (index_data) & (data.mask)
-            index_data = (index_data) & (numpy.isfinite(data.data))
+            index_data = (index_data) & (np.isfinite(data.data))
 
             if len(index_data[index_data]) < 10:
@@ -2148,5 +2148,5 @@
             index_data = (float(self.qmin.GetValue()) <= radius) & \
                          (radius <= float(self.qmax.GetValue()))
-            index_data = (index_data) & (numpy.isfinite(data.y))
+            index_data = (index_data) & (np.isfinite(data.y))
 
             if len(index_data[index_data]) < 5:
@@ -2220,6 +2220,6 @@
 
                 # Check that min is less than max
-                low = -numpy.inf if min_str == "" else float(min_str)
-                high = numpy.inf if max_str == "" else float(max_str)
+                low = -np.inf if min_str == "" else float(min_str)
+                high = np.inf if max_str == "" else float(max_str)
                 if high < low:
                     min_ctrl.SetBackgroundColour("pink")
@@ -2631,5 +2631,5 @@
             self.qmin_x = data_min
             self.qmax_x = math.sqrt(x * x + y * y)
-            # self.data.mask = numpy.ones(len(self.data.data),dtype=bool)
+            # self.data.mask = np.ones(len(self.data.data),dtype=bool)
             # check smearing
             if not self.disable_smearer.GetValue():
@@ -3343,6 +3343,6 @@
 
             if value[1] == 'array':
-                pd_vals = numpy.array(value[2])
-                pd_weights = numpy.array(value[3])
+                pd_vals = np.array(value[2])
+                pd_weights = np.array(value[3])
                 if len(pd_vals) == 0 or len(pd_vals) != len(pd_weights):
                     msg = ("bad array distribution parameters for %s"
Index: src/sas/sasgui/perspectives/fitting/fitpage.py
===================================================================
--- src/sas/sasgui/perspectives/fitting/fitpage.py	(revision d85f1d8ad367b855a9bd1434682c464411b1b00e)
+++ src/sas/sasgui/perspectives/fitting/fitpage.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -6,5 +6,5 @@
 import wx
 import wx.lib.newevent
-import numpy
+import numpy as np
 import copy
 import math
@@ -1115,11 +1115,11 @@
             if item.GetValue():
                 if button_list.index(item) == 0:
-                    flag = 0  # dy = numpy.ones_like(dy_data)
+                    flag = 0  # dy = np.ones_like(dy_data)
                 elif button_list.index(item) == 1:
                     flag = 1  # dy = dy_data
                 elif button_list.index(item) == 2:
-                    flag = 2  # dy = numpy.sqrt(numpy.abs(data))
+                    flag = 2  # dy = np.sqrt(np.abs(data))
                 elif button_list.index(item) == 3:
-                    flag = 3  # dy = numpy.abs(data)
+                    flag = 3  # dy = np.abs(data)
                 break
         return flag
@@ -1422,5 +1422,5 @@
         key = event.GetKeyCode()
         length = len(self.data.x)
-        indx = (numpy.abs(self.data.x - x_data)).argmin()
+        indx = (np.abs(self.data.x - x_data)).argmin()
         # return array.flat[idx]
         if key == wx.WXK_PAGEUP or key == wx.WXK_NUMPAD_PAGEUP:
@@ -1477,9 +1477,9 @@
                     self.enable2D:
                 # set mask
-                radius = numpy.sqrt(self.data.qx_data * self.data.qx_data +
+                radius = np.sqrt(self.data.qx_data * self.data.qx_data +
                                     self.data.qy_data * self.data.qy_data)
                 index_data = ((self.qmin_x <= radius) & (radius <= self.qmax_x))
                 index_data = (index_data) & (self.data.mask)
-                index_data = (index_data) & (numpy.isfinite(self.data.data))
+                index_data = (index_data) & (np.isfinite(self.data.data))
                 if len(index_data[index_data]) < 10:
                     msg = "Cannot Plot :No or too little npts in"
@@ -1598,11 +1598,11 @@
                 and data.dqx_data.any() != 0:
                 self.smear_type = "Pinhole2d"
-                self.dq_l = format_number(numpy.average(data.dqx_data))
-                self.dq_r = format_number(numpy.average(data.dqy_data))
+                self.dq_l = format_number(np.average(data.dqx_data))
+                self.dq_r = format_number(np.average(data.dqy_data))
                 return
             else:
                 return
         # check if it is pinhole smear and get min max if it is.
-        if data.dx is not None and numpy.any(data.dx):
+        if data.dx is not None and np.any(data.dx):
             self.smear_type = "Pinhole"
             self.dq_l = data.dx[0]
@@ -1612,7 +1612,7 @@
         elif data.dxl is not None or data.dxw is not None:
             self.smear_type = "Slit"
-            if data.dxl is not None and numpy.all(data.dxl, 0):
+            if data.dxl is not None and np.all(data.dxl, 0):
                 self.dq_l = data.dxl[0]
-            if data.dxw is not None and numpy.all(data.dxw, 0):
+            if data.dxw is not None and np.all(data.dxw, 0):
                 self.dq_r = data.dxw[0]
         # return self.smear_type,self.dq_l,self.dq_r
@@ -1914,17 +1914,17 @@
                 self.default_mask = copy.deepcopy(self.data.mask)
                 if self.data.err_data is not None \
-                        and numpy.any(self.data.err_data):
+                        and np.any(self.data.err_data):
                     di_flag = True
                 if self.data.dqx_data is not None \
-                        and numpy.any(self.data.dqx_data):
+                        and np.any(self.data.dqx_data):
                     dq_flag = True
             else:
                 self.slit_smearer.Enable(True)
                 self.pinhole_smearer.Enable(True)
-                if self.data.dy is not None and numpy.any(self.data.dy):
+                if self.data.dy is not None and np.any(self.data.dy):
                     di_flag = True
-                if self.data.dx is not None and numpy.any(self.data.dx):
+                if self.data.dx is not None and np.any(self.data.dx):
                     dq_flag = True
-                elif self.data.dxl is not None and numpy.any(self.data.dxl):
+                elif self.data.dxl is not None and np.any(self.data.dxl):
                     dq_flag = True
 
@@ -2060,9 +2060,9 @@
         if self.data.__class__.__name__ == "Data2D" or \
                         self.enable2D:
-            radius = numpy.sqrt(self.data.qx_data * self.data.qx_data +
+            radius = np.sqrt(self.data.qx_data * self.data.qx_data +
                                 self.data.qy_data * self.data.qy_data)
             index_data = (self.qmin_x <= radius) & (radius <= self.qmax_x)
             index_data = (index_data) & (self.data.mask)
-            index_data = (index_data) & (numpy.isfinite(self.data.data))
+            index_data = (index_data) & (np.isfinite(self.data.data))
             npts2fit = len(self.data.data[index_data])
         else:
@@ -2097,5 +2097,5 @@
         # make sure stop button to fit button all the time
         self._on_fit_complete()
-        if out is None or not numpy.isfinite(chisqr):
+        if out is None or not np.isfinite(chisqr):
             raise ValueError, "Fit error occured..."
 
@@ -2108,5 +2108,5 @@
 
         # Check if chi2 is finite
-        if chisqr is not None and numpy.isfinite(chisqr):
+        if chisqr is not None and np.isfinite(chisqr):
             # format chi2
             chi2 = format_number(chisqr, True)
@@ -2160,5 +2160,5 @@
 
                         if cov[ind] is not None:
-                            if numpy.isfinite(float(cov[ind])):
+                            if np.isfinite(float(cov[ind])):
                                 val_err = format_number(cov[ind], True)
                                 item[4].SetForegroundColour(wx.BLACK)
@@ -2280,10 +2280,10 @@
             self.smear_type = 'Pinhole2d'
             len_data = len(data.data)
-            data.dqx_data = numpy.zeros(len_data)
-            data.dqy_data = numpy.zeros(len_data)
+            data.dqx_data = np.zeros(len_data)
+            data.dqy_data = np.zeros(len_data)
         else:
             self.smear_type = 'Pinhole'
             len_data = len(data.x)
-            data.dx = numpy.zeros(len_data)
+            data.dx = np.zeros(len_data)
             data.dxl = None
             data.dxw = None
@@ -2458,9 +2458,9 @@
         try:
             self.dxl = float(self.smear_slit_height.GetValue())
-            data.dxl = self.dxl * numpy.ones(data_len)
+            data.dxl = self.dxl * np.ones(data_len)
             self.smear_slit_height.SetBackgroundColour(wx.WHITE)
         except:
             self.dxl = None
-            data.dxl = numpy.zeros(data_len)
+            data.dxl = np.zeros(data_len)
             if self.smear_slit_height.GetValue().lstrip().rstrip() != "":
                 self.smear_slit_height.SetBackgroundColour("pink")
@@ -2471,8 +2471,8 @@
             self.dxw = float(self.smear_slit_width.GetValue())
             self.smear_slit_width.SetBackgroundColour(wx.WHITE)
-            data.dxw = self.dxw * numpy.ones(data_len)
+            data.dxw = self.dxw * np.ones(data_len)
         except:
             self.dxw = None
-            data.dxw = numpy.zeros(data_len)
+            data.dxw = np.zeros(data_len)
             if self.smear_slit_width.GetValue().lstrip().rstrip() != "":
                 self.smear_slit_width.SetBackgroundColour("pink")
@@ -2601,5 +2601,5 @@
             if event is None:
                 output = "-"
-            elif not numpy.isfinite(event.output):
+            elif not np.isfinite(event.output):
                 output = "-"
             else:
Index: src/sas/sasgui/perspectives/fitting/fitting.py
===================================================================
--- src/sas/sasgui/perspectives/fitting/fitting.py	(revision 4c5098cac470ea0a367a8f92be0ed0ac428bcc12)
+++ src/sas/sasgui/perspectives/fitting/fitting.py	(revision 4c5098cac470ea0a367a8f92be0ed0ac428bcc12)
@@ -16,5 +16,5 @@
 import wx
 import logging
-import numpy
+import numpy as np
 import time
 from copy import deepcopy
@@ -1323,5 +1323,5 @@
                     new_theory = copy_data.data
                     new_theory[res.index] = res.theory
-                    new_theory[res.index == False] = numpy.nan
+                    new_theory[res.index == False] = np.nan
                     correct_result = True
                 #get all fittable parameters of the current model
@@ -1332,7 +1332,7 @@
                         param_list.remove(param)
                 if not correct_result or res.fitness is None or \
-                    not numpy.isfinite(res.fitness) or \
-                    numpy.any(res.pvec == None) or not \
-                    numpy.all(numpy.isfinite(res.pvec)):
+                    not np.isfinite(res.fitness) or \
+                        np.any(res.pvec == None) or not \
+                        np.all(np.isfinite(res.pvec)):
                     data_name = str(None)
                     if data is not None:
@@ -1343,5 +1343,5 @@
                     msg += "Data %s and Model %s did not fit.\n" % (data_name,
                                                                     model_name)
-                    ERROR = numpy.NAN
+                    ERROR = np.NAN
                     cell = BatchCell()
                     cell.label = res.fitness
@@ -1357,7 +1357,7 @@
                             batch_inputs["error on %s" % str(param)].append(ERROR)
                 else:
-                    # TODO: Why sometimes res.pvec comes with numpy.float64?
+                    # TODO: Why sometimes res.pvec comes with np.float64?
                     # probably from scipy lmfit
-                    if res.pvec.__class__ == numpy.float64:
+                    if res.pvec.__class__ == np.float64:
                         res.pvec = [res.pvec]
 
@@ -1523,16 +1523,16 @@
                 fit_msg = res.mesg
                 if res.fitness is None or \
-                    not numpy.isfinite(res.fitness) or \
-                    numpy.any(res.pvec == None) or \
-                    not numpy.all(numpy.isfinite(res.pvec)):
+                    not np.isfinite(res.fitness) or \
+                        np.any(res.pvec == None) or \
+                    not np.all(np.isfinite(res.pvec)):
                     fit_msg += "\nFitting did not converge!!!"
                     wx.CallAfter(self._update_fit_button, page_id)
                 else:
                     #set the panel when fit result are float not list
-                    if res.pvec.__class__ == numpy.float64:
+                    if res.pvec.__class__ == np.float64:
                         pvec = [res.pvec]
                     else:
                         pvec = res.pvec
-                    if res.stderr.__class__ == numpy.float64:
+                    if res.stderr.__class__ == np.float64:
                         stderr = [res.stderr]
                     else:
@@ -1682,5 +1682,5 @@
         if dy is None:
             new_plot.is_data = False
-            new_plot.dy = numpy.zeros(len(y))
+            new_plot.dy = np.zeros(len(y))
             # If this is a theory curve, pick the proper symbol to make it a curve
             new_plot.symbol = GUIFRAME_ID.CURVE_SYMBOL_NUM
@@ -1731,5 +1731,5 @@
         """
         try:
-            numpy.nan_to_num(y)
+            np.nan_to_num(y)
             new_plot = self.create_theory_1D(x, y, page_id, model, data, state,
                                              data_description=model.name,
@@ -1815,5 +1815,5 @@
         that can be plot.
         """
-        numpy.nan_to_num(image)
+        np.nan_to_num(image)
         new_plot = Data2D(image=image, err_image=data.err_data)
         new_plot.name = model.name + '2d'
@@ -2007,10 +2007,10 @@
         if data_copy.__class__.__name__ == "Data2D":
             if index == None:
-                index = numpy.ones(len(data_copy.data), dtype=bool)
+                index = np.ones(len(data_copy.data), dtype=bool)
             if weight != None:
                 data_copy.err_data = weight
             # get rid of zero error points
             index = index & (data_copy.err_data != 0)
-            index = index & (numpy.isfinite(data_copy.data))
+            index = index & (np.isfinite(data_copy.data))
             fn = data_copy.data[index]
             theory_data = self.page_finder[page_id].get_theory_data(fid=data_copy.id)
@@ -2022,9 +2022,9 @@
             # 1 d theory from model_thread is only in the range of index
             if index == None:
-                index = numpy.ones(len(data_copy.y), dtype=bool)
+                index = np.ones(len(data_copy.y), dtype=bool)
             if weight != None:
                 data_copy.dy = weight
             if data_copy.dy == None or data_copy.dy == []:
-                dy = numpy.ones(len(data_copy.y))
+                dy = np.ones(len(data_copy.y))
             else:
                 ## Set consistently w/AbstractFitengine:
@@ -2047,7 +2047,7 @@
             return
 
-        residuals = res[numpy.isfinite(res)]
+        residuals = res[np.isfinite(res)]
         # get chisqr only w/finite
-        chisqr = numpy.average(residuals * residuals)
+        chisqr = np.average(residuals * residuals)
 
         self._plot_residuals(page_id=page_id, data=data_copy,
@@ -2086,5 +2086,5 @@
             residuals.qy_data = data_copy.qy_data
             residuals.q_data = data_copy.q_data
-            residuals.err_data = numpy.ones(len(residuals.data))
+            residuals.err_data = np.ones(len(residuals.data))
             residuals.xmin = min(residuals.qx_data)
             residuals.xmax = max(residuals.qx_data)
@@ -2100,8 +2100,8 @@
             # 1 d theory from model_thread is only in the range of index
             if data_copy.dy == None or data_copy.dy == []:
-                dy = numpy.ones(len(data_copy.y))
+                dy = np.ones(len(data_copy.y))
             else:
                 if weight == None:
-                    dy = numpy.ones(len(data_copy.y))
+                    dy = np.ones(len(data_copy.y))
                 ## Set consitently w/AbstractFitengine:
                 ## But this should be corrected later.
@@ -2122,5 +2122,5 @@
                 residuals.y = (fn - gn[index]) / en
             residuals.x = data_copy.x[index]
-            residuals.dy = numpy.ones(len(residuals.y))
+            residuals.dy = np.ones(len(residuals.y))
             residuals.dx = None
             residuals.dxl = None
Index: src/sas/sasgui/perspectives/fitting/model_thread.py
===================================================================
--- src/sas/sasgui/perspectives/fitting/model_thread.py	(revision c1c9929d6b02699660b0af8a643376612943deb8)
+++ src/sas/sasgui/perspectives/fitting/model_thread.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -4,5 +4,5 @@
 
 import time
-import numpy
+import numpy as np
 import math
 from sas.sascalc.data_util.calcthread import CalcThread
@@ -68,5 +68,5 @@
 
         # Define matrix where data will be plotted
-        radius = numpy.sqrt((self.data.qx_data * self.data.qx_data) + \
+        radius = np.sqrt((self.data.qx_data * self.data.qx_data) + \
                     (self.data.qy_data * self.data.qy_data))
 
@@ -75,5 +75,5 @@
         index_model = (self.qmin <= radius) & (radius <= self.qmax)
         index_model = index_model & self.data.mask
-        index_model = index_model & numpy.isfinite(self.data.data)
+        index_model = index_model & np.isfinite(self.data.data)
 
         if self.smearer is not None:
@@ -91,5 +91,5 @@
                 self.data.qy_data[index_model]
             ])
-        output = numpy.zeros(len(self.data.qx_data))
+        output = np.zeros(len(self.data.qx_data))
         # output default is None
         # This method is to distinguish between masked
@@ -163,5 +163,5 @@
         """
         self.starttime = time.time()
-        output = numpy.zeros((len(self.data.x)))
+        output = np.zeros((len(self.data.x)))
         index = (self.qmin <= self.data.x) & (self.data.x <= self.qmax)
 
@@ -175,5 +175,5 @@
                                                              self.qmax)
             mask = self.data.x[first_bin:last_bin+1]
-            unsmeared_output = numpy.zeros((len(self.data.x)))
+            unsmeared_output = np.zeros((len(self.data.x)))
             unsmeared_output[first_bin:last_bin+1] = self.model.evalDistribution(mask)
             self.smearer.model = self.model
@@ -183,7 +183,7 @@
             # Check that the arrays are compatible. If we only have a model but no data,
             # the length of data.y will be zero.
-            if isinstance(self.data.y, numpy.ndarray) and output.shape == self.data.y.shape:
-                unsmeared_data = numpy.zeros((len(self.data.x)))
-                unsmeared_error = numpy.zeros((len(self.data.x)))
+            if isinstance(self.data.y, np.ndarray) and output.shape == self.data.y.shape:
+                unsmeared_data = np.zeros((len(self.data.x)))
+                unsmeared_error = np.zeros((len(self.data.x)))
                 unsmeared_data[first_bin:last_bin+1] = self.data.y[first_bin:last_bin+1]\
                                                         * unsmeared_output[first_bin:last_bin+1]\
@@ -209,6 +209,6 @@
 
         if p_model is not None and s_model is not None:
-            sq_values = numpy.zeros((len(self.data.x)))
-            pq_values = numpy.zeros((len(self.data.x)))
+            sq_values = np.zeros((len(self.data.x)))
+            pq_values = np.zeros((len(self.data.x)))
             sq_values[index] = s_model.evalDistribution(self.data.x[index])
             pq_values[index] = p_model.evalDistribution(self.data.x[index])
Index: src/sas/sasgui/perspectives/fitting/pagestate.py
===================================================================
--- src/sas/sasgui/perspectives/fitting/pagestate.py	(revision 27109e5cd4b7a9b36dd9bb6e66db62057374322b)
+++ src/sas/sasgui/perspectives/fitting/pagestate.py	(revision 27109e5cd4b7a9b36dd9bb6e66db62057374322b)
@@ -18,5 +18,5 @@
 import copy
 import logging
-import numpy
+import numpy as np
 import traceback
 
@@ -410,14 +410,14 @@
         for fittable, name, value, _, uncert, lower, upper, units in params:
             if not value:
-                value = numpy.nan
+                value = np.nan
             if not uncert or uncert[1] == '' or uncert[1] == 'None':
                 uncert[0] = False
-                uncert[1] = numpy.nan
+                uncert[1] = np.nan
             if not upper or upper[1] == '' or upper[1] == 'None':
                 upper[0] = False
-                upper[1] = numpy.nan
+                upper[1] = np.nan
             if not lower or lower[1] == '' or lower[1] == 'None':
                 lower[0] = False
-                lower[1] = numpy.nan
+                lower[1] = np.nan
             if is_string:
                 p[name] = str(value)
@@ -449,13 +449,13 @@
                 lower = params.get(name + ".lower", '-inf')
                 units = params.get(name + ".units")
-                if std is not None and std is not numpy.nan:
+                if std is not None and std is not np.nan:
                     std = [True, str(std)]
                 else:
                     std = [False, '']
-                if lower is not None and lower is not numpy.nan:
+                if lower is not None and lower is not np.nan:
                     lower = [True, str(lower)]
                 else:
                     lower = [True, '-inf']
-                if upper is not None and upper is not numpy.nan:
+                if upper is not None and upper is not np.nan:
                     upper = [True, str(upper)]
                 else:
@@ -1100,5 +1100,5 @@
                                        % (line, tagname, name))
                                 logging.error(msg + traceback.format_exc())
-                        dic[name] = numpy.array(value_list)
+                        dic[name] = np.array(value_list)
                     setattr(self, varname, dic)
 
Index: src/sas/sasgui/perspectives/fitting/utils.py
===================================================================
--- src/sas/sasgui/perspectives/fitting/utils.py	(revision d85c194ea2f78cb2b9b3de9c969e1b8ebea6b6d2)
+++ src/sas/sasgui/perspectives/fitting/utils.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -2,5 +2,5 @@
 Module contains functions frequently used in this package
 """
-import numpy
+import numpy as np
 
 
@@ -19,10 +19,10 @@
         data = data.y
     if flag == 0:
-        weight = numpy.ones_like(data)
+        weight = np.ones_like(data)
     elif flag == 1:
         weight = dy_data
     elif flag == 2:
-        weight = numpy.sqrt(numpy.abs(data))
+        weight = np.sqrt(np.abs(data))
     elif flag == 3:
-        weight = numpy.abs(data)
+        weight = np.abs(data)
     return weight
Index: src/sas/sasgui/perspectives/pr/explore_dialog.py
===================================================================
--- src/sas/sasgui/perspectives/pr/explore_dialog.py	(revision d85c194ea2f78cb2b9b3de9c969e1b8ebea6b6d2)
+++ src/sas/sasgui/perspectives/pr/explore_dialog.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -19,5 +19,5 @@
 
 import wx
-import numpy
+import numpy as np
 import logging
 import sys
@@ -65,8 +65,8 @@
 
         step = (self.max - self.min) / (self.npts - 1)
-        self.x = numpy.arange(self.min, self.max + step * 0.01, step)
-        dx = numpy.zeros(len(self.x))
-        y = numpy.ones(len(self.x))
-        dy = numpy.zeros(len(self.x))
+        self.x = np.arange(self.min, self.max + step * 0.01, step)
+        dx = np.zeros(len(self.x))
+        y = np.ones(len(self.x))
+        dy = np.zeros(len(self.x))
 
         # Plot area
Index: src/sas/sasgui/perspectives/pr/pr.py
===================================================================
--- src/sas/sasgui/perspectives/pr/pr.py	(revision a69a967b8ace2263edf57d6328d2ece6d26f1492)
+++ src/sas/sasgui/perspectives/pr/pr.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -21,5 +21,5 @@
 import time
 import math
-import numpy
+import numpy as np
 import pylab
 from sas.sasgui.guiframe.gui_manager import MDIFrame
@@ -207,6 +207,6 @@
         r = pylab.arange(0.01, d_max, d_max / 51.0)
         M = len(r)
-        y = numpy.zeros(M)
-        pr_err = numpy.zeros(M)
+        y = np.zeros(M)
+        pr_err = np.zeros(M)
 
         total = 0.0
@@ -253,5 +253,5 @@
         """
         # Show P(r)
-        y_true = numpy.zeros(len(x))
+        y_true = np.zeros(len(x))
 
         sum_true = 0.0
@@ -307,6 +307,6 @@
 
         x = pylab.arange(minq, maxq, maxq / 301.0)
-        y = numpy.zeros(len(x))
-        err = numpy.zeros(len(x))
+        y = np.zeros(len(x))
+        err = np.zeros(len(x))
         for i in range(len(x)):
             value = pr.iq(out, x[i])
@@ -337,6 +337,6 @@
         if pr.slit_width > 0 or pr.slit_height > 0:
             x = pylab.arange(minq, maxq, maxq / 301.0)
-            y = numpy.zeros(len(x))
-            err = numpy.zeros(len(x))
+            y = np.zeros(len(x))
+            err = np.zeros(len(x))
             for i in range(len(x)):
                 value = pr.iq_smeared(out, x[i])
@@ -382,11 +382,11 @@
         x = pylab.arange(0.0, pr.d_max, pr.d_max / self._pr_npts)
 
-        y = numpy.zeros(len(x))
-        dy = numpy.zeros(len(x))
-        y_true = numpy.zeros(len(x))
+        y = np.zeros(len(x))
+        dy = np.zeros(len(x))
+        y_true = np.zeros(len(x))
 
         total = 0.0
         pmax = 0.0
-        cov2 = numpy.ascontiguousarray(cov)
+        cov2 = np.ascontiguousarray(cov)
 
         for i in range(len(x)):
@@ -480,7 +480,7 @@
         """
         # 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
@@ -504,7 +504,7 @@
                         #err = 0
 
-                    data_x = numpy.append(data_x, x)
-                    data_y = numpy.append(data_y, y)
-                    data_err = numpy.append(data_err, err)
+                    data_x = np.append(data_x, x)
+                    data_y = np.append(data_y, y)
+                    data_err = np.append(data_err, err)
                 except:
                     logging.error(sys.exc_value)
@@ -528,7 +528,7 @@
         """
         # 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
@@ -555,7 +555,7 @@
                             #err = 0
 
-                        data_x = numpy.append(data_x, x)
-                        data_y = numpy.append(data_y, y)
-                        data_err = numpy.append(data_err, err)
+                        data_x = np.append(data_x, x)
+                        data_y = np.append(data_y, y)
+                        data_err = np.append(data_err, err)
                     except:
                         logging.error(sys.exc_value)
@@ -640,5 +640,5 @@
         # Now replot the original added data
         for plot in self._added_plots:
-            self._added_plots[plot].y = numpy.copy(self._default_Iq[plot])
+            self._added_plots[plot].y = np.copy(self._default_Iq[plot])
             wx.PostEvent(self.parent,
                          NewPlotEvent(plot=self._added_plots[plot],
@@ -664,5 +664,5 @@
         # Now scale the added plots too
         for plot in self._added_plots:
-            total = numpy.sum(self._added_plots[plot].y)
+            total = np.sum(self._added_plots[plot].y)
             npts = len(self._added_plots[plot].x)
             total *= self._added_plots[plot].x[npts - 1] / npts
@@ -814,5 +814,5 @@
         # Save Pr invertor
         self.pr = pr
-        cov = numpy.ascontiguousarray(cov)
+        cov = np.ascontiguousarray(cov)
 
         # Show result on control panel
@@ -982,5 +982,5 @@
         all_zeros = True
         if err == None:
-            err = numpy.zeros(len(pr.y))
+            err = np.zeros(len(pr.y))
         else:
             for i in range(len(err)):
@@ -1088,6 +1088,6 @@
         # If we have not errors, add statistical errors
         if y is not None:
-            if err == None or numpy.all(err) == 0:
-                err = numpy.zeros(len(y))
+            if err == None or np.all(err) == 0:
+                err = np.zeros(len(y))
                 scale = None
                 min_err = 0.0
Index: src/sas/sasgui/perspectives/simulation/simulation.py
===================================================================
--- src/sas/sasgui/perspectives/simulation/simulation.py	(revision d85c194ea2f78cb2b9b3de9c969e1b8ebea6b6d2)
+++ src/sas/sasgui/perspectives/simulation/simulation.py	(revision 9a5097cd1c76689d1f997b85ba43d12a95d8f243)
@@ -10,5 +10,5 @@
 import wx
 import os
-import numpy
+import numpy as np
 import time
 import logging
@@ -46,6 +46,6 @@
     def compute(self):
         x = self.x
-        output = numpy.zeros(len(x))
-        error = numpy.zeros(len(x))
+        output = np.zeros(len(x))
+        error = np.zeros(len(x))
         
         self.starttime = time.time()
@@ -123,5 +123,5 @@
         # Q-values for plotting simulated I(Q)
         step = (self.q_max-self.q_min)/(self.q_npts-1)
-        self.x = numpy.arange(self.q_min, self.q_max+step*0.01, step)        
+        self.x = np.arange(self.q_min, self.q_max+step*0.01, step)
         
         # Set the list of panels that are part of the simulation perspective
@@ -187,5 +187,5 @@
         # Q-values for plotting simulated I(Q)
         step = (self.q_max-self.q_min)/(self.q_npts-1)
-        self.x = numpy.arange(self.q_min, self.q_max+step*0.01, step)    
+        self.x = np.arange(self.q_min, self.q_max+step*0.01, step)
          
         # Compute the simulated I(Q)
