Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/sas/sasgui/perspectives/fitting/fitpage.py

    r55db501 rc8e1996  
    1414from sasmodels.weights import MODELS as POLYDISPERSITY_MODELS 
    1515 
    16 from sas.sasgui.guiframe.events import StatusEvent 
    17 from sas.sasgui.guiframe.events import NewPlotEvent 
    18 from sas.sasgui.guiframe.events import PlotQrangeEvent 
     16from sas.sasgui.guiframe.events import StatusEvent, NewPlotEvent, \ 
     17    PlotQrangeEvent 
    1918from sas.sasgui.guiframe.dataFitting import check_data_validity 
    20 from sas.sasgui.guiframe.utils import format_number 
    21 from sas.sasgui.guiframe.utils import check_float 
     19from sas.sasgui.guiframe.utils import format_number, check_float 
    2220from sas.sasgui.guiframe.documentation_window import DocumentationWindow 
     21 
     22from sas.sasgui.perspectives.fitting.basepage import BasicPage as BasicPage 
     23from sas.sasgui.perspectives.fitting.basepage import PageInfoEvent as \ 
     24    PageInfoEvent 
     25from sas.sascalc.data_util.qsmearing import smear_selection 
     26from .basepage import ModelTextCtrl 
    2327 
    2428(Chi2UpdateEvent, EVT_CHI2_UPDATE) = wx.lib.newevent.NewEvent() 
     
    2832SMEAR_SIZE_H = 0.00 
    2933 
    30 from sas.sasgui.perspectives.fitting.basepage import BasicPage as BasicPage 
    31 from sas.sasgui.perspectives.fitting.basepage import PageInfoEvent as PageInfoEvent 
    32 from sas.sascalc.data_util.qsmearing import smear_selection 
    33 from .basepage import ModelTextCtrl 
    34  
    3534 
    3635class FitPage(BasicPage): 
     
    4948        BasicPage.__init__(self, parent, color=color) 
    5049 
    51         ## draw sizer 
     50        # draw sizer 
    5251        self._fill_data_sizer() 
    5352        self.is_2D = None 
     
    7271        self.enable_fit_button() 
    7372        self.fill_data_combobox(data_list=self.data_list) 
    74         #create a default data for an empty panel 
     73        # create a default data for an empty panel 
    7574        self.create_default_data() 
    7675        self._manager.frame.Bind(wx.EVT_SET_FOCUS, self.on_set_focus) 
     
    105104        self.data_box_description.SetForegroundColour(dname_color) 
    106105        boxsizer1 = wx.StaticBoxSizer(self.data_box_description, wx.VERTICAL) 
    107         #---------------------------------------------------------- 
     106        # ---------------------------------------------------------- 
    108107        sizer_data = wx.BoxSizer(wx.HORIZONTAL) 
    109108        self.dataSource = wx.ComboBox(self, wx.ID_ANY, style=wx.CB_READONLY) 
     
    134133        self.enable_datasource() 
    135134        if len(data_list) > 0: 
    136             #find the maximum range covering all data 
     135            # find the maximum range covering all data 
    137136            qmin, qmax, npts = self.compute_data_set_range(data_list) 
    138137            self.qmin_data_set = qmin 
     
    169168            self.set_data(data) 
    170169        elif self.dataSource.GetCount() > 0: 
    171  
    172170            pos = self.dataSource.GetSelection() 
    173171            data = self.dataSource.GetClientData(pos) 
     
    186184 
    187185        :return: True or False 
    188  
    189186        """ 
    190187        if self.data.__class__.__name__ == "Data2D" or \ 
     
    200197        buttons, xi^2, number of points etc. 
    201198        """ 
    202         is_2Ddata = False 
     199        is_2d_data = False 
    203200 
    204201        # Check if data is 2D 
    205202        if self.data.__class__.__name__ == "Data2D" or \ 
    206203                        self.enable2D: 
    207             is_2Ddata = True 
     204            is_2d_data = True 
    208205 
    209206        title = "Fitting" 
    210         #smear messages & titles 
     207        # smear messages & titles 
    211208        smear_message_none = "No smearing is selected..." 
    212209        smear_message_dqdata = "The dQ data is being used for smearing..." 
     
    226223        self._get_smear_info() 
    227224 
    228         #Sizers 
     225        # Sizers 
    229226        box_description_range = wx.StaticBox(self, wx.ID_ANY, str(title)) 
    230227        box_description_range.SetForegroundColour(wx.BLUE) 
     
    245242        sizer_weighting = wx.BoxSizer(wx.HORIZONTAL) 
    246243        weighting_box.SetMinSize((_DATA_BOX_WIDTH, 40)) 
    247         #Filling the sizer containing weighting info. 
     244        # Filling the sizer containing weighting info. 
    248245        self.dI_noweight = wx.RadioButton(self, wx.ID_ANY, 
    249246                                          'No Weighting', style=wx.RB_GROUP) 
     
    287284                        self._on_select_accuracy) 
    288285 
    289         #Fit button 
     286        # Fit button 
    290287        self.btFit = wx.Button(self, self._ids.next(), 'Fit') 
    291288        self.default_bt_colour = self.btFit.GetDefaultAttributes() 
     
    293290        self.btFit.SetToolTipString("Start fitting.") 
    294291 
    295         #General Help button 
     292        # General Help button 
    296293        self.btFitHelp = wx.Button(self, wx.ID_ANY, 'Help') 
    297294        self.btFitHelp.SetToolTipString("General fitting help.") 
    298295        self.btFitHelp.Bind(wx.EVT_BUTTON, self._onFitHelp) 
    299296         
    300         #Resolution Smearing Help button (for now use same technique as 
    301         #used for dI help to get tiniest possible button that works 
    302         #both on MAC and PC.  Should completely rewrite the fitting sizer  
    303         #in future.  This is minimum to get out release 3.1 
     297        # Resolution Smearing Help button (for now use same technique as 
     298        # used for dI help to get tiniest possible button that works 
     299        # both on MAC and PC.  Should completely rewrite the fitting sizer 
     300        # in future.  This is minimum to get out release 3.1 
    304301        #        comment June 14, 2015     --- PDB 
    305302        if sys.platform.count("win32") > 0: 
    306             size_q = (20, 15)  #on PC 
     303            size_q = (20, 15)  # on PC 
    307304        else: 
    308             size_q = (30, 20)  #on MAC 
     305            size_q = (30, 20)  # on MAC 
    309306        self.btSmearHelp = wx.Button(self, wx.ID_ANY, '?', 
    310307                                     style=wx.BU_EXACTFIT, size=size_q) 
     
    312309        self.btSmearHelp.Bind(wx.EVT_BUTTON, self._onSmearHelp) 
    313310         
    314         #textcntrl for custom resolution 
     311        # textcntrl for custom resolution 
    315312        self.smear_pinhole_max = ModelTextCtrl(self, wx.ID_ANY, 
    316313                            size=(_BOX_WIDTH - 25, 20), 
     
    330327                            text_enter_callback=self.onSlitSmear) 
    331328 
    332         ## smear 
     329        # smear 
    333330        self.smear_data_left = BGTextCtrl(self, wx.ID_ANY, 
    334331                                          size=(_BOX_WIDTH - 25, 20), style=0) 
     
    338335        self.smear_data_right.SetValue(str(self.dq_r)) 
    339336 
    340         #set default values for smear 
     337        # set default values for smear 
    341338        self.smear_pinhole_max.SetValue(str(self.dx_max)) 
    342339        self.smear_pinhole_min.SetValue(str(self.dx_min)) 
     
    344341        self.smear_slit_width.SetValue(str(self.dxw)) 
    345342 
    346         #Filling the sizer containing instruments smearing info. 
     343        # Filling the sizer containing instruments smearing info. 
    347344        self.disable_smearer = wx.RadioButton(self, wx.ID_ANY, 
    348345                                              'None', style=wx.RB_GROUP) 
    349346        self.enable_smearer = wx.RadioButton(self, wx.ID_ANY, 'Use dQ Data') 
    350         #self.enable_smearer.SetToolTipString( 
    351         #"Click to use the loaded dQ data for smearing.") 
     347        # self.enable_smearer.SetToolTipString( 
     348        # "Click to use the loaded dQ data for smearing.") 
    352349        self.pinhole_smearer = wx.RadioButton(self, wx.ID_ANY, 
    353350                                              'Custom Pinhole Smear') 
    354         #self.pinhole_smearer.SetToolTipString 
    355         #("Click to input custom resolution for pinhole smearing.") 
     351        # self.pinhole_smearer.SetToolTipString 
     352        # ("Click to input custom resolution for pinhole smearing.") 
    356353        self.slit_smearer = wx.RadioButton(self, wx.ID_ANY, 'Custom Slit Smear') 
    357         #self.slit_smearer.SetToolTipString 
    358         #("Click to input custom resolution for slit smearing.") 
     354        # self.slit_smearer.SetToolTipString 
     355        # ("Click to input custom resolution for slit smearing.") 
    359356        self.Bind(wx.EVT_RADIOBUTTON, self.onSmear, 
    360357                  id=self.disable_smearer.GetId()) 
     
    379376        self.Npts_fit = BGTextCtrl(self, wx.ID_ANY, "-", size=(75, 20), style=0) 
    380377        self.Npts_fit.SetToolTipString( 
    381                             " Npts : number of points selected for fitting") 
     378            " Npts : number of points selected for fitting") 
    382379        self.Npts_total = ModelTextCtrl(self, wx.ID_ANY, size=(_BOX_WIDTH, 20), 
    383                             style=wx.TE_PROCESS_ENTER, 
    384                             text_enter_callback=self._onQrangeEnter) 
     380                                        style=wx.TE_PROCESS_ENTER, 
     381                                        text_enter_callback=self._onQrangeEnter) 
    385382        self.Npts_total.SetValue(format_number(self.npts_x)) 
    386         self.Npts_total.SetToolTipString(\ 
    387                                 " Total Npts : total number of data points") 
     383        self.Npts_total.SetToolTipString( 
     384            " Total Npts : total number of data points") 
    388385 
    389386        # Update and Draw button 
     
    430427        self.smear_description_2d_y = wx.StaticText(self, wx.ID_ANY, 
    431428                            smear_message_2d_y_title, style=wx.ALIGN_LEFT) 
    432         self.smear_description_2d_y.SetToolTipString(\ 
     429        self.smear_description_2d_y.SetToolTipString( 
    433430                                    " dQs(perpendicular) in q_phi direction.") 
    434431        self.smear_description_pin_min = wx.StaticText(self, wx.ID_ANY, 
     
    441438                        smear_message_slit_width_title, style=wx.ALIGN_LEFT) 
    442439 
    443         #arrange sizers 
     440        # arrange sizers 
    444441        self.sizer_set_smearer.Add(sizer_smearer) 
    445442        self.sizer_set_smearer.Add((10, 10)) 
    446443        self.sizer_set_smearer.Add(self.smear_description_none, 
    447                                     0, wx.CENTER, 10) 
     444                                   0, wx.CENTER, 10) 
    448445        self.sizer_set_smearer.Add(self.smear_description_dqdata, 
    449                                     0, wx.CENTER, 10) 
     446                                   0, wx.CENTER, 10) 
    450447        self.sizer_set_smearer.Add(self.smear_description_2d, 
    451                                     0, wx.CENTER, 10) 
     448                                   0, wx.CENTER, 10) 
    452449        self.sizer_new_smear.Add(self.smear_description_type, 
    453                                   0, wx.CENTER, 10) 
     450                                 0, wx.CENTER, 10) 
    454451        self.sizer_new_smear.Add(self.smear_description_accuracy_type, 
    455                                   0, wx.CENTER, 10) 
     452                                 0, wx.CENTER, 10) 
    456453        self.sizer_new_smear.Add(self.smear_accuracy) 
    457454        self.sizer_new_smear.Add(self.smear_description_smear_type, 
    458                                   0, wx.CENTER, 10) 
     455                                 0, wx.CENTER, 10) 
    459456        self.sizer_new_smear.Add((15, -1)) 
    460         self.sizer_new_smear.Add(self.smear_description_2d_x, 
    461                                   0, wx.CENTER, 10) 
     457        self.sizer_new_smear.Add(self.smear_description_2d_x, 0, wx.CENTER, 10) 
    462458        self.sizer_new_smear.Add(self.smear_description_pin_min, 
    463                                   0, wx.CENTER, 10) 
     459                                 0, wx.CENTER, 10) 
    464460        self.sizer_new_smear.Add(self.smear_description_slit_height, 
    465                                   0, wx.CENTER, 10) 
    466  
    467         self.sizer_new_smear.Add(self.smear_pinhole_min, 
    468                                   0, wx.CENTER, 10) 
    469         self.sizer_new_smear.Add(self.smear_slit_height, 
    470                                   0, wx.CENTER, 10) 
    471         self.sizer_new_smear.Add(self.smear_data_left, 
    472                                   0, wx.CENTER, 10) 
     461                                 0, wx.CENTER, 10) 
     462 
     463        self.sizer_new_smear.Add(self.smear_pinhole_min, 0, wx.CENTER, 10) 
     464        self.sizer_new_smear.Add(self.smear_slit_height, 0, wx.CENTER, 10) 
     465        self.sizer_new_smear.Add(self.smear_data_left, 0, wx.CENTER, 10) 
    473466        self.sizer_new_smear.Add((20, -1)) 
    474467        self.sizer_new_smear.Add(self.smear_description_2d_y, 
    475                                   0, wx.CENTER, 10) 
     468                                 0, wx.CENTER, 10) 
    476469        self.sizer_new_smear.Add(self.smear_description_pin_max, 
    477                                   0, wx.CENTER, 10) 
     470                                 0, wx.CENTER, 10) 
    478471        self.sizer_new_smear.Add(self.smear_description_slit_width, 
    479                                   0, wx.CENTER, 10) 
     472                                 0, wx.CENTER, 10) 
    480473 
    481474        self.sizer_new_smear.Add(self.smear_pinhole_max, 0, wx.CENTER, 10) 
     
    502495 
    503496        # Show only the relevant smear messages, etc 
    504         if self.current_smearer == None: 
    505             if not is_2Ddata: 
     497        if self.current_smearer is None: 
     498            if not is_2d_data: 
    506499                self.smear_description_none.Show(True) 
    507500                self.enable_smearer.Disable() 
     
    509502                self.smear_description_none.Show(True) 
    510503                self.slit_smearer.Disable() 
    511             if self.data == None: 
     504            if self.data is None: 
    512505                self.slit_smearer.Disable() 
    513506                self.pinhole_smearer.Disable() 
     
    516509            self._show_smear_sizer() 
    517510        boxsizer_range.Add(self.sizer_set_masking) 
    518         #2D data? default 
    519         is_2Ddata = False 
    520  
    521         #check if it is 2D data 
     511        # 2D data? default 
     512        is_2d_data = False 
     513 
     514        # check if it is 2D data 
    522515        if self.data.__class__.__name__ == "Data2D" or self.enable2D: 
    523             is_2Ddata = True 
     516            is_2d_data = True 
    524517 
    525518        self.sizer5.Clear(True) 
     
    569562        sizer.Add(wx.StaticText(self, wx.ID_ANY, ' Max[1/A]')) 
    570563        sizer.Add(self.EditMask_title) 
    571         sizer.Add((-1,5)) 
     564        sizer.Add((-1, 5)) 
    572565 
    573566        sizer.Add(self.reset_qrange) 
     
    575568        sizer.Add(self.qmax) 
    576569        sizer.Add(self.btEditMask) 
    577         sizer.Add((-1,5)) 
    578  
    579         sizer.AddMany(5*[(-1,5)]) 
     570        sizer.Add((-1, 5)) 
     571 
     572        sizer.AddMany(5*[(-1, 5)]) 
    580573 
    581574        sizer.Add(box_description_1, 0, 0) 
     
    583576        sizer.Add(self.points_sizer, 0, 0) 
    584577        sizer.Add(self.draw_button, 0, 0) 
    585         sizer.Add((-1,5)) 
     578        sizer.Add((-1, 5)) 
    586579         
    587580        sizer.Add(self.tcChi, 0, 0) 
     
    593586        boxsizer_range.Add(sizer_chi2) 
    594587        boxsizer_range.Add(sizer) 
    595         if is_2Ddata: 
     588        if is_2d_data: 
    596589            self.btEditMask.Enable() 
    597590            self.EditMask_title.Enable() 
     
    599592            self.btEditMask.Disable() 
    600593            self.EditMask_title.Disable() 
    601         ## save state 
     594        # save state 
    602595        self.save_current_state() 
    603596        self.sizer5.Add(boxsizer_range, 0, wx.EXPAND | wx.ALL, 10) 
    604597        self.sizer5.Layout() 
    605598 
    606  
    607599    def _set_sizer_dispersion(self): 
    608600        """ 
     
    614606 
    615607        self.sizer4_4.Clear(True) 
    616         if self.model == None: 
    617             ##no model is selected 
     608        if self.model is None: 
     609            # no model is selected 
    618610            return 
    619611        if not self.enable_disp.GetValue(): 
    620             ## the user didn't select dispersity display 
     612            # the user didn't select dispersity display 
    621613            return 
    622614 
    623615        self._reset_dispersity() 
    624616 
    625         ## fill a sizer with the combobox to select dispersion type 
     617        # fill a sizer with the combobox to select dispersion type 
    626618        model_disp = wx.StaticText(self, wx.ID_ANY, 'Function') 
    627         CHECK_STATE = self.cb1.GetValue() 
     619        CHECK_STATE = False 
    628620 
    629621        ix = 0 
     
    646638            err_text = '' 
    647639        self.text_disp_1 = wx.StaticText(self, wx.ID_ANY, err_text) 
    648         self.sizer4_4.Add(self.text_disp_1, (iy, ix), (1, 1), \ 
     640        self.sizer4_4.Add(self.text_disp_1, (iy, ix), (1, 1), 
    649641                          wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    650642 
    651643        ix += 1 
    652644        self.text_disp_min = wx.StaticText(self, wx.ID_ANY, 'Min') 
    653         self.sizer4_4.Add(self.text_disp_min, (iy, ix), (1, 1), \ 
     645        self.sizer4_4.Add(self.text_disp_min, (iy, ix), (1, 1), 
    654646                            wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    655647 
     
    684676                if item in self.model.magnetic_params: 
    685677                    continue 
    686             if not item in self.model.orientation_params: 
    687                 if not item in self.disp_cb_dict: 
     678            if item not in self.model.orientation_params: 
     679                if item not in self.disp_cb_dict: 
    688680                    self.disp_cb_dict[item] = None 
    689681                name0 = "Distribution of " + item 
     
    691683                name2 = item + ".npts" 
    692684                name3 = item + ".nsigmas" 
    693                 if not name1 in self.model.details: 
     685                if name1 not in self.model.details: 
    694686                    self.model.details[name1] = ["", None, None] 
    695687 
     
    717709                        ctl1.SetValue(str(format_number(value, True))) 
    718710                        self.sizer4_4.Add(ctl1, (iy, ix), (1, 1), wx.EXPAND) 
    719                         ## text to show error sign 
     711                        # text to show error sign 
    720712                        ix = 2 
    721713                        text2 = wx.StaticText(self, wx.ID_ANY, '+/-') 
     
    777769                        Tct2.SetValue(str(format_number(value))) 
    778770                        self.sizer4_4.Add(Tct2, (iy, ix), (1, 1), 
    779                                            wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
     771                                          wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    780772                        self.fixed_param.append([None, name3, Tct2, 
    781773                                                 None, None, None, 
     
    803795                if item in self.model.magnetic_params: 
    804796                    continue 
    805             if  item in self.model.orientation_params: 
    806                 if not item in self.disp_cb_dict: 
     797            if item in self.model.orientation_params: 
     798                if item not in self.disp_cb_dict: 
    807799                    self.disp_cb_dict[item] = None 
    808800                name0 = "Distribution of " + item 
     
    811803                name3 = item + ".nsigmas" 
    812804 
    813                 if not name1 in self.model.details: 
     805                if name1 not in self.model.details: 
    814806                    self.model.details[name1] = ["", None, None] 
    815807 
     
    856848 
    857849                        self.sizer4_4.Add(ctl1, (iy, ix), (1, 1), wx.EXPAND) 
    858                         ## text to show error sign 
     850                        # text to show error sign 
    859851                        ix = 2 
    860852                        text2 = wx.StaticText(self, wx.ID_ANY, '+/-') 
     
    969961 
    970962        self.state.model = self.model.clone() 
    971         ## save state into 
    972         self.state.cb1 = self.cb1.GetValue() 
     963        # save state into 
    973964        self._copy_parameters_state(self.parameters, self.state.parameters) 
    974965        self._copy_parameters_state(self.orientation_params_disp, 
     
    980971        wx.PostEvent(self.parent, 
    981972                     StatusEvent(status=" Selected Distribution: Gaussian")) 
    982         #Fill the list of fittable parameters 
    983         #self.select_all_param(event=None) 
     973        # Fill the list of fittable parameters 
    984974        self.get_all_checked_params() 
    985975        self.Layout() 
     
    989979        Update and Draw the model 
    990980        """ 
    991         if self.model == None: 
     981        if self.model is None: 
    992982            msg = "Please select a Model first..." 
    993983            wx.MessageBox(msg, 'Info') 
     
    999989            self.create_default_data() 
    1000990        """ 
    1001         flag,is_modified = self._update_paramv_on_fit() 
    1002  
    1003         wx.CallAfter(self._onparamEnter_helper,is_modified) 
     991        flag, is_modified = self._update_paramv_on_fit() 
     992 
     993        wx.CallAfter(self._onparamEnter_helper, is_modified) 
    1004994        if not flag: 
    1005995            msg = "The parameters are invalid" 
     
    10111001        Allow to fit 
    10121002        """ 
    1013         if event != None: 
     1003        if event is not None: 
    10141004            event.Skip() 
    10151005        if self.fit_started: 
     
    10511041            return 
    10521042 
    1053         self.select_param(event=None) 
     1043        self.select_param() 
    10541044 
    10551045        # Remove or do not allow fitting on the Q=0 point, especially 
     
    10621052                                    qmax=self.qmax_x) 
    10631053 
    1064         #single fit 
    1065         #self._manager.onFit(uid=self.uid) 
     1054        # single fit 
     1055        # self._manager.onFit(uid=self.uid) 
    10661056        self.fit_started = self._manager.onFit(uid=self.uid) 
    10671057        wx.CallAfter(self.set_fitbutton) 
     
    10761066        versions of Wx (before 2.9) and thus not the release version of 
    10771067        installers, the help comes up at the top level of the file as 
    1078         webbrowser does not pass anything past the # to the browser when it is 
     1068        web browser does not pass anything past the # to the browser when it is 
    10791069        running "file:///...." 
    10801070 
    1081     :param evt: Triggers on clicking the help button 
    1082     """ 
     1071        :param evt: Triggers on clicking the help button 
     1072        """ 
    10831073 
    10841074        _TreeLocation = "user/sasgui/perspectives/fitting/fitting_help.html" 
     
    10951085        versions of Wx (before 2.9) and thus not the release version of 
    10961086        installers, the help comes up at the top level of the file as 
    1097         webbrowser does not pass anything past the # to the browser when it is 
     1087        web browser does not pass anything past the # to the browser when it is 
    10981088        running "file:///...." 
    10991089 
    1100     :param evt: Triggers on clicking the help button 
    1101     """ 
     1090        :param evt: Triggers on clicking the help button 
     1091        """ 
    11021092 
    11031093        _TreeLocation = "user/sasgui/perspectives/fitting/sm_help.html" 
     
    11111101        """ 
    11121102        # Skip this feature if we are not on Windows 
    1113         #NOTE: the is_mac data member actually means "is no Windows". 
     1103        # NOTE: the is_mac data member actually means "is no Windows". 
    11141104        if self.is_mac: 
    11151105            return 
     
    11211111            label = "Fit" 
    11221112            color = "black" 
    1123         #self.btFit.Enable(False) 
     1113        # self.btFit.Enable(False) 
    11241114        self.btFit.SetLabel(label) 
    11251115        self.btFit.SetForegroundColour(color) 
     
    11521142        Stop fit 
    11531143        """ 
    1154         if event != None: 
     1144        if event is not None: 
    11551145            event.Skip() 
    11561146        self._manager.stop_fit(self.uid) 
     
    11721162        copy_flag = False 
    11731163        is_poly_enabled = None 
    1174         if event != None: 
    1175             if (event.GetEventObject() == self.formfactorbox\ 
     1164        if event is not None: 
     1165            if (event.GetEventObject() == self.formfactorbox 
    11761166                        and self.structurebox.GetLabel() != 'None')\ 
    11771167                        or event.GetEventObject() == self.structurebox\ 
     
    11861176            self._keep.Enable(False) 
    11871177            self._set_save_flag(False) 
    1188         # TODO: why do we have to variables for one flag?? 
    11891178        self.enable_disp.SetValue(False) 
    11901179        self.disable_disp.SetValue(True) 
     
    12161205                    self._keep.Enable(not self.batch_on) 
    12171206                    self._set_save_flag(True) 
     1207                    self._set_smear(self.data) 
    12181208 
    12191209            # more disables for 2D 
     
    12291219            except: 
    12301220                raise 
    1231                 ## error occured on chisqr computation 
    1232                 #pass 
    1233             ## event to post model to fit to fitting plugins 
     1221                # error occured on chisqr computation 
     1222                # pass 
     1223            # event to post model to fit to fitting plugins 
    12341224            (ModelEventbox, EVT_MODEL_BOX) = wx.lib.newevent.NewEvent() 
    12351225 
    1236             ## set smearing value whether or not 
    1237             #    the data contain the smearing info 
     1226            # set smearing value whether or not data contain the smearing info 
    12381227            evt = ModelEventbox(model=self.model, 
    12391228                            smearer=temp_smear, 
     
    12451234 
    12461235            self._manager._on_model_panel(evt=evt) 
    1247             self.mbox_description.SetLabel("Model [ %s ]" % str(self.model.name)) 
     1236            self.mbox_description.SetLabel("Model [ %s ]" % 
     1237                                           str(self.model.name)) 
    12481238            self.mbox_description.SetForegroundColour(wx.BLUE) 
    12491239            self.state.model = self.model.clone() 
    12501240            self.state.model.name = self.model.name 
    12511241 
    1252         if event != None: 
    1253             ## post state to fit panel 
     1242        if event is not None: 
     1243            # post state to fit panel 
    12541244            new_event = PageInfoEvent(page=self) 
    12551245            wx.PostEvent(self.parent, new_event) 
    1256             #update list of plugins if new plugin is available 
     1246            # update list of plugins if new plugin is available 
    12571247            custom_model = 'Customized Models' 
    12581248            mod_cat = self.categorybox.GetStringSelection() 
     
    12671257                    self.formfactorbox.SetValue(current_val) 
    12681258            # when select a model only from guictr/button 
    1269             if is_poly_enabled != None: 
     1259            if is_poly_enabled is not None: 
    12701260                self.enable_disp.SetValue(is_poly_enabled) 
    12711261                self.disable_disp.SetValue(not is_poly_enabled) 
     
    12951285        when enter value on panel redraw model according to changed 
    12961286        """ 
    1297         if self.model == None: 
     1287        if self.model is None: 
    12981288            msg = "Please select a Model first..." 
    12991289            wx.MessageBox(msg, 'Info') 
    13001290            return 
    13011291 
    1302         #default flag 
     1292        # default flag 
    13031293        flag = False 
    13041294        self.fitrange = True 
    1305         #get event object 
     1295        # get event object 
    13061296        tcrtl = event.GetEventObject() 
    1307         #Clear msg if previously shown. 
     1297        # Clear msg if previously shown. 
    13081298        msg = "" 
    13091299        wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
     
    13161306                if not self.disable_smearer.GetValue(): 
    13171307                    temp_smearer = self.current_smearer 
    1318                     ## set smearing value whether or not 
    1319                     #        the data contain the smearing info 
     1308                    # set smearing value whether or not data contain the 
     1309                    # smearing info 
    13201310                    if self.slit_smearer.GetValue(): 
    13211311                        flag1 = self.update_slit_smear() 
     
    13341324                                              enable_smearer=enable_smearer) 
    13351325                if flag: 
    1336                     #self.compute_chisqr(smearer= temp_smearer) 
    1337  
    1338                     ## new state posted 
     1326                    # self.compute_chisqr(smearer= temp_smearer) 
     1327 
     1328                    # new state posted 
    13391329                    if self.state_change: 
    1340                         #self._undo.Enable(True) 
     1330                        # self._undo.Enable(True) 
    13411331                        event = PageInfoEvent(page=self) 
    13421332                        wx.PostEvent(self.parent, event) 
     
    13481338        else: 
    13491339            self.save_current_state() 
    1350             msg = "Cannot Plot :Must enter a number!!!  " 
     1340            msg = "Cannot Plot: Must enter a number!!!  " 
    13511341            wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    13521342 
     
    13591349        """ 
    13601350        tcrtl = event.GetEventObject() 
    1361         #Clear msg if previously shown. 
     1351        # Clear msg if previously shown. 
    13621352        msg = "" 
    13631353        wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
     
    13771367            tcrtl.SetBackgroundColour(wx.WHITE) 
    13781368 
    1379         #self._undo.Enable(True) 
     1369        # self._undo.Enable(True) 
    13801370        self.save_current_state() 
    13811371        event = PageInfoEvent(page=self) 
     
    13871377        ON Qrange focus 
    13881378        """ 
    1389         if event != None: 
     1379        if event is not None: 
    13901380            event.Skip() 
    1391         #tcrtl = event.GetEventObject() 
     1381        # tcrtl = event.GetEventObject() 
    13921382        self._validate_qrange(self.qmin, self.qmax) 
    13931383 
     
    13961386        On Qrange textctrl click, make the qrange lines in the plot 
    13971387        """ 
    1398         if event != None: 
     1388        if event is not None: 
    13991389            event.Skip() 
    14001390        if self.data.__class__.__name__ == "Data2D": 
     
    14141404        #On q range value updated. DO not combine with qrange_click(). 
    14151405        """ 
    1416         if event != None: 
     1406        if event is not None: 
    14171407            event.Skip() 
    14181408        if self.data.__class__.__name__ == "Data2D": 
     
    14421432        length = len(self.data.x) 
    14431433        indx = (numpy.abs(self.data.x - x_data)).argmin() 
    1444         #return array.flat[idx] 
     1434        # return array.flat[idx] 
    14451435        if key == wx.WXK_PAGEUP or key == wx.WXK_NUMPAD_PAGEUP: 
    14461436            indx += 1 
     
    14611451        """ 
    14621452        tcrtl = event.GetEventObject() 
    1463         #Clear msg if previously shown. 
     1453        # Clear msg if previously shown. 
    14641454        msg = "" 
    14651455        wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
     
    14911481                wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    14921482                return 
    1493             #Check if # of points for theory model are valid(>0). 
     1483            # Check if # of points for theory model are valid(>0). 
    14941484            # check for 2d 
    14951485            if self.data.__class__.__name__ == "Data2D" or \ 
     
    14981488                radius = numpy.sqrt(self.data.qx_data * self.data.qx_data + 
    14991489                                    self.data.qy_data * self.data.qy_data) 
    1500                 index_data = ((self.qmin_x <= radius) & \ 
    1501                                 (radius <= self.qmax_x)) 
     1490                index_data = ((self.qmin_x <= radius) & (radius <= self.qmax_x)) 
    15021491                index_data = (index_data) & (self.data.mask) 
    15031492                index_data = (index_data) & (numpy.isfinite(self.data.data)) 
     
    15091498                    return 
    15101499                else: 
    1511                     #self.data.mask = index_data 
    1512                     #self.Npts_fit.SetValue(str(len(self.data.mask))) 
     1500                    # self.data.mask = index_data 
     1501                    # self.Npts_fit.SetValue(str(len(self.data.mask))) 
    15131502                    self.show_npts2fit() 
    15141503            else: 
    1515                 index_data = ((self.qmin_x <= self.data.x) & \ 
     1504                index_data = ((self.qmin_x <= self.data.x) & 
    15161505                              (self.data.x <= self.qmax_x)) 
    15171506                self.Npts_fit.SetValue(str(len(self.data.x[index_data]))) 
     
    15461535            for item in self.parameters: 
    15471536                if item[0].IsShown(): 
    1548                     #Skip the angle parameters if 1D data 
     1537                    # Skip the angle parameters if 1D data 
    15491538                    if self.data.__class__.__name__ != "Data2D" and \ 
    15501539                            not self.enable2D: 
     
    15531542                    if item in self.param_toFit: 
    15541543                        continue 
    1555                     ## hide statictext +/- 
     1544                    # hide statictext +/- 
    15561545                    if len(item) < 4: 
    15571546                        continue 
    1558                     if item[3] != None and item[3].IsShown(): 
     1547                    if item[3] is not None and item[3].IsShown(): 
    15591548                        item[3].Hide() 
    1560                     ## hide textcrtl  for error after fit 
    1561                     if item[4] != None and item[4].IsShown(): 
     1549                    # hide textcrtl  for error after fit 
     1550                    if item[4] is not None and item[4].IsShown(): 
    15621551                        item[4].Hide() 
    15631552 
     
    15651554            for item in self.fittable_param: 
    15661555                if item[0].IsShown(): 
    1567                     #Skip the angle parameters if 1D data 
     1556                    # Skip the angle parameters if 1D data 
    15681557                    if self.data.__class__.__name__ != "Data2D" and \ 
    15691558                            not self.enable2D: 
     
    15741563                    if len(item) < 4: 
    15751564                        continue 
    1576                     ## hide statictext +/- 
    1577                     if item[3] != None and item[3].IsShown(): 
     1565                    # hide statictext +/- 
     1566                    if item[3] is not None and item[3].IsShown(): 
    15781567                        item[3].Hide() 
    1579                     ## hide textcrtl  for error after fit 
    1580                     if item[4] != None and item[4].IsShown(): 
     1568                    # hide textcrtl  for error after fit 
     1569                    if item[4] is not None and item[4].IsShown(): 
    15811570                        item[4].Hide() 
    15821571        return 
     
    15871576        """ 
    15881577        # get the default values 
    1589         if self.dxl == None: 
     1578        if self.dxl is None: 
    15901579            self.dxl = 0.0 
    1591         if self.dxw == None: 
     1580        if self.dxw is None: 
    15921581            self.dxw = "" 
    1593         if self.dx_min == None: 
     1582        if self.dx_min is None: 
    15941583            self.dx_min = SMEAR_SIZE_L 
    1595         if self.dx_max == None: 
     1584        if self.dx_max is None: 
    15961585            self.dx_max = SMEAR_SIZE_H 
    15971586 
     
    16141603        elif self.data.__class__.__name__ == "Data2D" or \ 
    16151604            self.enable2D: 
    1616             if data.dqx_data == None or  data.dqy_data == None: 
     1605            if data.dqx_data is None or data.dqy_data is None: 
    16171606                return 
    1618             elif self.current_smearer != None \ 
     1607            elif self.current_smearer is not None \ 
    16191608                and data.dqx_data.any() != 0 \ 
    16201609                and data.dqx_data.any() != 0: 
     
    16261615                return 
    16271616        # check if it is pinhole smear and get min max if it is. 
    1628         if data.dx != None and all(data.dx != 0): 
     1617        if data.dx is not None and not numpy.any(data.dx): 
    16291618            self.smear_type = "Pinhole" 
    16301619            self.dq_l = data.dx[0] 
     
    16321621 
    16331622        # check if it is slit smear and get min max if it is. 
    1634         elif data.dxl != None or data.dxw != None: 
     1623        elif data.dxl is not None or data.dxw is not None: 
    16351624            self.smear_type = "Slit" 
    1636             if data.dxl != None and all(data.dxl != 0): 
     1625            if data.dxl is not None and not numpy.all(data.dxl, 0): 
    16371626                self.dq_l = data.dxl[0] 
    1638             if data.dxw != None and all(data.dxw != 0): 
     1627            if data.dxw is not None and not numpy.all(data.dxw, 0): 
    16391628                self.dq_r = data.dxw[0] 
    1640         #return self.smear_type,self.dq_l,self.dq_r 
     1629        # return self.smear_type,self.dq_l,self.dq_r 
    16411630 
    16421631    def _show_smear_sizer(self): 
     
    16621651 
    16631652            self.smear_description_dqdata.Show(True) 
    1664             if self.smear_type != None: 
     1653            if self.smear_type is not None: 
    16651654                self.smear_description_smear_type.Show(True) 
    16661655                if self.smear_type == 'Slit': 
     
    17531742        Select an accuracy in 2D custom smear: Xhigh, High, Med, or Low 
    17541743        """ 
    1755         #event.Skip() 
     1744        # event.Skip() 
    17561745        # Check if the accuracy is same as before 
    1757         #self.smear2d_accuracy = event.GetEventObject().GetValue() 
     1746        # self.smear2d_accuracy = event.GetEventObject().GetValue() 
    17581747        self.smear2d_accuracy = self.smear_accuracy.GetValue() 
    17591748        if self.pinhole_smearer.GetValue(): 
     
    17611750        else: 
    17621751            self.onSmear(event=None) 
    1763             if self.current_smearer != None: 
     1752            if self.current_smearer is not None: 
    17641753                self.current_smearer.set_accuracy(accuracy=\ 
    17651754                                                  self.smear2d_accuracy) 
     
    17931782        Build a panel to allow to edit Mask 
    17941783        """ 
    1795         from sas.sasgui.guiframe.local_perspectives.plotting.masking \ 
    1796         import MaskPanel as MaskDialog 
     1784        from sas.sasgui.guiframe.local_perspectives.plotting.masking import \ 
     1785            MaskPanel as MaskDialog 
    17971786 
    17981787        self.panel = MaskDialog(base=self, data=self.data, id=wx.NewId()) 
     
    18051794        is_valid_qrange = self._update_paramv_on_fit() 
    18061795 
    1807         if is_valid_qrange and self.model != None: 
     1796        if is_valid_qrange and self.model is not None: 
    18081797            self.panel.MakeModal(False) 
    18091798            event.Skip() 
     
    18111800            self._draw_model() 
    18121801            self.show_npts2fit() 
    1813         elif self.model == None: 
     1802        elif self.model is None: 
    18141803            self.panel.MakeModal(False) 
    18151804            event.Skip() 
     
    18781867                    npts = len(data.x) 
    18791868                except: 
    1880                     msg = "Unable to find min/max/length of \n data named %s" % \ 
     1869                    msg = "Unable to find min/max/length of \n data named %s" %\ 
    18811870                                data.filename 
    18821871                    wx.PostEvent(self._manager.parent, StatusEvent(status=msg, 
     
    18951884                                               info="error")) 
    18961885                    raise ValueError, msg 
    1897                 ## Maximum value of data 
     1886                # Maximum value of data 
    18981887                qmax = math.sqrt(x * x + y * y) 
    18991888                npts = len(data.data) 
     
    19071896        flag = False 
    19081897        is_data = False 
     1898        npts = 0 
    19091899        try: 
    19101900            old_id = self.data.id 
     
    19181908                flag = True 
    19191909        if data is not None: 
    1920             id = data.id 
    19211910            if is_data: 
    19221911                self.graph_id = self.data.group_id 
     
    19331922            self._set_save_flag(False) 
    19341923        else: 
    1935             if self.model != None: 
     1924            if self.model is not None: 
    19361925                self._set_bookmark_flag(not self.batch_on) 
    19371926                self._keep.Enable(not self.batch_on) 
     
    19401929                self._set_preview_flag(True) 
    19411930 
    1942             self._set_smear(data) 
    19431931            # more disables for 2D 
    19441932            if self.data.__class__.__name__ == "Data2D" or \ 
     
    19471935                self.pinhole_smearer.Enable(True) 
    19481936                self.default_mask = copy.deepcopy(self.data.mask) 
    1949                 if self.data.err_data == None or\ 
    1950                         (self.data.err_data == 1).all() or\ 
    1951                         (self.data.err_data == 0).all(): 
     1937                if self.data.err_data is None or\ 
     1938                        numpy.all(err == 1 for err in self.data.err_data) or \ 
     1939                        not numpy.any(self.data.err_data): 
    19521940                    self.dI_didata.Enable(False) 
    19531941                    self.dI_noweight.SetValue(True) 
     
    19601948                self.slit_smearer.Enable(True) 
    19611949                self.pinhole_smearer.Enable(True) 
    1962                 if self.data.dy == None or\ 
    1963                      (self.data.dy == 1).all() or\ 
    1964                      (self.data.dy == 0).all(): 
     1950 
     1951                if self.data.dy is None or\ 
     1952                     numpy.all(self.data.dy == 1) or\ 
     1953                     not numpy.any(self.data.dy): 
    19651954                    self.dI_didata.Enable(False) 
    19661955                    self.dI_noweight.SetValue(True) 
     
    19701959                    self.dI_didata.SetValue(True) 
    19711960                    self.weightbt_string = self.dI_didata.GetLabelText() 
    1972             # Enable weighting radio uttons 
     1961            # Enable weighting radio buttons 
    19731962            self.dI_noweight.Enable(True) 
    19741963            self.dI_sqrdata.Enable(True) 
     
    19791968            data_name = self.data.name 
    19801969            _, _, npts = self.compute_data_range(self.data) 
    1981             #set maximum range for x in linear scale 
     1970            # set maximum range for x in linear scale 
    19821971            if not hasattr(self.data, "data"):  # Display only for 1D data fit 
    19831972                self.btEditMask.Disable() 
     
    19881977 
    19891978        self.Npts_total.SetValue(str(npts)) 
    1990         #default:number of data points selected to fit 
     1979        # default:number of data points selected to fit 
    19911980        self.Npts_fit.SetValue(str(npts)) 
    19921981        self.Npts_total.SetEditable(False) 
    1993         self.Npts_total.SetBackgroundColour(\ 
     1982        self.Npts_total.SetBackgroundColour( 
    19941983                                    self.GetParent().GetBackgroundColour()) 
    19951984 
     
    20011990        # send graph_id to page_finder 
    20021991        self._manager.set_graph_id(uid=self.uid, graph_id=self.graph_id) 
    2003         #focus the page 
     1992        # focus the page 
    20041993        if check_data_validity(data): 
    20051994            self.data_box_description.SetForegroundColour(wx.BLUE) 
     
    20132002        self.on_set_focus(None) 
    20142003        self.Refresh() 
    2015         #update model plot with new data information 
     2004        # update model plot with new data information 
    20162005        if flag: 
    2017             #set model view button 
    2018             self.onSmear(None) 
    2019  
    20202006            if self.data.__class__.__name__ == "Data2D": 
    20212007                self.enable2D = True 
     
    20252011                self.model_view.SetLabel("1D Mode") 
    20262012            self.model_view.Disable() 
    2027             #replace data plot on combo box selection 
    2028             #by removing the previous selected data 
     2013            #  replace data plot on combo box selection 
     2014            # by removing the previous selected data 
    20292015            try: 
    20302016                wx.PostEvent(self._manager.parent, 
     
    20332019            except: 
    20342020                pass 
    2035             #plot the current selected data 
     2021            # plot the current selected data 
    20362022            wx.PostEvent(self._manager.parent, 
    20372023                         NewPlotEvent(action="check", plot=self.data, 
     
    20532039            self.reset_page_helper(state) 
    20542040 
    2055             self.select_param(event=None) 
    2056             #Save state_fit 
     2041            self.select_param() 
     2042            # Save state_fit 
    20572043            self.save_current_state_fit() 
    20582044        except: 
     
    20932079        else: 
    20942080            for qx in self.data.x: 
    2095                 if qx >= qmin and qx <= qmax: 
     2081                if qmax >= qx >= qmin: 
    20962082                    npts2fit += 1 
    20972083        return npts2fit 
     
    21222108        # make sure stop button to fit button all the time 
    21232109        self._on_fit_complete() 
    2124         if out == None or not numpy.isfinite(chisqr): 
     2110        if out is None or not numpy.isfinite(chisqr): 
    21252111            raise ValueError, "Fit error occured..." 
    21262112 
     
    21292115        dispersity = '' 
    21302116 
    2131         #Hide textctrl boxes of errors. 
     2117        # Hide textctrl boxes of errors. 
    21322118        self._clear_Err_on_Fit() 
    21332119 
    2134         #Check if chi2 is finite 
    2135         if chisqr != None and numpy.isfinite(chisqr): 
    2136             #format chi2 
     2120        # Check if chi2 is finite 
     2121        if chisqr is not None and numpy.isfinite(chisqr): 
     2122            # format chi2 
    21372123            chi2 = format_number(chisqr, True) 
    21382124            self.tcChi.SetValue(chi2) 
     
    21412127            self.tcChi.SetValue("-") 
    21422128 
    2143         #Hide error title 
     2129        # Hide error title 
    21442130        if self.text2_3.IsShown() and not self.is_mac: 
    21452131            self.text2_3.Hide() 
     
    21482134            if self.enable_disp.GetValue(): 
    21492135                if hasattr(self, "text_disp_1"): 
    2150                     if self.text_disp_1 != None and not self.is_mac: 
     2136                    if self.text_disp_1 is not None and not self.is_mac: 
    21512137                        self.text_disp_1.Hide() 
    21522138        except: 
     
    21552141 
    21562142        i = 0 
    2157         #Set the panel when fit result are list 
     2143        # Set the panel when fit result are list 
    21582144 
    21592145        for item in self.param_toFit: 
    2160             if len(item) > 5 and item != None: 
     2146            if len(item) > 5 and item is not None: 
    21612147 
    21622148                if item[0].IsShown(): 
    2163                     ## reset error value to initial state 
     2149                    # reset error value to initial state 
    21642150                    if not self.is_mac: 
    21652151                        item[3].Hide() 
     
    21682154                        if item[1] == p_name[ind]: 
    21692155                            break 
    2170                     if len(out) > 0 and out[ind] != None: 
     2156                    if len(out) > 0 and out[ind] is not None: 
    21712157                        val_out = format_number(out[ind], True) 
    21722158                        item[2].SetValue(val_out) 
    21732159 
    2174                     if(cov != None and len(cov) == len(out)): 
     2160                    if(cov is not None and len(cov) == len(out)): 
    21752161                        try: 
    2176                             if dispersity != None: 
     2162                            if dispersity is not None: 
    21772163                                if self.enable_disp.GetValue(): 
    21782164                                    if hasattr(self, "text_disp_1"): 
    2179                                         if self.text_disp_1 != None: 
     2165                                        if self.text_disp_1 is not None: 
    21802166                                            if not self.text_disp_1.IsShown()\ 
    2181                                                 and not self.is_mac: 
     2167                                                  and not self.is_mac: 
    21822168                                                self.text_disp_1.Show(True) 
    21832169                        except: 
    21842170                            pass 
    21852171 
    2186                         if cov[ind] != None: 
     2172                        if cov[ind] is not None: 
    21872173                            if numpy.isfinite(float(cov[ind])): 
    21882174                                val_err = format_number(cov[ind], True) 
    2189                                 item[4].SetForegroundColour(wx.BLACK) 
     2175                                item[4].SetForegroundColour(wx.BLACK) 
    21902176                            else: 
    21912177                                val_err = 'NaN' 
     
    21992185            else: 
    22002186                raise ValueError, "onsetValues: Invalid parameters..." 
    2201         #Show error title when any errors displayed 
     2187        # Show error title when any errors displayed 
    22022188        if has_error: 
    22032189            if not self.text2_3.IsShown(): 
    22042190                self.text2_3.Show(True) 
    2205         ## save current state 
     2191        # save current state 
    22062192        self.save_current_state() 
    22072193 
     
    22102196            self.Refresh() 
    22112197        self._mac_sleep(0.1) 
    2212         #plot model ( when drawing, do not update chisqr value again) 
     2198        # plot model ( when drawing, do not update chisqr value again) 
    22132199        self._draw_model(update_chisqr=False, source='fit') 
    22142200 
     
    22262212        # compute weight for the current data 
    22272213        flag_weight = self.get_weight_flag() 
    2228         if is_2D == None: 
     2214        if is_2D is None: 
    22292215            is_2D = self._is_2D() 
    22302216        self._manager.set_fit_weight(uid=self.uid, 
     
    22452231        self._update_paramv_on_fit() 
    22462232 
    2247         if event != None: 
     2233        if event is not None: 
    22482234            tcrtl = event.GetEventObject() 
    22492235            # event case of radio button 
    2250             if tcrtl.GetValue() == True: 
     2236            if tcrtl.GetValue(): 
    22512237                self.dx_min = 0.0 
    22522238                self.dx_max = 0.0 
     
    22662252 
    22672253        self.sizer_set_smearer.Layout() 
    2268         ## we need FitInside here not just self.Layout to ensure all the sizers 
    2269         ## end up with the necessasary space to in the scroll panel. In 
    2270         ## particular the compute and fit buttons end up on top of each other 
    2271         ## PDB Nov 28 2015.  
     2254        # we need FitInside here not just self.Layout to ensure all the sizers 
     2255        # end up with the necessasary space to in the scroll panel. In 
     2256        # particular the compute and fit buttons end up on top of each other 
     2257        # PDB Nov 28 2015. 
    22722258        self.FitInside() 
    22732259 
    2274         if event != None: 
     2260        if event is not None: 
    22752261            event.Skip() 
    2276         #self._undo.Enable(True) 
     2262        # self._undo.Enable(True) 
    22772263        self.save_current_state() 
    22782264        event = PageInfoEvent(page=self) 
     
    23492335                get_pin_max.SetBackgroundColour("pink") 
    23502336                msg = "Model Error:This value can not be negative!!!" 
    2351             elif self.dx_min != None and self.dx_max != None: 
     2337            elif self.dx_min is not None and self.dx_max is not None: 
    23522338                if self._is_2D(): 
    23532339                    data.dqx_data[data.dqx_data == 0] = self.dx_min 
     
    23602346                                           self.dx_max + step / 1.1, 
    23612347                                           step) 
    2362             elif self.dx_min != None: 
     2348            elif self.dx_min is not None: 
    23632349                if self._is_2D(): 
    23642350                    data.dqx_data[data.dqx_data == 0] = self.dx_min 
    23652351                else: 
    23662352                    data.dx[data.dx == 0] = self.dx_min 
    2367             elif self.dx_max != None: 
     2353            elif self.dx_max is not None: 
    23682354                if self._is_2D(): 
    23692355                    data.dqy_data[data.dqy_data == 0] = self.dx_max 
     
    23732359            # 2D need to set accuracy 
    23742360            if self._is_2D(): 
    2375                 self.current_smearer.set_accuracy(accuracy=\ 
    2376                                                   self.smear2d_accuracy) 
    2377  
    2378         if msg != None: 
     2361                self.current_smearer.set_accuracy( 
     2362                    accuracy=self.smear2d_accuracy) 
     2363 
     2364        if msg is not None: 
    23792365            wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    23802366        else: 
    23812367            get_pin_min.SetBackgroundColour("white") 
    23822368            get_pin_max.SetBackgroundColour("white") 
    2383         ## set smearing value whether or not the data contain the smearing info 
     2369        # set smearing value whether or not the data contain the smearing info 
    23842370 
    23852371        enable_smearer = not self.disable_smearer.GetValue() 
     
    24072393        wx.CallAfter(self.save_current_state) 
    24082394 
    2409         if msg != None: 
     2395        if msg is not None: 
    24102396            return False 
    24112397        else: 
     
    24232409        msg = None 
    24242410        # for event given 
    2425         if event != None: 
     2411        if event is not None: 
    24262412            tcrtl = event.GetEventObject() 
    24272413            # event case of radio button 
     
    24442430        self._show_smear_sizer() 
    24452431        self.sizer_set_smearer.Layout() 
    2446         ## we need FitInside here not just self.Layout to ensure all the sizers 
    2447         ## end up with the necessasary space to in the scroll panel. In 
    2448         ## particular the compute and fit buttons end up on top of each other 
    2449         ## PDB Nov 28 2015.  
     2432        # we need FitInside here not just self.Layout to ensure all the sizers 
     2433        # end up with the necessasary space to in the scroll panel. In 
     2434        # particular the compute and fit buttons end up on top of each other 
     2435        # PDB Nov 28 2015. 
    24502436        self.FitInside() 
    24512437 
    2452         if event != None: 
     2438        if event is not None: 
    24532439            event.Skip() 
    24542440        self.save_current_state() 
    24552441        event = PageInfoEvent(page=self) 
    24562442        wx.PostEvent(self.parent, event) 
    2457         if msg != None: 
     2443        if msg is not None: 
    24582444            wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    24592445 
     
    25442530 
    25452531        self.current_smearer = smear_selection(data, self.model) 
    2546         ## set smearing value whether or not the data contain the smearing info 
     2532        # set smearing value whether or not the data contain the smearing info 
    25472533        enable_smearer = not self.disable_smearer.GetValue() 
    25482534        self._manager.set_smearer(smearer=self.current_smearer, 
     
    25672553        if self._is_changed_slit(): 
    25682554            msg = self._set_slit_smear() 
    2569         #self._undo.Enable(True) 
     2555        # self._undo.Enable(True) 
    25702556        self.save_current_state() 
    25712557 
    2572         if msg != None: 
     2558        if msg is not None: 
    25732559            return False 
    25742560        else: 
     
    25802566        are computed when fitting 
    25812567        """ 
    2582         if event != None: 
     2568        if event is not None: 
    25832569            event.Skip() 
    25842570        if self.data is None: 
     
    25932579 
    25942580        self.sizer_set_smearer.Layout() 
    2595         ## we need FitInside here not just self.Layout to ensure all the sizers 
    2596         ## end up with the necessasary space to in the scroll panel. In 
    2597         ## particular the compute and fit buttons end up on top of each other 
    2598         ## PDB Nov 28 2015.  
     2581        # we need FitInside here not just self.Layout to ensure all the sizers 
     2582        # end up with the necessasary space to in the scroll panel. In 
     2583        # particular the compute and fit buttons end up on top of each other 
     2584        # PDB Nov 28 2015. 
    25992585        self.FitInside() 
    26002586        self._set_weight() 
    26012587 
    2602         ## set smearing value whether or not the data contain the smearing info 
     2588        # set smearing value whether or not the data contain the smearing info 
    26032589        enable_smearer = not self.disable_smearer.GetValue() 
    26042590        wx.CallAfter(self._manager.set_smearer, uid=self.uid, 
     
    26212607        """ 
    26222608        self._get_smear_info() 
    2623         #renew smear sizer 
     2609        # renew smear sizer 
    26242610        if self.smear_type is not None: 
    26252611            self.smear_description_smear_type.SetValue(str(self.smear_type)) 
     
    26612647        """ 
    26622648        try: 
    2663             if event == None: 
     2649            if event is None: 
    26642650                output = "-" 
    26652651            elif not numpy.isfinite(event.output): 
     
    26962682        self._manager.set_param2fit(self.uid, param2fit) 
    26972683 
    2698     def select_all_param(self, event): 
    2699         """ 
    2700         set to true or false all checkBox given the main checkbox value cb1 
    2701         """ 
    2702         self.param_toFit = [] 
    2703         if  self.parameters != []: 
    2704             if  self.cb1.GetValue(): 
    2705                 for item in self.parameters: 
    2706                     if item[0].IsShown(): 
    2707                         ## for data2D select all to fit 
    2708                         if self.data.__class__.__name__ == "Data2D" or \ 
    2709                                 self.enable2D: 
    2710                             item[0].SetValue(True) 
    2711                             self.param_toFit.append(item) 
    2712                         else: 
    2713                             ## for 1D all parameters except orientation 
    2714                             if not item in self.orientation_params: 
    2715                                 item[0].SetValue(True) 
    2716                                 self.param_toFit.append(item) 
    2717                     else: 
    2718                         item[0].SetValue(False) 
    2719                 #if len(self.fittable_param)>0: 
    2720                 for item in self.fittable_param: 
    2721                     if item[0].IsShown(): 
    2722                         if self.data.__class__.__name__ == "Data2D" or \ 
    2723                                 self.enable2D: 
    2724                             item[0].SetValue(True) 
    2725                             self.param_toFit.append(item) 
    2726                             try: 
    2727                                 if len(self.values[item[1]]) > 0: 
    2728                                     item[0].SetValue(False) 
    2729                             except: 
    2730                                 pass 
    2731  
    2732                         else: 
    2733                             ## for 1D all parameters except orientation 
    2734                             if not item in self.orientation_params_disp: 
    2735                                 item[0].SetValue(True) 
    2736                                 self.param_toFit.append(item) 
    2737                                 try: 
    2738                                     if len(self.values[item[1]]) > 0: 
    2739                                         item[0].SetValue(False) 
    2740                                 except: 
    2741                                     pass 
    2742                     else: 
    2743                         item[0].SetValue(False) 
    2744  
    2745             else: 
    2746                 for item in self.parameters: 
    2747                     item[0].SetValue(False) 
    2748                 for item in self.fittable_param: 
    2749                     item[0].SetValue(False) 
    2750                 self.param_toFit = [] 
    2751  
    2752         self.save_current_state_fit() 
    2753  
    2754         if event != None: 
    2755             #self._undo.Enable(True) 
    2756             ## post state to fit panel 
    2757             event = PageInfoEvent(page=self) 
    2758             wx.PostEvent(self.parent, event) 
    2759         param2fit = [] 
    2760         for item in self.param_toFit: 
    2761             if item[0] and item[0].IsShown(): 
    2762                 param2fit.append(item[1]) 
    2763         self.parent._manager.set_param2fit(self.uid, param2fit) 
    2764  
    2765     def select_param(self, event): 
     2684    def select_param(self, event=None): 
    27662685        """ 
    27672686        Select TextCtrl  checked for fitting purpose and stores them 
     
    27702689        self.param_toFit = [] 
    27712690        for item in self.parameters: 
    2772             #Skip t ifhe angle parameters if 1D data 
     2691            # Skip t ifhe angle parameters if 1D data 
    27732692            if self.data.__class__.__name__ != "Data2D" and\ 
    27742693                        not self.enable2D: 
    27752694                if item in self.orientation_params: 
    27762695                    continue 
    2777             #Select parameters to fit for list of primary parameters 
     2696            # Select parameters to fit for list of primary parameters 
    27782697            if item[0].GetValue() and item[0].IsShown(): 
    27792698                if not (item in self.param_toFit): 
     
    27842703                    self.param_toFit.remove(item) 
    27852704 
    2786         #Select parameters to fit for list of fittable parameters 
     2705        # Select parameters to fit for list of fittable parameters 
    27872706        #        with dispersion 
    27882707        for item in self.fittable_param: 
    2789             #Skip t ifhe angle parameters if 1D data 
     2708            # Skip t ifhe angle parameters if 1D data 
    27902709            if self.data.__class__.__name__ != "Data2D" and\ 
    27912710                        not self.enable2D: 
     
    27962715                    self.param_toFit.append(item) 
    27972716            else: 
    2798                 #remove parameters from the fitting list 
     2717                # remove parameters from the fitting list 
    27992718                if item in self.param_toFit: 
    28002719                    self.param_toFit.remove(item) 
    28012720 
    2802         #Calculate num. of angle parameters 
     2721        # Calculate num. of angle parameters 
    28032722        if self.data.__class__.__name__ == "Data2D" or \ 
    28042723                       self.enable2D: 
     
    28062725        else: 
    28072726            len_orient_para = len(self.orientation_params)  # assume even len 
    2808         #Total num. of angle parameters 
     2727        # Total num. of angle parameters 
    28092728        if len(self.fittable_param) > 0: 
    28102729            len_orient_para *= 2 
    2811         #Set the value of checkbox that selected every checkbox or not 
    2812         if len(self.parameters) + len(self.fittable_param) - len_orient_para \ 
    2813             == len(self.param_toFit): 
    2814             self.cb1.SetValue(True) 
    2815         else: 
    2816             self.cb1.SetValue(False) 
    28172730 
    28182731        self.save_current_state_fit() 
    2819         if event != None: 
    2820             ## post state to fit panel 
     2732        if event is not None: 
     2733            # post state to fit panel 
    28212734            event = PageInfoEvent(page=self) 
    28222735            wx.PostEvent(self.parent, event) 
     
    28442757        self.orientation_params_disp = [] 
    28452758 
    2846         if model == None: 
     2759        if model is None: 
    28472760            self.sizer3.Layout() 
    28482761            self.SetupScrolling() 
     
    28522765        boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL) 
    28532766        sizer = wx.GridBagSizer(5, 5) 
    2854         ## save the current model 
     2767        # save the current model 
    28552768        self.model = model 
    28562769 
    28572770        keys = self.model.getParamList() 
    28582771 
    2859         #list of dispersion parameters 
     2772        # list of dispersion parameters 
    28602773        self.disp_list = self.model.getDispParamList() 
    28612774 
     
    28902803                return -1 
    28912804            # both have a number 
    2892             if num_a != None and num_b != None: 
     2805            if num_a is not None and num_b is not None: 
    28932806                if num_a > num_b: 
    28942807                    return -1 
     
    29032816                    return 1 
    29042817            # one of them has a number 
    2905             elif num_a != None: 
     2818            elif num_a is not None: 
    29062819                return 1 
    2907             elif num_b != None: 
     2820            elif num_b is not None: 
    29082821                return -1 
    29092822            # no numbers 
     
    29112824                return cmp(a.lower(), b.lower()) 
    29122825         
    2913         # keys obtained now from ordered dict, so commenting alphabetical ordering 
    2914         #keys.sort(custom_compare) 
     2826        # keys obtained now from ordered dict, so commenting alphabetical 
     2827        # ordering keys.sort(custom_compare) 
    29152828 
    29162829        iy = 0 
    29172830        ix = 0 
    2918         select_text = "Select All" 
    2919         self.cb1 = wx.CheckBox(self, wx.ID_ANY, str(select_text), (10, 10)) 
    2920         wx.EVT_CHECKBOX(self, self.cb1.GetId(), self.select_all_param) 
    2921         self.cb1.SetToolTipString("To check/uncheck all the boxes below.") 
    2922         self.cb1.SetValue(True) 
    2923  
    2924         sizer.Add(self.cb1, (iy, ix), (1, 1), \ 
    2925                              wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 5) 
     2831        sizer.Add(wx.StaticText(self, wx.ID_ANY, 'Parameter'), 
     2832                  (iy, ix), (1, 1), wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    29262833        ix += 1 
    29272834        self.text2_2 = wx.StaticText(self, wx.ID_ANY, 'Value') 
    2928         sizer.Add(self.text2_2, (iy, ix), (1, 1), \ 
     2835        sizer.Add(self.text2_2, (iy, ix), (1, 1), 
    29292836                            wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    29302837        ix += 2 
    29312838        self.text2_3 = wx.StaticText(self, wx.ID_ANY, 'Error') 
    2932         sizer.Add(self.text2_3, (iy, ix), (1, 1), \ 
    2933                             wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
     2839        sizer.Add(self.text2_3, (iy, ix), (1, 1), 
     2840                  wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    29342841        if not self.is_mac: 
    29352842            self.text2_3.Hide() 
    29362843        ix += 1 
    29372844        self.text2_min = wx.StaticText(self, wx.ID_ANY, 'Min') 
    2938         sizer.Add(self.text2_min, (iy, ix), (1, 1), \ 
    2939                             wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    2940         #self.text2_min.Hide() 
     2845        sizer.Add(self.text2_min, (iy, ix), (1, 1), 
     2846                  wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
     2847        # self.text2_min.Hide() 
    29412848        ix += 1 
    29422849        self.text2_max = wx.StaticText(self, wx.ID_ANY, 'Max') 
    2943         sizer.Add(self.text2_max, (iy, ix), (1, 1), \ 
    2944                             wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    2945         #self.text2_max.Hide() 
     2850        sizer.Add(self.text2_max, (iy, ix), (1, 1), 
     2851                  wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
     2852        # self.text2_max.Hide() 
    29462853        ix += 1 
    29472854        self.text2_4 = wx.StaticText(self, wx.ID_ANY, '[Units]') 
    2948         sizer.Add(self.text2_4, (iy, ix), (1, 1), \ 
    2949                             wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
     2855        sizer.Add(self.text2_4, (iy, ix), (1, 1), 
     2856                  wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    29502857        self.text2_4.Hide() 
    29512858 
    2952         CHECK_STATE = self.cb1.GetValue() 
     2859        CHECK_STATE = False 
    29532860        for item in keys: 
    29542861 
    2955             if not item in self.disp_list and not item in \ 
     2862            if item not in self.disp_list and not item in \ 
    29562863                    self.model.orientation_params: 
    29572864 
    2958                 ##prepare a spot to store errors 
    2959                 if not item in self.model.details: 
     2865                # prepare a spot to store errors 
     2866                if item not in self.model.details: 
    29602867                    self.model.details[item] = ["", None, None] 
    29612868 
    29622869                iy += 1 
    29632870                ix = 0 
    2964                 if (self.model.__class__ in \ 
    2965                     self.model_list_box["Multi-Functions"] or \ 
     2871                if (self.model.__class__ in 
     2872                    self.model_list_box["Multi-Functions"] or 
    29662873                    self.temp_multi_functional)\ 
    29672874                    and (item in self.model.non_fittable): 
    29682875                    non_fittable_name = wx.StaticText(self, wx.ID_ANY, item) 
    2969                     sizer.Add(non_fittable_name, (iy, ix), (1, 1), \ 
     2876                    sizer.Add(non_fittable_name, (iy, ix), (1, 1), 
    29702877                            wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 21) 
    2971                     ## add parameter value 
     2878                    # add parameter value 
    29722879                    ix += 1 
    29732880                    value = self.model.getParam(item) 
    29742881                    if len(self.model.fun_list) > 0: 
    2975                         #num = item.split('_')[1][5:7] 
     2882                        # num = item.split('_')[1][5:7] 
    29762883                        fun_box = wx.ComboBox(self, wx.ID_ANY, size=(100, -1), 
    29772884                                    style=wx.CB_READONLY, name='%s' % item) 
    29782885                        self._set_fun_box_list(fun_box) 
    29792886                        fun_box.SetSelection(0) 
    2980                         #self.fun_box.SetToolTipString("A function 
     2887                        # self.fun_box.SetToolTipString("A function 
    29812888                        #    describing the interface") 
    29822889                        wx.EVT_COMBOBOX(fun_box, wx.ID_ANY, self._on_fun_box) 
     
    29852892                                                size=(_BOX_WIDTH, 20), 
    29862893                                style=wx.TE_PROCESS_ENTER, name='%s' % item) 
    2987                         fun_box.SetToolTipString(\ 
     2894                        fun_box.SetToolTipString( 
    29882895                                "Hit 'Enter' after typing to update the plot.") 
    29892896                        fun_box.SetValue(format_number(value, True)) 
     
    29932900                                                None, None]) 
    29942901                else: 
    2995                     ## add parameters name with checkbox for selecting to fit 
     2902                    # add parameters name with checkbox for selecting to fit 
    29962903                    cb = wx.CheckBox(self, wx.ID_ANY, item) 
    29972904                    cb.SetValue(CHECK_STATE) 
    29982905                    cb.SetToolTipString(" Check mark to fit.") 
    2999                     #cb.SetValue(True) 
     2906                    # cb.SetValue(True) 
    30002907                    wx.EVT_CHECKBOX(self, cb.GetId(), self.select_param) 
    30012908 
     
    30032910                              wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 5) 
    30042911 
    3005                     ## add parameter value 
     2912                    # add parameter value 
    30062913                    ix += 1 
    30072914                    value = self.model.getParam(item) 
    30082915                    ctl1 = ModelTextCtrl(self, wx.ID_ANY, size=(_BOX_WIDTH, 20), 
    30092916                                         style=wx.TE_PROCESS_ENTER) 
    3010                     ctl1.SetToolTipString(\ 
     2917                    ctl1.SetToolTipString( 
    30112918                                "Hit 'Enter' after typing to update the plot.") 
    30122919                    ctl1.SetValue(format_number(value, True)) 
    30132920                    sizer.Add(ctl1, (iy, ix), (1, 1), wx.EXPAND) 
    3014                     ## text to show error sign 
     2921                    # text to show error sign 
    30152922                    ix += 1 
    30162923                    text2 = wx.StaticText(self, wx.ID_ANY, '+/-') 
    3017                     sizer.Add(text2, (iy, ix), (1, 1), \ 
     2924                    sizer.Add(text2, (iy, ix), (1, 1), 
    30182925                              wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    30192926                    if not self.is_mac: 
     
    30762983        iy += 1 
    30772984        ix = 0 
    3078         #Add tile for orientational angle 
     2985        # Add tile for orientational angle 
    30792986        for item in keys: 
    30802987            if item in self.model.orientation_params: 
     
    30832990                mag_on_button.SetToolTipString("Turn Pol Beam/Mag scatt on/off") 
    30842991                mag_on_button.Bind(wx.EVT_BUTTON, self._on_mag_on) 
    3085                 mag_angle_help_button = wx.Button(self, wx.ID_ANY, "Magnetic angles?") 
     2992                mag_angle_help_button = wx.Button(self, wx.ID_ANY, 
     2993                                                  "Magnetic angles?") 
    30862994                mag_angle_help_button.SetToolTipString("see angle definitions") 
    30872995                mag_help_button = wx.Button(self, wx.ID_ANY, "Mag HELP") 
    30882996                mag_help_button.SetToolTipString("Help on pol beam/mag fitting") 
    30892997                mag_help_button.Bind(wx.EVT_BUTTON, self._on_mag_help) 
    3090                 mag_angle_help_button.Bind(wx.EVT_BUTTON, \ 
     2998                mag_angle_help_button.Bind(wx.EVT_BUTTON, 
    30912999                                            self._on_mag_angle_help) 
    30923000                sizer.Add(orient_angle, (iy, ix), (1, 1), 
     
    31013009                          wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15) 
    31023010 
    3103                 #handle the magnetic buttons 
    3104                 #clean this up so that assume mag is off then turn  
    3105                 #all buttons on IF mag has mag and has 2D 
     3011                # handle the magnetic buttons 
     3012                # clean this up so that assume mag is off then turn 
     3013                # all buttons on IF mag has mag and has 2D 
    31063014                if not self._has_magnetic: 
    31073015                    mag_on_button.Show(False) 
     
    31293037                break 
    31303038 
    3131         #For Gaussian only 
     3039        # For Gaussian only 
    31323040        if type.lower() != "array": 
    31333041            for item in self.model.orientation_params: 
     
    31353043                    if item in self.model.magnetic_params: 
    31363044                        continue 
    3137                 if not item in self.disp_list: 
    3138                     ##prepare a spot to store min max 
    3139                     if not item in self.model.details: 
     3045                if item not in self.disp_list: 
     3046                    # prepare a spot to store min max 
     3047                    if item not in self.model.details: 
    31403048                        self.model.details[item] = ["", None, None] 
    31413049 
    31423050                    iy += 1 
    31433051                    ix = 0 
    3144                     ## add parameters name with checkbox for selecting to fit 
     3052                    # add parameters name with checkbox for selecting to fit 
    31453053                    cb = wx.CheckBox(self, wx.ID_ANY, item) 
    31463054                    cb.SetValue(CHECK_STATE) 
     
    31553063                              wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 5) 
    31563064 
    3157                     ## add parameter value 
     3065                    # add parameter value 
    31583066                    ix += 1 
    31593067                    value = self.model.getParam(item) 
    31603068                    ctl1 = ModelTextCtrl(self, -1, size=(_BOX_WIDTH, 20), 
    31613069                                         style=wx.TE_PROCESS_ENTER) 
    3162                     ctl1.SetToolTipString(\ 
     3070                    ctl1.SetToolTipString( 
    31633071                                "Hit 'Enter' after typing to update the plot.") 
    31643072                    ctl1.SetValue(format_number(value, True)) 
     
    31693077                        ctl1.Hide() 
    31703078                    sizer.Add(ctl1, (iy, ix), (1, 1), wx.EXPAND) 
    3171                     ## text to show error sign 
     3079                    # text to show error sign 
    31723080                    ix += 1 
    31733081                    text2 = wx.StaticText(self, -1, '+/-') 
    3174                     sizer.Add(text2, (iy, ix), (1, 1), \ 
     3082                    sizer.Add(text2, (iy, ix), (1, 1), 
    31753083                              wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    31763084 
     
    32373145        iy += 1 
    32383146        box_description.SetForegroundColour(wx.BLUE) 
    3239         #Display units text on panel 
     3147        # Display units text on panel 
    32403148        for item in keys: 
    32413149            if item in self.model.details: 
    32423150                self.text2_4.Show() 
    3243         #Fill the list of fittable parameters 
     3151        # Fill the list of fittable parameters 
    32443152        self.get_all_checked_params() 
    32453153        self.save_current_state_fit() 
     
    32533161        Get key stroke event 
    32543162        """ 
    3255         if self.data == None: 
     3163        if self.data is None: 
    32563164            return 
    32573165        # Figuring out key combo: Cmd for copy, Alt for paste 
Note: See TracChangeset for help on using the changeset viewer.