Changeset ed2276f in sasview for src/sas/sasgui

Timestamp:

Apr 4, 2017 12:00:18 PM (8 years ago)

Author:

GitHub <noreply@…>

Branches:

master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, costrafo411, magnetic_scatt, release-4.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload

Children:

7b15990

Parents:

9a5097c (diff), 571bf4b (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

git-author:

Andrew Jackson <andrew.jackson@…> (04/04/17 12:00:18)

git-committer:

GitHub <noreply@…> (04/04/17 12:00:18)

Message:

Merge branch 'master' into numpy_import

Location:

src/sas/sasgui

Files:

• perspectives/fitting/basepage.py (modified) (2 diffs)
• perspectives/fitting/fitpage.py (modified) (2 diffs)
• perspectives/fitting/fitting.py (modified) (5 diffs)
• perspectives/fitting/pagestate.py (modified) (1 diff)
• guiframe/dataFitting.py (modified) (7 diffs)
• guiframe/data_processor.py (modified) (2 diffs)
• guiframe/local_perspectives/plotting/Plotter1D.py (modified) (2 diffs)
• guiframe/local_perspectives/plotting/Plotter2D.py (modified) (2 diffs)
• guiframe/local_perspectives/plotting/boxSlicer.py (modified) (3 diffs)
• guiframe/local_perspectives/plotting/masking.py (modified) (3 diffs)
• perspectives/calculator/data_operator.py (modified) (2 diffs)
• perspectives/calculator/gen_scatter_panel.py (modified) (19 diffs)
• perspectives/fitting/model_thread.py (modified) (8 diffs)
• perspectives/fitting/utils.py (modified) (2 diffs)
• perspectives/pr/explore_dialog.py (modified) (2 diffs)
• perspectives/pr/pr.py (modified) (15 diffs)
• perspectives/simulation/simulation.py (modified) (4 diffs)
• plottools/PlotPanel.py (modified) (8 diffs)
• plottools/fitDialog.py (modified) (5 diffs)
• plottools/plottables.py (modified) (6 diffs)

src/sas/sasgui/perspectives/fitting/basepage.py

@@ -1449 +1449 @@
                 self.state_change = True
                 self._draw_model()
-                # Time delay has been introduced to prevent _handle error
-                # on Windows
-                # This part of code is executed when model is selected and
-                # it's parameters are changed (with respect to previously
-                # selected model). There are two Iq evaluations occuring one
-                # after another and therefore there may be compilation error
-                # if model is calculated for the first time.
-                # This seems to be Windows only issue - haven't tested on Linux
-                # though.The proper solution (other than time delay) requires
-                # more fundemental code refatoring
-                # Wojtek P. Nov 7, 2016
-                if not ON_MAC:
-                    time.sleep(0.1)
                 self.Refresh()
 
@@ -2609 +2596 @@
             Layout is called after fitting.
         """
-        self._sleep4sec()
         self.Layout()
         return
-
-    def _sleep4sec(self):
-        """
-            sleep for 1 sec only applied on Mac
-            Note: This 1sec helps for Mac not to crash on self.
-            Layout after self._draw_model
-        """
-        if ON_MAC:
-            time.sleep(1)
 
     def _find_polyfunc_selection(self, disp_func=None):

src/sas/sasgui/perspectives/fitting/fitpage.py

@@ -1809 +1809 @@
             self.onSmear(None)
 
-    def _mac_sleep(self, sec=0.2):
-        """
-        Give sleep to MAC
-        """
-        if self.is_mac:
-            time.sleep(sec)
-
     def get_view_mode(self):
         """
@@ -2188 +2181 @@
         self.save_current_state()
 
-        if not self.is_mac:
-            self.Layout()
-            self.Refresh()
-        self._mac_sleep(0.1)
         # plot model ( when drawing, do not update chisqr value again)
         self._draw_model(update_chisqr=False, source='fit')

src/sas/sasgui/perspectives/fitting/fitting.py

@@ -876 +876 @@
                 qmin=qmin, qmax=qmax, weight=weight)
 
-    def _mac_sleep(self, sec=0.2):
-        """
-        Give sleep to MAC
-        """
-        if ON_MAC:
-            time.sleep(sec)
-
     def draw_model(self, model, page_id, data=None, smearer=None,
                    enable1D=True, enable2D=False,
@@ -1030 +1023 @@
                                 manager=self,
                                 improvement_delta=0.1)
-        self._mac_sleep(0.2)
 
         # batch fit
@@ -1270 +1262 @@
         :param elapsed: time spent at the fitting level
         """
-        self._mac_sleep(0.2)
         uid = page_id[0]
         if uid in self.fit_thread_list.keys():
@@ -1520 +1511 @@
             page_id = []
         ## fit more than 1 model at the same time
-        self._mac_sleep(0.2)
         try:
             index = 0
@@ -1755 +1745 @@
                                           data_id="Data  " + data.name + " unsmeared",
                                           dy=unsmeared_error)
-                
-            if sq_model is not None and pq_model is not None:
-                self.create_theory_1D(x, sq_model, page_id, model, data, state,
-                                      data_description=model.name + " S(q)",
-                                      data_id=str(page_id) + " " + data.name + " S(q)")
-                self.create_theory_1D(x, pq_model, page_id, model, data, state,
-                                      data_description=model.name + " P(q)",
-                                      data_id=str(page_id) + " " + data.name + " P(q)")
-
+            # Comment this out until we can get P*S models with correctly populated parameters
+            #if sq_model is not None and pq_model is not None:
+            #    self.create_theory_1D(x, sq_model, page_id, model, data, state,
+            #                          data_description=model.name + " S(q)",
+            #                          data_id=str(page_id) + " " + data.name + " S(q)")
+            #    self.create_theory_1D(x, pq_model, page_id, model, data, state,
+            #                          data_description=model.name + " P(q)",
+            #                          data_id=str(page_id) + " " + data.name + " P(q)")
 
             current_pg = self.fit_panel.get_page_by_id(page_id)

src/sas/sasgui/perspectives/fitting/pagestate.py

@@ -819 +819 @@
 
         attr = newdoc.createAttribute("version")
-        import sasview
+        from sas import sasview
         attr.nodeValue = sasview.__version__
         # attr.nodeValue = '1.0'

src/sas/sasgui/guiframe/dataFitting.py

@@ -3 +3 @@
 """
 import copy
-import numpy
+import numpy as np
 import math
 from sas.sascalc.data_util.uncertainty import Uncertainty
@@ -81 +81 @@
             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)):
@@ -128 +128 @@
             result.dlam = None
         else:
-            result.dlam = numpy.zeros(tot_length)
+            result.dlam = np.zeros(tot_length)
         if self.dy == None or other.dy is None:
             result.dy = None
         else:
-            result.dy = numpy.zeros(tot_length)
+            result.dy = np.zeros(tot_length)
         if self.dx == None or other.dx is None:
             result.dx = None
         else:
-            result.dx = numpy.zeros(tot_length)
+            result.dx = np.zeros(tot_length)
         if self.dxw == None or other.dxw is None:
             result.dxw = None
         else:
-            result.dxw = numpy.zeros(tot_length)
+            result.dxw = np.zeros(tot_length)
         if self.dxl == None or other.dxl is None:
             result.dxl = None
         else:
-            result.dxl = numpy.zeros(tot_length)
-
-        result.x = numpy.append(self.x, other.x)
+            result.dxl = np.zeros(tot_length)
+
+        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]
-        result.lam = numpy.append(self.lam, other.lam)
+        result.lam = np.append(self.lam, other.lam)
         result.lam = result.lam[ind]
         if result.dlam != None:
-            result.dlam = numpy.append(self.dlam, other.dlam)
+            result.dlam = np.append(self.dlam, other.dlam)
             result.dlam = result.dlam[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
@@ -230 +230 @@
             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))
-
-        for i in range(numpy.size(self.x)):
+            result.dxl = np.zeros(len(self.x))
+
+        for i in range(np.size(self.x)):
             result.x[i] = self.x[i]
             if self.dx is not None and len(self.x) == len(self.dx):
@@ -282 +282 @@
             result.dlam = None
         else:
-            result.dlam = numpy.zeros(tot_length)
+            result.dlam = np.zeros(tot_length)
         if self.dy == None or other.dy is None:
             result.dy = None
         else:
-            result.dy = numpy.zeros(tot_length)
+            result.dy = np.zeros(tot_length)
         if self.dx == None or other.dx is None:
             result.dx = None
         else:
-            result.dx = numpy.zeros(tot_length)
+            result.dx = np.zeros(tot_length)
         if self.dxw == None or other.dxw is None:
             result.dxw = None
         else:
-            result.dxw = numpy.zeros(tot_length)
+            result.dxw = np.zeros(tot_length)
         if self.dxl == None or other.dxl is None:
             result.dxl = None
         else:
-            result.dxl = numpy.zeros(tot_length)
-        result.x = numpy.append(self.x, other.x)
+            result.dxl = np.zeros(tot_length)
+        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]
-        result.lam = numpy.append(self.lam, other.lam)
+        result.lam = np.append(self.lam, other.lam)
         result.lam = result.lam[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
@@ -409 +409 @@
             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:
@@ -473 +473 @@
             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

src/sas/sasgui/guiframe/data_processor.py

@@ -1091 +1091 @@
             # When inputs are from an external file
             return inputs, outputs
-        inds = numpy.lexsort((to_be_sort, to_be_sort))
+        inds = np.lexsort((to_be_sort, to_be_sort))
         for key in outputs.keys():
             key_list = outputs[key]
@@ -1379 +1379 @@
             return
         if dy == None:
-            dy = numpy.zeros(len(y))
+            dy = np.zeros(len(y))
         #plotting
         new_plot = Data1D(x=x, y=y, dy=dy)

src/sas/sasgui/guiframe/local_perspectives/plotting/Plotter1D.py

@@ -14 +14 @@
 import sys
 import math
-import numpy
+import numpy as np
 import logging
 from sas.sasgui.plottools.PlotPanel import PlotPanel
@@ -288 +288 @@
         :Param value: float
         """
-        idx = (numpy.abs(array - value)).argmin()
+        idx = (np.abs(array - value)).argmin()
         return int(idx)  # array.flat[idx]
 

src/sas/sasgui/guiframe/local_perspectives/plotting/Plotter2D.py

@@ -14 +14 @@
 import sys
 import math
-import numpy
+import numpy as np
 import logging
 from sas.sasgui.plottools.PlotPanel import PlotPanel
@@ -567 +567 @@
         """
         # Find the best number of bins
-        npt = math.sqrt(len(self.data2D.data[numpy.isfinite(self.data2D.data)]))
+        npt = math.sqrt(len(self.data2D.data[np.isfinite(self.data2D.data)]))
         npt = math.floor(npt)
         from sas.sascalc.dataloader.manipulations import CircularAverage

src/sas/sasgui/guiframe/local_perspectives/plotting/boxSlicer.py

@@ -1 +1 @@
 import wx
 import math
-import numpy
+import numpy as np
 from sas.sasgui.guiframe.events import NewPlotEvent
 from sas.sasgui.guiframe.events import StatusEvent
@@ -358 +358 @@
         # # Reset x, y- coordinates if send as parameters
         if x != None:
-            self.x = numpy.sign(self.x) * math.fabs(x)
+            self.x = np.sign(self.x) * math.fabs(x)
         if y != None:
-            self.y = numpy.sign(self.y) * math.fabs(y)
+            self.y = np.sign(self.y) * math.fabs(y)
         # # Draw lines and markers
         self.inner_marker.set(xdata=[0], ydata=[self.y])
@@ -465 +465 @@
         # # reset x, y -coordinates if given as parameters
         if x != None:
-            self.x = numpy.sign(self.x) * math.fabs(x)
+            self.x = np.sign(self.x) * math.fabs(x)
         if y != None:
-            self.y = numpy.sign(self.y) * math.fabs(y)
+            self.y = np.sign(self.y) * math.fabs(y)
         # # draw lines and markers
         self.inner_marker.set(xdata=[self.x], ydata=[0])

src/sas/sasgui/guiframe/local_perspectives/plotting/masking.py

@@ -24 +24 @@
 import math
 import copy
-import numpy
+import numpy as np
 from sas.sasgui.plottools.PlotPanel import PlotPanel
 from sas.sasgui.plottools.plottables import Graph
@@ -298 +298 @@
         self.subplot.set_ylim(self.data.ymin, self.data.ymax)
         self.subplot.set_xlim(self.data.xmin, self.data.xmax)
-        mask = numpy.ones(len(self.data.mask), dtype=bool)
+        mask = np.ones(len(self.data.mask), dtype=bool)
         self.data.mask = mask
         # update mask plot
@@ -343 +343 @@
             self.mask = mask
         # make temperary data to plot
-        temp_mask = numpy.zeros(len(mask))
+        temp_mask = np.zeros(len(mask))
         temp_data = copy.deepcopy(self.data)
         # temp_data default is None

src/sas/sasgui/perspectives/calculator/data_operator.py

@@ -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 +541 @@
                     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

src/sas/sasgui/perspectives/calculator/gen_scatter_panel.py

@@ -7 +7 @@
 import sys
 import os
-import numpy
+import numpy as np
 #import math
 import wx.aui as aui
@@ -741 +741 @@
             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 +757 @@
             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 +767 @@
                         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 +795 @@
                 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 +812 @@
                         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 +880 @@
             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 +989 @@
         :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 +998 @@
                 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 +1006 @@
                           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 +1027 @@
         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 +1048 @@
         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 +1084 @@
         :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 +1091 @@
         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 +1171 @@
         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 +1640 @@
             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 +1733 @@
                     npts = -1
                     break
-                if numpy.isfinite(n_val):
+                if np.isfinite(n_val):
                     npts *= int(n_val)
             if npts > 0:
@@ -1770 +1770 @@
                         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 +1787 @@
         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:

src/sas/sasgui/perspectives/fitting/model_thread.py

@@ -4 +4 @@
 
 import time
-import numpy
+import numpy as np
 import math
 from sas.sascalc.data_util.calcthread import CalcThread
@@ -68 +68 @@
 
         # 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 +75 @@
         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 +91 @@
                 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 +163 @@
         """
         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 +175 @@
                                                              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 +183 @@
             # 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 +209 @@
 
         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])

src/sas/sasgui/perspectives/fitting/utils.py

@@ -2 +2 @@
 Module contains functions frequently used in this package
 """
-import numpy
+import numpy as np
 
 
@@ -19 +19 @@
         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

src/sas/sasgui/perspectives/pr/explore_dialog.py

@@ -19 +19 @@
 
 import wx
-import numpy
+import numpy as np
 import logging
 import sys
@@ -65 +65 @@
 
         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

src/sas/sasgui/perspectives/pr/pr.py

@@ -21 +21 @@
 import time
 import math
-import numpy
+import numpy as np
 import pylab
 from sas.sasgui.guiframe.gui_manager import MDIFrame
@@ -207 +207 @@
         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 +253 @@
         """
         # Show P(r)
-        y_true = numpy.zeros(len(x))
+        y_true = np.zeros(len(x))
 
         sum_true = 0.0
@@ -307 +307 @@
 
         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 +337 @@
         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 +382 @@
         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 +480 @@
         """
         # 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 +504 @@
                         #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 +528 @@
         """
         # 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 +555 @@
                             #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 +640 @@
         # 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 +664 @@
         # 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 +814 @@
         # Save Pr invertor
         self.pr = pr
-        cov = numpy.ascontiguousarray(cov)
+        cov = np.ascontiguousarray(cov)
 
         # Show result on control panel
@@ -982 +982 @@
         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 +1088 @@
         # 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

src/sas/sasgui/perspectives/simulation/simulation.py

@@ -10 +10 @@
 import wx
 import os
-import numpy
+import numpy as np
 import time
 import logging
@@ -46 +46 @@
     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 +123 @@
         # 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 +187 @@
         # 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)

src/sas/sasgui/plottools/PlotPanel.py

@@ -29 +29 @@
 DEFAULT_CMAP = pylab.cm.jet
 import copy
-import numpy
+import numpy as np
 
 from sas.sasgui.guiframe.events import StatusEvent
@@ -1452 +1452 @@
                 if  self.zmin_2D <= 0  and len(output[output > 0]) > 0:
                     zmin_temp = self.zmin_2D
-                    output[output > 0] = numpy.log10(output[output > 0])
+                    output[output > 0] = np.log10(output[output > 0])
                     #In log scale Negative values are not correct in general
-                    #output[output<=0] = math.log(numpy.min(output[output>0]))
+                    #output[output<=0] = math.log(np.min(output[output>0]))
                 elif self.zmin_2D <= 0:
                     zmin_temp = self.zmin_2D
-                    output[output > 0] = numpy.zeros(len(output))
+                    output[output > 0] = np.zeros(len(output))
                     output[output <= 0] = -32
                 else:
                     zmin_temp = self.zmin_2D
-                    output[output > 0] = numpy.log10(output[output > 0])
+                    output[output > 0] = np.log10(output[output > 0])
                     #In log scale Negative values are not correct in general
-                    #output[output<=0] = math.log(numpy.min(output[output>0]))
+                    #output[output<=0] = math.log(np.min(output[output>0]))
             except:
                 #Too many problems in 2D plot with scale
@@ -1492 +1492 @@
             X = self.x_bins[0:-1]
             Y = self.y_bins[0:-1]
-            X, Y = numpy.meshgrid(X, Y)
+            X, Y = np.meshgrid(X, Y)
 
             try:
@@ -1555 +1555 @@
         # 1d array to use for weighting the data point averaging
         #when they fall into a same bin.
-        weights_data = numpy.ones([self.data.size])
+        weights_data = np.ones([self.data.size])
         # get histogram of ones w/len(data); this will provide
         #the weights of data on each bins
-        weights, xedges, yedges = numpy.histogram2d(x=self.qy_data,
+        weights, xedges, yedges = np.histogram2d(x=self.qy_data,
                                                     y=self.qx_data,
                                                     bins=[self.y_bins, self.x_bins],
                                                     weights=weights_data)
         # get histogram of data, all points into a bin in a way of summing
-        image, xedges, yedges = numpy.histogram2d(x=self.qy_data,
+        image, xedges, yedges = np.histogram2d(x=self.qy_data,
                                                   y=self.qx_data,
                                                   bins=[self.y_bins, self.x_bins],
@@ -1581 +1581 @@
         # do while loop until all vacant bins are filled up up
         #to loop = max_loop
-        while not(numpy.isfinite(image[weights == 0])).all():
+        while not(np.isfinite(image[weights == 0])).all():
             if loop >= max_loop:  # this protects never-ending loop
                 break
@@ -1630 +1630 @@
 
         # store x and y bin centers in q space
-        x_bins = numpy.linspace(xmin, xmax, npix_x)
-        y_bins = numpy.linspace(ymin, ymax, npix_y)
+        x_bins = np.linspace(xmin, xmax, npix_x)
+        y_bins = np.linspace(ymin, ymax, npix_y)
 
         #set x_bins and y_bins
@@ -1650 +1650 @@
         """
         # No image matrix given
-        if image == None or numpy.ndim(image) != 2 \
-                or numpy.isfinite(image).all() \
+        if image == None or np.ndim(image) != 2 \
+                or np.isfinite(image).all() \
                 or weights == None:
             return image
@@ -1657 +1657 @@
         len_y = len(image)
         len_x = len(image[1])
-        temp_image = numpy.zeros([len_y, len_x])
-        weit = numpy.zeros([len_y, len_x])
+        temp_image = np.zeros([len_y, len_x])
+        weit = np.zeros([len_y, len_x])
         # do for-loop for all pixels
         for n_y in range(len(image)):
             for n_x in range(len(image[1])):
                 # find only null pixels
-                if weights[n_y][n_x] > 0 or numpy.isfinite(image[n_y][n_x]):
+                if weights[n_y][n_x] > 0 or np.isfinite(image[n_y][n_x]):
                     continue
                 else:
                     # find 4 nearest neighbors
                     # check where or not it is at the corner
-                    if n_y != 0 and numpy.isfinite(image[n_y - 1][n_x]):
+                    if n_y != 0 and np.isfinite(image[n_y - 1][n_x]):
                         temp_image[n_y][n_x] += image[n_y - 1][n_x]
                         weit[n_y][n_x] += 1
-                    if n_x != 0 and numpy.isfinite(image[n_y][n_x - 1]):
+                    if n_x != 0 and np.isfinite(image[n_y][n_x - 1]):
                         temp_image[n_y][n_x] += image[n_y][n_x - 1]
                         weit[n_y][n_x] += 1
-                    if n_y != len_y - 1 and numpy.isfinite(image[n_y + 1][n_x]):
+                    if n_y != len_y - 1 and np.isfinite(image[n_y + 1][n_x]):
                         temp_image[n_y][n_x] += image[n_y + 1][n_x]
                         weit[n_y][n_x] += 1
-                    if n_x != len_x - 1 and numpy.isfinite(image[n_y][n_x + 1]):
+                    if n_x != len_x - 1 and np.isfinite(image[n_y][n_x + 1]):
                         temp_image[n_y][n_x] += image[n_y][n_x + 1]
                         weit[n_y][n_x] += 1
                     # go 4 next nearest neighbors when no non-zero
                     # neighbor exists
-                    if n_y != 0 and n_x != 0 and\
-                         numpy.isfinite(image[n_y - 1][n_x - 1]):
+                    if n_y != 0 and n_x != 0 and \
+                            np.isfinite(image[n_y - 1][n_x - 1]):
                         temp_image[n_y][n_x] += image[n_y - 1][n_x - 1]
                         weit[n_y][n_x] += 1
                     if n_y != len_y - 1 and n_x != 0 and \
-                        numpy.isfinite(image[n_y + 1][n_x - 1]):
+                            np.isfinite(image[n_y + 1][n_x - 1]):
                         temp_image[n_y][n_x] += image[n_y + 1][n_x - 1]
                         weit[n_y][n_x] += 1
                     if n_y != len_y and n_x != len_x - 1 and \
-                        numpy.isfinite(image[n_y - 1][n_x + 1]):
+                            np.isfinite(image[n_y - 1][n_x + 1]):
                         temp_image[n_y][n_x] += image[n_y - 1][n_x + 1]
                         weit[n_y][n_x] += 1
                     if n_y != len_y - 1 and n_x != len_x - 1 and \
-                        numpy.isfinite(image[n_y + 1][n_x + 1]):
+                            np.isfinite(image[n_y + 1][n_x + 1]):
                         temp_image[n_y][n_x] += image[n_y + 1][n_x + 1]
                         weit[n_y][n_x] += 1

src/sas/sasgui/plottools/fitDialog.py

@@ -2 +2 @@
 from plottables import Theory1D
 import math
-import numpy
+import numpy as np
 import fittings
 import transform
@@ -482 +482 @@
 
                 if self.xLabel.lower() == "log10(x)":
-                    tempdy = numpy.asarray(tempdy)
+                    tempdy = np.asarray(tempdy)
                     tempdy[tempdy == 0] = 1
                     chisqr, out, cov = fittings.sasfit(self.model,
@@ -491 +491 @@
                                                        math.log10(xmax))
                 else:
-                    tempdy = numpy.asarray(tempdy)
+                    tempdy = np.asarray(tempdy)
                     tempdy[tempdy == 0] = 1
                     chisqr, out, cov = fittings.sasfit(self.model,
@@ -572 +572 @@
         if self.rg_on:
             if self.Rg_tctr.IsShown():
-                rg = numpy.sqrt(-3 * float(cstA))
+                rg = np.sqrt(-3 * float(cstA))
                 value = format_number(rg)
                 self.Rg_tctr.SetValue(value)
                 if self.I0_tctr.IsShown():
-                    val = numpy.exp(cstB)
+                    val = np.exp(cstB)
                     self.I0_tctr.SetValue(format_number(val))
             if self.Rgerr_tctr.IsShown():
@@ -585 +585 @@
                 self.Rgerr_tctr.SetValue(value)
                 if self.I0err_tctr.IsShown():
-                    val = numpy.abs(numpy.exp(cstB) * errB)
+                    val = np.abs(np.exp(cstB) * errB)
                     self.I0err_tctr.SetValue(format_number(val))
             if self.Diameter_tctr.IsShown():
-                rg = numpy.sqrt(-2 * float(cstA))
-                _diam = 4 * numpy.sqrt(-float(cstA))
+                rg = np.sqrt(-2 * float(cstA))
+                _diam = 4 * np.sqrt(-float(cstA))
                 value = format_number(_diam)
                 self.Diameter_tctr.SetValue(value)

src/sas/sasgui/plottools/plottables.py

@@ -43 +43 @@
 # Support for ancient python versions
 import copy
-import numpy
+import numpy as np
 import sys
 import logging
@@ -706 +706 @@
                 self.dy = None
             if not has_err_x:
-                dx = numpy.zeros(len(x))
+                dx = np.zeros(len(x))
             if not has_err_y:
-                dy = numpy.zeros(len(y))
+                dy = np.zeros(len(y))
             for i in range(len(x)):
                 try:
@@ -796 +796 @@
         tempdy = []
         if self.dx == None:
-            self.dx = numpy.zeros(len(self.x))
+            self.dx = np.zeros(len(self.x))
         if self.dy == None:
-            self.dy = numpy.zeros(len(self.y))
+            self.dy = np.zeros(len(self.y))
         if self.xLabel == "log10(x)":
             for i in range(len(self.x)):
@@ -826 +826 @@
         tempdy = []
         if self.dx == None:
-            self.dx = numpy.zeros(len(self.x))
+            self.dx = np.zeros(len(self.x))
         if self.dy == None:
-            self.dy = numpy.zeros(len(self.y))
+            self.dy = np.zeros(len(self.y))
         if self.yLabel == "log10(y)":
             for i in range(len(self.x)):
@@ -859 +859 @@
         tempdy = []
         if self.dx == None:
-            self.dx = numpy.zeros(len(self.x))
+            self.dx = np.zeros(len(self.x))
         if self.dy == None:
-            self.dy = numpy.zeros(len(self.y))
+            self.dy = np.zeros(len(self.y))
         if xmin != None and xmax != None:
             for i in range(len(self.x)):
@@ -1228 +1228 @@
 
 def sample_graph():
-    import numpy as nx
+    import numpy as np
 
     # Construct a simple graph
     if False:
-        x = nx.array([1, 2, 3, 4, 5, 6], 'd')
-        y = nx.array([4, 5, 6, 5, 4, 5], 'd')
-        dy = nx.array([0.2, 0.3, 0.1, 0.2, 0.9, 0.3])
+        x = np.array([1, 2, 3, 4, 5, 6], 'd')
+        y = np.array([4, 5, 6, 5, 4, 5], 'd')
+        dy = np.array([0.2, 0.3, 0.1, 0.2, 0.9, 0.3])
     else:
-        x = nx.linspace(0, 1., 10000)
-        y = nx.sin(2 * nx.pi * x * 2.8)
-        dy = nx.sqrt(100 * nx.abs(y)) / 100
+        x = np.linspace(0, 1., 10000)
+        y = np.sin(2 * np.pi * x * 2.8)
+        dy = np.sqrt(100 * np.abs(y)) / 100
     data = Data1D(x, y, dy=dy)
     data.xaxis('distance', 'm')