Changeset 80a49c2 in sasview for src/sas/sasgui/perspectives


Ignore:
Timestamp:
Apr 6, 2017 5:55:21 AM (8 years ago)
Author:
gonzalezm
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:
8fbf8d6, 5f768c2
Parents:
c5251f6 (diff), 5e2f36c (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.
Message:

Merge branch 'master' of ​https://github.com/SasView/sasview

Location:
src/sas/sasgui/perspectives
Files:
24 edited

Legend:

Unmodified
Added
Removed

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

    ra0c1e1d r463e7ffc  
    2828import logging 
    2929 
     30logger = logging.getLogger(__name__) 
     31 
    3032class Plugin(PluginBase): 
    3133    """ 
    … …  
    3638        PluginBase.__init__(self, name="Calculator") 
    3739        # Log startup 
    38         logging.info("Calculator plug-in started") 
     40        logger.info("Calculator plug-in started") 
    3941        self.sub_menu = "Tool" 
    4042        self.data_edit_frame = None 

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

    r61780e3 r9a5097c  
    55import sys 
    66import time 
    7 import numpy 
     7import numpy as np 
    88from sas.sascalc.dataloader.data_info import Data1D 
    99from sas.sasgui.plottools.PlotPanel import PlotPanel 
    … …  
    541541                    theory, _ = theory_list.values()[0] 
    542542                    dnames.append(theory.name) 
    543         ind = numpy.argsort(dnames) 
     543        ind = np.argsort(dnames) 
    544544        if len(ind) > 0: 
    545             val_list = numpy.array(self._data.values())[ind] 
     545            val_list = np.array(self._data.values())[ind] 
    546546            for datastate in val_list: 
    547547                data = datastate.data 

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

    r0f7c930 r9c0f3c17  
    77import sys 
    88import os 
    9 import numpy 
     9import numpy as np 
    1010#import math 
    1111import wx.aui as aui 
    … …  
    3838from sas.sasgui.guiframe.events import NewPlotEvent 
    3939from sas.sasgui.guiframe.documentation_window import DocumentationWindow 
     40 
     41logger = logging.getLogger(__name__) 
    4042 
    4143_BOX_WIDTH = 76 
    … …  
    699701                ax = Axes3D(panel.figure) 
    700702            except: 
    701                 logging.error("PlotPanel could not import Axes3D") 
     703                logger.error("PlotPanel could not import Axes3D") 
    702704                raise 
    703705        panel.dimension = 3 
    … …  
    741743            marker = 'o' 
    742744            m_size = 3.5 
    743         sld_tot = (numpy.fabs(sld_mx) + numpy.fabs(sld_my) + \ 
    744                    numpy.fabs(sld_mz) + numpy.fabs(output.sld_n)) 
     745        sld_tot = (np.fabs(sld_mx) + np.fabs(sld_my) + \ 
     746                   np.fabs(sld_mz) + np.fabs(output.sld_n)) 
    745747        is_nonzero = sld_tot > 0.0 
    746748        is_zero = sld_tot == 0.0 
    … …  
    757759            pix_symbol = output.pix_symbol[is_nonzero] 
    758760        # II. Plot selective points in color 
    759         other_color = numpy.ones(len(pix_symbol), dtype='bool') 
     761        other_color = np.ones(len(pix_symbol), dtype='bool') 
    760762        for key in color_dic.keys(): 
    761763            chosen_color = pix_symbol == key 
    762             if numpy.any(chosen_color): 
     764            if np.any(chosen_color): 
    763765                other_color = other_color & (chosen_color != True) 
    764766                color = color_dic[key] 
    … …  
    767769                        markeredgecolor=color, markersize=m_size, label=key) 
    768770        # III. Plot All others         
    769         if numpy.any(other_color): 
     771        if np.any(other_color): 
    770772            a_name = '' 
    771773            if output.pix_type == 'atom': 
    … …  
    795797                draw magnetic vectors w/arrow 
    796798                """ 
    797                 max_mx = max(numpy.fabs(sld_mx)) 
    798                 max_my = max(numpy.fabs(sld_my)) 
    799                 max_mz = max(numpy.fabs(sld_mz)) 
     799                max_mx = max(np.fabs(sld_mx)) 
     800                max_my = max(np.fabs(sld_my)) 
     801                max_mz = max(np.fabs(sld_mz)) 
    800802                max_m = max(max_mx, max_my, max_mz) 
    801803                try: 
    … …  
    812814                        unit_z2 = sld_mz / max_m 
    813815                        # 0.8 is for avoiding the color becomes white=(1,1,1)) 
    814                         color_x = numpy.fabs(unit_x2 * 0.8) 
    815                         color_y = numpy.fabs(unit_y2 * 0.8) 
    816                         color_z = numpy.fabs(unit_z2 * 0.8) 
     816                        color_x = np.fabs(unit_x2 * 0.8) 
     817                        color_y = np.fabs(unit_y2 * 0.8) 
     818                        color_z = np.fabs(unit_z2 * 0.8) 
    817819                        x2 = pos_x + unit_x2 * max_step 
    818820                        y2 = pos_y + unit_y2 * max_step 
    819821                        z2 = pos_z + unit_z2 * max_step 
    820                         x_arrow = numpy.column_stack((pos_x, x2)) 
    821                         y_arrow = numpy.column_stack((pos_y, y2)) 
    822                         z_arrow = numpy.column_stack((pos_z, z2)) 
    823                         colors = numpy.column_stack((color_x, color_y, color_z)) 
     822                        x_arrow = np.column_stack((pos_x, x2)) 
     823                        y_arrow = np.column_stack((pos_y, y2)) 
     824                        z_arrow = np.column_stack((pos_z, z2)) 
     825                        colors = np.column_stack((color_x, color_y, color_z)) 
    824826                        arrows = Arrow3D(panel, x_arrow, z_arrow, y_arrow, 
    825827                                        colors, mutation_scale=10, lw=1, 
    … …  
    880882            if self.is_avg or self.is_avg == None: 
    881883                self._create_default_1d_data() 
    882                 i_out = numpy.zeros(len(self.data.y)) 
     884                i_out = np.zeros(len(self.data.y)) 
    883885                inputs = [self.data.x, [], i_out] 
    884886            else: 
    885887                self._create_default_2d_data() 
    886                 i_out = numpy.zeros(len(self.data.data)) 
     888                i_out = np.zeros(len(self.data.data)) 
    887889                inputs = [self.data.qx_data, self.data.qy_data, i_out] 
    888890 
    … …  
    989991        :Param input: input list [qx_data, qy_data, i_out] 
    990992        """ 
    991         out = numpy.empty(0) 
     993        out = np.empty(0) 
    992994        #s = time.time() 
    993995        for ind in range(len(input[0])): 
    … …  
    9981000                inputi = [input[0][ind:ind + 1], [], input[2][ind:ind + 1]] 
    9991001                outi = self.model.run(inputi) 
    1000                 out = numpy.append(out, outi) 
     1002                out = np.append(out, outi) 
    10011003            else: 
    10021004                if ind % 50 == 0  and update != None: 
    … …  
    10061008                          input[2][ind:ind + 1]] 
    10071009                outi = self.model.runXY(inputi) 
    1008                 out = numpy.append(out, outi) 
     1010                out = np.append(out, outi) 
    10091011        #print time.time() - s 
    10101012        if self.is_avg or self.is_avg == None: 
    … …  
    10271029        self.npts_x = int(float(self.npt_ctl.GetValue())) 
    10281030        self.data = Data2D() 
    1029         qmax = self.qmax_x #/ numpy.sqrt(2) 
     1031        qmax = self.qmax_x #/ np.sqrt(2) 
    10301032        self.data.xaxis('\\rm{Q_{x}}', '\AA^{-1}') 
    10311033        self.data.yaxis('\\rm{Q_{y}}', '\AA^{-1}') 
    … …  
    10481050        qstep = self.npts_x 
    10491051 
    1050         x = numpy.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True) 
    1051         y = numpy.linspace(start=ymin, stop=ymax, num=qstep, endpoint=True) 
     1052        x = np.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True) 
     1053        y = np.linspace(start=ymin, stop=ymax, num=qstep, endpoint=True) 
    10521054        ## use data info instead 
    1053         new_x = numpy.tile(x, (len(y), 1)) 
    1054         new_y = numpy.tile(y, (len(x), 1)) 
     1055        new_x = np.tile(x, (len(y), 1)) 
     1056        new_y = np.tile(y, (len(x), 1)) 
    10551057        new_y = new_y.swapaxes(0, 1) 
    10561058        # all data reuire now in 1d array 
    10571059        qx_data = new_x.flatten() 
    10581060        qy_data = new_y.flatten() 
    1059         q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data) 
     1061        q_data = np.sqrt(qx_data * qx_data + qy_data * qy_data) 
    10601062        # set all True (standing for unmasked) as default 
    1061         mask = numpy.ones(len(qx_data), dtype=bool) 
     1063        mask = np.ones(len(qx_data), dtype=bool) 
    10621064        # store x and y bin centers in q space 
    10631065        x_bins = x 
    10641066        y_bins = y 
    10651067        self.data.source = Source() 
    1066         self.data.data = numpy.ones(len(mask)) 
    1067         self.data.err_data = numpy.ones(len(mask)) 
     1068        self.data.data = np.ones(len(mask)) 
     1069        self.data.err_data = np.ones(len(mask)) 
    10681070        self.data.qx_data = qx_data 
    10691071        self.data.qy_data = qy_data 
    … …  
    10841086        :warning: This data is never plotted. 
    10851087                    residuals.x = data_copy.x[index] 
    1086             residuals.dy = numpy.ones(len(residuals.y)) 
     1088            residuals.dy = np.ones(len(residuals.y)) 
    10871089            residuals.dx = None 
    10881090            residuals.dxl = None 
    … …  
    10911093        self.qmax_x = float(self.qmax_ctl.GetValue()) 
    10921094        self.npts_x = int(float(self.npt_ctl.GetValue())) 
    1093         qmax = self.qmax_x #/ numpy.sqrt(2) 
     1095        qmax = self.qmax_x #/ np.sqrt(2) 
    10941096        ## Default values 
    10951097        xmax = qmax 
    10961098        xmin = qmax * _Q1D_MIN 
    10971099        qstep = self.npts_x 
    1098         x = numpy.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True) 
     1100        x = np.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True) 
    10991101        # store x and y bin centers in q space 
    11001102        #self.data.source = Source() 
    1101         y = numpy.ones(len(x)) 
    1102         dy = numpy.zeros(len(x)) 
    1103         dx = numpy.zeros(len(x)) 
     1103        y = np.ones(len(x)) 
     1104        dy = np.zeros(len(x)) 
     1105        dx = np.zeros(len(x)) 
    11041106        self.data = Data1D(x=x, y=y) 
    11051107        self.data.dx = dx 
    … …  
    11711173        state = None 
    11721174 
    1173         numpy.nan_to_num(image) 
     1175        np.nan_to_num(image) 
    11741176        new_plot = Data2D(image=image, err_image=data.err_data) 
    11751177        new_plot.name = model.name + '2d' 
    … …  
    13441346            msg = "OMF Panel: %s" % sys.exc_value 
    13451347            infor = 'Error' 
    1346             #logging.error(msg) 
     1348            #logger.error(msg) 
    13471349            if self.parent.parent != None: 
    13481350                # inform msg to wx 
    … …  
    16401642            for key in sld_list.keys(): 
    16411643                if ctr_list[0] == key: 
    1642                     min_val = numpy.min(sld_list[key]) 
    1643                     max_val = numpy.max(sld_list[key]) 
    1644                     mean_val = numpy.mean(sld_list[key]) 
     1644                    min_val = np.min(sld_list[key]) 
     1645                    max_val = np.max(sld_list[key]) 
     1646                    mean_val = np.mean(sld_list[key]) 
    16451647                    enable = (min_val == max_val) and \ 
    16461648                             sld_data.pix_type == 'pixel' 
    … …  
    16961698                msg = "%s cannot write %s\n" % ('Generic Scattering', str(path)) 
    16971699                infor = 'Error' 
    1698                 #logging.error(msg) 
     1700                #logger.error(msg) 
    16991701                if self.parent.parent != None: 
    17001702                    # inform msg to wx 
    … …  
    17331735                    npts = -1 
    17341736                    break 
    1735                 if numpy.isfinite(n_val): 
     1737                if np.isfinite(n_val): 
    17361738                    npts *= int(n_val) 
    17371739            if npts > 0: 
    … …  
    17701772                        ctl.Refresh() 
    17711773                        return 
    1772                     if numpy.isfinite(s_val): 
     1774                    if np.isfinite(s_val): 
    17731775                        s_size *= s_val 
    17741776                self.sld_data.set_pixel_volumes(s_size) 
    … …  
    17871789        try: 
    17881790            sld_data = self.parent.get_sld_from_omf() 
    1789             #nop = (nop * numpy.pi) / 6 
     1791            #nop = (nop * np.pi) / 6 
    17901792            nop = len(sld_data.sld_n) 
    17911793        except: 

  • src/sas/sasgui/perspectives/calculator/model_editor.py

    rddbac66 r463e7ffc  
    3232from sas.sasgui.guiframe.documentation_window import DocumentationWindow 
    3333from .pyconsole import show_model_output, check_model 
     34 
     35logger = logging.getLogger(__name__) 
    3436 
    3537 
    … …  
    985987                exec "from %s import Model" % name 
    986988            except: 
    987                 logging.error(sys.exc_value) 
     989                logger.error(sys.exc_value) 
    988990 
    989991        # Prepare the messagebox 

  • src/sas/sasgui/perspectives/calculator/resolution_calculator_panel.py

    ra0c1e1d r463e7ffc  
    3434from sas.sasgui.perspectives.calculator import calculator_widgets as widget 
    3535from sas.sasgui.guiframe.documentation_window import DocumentationWindow 
     36 
     37logger = logging.getLogger(__name__) 
    3638 
    3739_BOX_WIDTH = 100 
    … …  
    10981100                new_string.append(value) 
    10991101            except: 
    1100                 logging.error(sys.exc_value) 
     1102                logger.error(sys.exc_value) 
    11011103 
    11021104        return new_string 
    … …  
    11401142                        return out 
    11411143                except: 
    1142                     logging.error(sys.exc_value) 
     1144                    logger.error(sys.exc_value) 
    11431145 
    11441146    def _on_xy_coordinate(self, event=None): 
    … …  
    13181320                except: 
    13191321                    # Skip non-data lines 
    1320                     logging.error(sys.exc_value) 
     1322                    logger.error(sys.exc_value) 
    13211323 
    13221324            return [wavelength, intensity] 

  • src/sas/sasgui/perspectives/corfunc/corfunc.py

    r1dc8ec9 r463e7ffc  
    2020from plot_labels import * 
    2121 
     22logger = logging.getLogger(__name__) 
    2223 
    2324class Plugin(PluginBase): 
    … …  
    2930    def __init__(self): 
    3031        PluginBase.__init__(self, name="Correlation Function") 
    31         logging.info("Correlation function plug-in started") 
     32        logger.info("Correlation function plug-in started") 
    3233        self._always_active = True 
    3334        self.state_reader = Reader(self.set_state) 

  • src/sas/sasgui/perspectives/corfunc/corfunc_state.py

    rae9b8bf r463e7ffc  
    1313from sas.sascalc.dataloader.loader import Loader 
    1414 
     15logger = logging.getLogger(__name__) 
     16 
    1517CORNODE_NAME = 'corfunc' 
    1618CANSAS_NS = 'cansas1d/1.0' 
    … …  
    216218                    msg = ("CorfuncState.fromXML: Could not read timestamp", 
    217219                        "\n{}").format(sys.exc_value) 
    218                     logging.error(msg) 
     220                    logger.error(msg) 
    219221 
    220222            # Parse current state 
    … …  
    360362            msg = "XML document does not contain CorfuncState information\n{}" 
    361363            msg.format(sys.exc_value) 
    362             logging.info(msg) 
     364            logger.info(msg) 
    363365        return state 

  • src/sas/sasgui/perspectives/file_converter/file_converter.py

    rba65aff r463e7ffc  
    66from sas.sasgui.guiframe.plugin_base import PluginBase 
    77from sas.sasgui.perspectives.file_converter.converter_panel import ConverterWindow 
     8 
     9logger = logging.getLogger(__name__) 
    810 
    911class Plugin(PluginBase): 
    … …  
    1517    def __init__(self): 
    1618        PluginBase.__init__(self, name="File Converter") 
    17         logging.info("File Converter plug-in started") 
     19        logger.info("File Converter plug-in started") 
    1820        self._sub_menu = "Tool" 
    1921        self.converter_frame = None 

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

    rb301db9 r9c0f3c17  
    55import os 
    66import wx 
    7 import numpy 
     7import numpy as np 
    88import time 
    99import copy 
    … …  
    3434from sas.sasgui.guiframe.documentation_window import DocumentationWindow 
    3535 
     36logger = logging.getLogger(__name__) 
    3637 
    3738(PageInfoEvent, EVT_PAGE_INFO) = wx.lib.newevent.NewEvent() 
    … …  
    100101        self.graph_id = None 
    101102        # Q range for data set 
    102         self.qmin_data_set = numpy.inf 
     103        self.qmin_data_set = np.inf 
    103104        self.qmax_data_set = None 
    104105        self.npts_data_set = 0 
    … …  
    278279 
    279280        """ 
    280         x = numpy.linspace(start=self.qmin_x, stop=self.qmax_x, 
     281        x = np.linspace(start=self.qmin_x, stop=self.qmax_x, 
    281282                           num=self.npts_x, endpoint=True) 
    282283        self.data = Data1D(x=x) 
    … …  
    295296        """ 
    296297        if self.qmin_x >= 1.e-10: 
    297             qmin = numpy.log10(self.qmin_x) 
     298            qmin = np.log10(self.qmin_x) 
    298299        else: 
    299300            qmin = -10. 
    300301 
    301302        if self.qmax_x <= 1.e10: 
    302             qmax = numpy.log10(self.qmax_x) 
     303            qmax = np.log10(self.qmax_x) 
    303304        else: 
    304305            qmax = 10. 
    305306 
    306         x = numpy.logspace(start=qmin, stop=qmax, 
     307        x = np.logspace(start=qmin, stop=qmax, 
    307308                           num=self.npts_x, endpoint=True, base=10.0) 
    308309        self.data = Data1D(x=x) 
    … …  
    341342        qstep = self.npts_x 
    342343 
    343         x = numpy.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True) 
    344         y = numpy.linspace(start=ymin, stop=ymax, num=qstep, endpoint=True) 
     344        x = np.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True) 
     345        y = np.linspace(start=ymin, stop=ymax, num=qstep, endpoint=True) 
    345346        # use data info instead 
    346         new_x = numpy.tile(x, (len(y), 1)) 
    347         new_y = numpy.tile(y, (len(x), 1)) 
     347        new_x = np.tile(x, (len(y), 1)) 
     348        new_y = np.tile(y, (len(x), 1)) 
    348349        new_y = new_y.swapaxes(0, 1) 
    349350        # all data reuire now in 1d array 
    350351        qx_data = new_x.flatten() 
    351352        qy_data = new_y.flatten() 
    352         q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data) 
     353        q_data = np.sqrt(qx_data * qx_data + qy_data * qy_data) 
    353354        # set all True (standing for unmasked) as default 
    354         mask = numpy.ones(len(qx_data), dtype=bool) 
     355        mask = np.ones(len(qx_data), dtype=bool) 
    355356        # store x and y bin centers in q space 
    356357        x_bins = x 
    … …  
    358359 
    359360        self.data.source = Source() 
    360         self.data.data = numpy.ones(len(mask)) 
    361         self.data.err_data = numpy.ones(len(mask)) 
     361        self.data.data = np.ones(len(mask)) 
     362        self.data.err_data = np.ones(len(mask)) 
    362363        self.data.qx_data = qx_data 
    363364        self.data.qy_data = qy_data 
    … …  
    782783                except Exception: 
    783784                    # Skip non-data lines 
    784                     logging.error(traceback.format_exc()) 
    785             return numpy.array(angles), numpy.array(weights) 
     785                    logger.error(traceback.format_exc()) 
     786            return np.array(angles), np.array(weights) 
    786787        except: 
    787788            raise 
    … …  
    13041305                    [state.values, state.weights] 
    13051306            except Exception: 
    1306                 logging.error(traceback.format_exc()) 
     1307                logger.error(traceback.format_exc()) 
    13071308            selection = self._find_polyfunc_selection(disp_model) 
    13081309            for list in self.fittable_param: 
    … …  
    13211322                            list[6].Disable() 
    13221323                        except Exception: 
    1323                             logging.error(traceback.format_exc()) 
     1324                            logger.error(traceback.format_exc()) 
    13241325            # For array, disable all fixed params 
    13251326            if selection == 1: 
    … …  
    13301331                            item[2].Disable() 
    13311332                        except Exception: 
    1332                             logging.error(traceback.format_exc()) 
     1333                            logger.error(traceback.format_exc()) 
    13331334 
    13341335    def _selectDlg(self): 
    … …  
    14491450                self.state_change = True 
    14501451                self._draw_model() 
    1451                 # Time delay has been introduced to prevent _handle error 
    1452                 # on Windows 
    1453                 # This part of code is executed when model is selected and 
    1454                 # it's parameters are changed (with respect to previously 
    1455                 # selected model). There are two Iq evaluations occuring one 
    1456                 # after another and therefore there may be compilation error 
    1457                 # if model is calculated for the first time. 
    1458                 # This seems to be Windows only issue - haven't tested on Linux 
    1459                 # though.The proper solution (other than time delay) requires 
    1460                 # more fundemental code refatoring 
    1461                 # Wojtek P. Nov 7, 2016 
    1462                 if not ON_MAC: 
    1463                     time.sleep(0.1) 
    14641452                self.Refresh() 
    14651453 
    1466         # logging.info("is_modified flag set to %g",is_modified) 
     1454        # logger.info("is_modified flag set to %g",is_modified) 
    14671455        return is_modified 
    14681456 
    … …  
    15691557            self.save_current_state() 
    15701558        except Exception: 
    1571             logging.error(traceback.format_exc()) 
     1559            logger.error(traceback.format_exc()) 
    15721560 
    15731561        return flag, is_modified 
    … …  
    21202108        for data in self.data_list: 
    21212109            # q value from qx and qy 
    2122             radius = numpy.sqrt(data.qx_data * data.qx_data + 
     2110            radius = np.sqrt(data.qx_data * data.qx_data + 
    21232111                                data.qy_data * data.qy_data) 
    21242112            # get unmasked index 
    … …  
    21262114                         (radius <= float(self.qmax.GetValue())) 
    21272115            index_data = (index_data) & (data.mask) 
    2128             index_data = (index_data) & (numpy.isfinite(data.data)) 
     2116            index_data = (index_data) & (np.isfinite(data.data)) 
    21292117 
    21302118            if len(index_data[index_data]) < 10: 
    … …  
    21612149            index_data = (float(self.qmin.GetValue()) <= radius) & \ 
    21622150                         (radius <= float(self.qmax.GetValue())) 
    2163             index_data = (index_data) & (numpy.isfinite(data.y)) 
     2151            index_data = (index_data) & (np.isfinite(data.y)) 
    21642152 
    21652153            if len(index_data[index_data]) < 5: 
    … …  
    22332221 
    22342222                # Check that min is less than max 
    2235                 low = -numpy.inf if min_str == "" else float(min_str) 
    2236                 high = numpy.inf if max_str == "" else float(max_str) 
     2223                low = -np.inf if min_str == "" else float(min_str) 
     2224                high = np.inf if max_str == "" else float(max_str) 
    22372225                if high < low: 
    22382226                    min_ctrl.SetBackgroundColour("pink") 
    … …  
    23842372                    self.model.set_dispersion(p, disp_model) 
    23852373                except Exception: 
    2386                     logging.error(traceback.format_exc()) 
     2374                    logger.error(traceback.format_exc()) 
    23872375 
    23882376        # save state into 
    … …  
    24992487            self.Refresh() 
    25002488        except Exception: 
    2501             logging.error(traceback.format_exc()) 
     2489            logger.error(traceback.format_exc()) 
    25022490            # Error msg 
    25032491            msg = "Error occurred:" 
    … …  
    26002588                del self.state.model._persistency_dict[name.split('.')[0]] 
    26012589        except Exception: 
    2602             logging.error(traceback.format_exc()) 
     2590            logger.error(traceback.format_exc()) 
    26032591 
    26042592    def _lay_out(self): 
    … …  
    26092597            Layout is called after fitting. 
    26102598        """ 
    2611         self._sleep4sec() 
    26122599        self.Layout() 
    26132600        return 
    2614  
    2615     def _sleep4sec(self): 
    2616         """ 
    2617             sleep for 1 sec only applied on Mac 
    2618             Note: This 1sec helps for Mac not to crash on self. 
    2619             Layout after self._draw_model 
    2620         """ 
    2621         if ON_MAC: 
    2622             time.sleep(1) 
    26232601 
    26242602    def _find_polyfunc_selection(self, disp_func=None): 
    … …  
    26542632            self.qmin_x = data_min 
    26552633            self.qmax_x = math.sqrt(x * x + y * y) 
    2656             # self.data.mask = numpy.ones(len(self.data.data),dtype=bool) 
     2634            # self.data.mask = np.ones(len(self.data.data),dtype=bool) 
    26572635            # check smearing 
    26582636            if not self.disable_smearer.GetValue(): 
    … …  
    27422720            except Exception: 
    27432721                # Not for control panels 
    2744                 logging.error(traceback.format_exc()) 
     2722                logger.error(traceback.format_exc()) 
    27452723        # Make sure the resduals plot goes to the last 
    27462724        if res_item is not None: 
    … …  
    30753053                    disfunc = str(item[7].GetValue()) 
    30763054            except Exception: 
    3077                 logging.error(traceback.format_exc()) 
     3055                logger.error(traceback.format_exc()) 
    30783056 
    30793057            # 2D 
    … …  
    31183096                        disfunc += ' ' + str(weight) 
    31193097            except Exception: 
    3120                 logging.error(traceback.format_exc()) 
     3098                logger.error(traceback.format_exc()) 
    31213099            content += name + ',' + str(check) + ',' + value + disfunc + ',' + \ 
    31223100                       bound_lo + ',' + bound_hi + ':' 
    … …  
    33663344 
    33673345            if value[1] == 'array': 
    3368                 pd_vals = numpy.array(value[2]) 
    3369                 pd_weights = numpy.array(value[3]) 
     3346                pd_vals = np.array(value[2]) 
     3347                pd_weights = np.array(value[3]) 
    33703348                if len(pd_vals) == 0 or len(pd_vals) != len(pd_weights): 
    33713349                    msg = ("bad array distribution parameters for %s" 
    … …  
    33893367 
    33903368        except Exception: 
    3391             logging.error(traceback.format_exc()) 
     3369            logger.error(traceback.format_exc()) 
    33923370            print "Error in BasePage._paste_poly_help: %s" % \ 
    33933371                  sys.exc_info()[1] 

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

    rd85f1d8a red2276f  
    66import wx 
    77import wx.lib.newevent 
    8 import numpy 
     8import numpy as np 
    99import copy 
    1010import math 
    … …  
    11151115            if item.GetValue(): 
    11161116                if button_list.index(item) == 0: 
    1117                     flag = 0  # dy = numpy.ones_like(dy_data) 
     1117                    flag = 0  # dy = np.ones_like(dy_data) 
    11181118                elif button_list.index(item) == 1: 
    11191119                    flag = 1  # dy = dy_data 
    11201120                elif button_list.index(item) == 2: 
    1121                     flag = 2  # dy = numpy.sqrt(numpy.abs(data)) 
     1121                    flag = 2  # dy = np.sqrt(np.abs(data)) 
    11221122                elif button_list.index(item) == 3: 
    1123                     flag = 3  # dy = numpy.abs(data) 
     1123                    flag = 3  # dy = np.abs(data) 
    11241124                break 
    11251125        return flag 
    … …  
    14221422        key = event.GetKeyCode() 
    14231423        length = len(self.data.x) 
    1424         indx = (numpy.abs(self.data.x - x_data)).argmin() 
     1424        indx = (np.abs(self.data.x - x_data)).argmin() 
    14251425        # return array.flat[idx] 
    14261426        if key == wx.WXK_PAGEUP or key == wx.WXK_NUMPAD_PAGEUP: 
    … …  
    14771477                    self.enable2D: 
    14781478                # set mask 
    1479                 radius = numpy.sqrt(self.data.qx_data * self.data.qx_data + 
     1479                radius = np.sqrt(self.data.qx_data * self.data.qx_data + 
    14801480                                    self.data.qy_data * self.data.qy_data) 
    14811481                index_data = ((self.qmin_x <= radius) & (radius <= self.qmax_x)) 
    14821482                index_data = (index_data) & (self.data.mask) 
    1483                 index_data = (index_data) & (numpy.isfinite(self.data.data)) 
     1483                index_data = (index_data) & (np.isfinite(self.data.data)) 
    14841484                if len(index_data[index_data]) < 10: 
    14851485                    msg = "Cannot Plot :No or too little npts in" 
    … …  
    15981598                and data.dqx_data.any() != 0: 
    15991599                self.smear_type = "Pinhole2d" 
    1600                 self.dq_l = format_number(numpy.average(data.dqx_data)) 
    1601                 self.dq_r = format_number(numpy.average(data.dqy_data)) 
     1600                self.dq_l = format_number(np.average(data.dqx_data)) 
     1601                self.dq_r = format_number(np.average(data.dqy_data)) 
    16021602                return 
    16031603            else: 
    16041604                return 
    16051605        # check if it is pinhole smear and get min max if it is. 
    1606         if data.dx is not None and numpy.any(data.dx): 
     1606        if data.dx is not None and np.any(data.dx): 
    16071607            self.smear_type = "Pinhole" 
    16081608            self.dq_l = data.dx[0] 
    … …  
    16121612        elif data.dxl is not None or data.dxw is not None: 
    16131613            self.smear_type = "Slit" 
    1614             if data.dxl is not None and numpy.all(data.dxl, 0): 
     1614            if data.dxl is not None and np.all(data.dxl, 0): 
    16151615                self.dq_l = data.dxl[0] 
    1616             if data.dxw is not None and numpy.all(data.dxw, 0): 
     1616            if data.dxw is not None and np.all(data.dxw, 0): 
    16171617                self.dq_r = data.dxw[0] 
    16181618        # return self.smear_type,self.dq_l,self.dq_r 
    … …  
    18081808        if not flag: 
    18091809            self.onSmear(None) 
    1810  
    1811     def _mac_sleep(self, sec=0.2): 
    1812         """ 
    1813         Give sleep to MAC 
    1814         """ 
    1815         if self.is_mac: 
    1816             time.sleep(sec) 
    18171810 
    18181811    def get_view_mode(self): 
    … …  
    19211914                self.default_mask = copy.deepcopy(self.data.mask) 
    19221915                if self.data.err_data is not None \ 
    1923                         and numpy.any(self.data.err_data): 
     1916                        and np.any(self.data.err_data): 
    19241917                    di_flag = True 
    19251918                if self.data.dqx_data is not None \ 
    1926                         and numpy.any(self.data.dqx_data): 
     1919                        and np.any(self.data.dqx_data): 
    19271920                    dq_flag = True 
    19281921            else: 
    19291922                self.slit_smearer.Enable(True) 
    19301923                self.pinhole_smearer.Enable(True) 
    1931                 if self.data.dy is not None and numpy.any(self.data.dy): 
     1924                if self.data.dy is not None and np.any(self.data.dy): 
    19321925                    di_flag = True 
    1933                 if self.data.dx is not None and numpy.any(self.data.dx): 
     1926                if self.data.dx is not None and np.any(self.data.dx): 
    19341927                    dq_flag = True 
    1935                 elif self.data.dxl is not None and numpy.any(self.data.dxl): 
     1928                elif self.data.dxl is not None and np.any(self.data.dxl): 
    19361929                    dq_flag = True 
    19371930 
    … …  
    20672060        if self.data.__class__.__name__ == "Data2D" or \ 
    20682061                        self.enable2D: 
    2069             radius = numpy.sqrt(self.data.qx_data * self.data.qx_data + 
     2062            radius = np.sqrt(self.data.qx_data * self.data.qx_data + 
    20702063                                self.data.qy_data * self.data.qy_data) 
    20712064            index_data = (self.qmin_x <= radius) & (radius <= self.qmax_x) 
    20722065            index_data = (index_data) & (self.data.mask) 
    2073             index_data = (index_data) & (numpy.isfinite(self.data.data)) 
     2066            index_data = (index_data) & (np.isfinite(self.data.data)) 
    20742067            npts2fit = len(self.data.data[index_data]) 
    20752068        else: 
    … …  
    21042097        # make sure stop button to fit button all the time 
    21052098        self._on_fit_complete() 
    2106         if out is None or not numpy.isfinite(chisqr): 
     2099        if out is None or not np.isfinite(chisqr): 
    21072100            raise ValueError, "Fit error occured..." 
    21082101 
    … …  
    21152108 
    21162109        # Check if chi2 is finite 
    2117         if chisqr is not None and numpy.isfinite(chisqr): 
     2110        if chisqr is not None and np.isfinite(chisqr): 
    21182111            # format chi2 
    21192112            chi2 = format_number(chisqr, True) 
    … …  
    21672160 
    21682161                        if cov[ind] is not None: 
    2169                             if numpy.isfinite(float(cov[ind])): 
     2162                            if np.isfinite(float(cov[ind])): 
    21702163                                val_err = format_number(cov[ind], True) 
    21712164                                item[4].SetForegroundColour(wx.BLACK) 
    … …  
    21882181        self.save_current_state() 
    21892182 
    2190         if not self.is_mac: 
    2191             self.Layout() 
    2192             self.Refresh() 
    2193         self._mac_sleep(0.1) 
    21942183        # plot model ( when drawing, do not update chisqr value again) 
    21952184        self._draw_model(update_chisqr=False, source='fit') 
    … …  
    22912280            self.smear_type = 'Pinhole2d' 
    22922281            len_data = len(data.data) 
    2293             data.dqx_data = numpy.zeros(len_data) 
    2294             data.dqy_data = numpy.zeros(len_data) 
     2282            data.dqx_data = np.zeros(len_data) 
     2283            data.dqy_data = np.zeros(len_data) 
    22952284        else: 
    22962285            self.smear_type = 'Pinhole' 
    22972286            len_data = len(data.x) 
    2298             data.dx = numpy.zeros(len_data) 
     2287            data.dx = np.zeros(len_data) 
    22992288            data.dxl = None 
    23002289            data.dxw = None 
    … …  
    24692458        try: 
    24702459            self.dxl = float(self.smear_slit_height.GetValue()) 
    2471             data.dxl = self.dxl * numpy.ones(data_len) 
     2460            data.dxl = self.dxl * np.ones(data_len) 
    24722461            self.smear_slit_height.SetBackgroundColour(wx.WHITE) 
    24732462        except: 
    24742463            self.dxl = None 
    2475             data.dxl = numpy.zeros(data_len) 
     2464            data.dxl = np.zeros(data_len) 
    24762465            if self.smear_slit_height.GetValue().lstrip().rstrip() != "": 
    24772466                self.smear_slit_height.SetBackgroundColour("pink") 
    … …  
    24822471            self.dxw = float(self.smear_slit_width.GetValue()) 
    24832472            self.smear_slit_width.SetBackgroundColour(wx.WHITE) 
    2484             data.dxw = self.dxw * numpy.ones(data_len) 
     2473            data.dxw = self.dxw * np.ones(data_len) 
    24852474        except: 
    24862475            self.dxw = None 
    2487             data.dxw = numpy.zeros(data_len) 
     2476            data.dxw = np.zeros(data_len) 
    24882477            if self.smear_slit_width.GetValue().lstrip().rstrip() != "": 
    24892478                self.smear_slit_width.SetBackgroundColour("pink") 
    … …  
    26122601            if event is None: 
    26132602                output = "-" 
    2614             elif not numpy.isfinite(event.output): 
     2603            elif not np.isfinite(event.output): 
    26152604                output = "-" 
    26162605            else: 

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

    r4c5098c r9c0f3c17  
    1616import wx 
    1717import logging 
    18 import numpy 
     18import numpy as np 
    1919import time 
    2020from copy import deepcopy 
    … …  
    4848 
    4949from . import models 
     50 
     51logger = logging.getLogger(__name__) 
    5052 
    5153MAX_NBR_DATA = 4 
    … …  
    119121        self.page_finder = {} 
    120122        # Log startup 
    121         logging.info("Fitting plug-in started") 
     123        logger.info("Fitting plug-in started") 
    122124        self.batch_capable = self.get_batch_capable() 
    123125 
    … …  
    346348                                page.formfactorbox.SetLabel(current_val) 
    347349        except: 
    348             logging.error("update_custom_combo: %s", sys.exc_value) 
     350            logger.error("update_custom_combo: %s", sys.exc_value) 
    349351 
    350352    def set_edit_menu(self, owner): 
    … …  
    586588                msg = "Fitting: cannot deal with the theory received" 
    587589                evt = StatusEvent(status=msg, info="error") 
    588                 logging.error("set_theory " + msg + "\n" + str(sys.exc_value)) 
     590                logger.error("set_theory " + msg + "\n" + str(sys.exc_value)) 
    589591                wx.PostEvent(self.parent, evt) 
    590592 
    … …  
    875877                enable1D=enable1D, enable2D=enable2D, 
    876878                qmin=qmin, qmax=qmax, weight=weight) 
    877  
    878     def _mac_sleep(self, sec=0.2): 
    879         """ 
    880         Give sleep to MAC 
    881         """ 
    882         if ON_MAC: 
    883             time.sleep(sec) 
    884879 
    885880    def draw_model(self, model, page_id, data=None, smearer=None, 
    … …  
    10301025                                manager=self, 
    10311026                                improvement_delta=0.1) 
    1032         self._mac_sleep(0.2) 
    10331027 
    10341028        # batch fit 
    … …  
    12701264        :param elapsed: time spent at the fitting level 
    12711265        """ 
    1272         self._mac_sleep(0.2) 
    12731266        uid = page_id[0] 
    12741267        if uid in self.fit_thread_list.keys(): 
    … …  
    13321325                    new_theory = copy_data.data 
    13331326                    new_theory[res.index] = res.theory 
    1334                     new_theory[res.index == False] = numpy.nan 
     1327                    new_theory[res.index == False] = np.nan 
    13351328                    correct_result = True 
    13361329                #get all fittable parameters of the current model 
    … …  
    13411334                        param_list.remove(param) 
    13421335                if not correct_result or res.fitness is None or \ 
    1343                     not numpy.isfinite(res.fitness) or \ 
    1344                     numpy.any(res.pvec == None) or not \ 
    1345                     numpy.all(numpy.isfinite(res.pvec)): 
     1336                    not np.isfinite(res.fitness) or \ 
     1337                        np.any(res.pvec == None) or not \ 
     1338                        np.all(np.isfinite(res.pvec)): 
    13461339                    data_name = str(None) 
    13471340                    if data is not None: 
    … …  
    13521345                    msg += "Data %s and Model %s did not fit.\n" % (data_name, 
    13531346                                                                    model_name) 
    1354                     ERROR = numpy.NAN 
     1347                    ERROR = np.NAN 
    13551348                    cell = BatchCell() 
    13561349                    cell.label = res.fitness 
    … …  
    13661359                            batch_inputs["error on %s" % str(param)].append(ERROR) 
    13671360                else: 
    1368                     # TODO: Why sometimes res.pvec comes with numpy.float64? 
     1361                    # TODO: Why sometimes res.pvec comes with np.float64? 
    13691362                    # probably from scipy lmfit 
    1370                     if res.pvec.__class__ == numpy.float64: 
     1363                    if res.pvec.__class__ == np.float64: 
    13711364                        res.pvec = [res.pvec] 
    13721365 
    … …  
    15201513            page_id = [] 
    15211514        ## fit more than 1 model at the same time 
    1522         self._mac_sleep(0.2) 
    15231515        try: 
    15241516            index = 0 
    … …  
    15331525                fit_msg = res.mesg 
    15341526                if res.fitness is None or \ 
    1535                     not numpy.isfinite(res.fitness) or \ 
    1536                     numpy.any(res.pvec == None) or \ 
    1537                     not numpy.all(numpy.isfinite(res.pvec)): 
     1527                    not np.isfinite(res.fitness) or \ 
     1528                        np.any(res.pvec == None) or \ 
     1529                    not np.all(np.isfinite(res.pvec)): 
    15381530                    fit_msg += "\nFitting did not converge!!!" 
    15391531                    wx.CallAfter(self._update_fit_button, page_id) 
    15401532                else: 
    15411533                    #set the panel when fit result are float not list 
    1542                     if res.pvec.__class__ == numpy.float64: 
     1534                    if res.pvec.__class__ == np.float64: 
    15431535                        pvec = [res.pvec] 
    15441536                    else: 
    15451537                        pvec = res.pvec 
    1546                     if res.stderr.__class__ == numpy.float64: 
     1538                    if res.stderr.__class__ == np.float64: 
    15471539                        stderr = [res.stderr] 
    15481540                    else: 
    … …  
    16921684        if dy is None: 
    16931685            new_plot.is_data = False 
    1694             new_plot.dy = numpy.zeros(len(y)) 
     1686            new_plot.dy = np.zeros(len(y)) 
    16951687            # If this is a theory curve, pick the proper symbol to make it a curve 
    16961688            new_plot.symbol = GUIFRAME_ID.CURVE_SYMBOL_NUM 
    … …  
    17411733        """ 
    17421734        try: 
    1743             numpy.nan_to_num(y) 
     1735            np.nan_to_num(y) 
    17441736            new_plot = self.create_theory_1D(x, y, page_id, model, data, state, 
    17451737                                             data_description=model.name, 
    … …  
    18061798        Handle exception from calculator by posting it as an error. 
    18071799        """ 
    1808         logging.error("".join(traceback.format_exception(etype, value, tb))) 
     1800        logger.error("".join(traceback.format_exception(etype, value, tb))) 
    18091801        msg = traceback.format_exception(etype, value, tb, limit=1) 
    18101802        evt = StatusEvent(status="".join(msg), type="stop", info="error") 
    … …  
    18251817        that can be plot. 
    18261818        """ 
    1827         numpy.nan_to_num(image) 
     1819        np.nan_to_num(image) 
    18281820        new_plot = Data2D(image=image, err_image=data.err_data) 
    18291821        new_plot.name = model.name + '2d' 
    … …  
    20172009        if data_copy.__class__.__name__ == "Data2D": 
    20182010            if index == None: 
    2019                 index = numpy.ones(len(data_copy.data), dtype=bool) 
     2011                index = np.ones(len(data_copy.data), dtype=bool) 
    20202012            if weight != None: 
    20212013                data_copy.err_data = weight 
    20222014            # get rid of zero error points 
    20232015            index = index & (data_copy.err_data != 0) 
    2024             index = index & (numpy.isfinite(data_copy.data)) 
     2016            index = index & (np.isfinite(data_copy.data)) 
    20252017            fn = data_copy.data[index] 
    20262018            theory_data = self.page_finder[page_id].get_theory_data(fid=data_copy.id) 
    … …  
    20322024            # 1 d theory from model_thread is only in the range of index 
    20332025            if index == None: 
    2034                 index = numpy.ones(len(data_copy.y), dtype=bool) 
     2026                index = np.ones(len(data_copy.y), dtype=bool) 
    20352027            if weight != None: 
    20362028                data_copy.dy = weight 
    20372029            if data_copy.dy == None or data_copy.dy == []: 
    2038                 dy = numpy.ones(len(data_copy.y)) 
     2030                dy = np.ones(len(data_copy.y)) 
    20392031            else: 
    20402032                ## Set consistently w/AbstractFitengine: 
    … …  
    20572049            return 
    20582050 
    2059         residuals = res[numpy.isfinite(res)] 
     2051        residuals = res[np.isfinite(res)] 
    20602052        # get chisqr only w/finite 
    2061         chisqr = numpy.average(residuals * residuals) 
     2053        chisqr = np.average(residuals * residuals) 
    20622054 
    20632055        self._plot_residuals(page_id=page_id, data=data_copy, 
    … …  
    20962088            residuals.qy_data = data_copy.qy_data 
    20972089            residuals.q_data = data_copy.q_data 
    2098             residuals.err_data = numpy.ones(len(residuals.data)) 
     2090            residuals.err_data = np.ones(len(residuals.data)) 
    20992091            residuals.xmin = min(residuals.qx_data) 
    21002092            residuals.xmax = max(residuals.qx_data) 
    … …  
    21102102            # 1 d theory from model_thread is only in the range of index 
    21112103            if data_copy.dy == None or data_copy.dy == []: 
    2112                 dy = numpy.ones(len(data_copy.y)) 
     2104                dy = np.ones(len(data_copy.y)) 
    21132105            else: 
    21142106                if weight == None: 
    2115                     dy = numpy.ones(len(data_copy.y)) 
     2107                    dy = np.ones(len(data_copy.y)) 
    21162108                ## Set consitently w/AbstractFitengine: 
    21172109                ## But this should be corrected later. 
    … …  
    21322124                residuals.y = (fn - gn[index]) / en 
    21332125            residuals.x = data_copy.x[index] 
    2134             residuals.dy = numpy.ones(len(residuals.y)) 
     2126            residuals.dy = np.ones(len(residuals.y)) 
    21352127            residuals.dx = None 
    21362128            residuals.dxl = None 

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

    rc1c9929 r9a5097c  
    44 
    55import time 
    6 import numpy 
     6import numpy as np 
    77import math 
    88from sas.sascalc.data_util.calcthread import CalcThread 
    … …  
    6868 
    6969        # Define matrix where data will be plotted 
    70         radius = numpy.sqrt((self.data.qx_data * self.data.qx_data) + \ 
     70        radius = np.sqrt((self.data.qx_data * self.data.qx_data) + \ 
    7171                    (self.data.qy_data * self.data.qy_data)) 
    7272 
    … …  
    7575        index_model = (self.qmin <= radius) & (radius <= self.qmax) 
    7676        index_model = index_model & self.data.mask 
    77         index_model = index_model & numpy.isfinite(self.data.data) 
     77        index_model = index_model & np.isfinite(self.data.data) 
    7878 
    7979        if self.smearer is not None: 
    … …  
    9191                self.data.qy_data[index_model] 
    9292            ]) 
    93         output = numpy.zeros(len(self.data.qx_data)) 
     93        output = np.zeros(len(self.data.qx_data)) 
    9494        # output default is None 
    9595        # This method is to distinguish between masked 
    … …  
    163163        """ 
    164164        self.starttime = time.time() 
    165         output = numpy.zeros((len(self.data.x))) 
     165        output = np.zeros((len(self.data.x))) 
    166166        index = (self.qmin <= self.data.x) & (self.data.x <= self.qmax) 
    167167 
    … …  
    175175                                                             self.qmax) 
    176176            mask = self.data.x[first_bin:last_bin+1] 
    177             unsmeared_output = numpy.zeros((len(self.data.x))) 
     177            unsmeared_output = np.zeros((len(self.data.x))) 
    178178            unsmeared_output[first_bin:last_bin+1] = self.model.evalDistribution(mask) 
    179179            self.smearer.model = self.model 
    … …  
    183183            # Check that the arrays are compatible. If we only have a model but no data, 
    184184            # the length of data.y will be zero. 
    185             if isinstance(self.data.y, numpy.ndarray) and output.shape == self.data.y.shape: 
    186                 unsmeared_data = numpy.zeros((len(self.data.x))) 
    187                 unsmeared_error = numpy.zeros((len(self.data.x))) 
     185            if isinstance(self.data.y, np.ndarray) and output.shape == self.data.y.shape: 
     186                unsmeared_data = np.zeros((len(self.data.x))) 
     187                unsmeared_error = np.zeros((len(self.data.x))) 
    188188                unsmeared_data[first_bin:last_bin+1] = self.data.y[first_bin:last_bin+1]\ 
    189189                                                        * unsmeared_output[first_bin:last_bin+1]\ 
    … …  
    209209 
    210210        if p_model is not None and s_model is not None: 
    211             sq_values = numpy.zeros((len(self.data.x))) 
    212             pq_values = numpy.zeros((len(self.data.x))) 
     211            sq_values = np.zeros((len(self.data.x))) 
     212            pq_values = np.zeros((len(self.data.x))) 
    213213            sq_values[index] = s_model.evalDistribution(self.data.x[index]) 
    214214            pq_values[index] = p_model.evalDistribution(self.data.x[index]) 

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

    rc5251f6 r80a49c2  
    1818from sas.sasgui.guiframe.CategoryInstaller import CategoryInstaller 
    1919from sasmodels.sasview_model import load_custom_model, load_standard_models 
     20 
     21logger = logging.getLogger(__name__) 
    2022 
    2123 
    … …  
    168170    if not os.path.isdir(dir): 
    169171        msg = "SasView couldn't locate Model plugin folder %r." % dir 
    170         logging.warning(msg) 
     172        logger.warning(msg) 
    171173        return {} 
    172174 
    173175    plugin_log("looking for models in: %s" % str(dir)) 
    174176    #compile_file(dir)  #always recompile the folder plugin 
    175     logging.info("plugin model dir: %s" % str(dir)) 
     177    logger.info("plugin model dir: %s" % str(dir)) 
    176178 
    177179    plugins = {} 
    … …  
    188190                msg += "\nwhile accessing model in %r" % path 
    189191                plugin_log(msg) 
    190                 logging.warning("Failed to load plugin %r. See %s for details" 
     192                logger.warning("Failed to load plugin %r. See %s for details" 
    191193                                % (path, PLUGIN_LOG)) 
    192194             
    … …  
    261263        if self.is_changed(): 
    262264            return  _findModels(dir) 
    263         logging.info("plugin model : %s" % str(temp)) 
     265        logger.info("plugin model : %s" % str(temp)) 
    264266        return temp 
    265267 

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

    r27109e5 r9c0f3c17  
    1818import copy 
    1919import logging 
    20 import numpy 
     20import numpy as np 
    2121import traceback 
    2222 
    … …  
    3333from sas.sascalc.dataloader.data_info import Data2D, Collimation, Detector 
    3434from sas.sascalc.dataloader.data_info import Process, Aperture 
     35 
     36logger = logging.getLogger(__name__) 
    3537 
    3638# Information to read/write state as xml 
    … …  
    395397                    msg = "Save state does not have enough information to load" 
    396398                    msg += " the all of the data." 
    397                     logging.warning(msg=msg) 
     399                    logger.warning(msg=msg) 
    398400            else: 
    399401                self.formfactorcombobox = FIRST_FORM[self.categorycombobox] 
    … …  
    410412        for fittable, name, value, _, uncert, lower, upper, units in params: 
    411413            if not value: 
    412                 value = numpy.nan 
     414                value = np.nan 
    413415            if not uncert or uncert[1] == '' or uncert[1] == 'None': 
    414416                uncert[0] = False 
    415                 uncert[1] = numpy.nan 
     417                uncert[1] = np.nan 
    416418            if not upper or upper[1] == '' or upper[1] == 'None': 
    417419                upper[0] = False 
    418                 upper[1] = numpy.nan 
     420                upper[1] = np.nan 
    419421            if not lower or lower[1] == '' or lower[1] == 'None': 
    420422                lower[0] = False 
    421                 lower[1] = numpy.nan 
     423                lower[1] = np.nan 
    422424            if is_string: 
    423425                p[name] = str(value) 
    … …  
    449451                lower = params.get(name + ".lower", '-inf') 
    450452                units = params.get(name + ".units") 
    451                 if std is not None and std is not numpy.nan: 
     453                if std is not None and std is not np.nan: 
    452454                    std = [True, str(std)] 
    453455                else: 
    454456                    std = [False, ''] 
    455                 if lower is not None and lower is not numpy.nan: 
     457                if lower is not None and lower is not np.nan: 
    456458                    lower = [True, str(lower)] 
    457459                else: 
    458460                    lower = [True, '-inf'] 
    459                 if upper is not None and upper is not numpy.nan: 
     461                if upper is not None and upper is not np.nan: 
    460462                    upper = [True, str(upper)] 
    461463                else: 
    … …  
    620622            except Exception: 
    621623                msg = "Report string expected 'name: value' but got %r" % line 
    622                 logging.error(msg) 
     624                logger.error(msg) 
    623625            if name.count("State created"): 
    624626                repo_time = "" + value 
    … …  
    662664                except Exception: 
    663665                    msg = "While parsing 'data: ...'\n" 
    664                     logging.error(msg + traceback.format_exc()) 
     666                    logger.error(msg + traceback.format_exc()) 
    665667            if name == "model name ": 
    666668                try: 
    … …  
    678680                except Exception: 
    679681                    msg = "While parsing 'Plotting Range: ...'\n" 
    680                     logging.error(msg + traceback.format_exc()) 
     682                    logger.error(msg + traceback.format_exc()) 
    681683        paramval = "" 
    682684        for lines in param_string.split(":"): 
    … …  
    10371039                    msg = "PageState.fromXML: Could not" 
    10381040                    msg += " read timestamp\n %s" % sys.exc_value 
    1039                     logging.error(msg) 
     1041                    logger.error(msg) 
    10401042 
    10411043            if entry is not None: 
    … …  
    10771079                            except Exception: 
    10781080                                base = "unable to load distribution %r for %s" 
    1079                                 logging.error(base % (value, parameter)) 
     1081                                logger.error(base % (value, parameter)) 
    10801082                                continue 
    10811083                        _disp_obj_dict = getattr(self, varname) 
    … …  
    10991101                                msg = ("Error reading %r from %s %s\n" 
    11001102                                       % (line, tagname, name)) 
    1101                                 logging.error(msg + traceback.format_exc()) 
    1102                         dic[name] = numpy.array(value_list) 
     1103                                logger.error(msg + traceback.format_exc()) 
     1104                        dic[name] = np.array(value_list) 
    11031105                    setattr(self, varname, dic) 
    11041106 
    … …  
    12071209 
    12081210        except: 
    1209             logging.info("XML document does not contain fitting information.\n" 
     1211            logger.info("XML document does not contain fitting information.\n" 
    12101212                         + traceback.format_exc()) 
    12111213 

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

    rd85c194 r9a5097c  
    22Module contains functions frequently used in this package 
    33""" 
    4 import numpy 
     4import numpy as np 
    55 
    66 
    … …  
    1919        data = data.y 
    2020    if flag == 0: 
    21         weight = numpy.ones_like(data) 
     21        weight = np.ones_like(data) 
    2222    elif flag == 1: 
    2323        weight = dy_data 
    2424    elif flag == 2: 
    25         weight = numpy.sqrt(numpy.abs(data)) 
     25        weight = np.sqrt(np.abs(data)) 
    2626    elif flag == 3: 
    27         weight = numpy.abs(data) 
     27        weight = np.abs(data) 
    2828    return weight 

  • src/sas/sasgui/perspectives/invariant/invariant.py

    rc10d9d6c r463e7ffc  
    2727from sas.sasgui.guiframe.plugin_base import PluginBase 
    2828 
     29logger = logging.getLogger(__name__) 
     30 
    2931class Plugin(PluginBase): 
    3032    """ 
    … …  
    4648 
    4749        # Log startup 
    48         logging.info("Invariant plug-in started") 
     50        logger.info("Invariant plug-in started") 
    4951 
    5052    def get_data(self): 
    … …  
    280282 
    281283        except: 
    282             logging.error("invariant.set_state: %s" % sys.exc_value) 
     284            logger.error("invariant.set_state: %s" % sys.exc_value) 
    283285 
    284286    def on_set_state_helper(self, event=None): 

  • src/sas/sasgui/perspectives/invariant/invariant_panel.py

    r18b7ecb9 r463e7ffc  
    2424from sas.sasgui.guiframe.panel_base import PanelBase 
    2525from sas.sasgui.guiframe.documentation_window import DocumentationWindow 
     26 
     27logger = logging.getLogger(__name__) 
    2628 
    2729# The minimum q-value to be used when extrapolating 
    … …  
    460462                self._manager.plot_theory(name="Low-Q extrapolation") 
    461463            except: 
    462                 logging.error(sys.exc_value) 
     464                logger.error(sys.exc_value) 
    463465 
    464466    def get_high_qstar(self, inv, high_q=False): 
    … …  
    494496                self._manager.plot_theory(name="High-Q extrapolation") 
    495497            except: 
    496                 logging.error(sys.exc_value) 
     498                logger.error(sys.exc_value) 
    497499 
    498500    def get_qstar(self, inv): 
    … …  
    845847            attr.SetValue(value) 
    846848        except: 
    847             logging.error("Invariant state: %s", sys.exc_value) 
     849            logger.error("Invariant state: %s", sys.exc_value) 
    848850 
    849851    def get_bookmark_by_num(self, num=None): 
    … …  
    862864            _, _, current_state, comp_state = self.state.bookmark_list[int(num)] 
    863865        except: 
    864             logging.error(sys.exc_value) 
     866            logger.error(sys.exc_value) 
    865867            raise ValueError, "No such bookmark exists" 
    866868 
    … …  
    957959                    self.state.clone_state() 
    958960        except: 
    959             logging.error(sys.exc_value) 
     961            logger.error(sys.exc_value) 
    960962 
    961963        self._set_undo_flag(True) 
    … …  
    10011003                del self.state.state_list[str(i)] 
    10021004            except: 
    1003                 logging.error(sys.exc_value) 
     1005                logger.error(sys.exc_value) 
    10041006        # Enable the undo button if it was not 
    10051007        self._set_undo_flag(True) 
    … …  
    10661068                del self.state.state_list[str(i)] 
    10671069            except: 
    1068                 logging.error(sys.exc_value) 
     1070                logger.error(sys.exc_value) 
    10691071 
    10701072        # try to add new state of the text changes in the state_list 
    … …  
    10811083            self.state.state_list[str(self.state.state_num)] = self.state.clone_state() 
    10821084        except: 
    1083             logging.error(sys.exc_value) 
     1085            logger.error(sys.exc_value) 
    10841086 
    10851087        self._set_undo_flag(True) 
    … …  
    11031105            self.state.state_list[str(self.state.state_num)] = self.state.clone_state() 
    11041106        except: 
    1105             logging.error(sys.exc_value) 
     1107            logger.error(sys.exc_value) 
    11061108 
    11071109    def _get_input_list(self): 

  • src/sas/sasgui/perspectives/invariant/invariant_state.py

    rdb5294e r463e7ffc  
    1616from sas.sasgui.guiframe.gui_style import GUIFRAME_ID 
    1717from sas.sasgui.guiframe.dataFitting import Data1D 
     18 
     19logger = logging.getLogger(__name__) 
    1820 
    1921INVNODE_NAME = 'invariant' 
    … …  
    381383                    msg = "InvariantSate.fromXML: Could not read" 
    382384                    msg += " timestamp\n %s" % sys.exc_value 
    383                     logging.error(msg) 
     385                    logger.error(msg) 
    384386 
    385387            # Parse bookmarks 
    … …  
    694696            msg = "XML document does not contain invariant" 
    695697            msg += " information.\n %s" % sys.exc_value 
    696             logging.info(msg) 
     698            logger.info(msg) 
    697699        return state 
    698700 

  • src/sas/sasgui/perspectives/invariant/report_dialog.py

    rd85c194 r463e7ffc  
    2020 
    2121from sas.sasgui.guiframe.report_dialog import BaseReportDialog 
     22 
     23logger = logging.getLogger(__name__) 
    2224 
    2325class ReportDialog(BaseReportDialog): 
    … …  
    9294                    except: 
    9395                        # DO not open 
    94                         logging.error("Could not open file: %s" % sys.exc_value) 
     96                        logger.error("Could not open file: %s" % sys.exc_value) 
    9597            # delete image file 
    9698            os.remove(pic_fname) 

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

    rd85c194 r9c0f3c17  
    1919 
    2020import wx 
    21 import numpy 
     21import numpy as np 
    2222import logging 
    2323import sys 
     24 
     25logger = logging.getLogger(__name__) 
    2426 
    2527# Avoid Matplotlib complaining about the lack of legend on the plot 
    … …  
    6567 
    6668        step = (self.max - self.min) / (self.npts - 1) 
    67         self.x = numpy.arange(self.min, self.max + step * 0.01, step) 
    68         dx = numpy.zeros(len(self.x)) 
    69         y = numpy.ones(len(self.x)) 
    70         dy = numpy.zeros(len(self.x)) 
     69        self.x = np.arange(self.min, self.max + step * 0.01, step) 
     70        dx = np.zeros(len(self.x)) 
     71        y = np.ones(len(self.x)) 
     72        dy = np.zeros(len(self.x)) 
    7173 
    7274        # Plot area 
    … …  
    284286            msg += "a change in the " % str(output_type) 
    285287            msg += "ExploreDialog code." 
    286             logging.error(msg) 
     288            logger.error(msg) 
    287289 
    288290    def __do_layout(self): 
    … …  
    418420                msg = "ExploreDialog: inversion failed " 
    419421                msg += "for D_max=%s\n%s" % (str(d), sys.exc_value) 
    420                 logging.error(msg) 
     422                logger.error(msg) 
    421423 
    422424        self.results = results 

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

    r18b7ecb9 r463e7ffc  
    1717from pr_widgets import OutputTextCtrl 
    1818from sas.sasgui.guiframe.documentation_window import DocumentationWindow 
     19 
     20logger = logging.getLogger(__name__) 
    1921 
    2022if sys.platform.count("win32") > 0: 
    … …  
    710712            self.alpha_ctl.SetValue(alpha) 
    711713        except ValueError: 
    712             logging.error("InversionControl._on_accept_alpha got a value that was not a number: %s" % alpha ) 
     714            logger.error("InversionControl._on_accept_alpha got a value that was not a number: %s" % alpha ) 
    713715        except: 
    714716            # No estimate or bad estimate, either do nothing 
    715             logging.error("InversionControl._on_accept_alpha: %s" % sys.exc_value) 
     717            logger.error("InversionControl._on_accept_alpha: %s" % sys.exc_value) 
    716718 
    717719    def _on_accept_nterms(self, evt): 
    … …  
    726728            self.nfunc_ctl.SetValue(nterms) 
    727729        except ValueError: 
    728             logging.error("InversionControl._on_accept_nterms got a value that was not a number: %s" % nterms ) 
     730            logger.error("InversionControl._on_accept_nterms got a value that was not a number: %s" % nterms ) 
    729731        except: 
    730732            # No estimate or bad estimate, either do nothing 
    731             logging.error("InversionControl._on_accept_nterms: %s" % sys.exc_value) 
     733            logger.error("InversionControl._on_accept_nterms: %s" % sys.exc_value) 
    732734 
    733735    def clear_panel(self): 
    … …  
    947949            except: 
    948950                msg = "InversionControl._change_file: %s" % sys.exc_value 
    949                 logging.error(msg) 
     951                logger.error(msg) 
    950952 
    951953    def on_help(self, event): 

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

    rd85c194 r463e7ffc  
    2222from sas.sascalc.dataloader.readers.cansas_reader import get_content 
    2323 
     24logger = logging.getLogger(__name__) 
     25 
    2426PRNODE_NAME = 'pr_inversion' 
    2527CANSAS_NS = "cansas1d/1.0" 
    … …  
    250252                    msg = "InversionState.fromXML: Could not read " 
    251253                    msg += "timestamp\n %s" % sys.exc_value 
    252                     logging.error(msg) 
     254                    logger.error(msg) 
    253255 
    254256            # Parse inversion inputs 
    … …  
    306308                        err_msg += "%d %d" % (len(self.coefficients), 
    307309                                              self.nfunc) 
    308                         logging.error(err_msg) 
     310                        logger.error(err_msg) 
    309311                        self.coefficients = None 
    310312 
    … …  
    343345                        err_msg += " covariance matrix: " 
    344346                        err_msg += "%d %d" % (len(self.covariance), self.nfunc) 
    345                         logging.error(err_msg) 
     347                        logger.error(err_msg) 
    346348                        self.covariance = None 
    347349 
    … …  
    430432            msg = "XML document does not contain P(r) " 
    431433            msg += "information.\n %s" % sys.exc_value 
    432             logging.info(msg) 
     434            logger.info(msg) 
    433435 
    434436        return state 

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

    ra69a967 r9c0f3c17  
    2121import time 
    2222import math 
    23 import numpy 
     23import numpy as np 
    2424import pylab 
    2525from sas.sasgui.guiframe.gui_manager import MDIFrame 
    … …  
    3434from pr_widgets import load_error 
    3535from sas.sasgui.guiframe.plugin_base import PluginBase 
     36 
     37logger = logging.getLogger(__name__) 
    3638 
    3739 
    … …  
    113115 
    114116        # Log startup 
    115         logging.info("Pr(r) plug-in started") 
     117        logger.info("Pr(r) plug-in started") 
    116118 
    117119    def delete_data(self, data_id): 
    … …  
    181183            self.control_panel.set_state(state) 
    182184        except: 
    183             logging.error("prview.set_state: %s" % sys.exc_value) 
     185            logger.error("prview.set_state: %s" % sys.exc_value) 
    184186 
    185187 
    … …  
    207209        r = pylab.arange(0.01, d_max, d_max / 51.0) 
    208210        M = len(r) 
    209         y = numpy.zeros(M) 
    210         pr_err = numpy.zeros(M) 
     211        y = np.zeros(M) 
     212        pr_err = np.zeros(M) 
    211213 
    212214        total = 0.0 
    … …  
    253255        """ 
    254256        # Show P(r) 
    255         y_true = numpy.zeros(len(x)) 
     257        y_true = np.zeros(len(x)) 
    256258 
    257259        sum_true = 0.0 
    … …  
    307309 
    308310        x = pylab.arange(minq, maxq, maxq / 301.0) 
    309         y = numpy.zeros(len(x)) 
    310         err = numpy.zeros(len(x)) 
     311        y = np.zeros(len(x)) 
     312        err = np.zeros(len(x)) 
    311313        for i in range(len(x)): 
    312314            value = pr.iq(out, x[i]) 
    … …  
    337339        if pr.slit_width > 0 or pr.slit_height > 0: 
    338340            x = pylab.arange(minq, maxq, maxq / 301.0) 
    339             y = numpy.zeros(len(x)) 
    340             err = numpy.zeros(len(x)) 
     341            y = np.zeros(len(x)) 
     342            err = np.zeros(len(x)) 
    341343            for i in range(len(x)): 
    342344                value = pr.iq_smeared(out, x[i]) 
    … …  
    382384        x = pylab.arange(0.0, pr.d_max, pr.d_max / self._pr_npts) 
    383385 
    384         y = numpy.zeros(len(x)) 
    385         dy = numpy.zeros(len(x)) 
    386         y_true = numpy.zeros(len(x)) 
     386        y = np.zeros(len(x)) 
     387        dy = np.zeros(len(x)) 
     388        y_true = np.zeros(len(x)) 
    387389 
    388390        total = 0.0 
    389391        pmax = 0.0 
    390         cov2 = numpy.ascontiguousarray(cov) 
     392        cov2 = np.ascontiguousarray(cov) 
    391393 
    392394        for i in range(len(x)): 
    … …  
    480482        """ 
    481483        # Read the data from the data file 
    482         data_x = numpy.zeros(0) 
    483         data_y = numpy.zeros(0) 
    484         data_err = numpy.zeros(0) 
     484        data_x = np.zeros(0) 
     485        data_y = np.zeros(0) 
     486        data_err = np.zeros(0) 
    485487        scale = None 
    486488        min_err = 0.0 
    … …  
    504506                        #err = 0 
    505507 
    506                     data_x = numpy.append(data_x, x) 
    507                     data_y = numpy.append(data_y, y) 
    508                     data_err = numpy.append(data_err, err) 
     508                    data_x = np.append(data_x, x) 
     509                    data_y = np.append(data_y, y) 
     510                    data_err = np.append(data_err, err) 
    509511                except: 
    510                     logging.error(sys.exc_value) 
     512                    logger.error(sys.exc_value) 
    511513 
    512514        if not scale == None: 
    … …  
    528530        """ 
    529531        # Read the data from the data file 
    530         data_x = numpy.zeros(0) 
    531         data_y = numpy.zeros(0) 
    532         data_err = numpy.zeros(0) 
     532        data_x = np.zeros(0) 
     533        data_y = np.zeros(0) 
     534        data_err = np.zeros(0) 
    533535        scale = None 
    534536        min_err = 0.0 
    … …  
    555557                            #err = 0 
    556558 
    557                         data_x = numpy.append(data_x, x) 
    558                         data_y = numpy.append(data_y, y) 
    559                         data_err = numpy.append(data_err, err) 
     559                        data_x = np.append(data_x, x) 
     560                        data_y = np.append(data_y, y) 
     561                        data_err = np.append(data_err, err) 
    560562                    except: 
    561                         logging.error(sys.exc_value) 
     563                        logger.error(sys.exc_value) 
    562564                elif line.find("The 6 columns") >= 0: 
    563565                    data_started = True 
    … …  
    640642        # Now replot the original added data 
    641643        for plot in self._added_plots: 
    642             self._added_plots[plot].y = numpy.copy(self._default_Iq[plot]) 
     644            self._added_plots[plot].y = np.copy(self._default_Iq[plot]) 
    643645            wx.PostEvent(self.parent, 
    644646                         NewPlotEvent(plot=self._added_plots[plot], 
    … …  
    664666        # Now scale the added plots too 
    665667        for plot in self._added_plots: 
    666             total = numpy.sum(self._added_plots[plot].y) 
     668            total = np.sum(self._added_plots[plot].y) 
    667669            npts = len(self._added_plots[plot].x) 
    668670            total *= self._added_plots[plot].x[npts - 1] / npts 
    … …  
    814816        # Save Pr invertor 
    815817        self.pr = pr 
    816         cov = numpy.ascontiguousarray(cov) 
     818        cov = np.ascontiguousarray(cov) 
    817819 
    818820        # Show result on control panel 
    … …  
    982984        all_zeros = True 
    983985        if err == None: 
    984             err = numpy.zeros(len(pr.y)) 
     986            err = np.zeros(len(pr.y)) 
    985987        else: 
    986988            for i in range(len(err)): 
    … …  
    10881090        # If we have not errors, add statistical errors 
    10891091        if y is not None: 
    1090             if err == None or numpy.all(err) == 0: 
    1091                 err = numpy.zeros(len(y)) 
     1092            if err == None or np.all(err) == 0: 
     1093                err = np.zeros(len(y)) 
    10921094                scale = None 
    10931095                min_err = 0.0 
    … …  
    12011203            dataset = panel.plots[panel.graph.selected_plottable].name 
    12021204        else: 
    1203             logging.info("Prview Error: No data is available") 
     1205            logger.info("Prview Error: No data is available") 
    12041206            return 
    12051207 
    … …  
    12111213        except: 
    12121214            self.control_panel.alpha = self.alpha 
    1213             logging.info("Prview :Alpha Not estimate yet") 
     1215            logger.info("Prview :Alpha Not estimate yet") 
    12141216        try: 
    12151217            estimate = int(self.control_panel.nterms_estimate) 
    … …  
    12171219        except: 
    12181220            self.control_panel.nfunc = self.nfunc 
    1219             logging.info("Prview : ntemrs Not estimate yet") 
     1221            logger.info("Prview : ntemrs Not estimate yet") 
    12201222 
    12211223        self.current_plottable = panel.plots[panel.graph.selected_plottable] 

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

    rd85c194 r9c0f3c17  
    1010import wx 
    1111import os 
    12 import numpy 
     12import numpy as np 
    1313import time 
    1414import logging 
    … …  
    2424from sas.sascalc.data_util.calcthread import CalcThread 
    2525from sas.guicomm.events import NewPlotEvent, StatusEvent     
     26 
     27logger = logging.getLogger(__name__) 
    2628 
    2729class Calc1D(CalcThread): 
    … …  
    4648    def compute(self): 
    4749        x = self.x 
    48         output = numpy.zeros(len(x)) 
    49         error = numpy.zeros(len(x)) 
     50        output = np.zeros(len(x)) 
     51        error = np.zeros(len(x)) 
    5052         
    5153        self.starttime = time.time() 
    … …  
    9395        self._default_save_location = os.getcwd() 
    9496        # Log startup 
    95         logging.info("Simulation plug-in started") 
     97        logger.info("Simulation plug-in started") 
    9698         
    9799    def get_panels(self, parent): 
    … …  
    123125        # Q-values for plotting simulated I(Q) 
    124126        step = (self.q_max-self.q_min)/(self.q_npts-1) 
    125         self.x = numpy.arange(self.q_min, self.q_max+step*0.01, step)         
     127        self.x = np.arange(self.q_min, self.q_max+step*0.01, step) 
    126128         
    127129        # Set the list of panels that are part of the simulation perspective 
    … …  
    187189        # Q-values for plotting simulated I(Q) 
    188190        step = (self.q_max-self.q_min)/(self.q_npts-1) 
    189         self.x = numpy.arange(self.q_min, self.q_max+step*0.01, step)     
     191        self.x = np.arange(self.q_min, self.q_max+step*0.01, step) 
    190192          
    191193        # Compute the simulated I(Q) 
Note: See TracChangeset for help on using the changeset viewer.