Changeset 4a7ad5f in sasview for sansview/perspectives/fitting


Ignore:
Timestamp:
Nov 23, 2010 4:12:46 PM (14 years ago)
Author:
Gervaise Alina <gervyh@…>
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.1.1, release-4.1.2, release-4.2.2, release_4.0.1, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
07c4599
Parents:
a54e4be
Message:

working on pylint

File:
1 edited

Legend:

Unmodified
Added
Removed
  • sansview/perspectives/fitting/basepage.py

    rda9ac4e6 r4a7ad5f  
    3838    window_caption = "Basic page " 
    3939     
    40     def __init__(self,parent, page_info): 
    41         """ 
    42         """ 
    43         wx.ScrolledWindow.__init__(self, parent,style=wx.FULL_REPAINT_ON_RESIZE) 
     40    def __init__(self, parent, page_info): 
     41        """ 
     42        """ 
     43        wx.ScrolledWindow.__init__(self, parent,  
     44                                   style=wx.FULL_REPAINT_ON_RESIZE) 
    4445        #Set window's font size  
    4546        self.SetWindowVariant(variant=FONT_VARIANT) 
     
    4849        self.parent = parent 
    4950        ## manager is the fitting plugin 
    50         self.manager= None 
     51        self.manager = None 
    5152        ## owner of the page (fitting plugin) 
    52         self.event_owner= None 
     53        self.event_owner = None 
    5354         ## current model 
    5455        self.model = None 
     
    9394        ## each item related to a given parameters 
    9495        ##[cb state, name, value, "+/-", error of fit, min, max , units] 
    95         self.parameters=[] 
     96        self.parameters = [] 
    9697        # non-fittable parameter whose value is astring 
    9798        self.str_parameters = [] 
    9899        ## list of parameters to fit , must be like self.parameters 
    99         self.param_toFit=[] 
     100        self.param_toFit = [] 
    100101        ## list of looking like parameters but with non fittable parameters info 
    101         self.fixed_param=[] 
     102        self.fixed_param = [] 
    102103        ## list of looking like parameters but with  fittable parameters info 
    103         self.fittable_param=[] 
     104        self.fittable_param = [] 
    104105        ##list of dispersion parameters 
    105         self.disp_list=[] 
    106         self.disp_name="" 
     106        self.disp_list = [] 
     107        self.disp_name = "" 
    107108         
    108109        ## list of orientation parameters 
    109         self.orientation_params=[] 
    110         self.orientation_params_disp=[] 
    111         if self.model !=None: 
    112             self.disp_list= self.model.getDispParamList() 
     110        self.orientation_params = [] 
     111        self.orientation_params_disp = [] 
     112        if self.model != None: 
     113            self.disp_list = self.model.getDispParamList() 
    113114         
    114115        ##enable model 2D draw 
    115         self.enable2D= False 
     116        self.enable2D = False 
    116117        ## check that the fit range is correct to plot the model again 
    117         self.fitrange= True 
     118        self.fitrange = True 
    118119        ## Create memento to save the current state 
    119         self.state= PageState(parent= self.parent,model=self.model, data=self.data) 
     120        self.state = PageState(parent=self.parent, 
     121                               model=self.model, data=self.data) 
    120122        ## flag to determine if state has change 
    121         self.state_change= False 
     123        self.state_change = False 
    122124        ## save customized array 
    123         self.values=[] 
    124         self.weights=[] 
     125        self.values = [] 
     126        self.weights = [] 
    125127        ## retrieve saved state 
    126         self.number_saved_state= 0 
     128        self.number_saved_state = 0 
    127129        ## dictionary of saved state 
    128         self.saved_states={}  
    129          
     130        self.saved_states = {}  
    130131        ## Create context menu for page 
    131132        self.popUpMenu = wx.Menu() 
    132133        #id = wx.NewId() 
    133         #self._undo = wx.MenuItem(self.popUpMenu,id, "Undo","cancel the previous action") 
     134        #self._undo = wx.MenuItem(self.popUpMenu,id, "Undo", 
     135        #"cancel the previous action") 
    134136        #self.popUpMenu.AppendItem(self._undo) 
    135137        #self._undo.Enable(False) 
     
    137139         
    138140        #id = wx.NewId() 
    139         #self._redo = wx.MenuItem(self.popUpMenu,id,"Redo"," Restore the previous action") 
     141        #self._redo = wx.MenuItem(self.popUpMenu,id,"Redo", 
     142        #" Restore the previous action") 
    140143        #self.popUpMenu.AppendItem(self._redo) 
    141144        #self._redo.Enable(False) 
     
    144147        #if sys.platform.count("win32")>0:         
    145148        id = wx.NewId() 
    146         self._keep = wx.MenuItem(self.popUpMenu,id,"BookMark"," Keep the panel status to recall it later") 
     149        self._keep = wx.MenuItem(self.popUpMenu,id,"BookMark", 
     150                                 " Keep the panel status to recall it later") 
    147151        self.popUpMenu.AppendItem(self._keep) 
    148152        self._keep.Enable(True) 
     
    181185        _on_set_focus_callback = None 
    182186         
    183         def __init__(self, parent, id=-1, value=wx.EmptyString, pos=wx.DefaultPosition,  
    184                      size=wx.DefaultSize, style=0, validator=wx.DefaultValidator, name=wx.TextCtrlNameStr, 
    185                      kill_focus_callback = None, set_focus_callback  = None, 
    186                      mouse_up_callback   = None, text_enter_callback = None): 
     187        def __init__(self, parent, id=-1,  
     188                     value=wx.EmptyString,  
     189                     pos=wx.DefaultPosition,  
     190                     size=wx.DefaultSize, 
     191                     style=0,  
     192                     validator=wx.DefaultValidator, 
     193                     name=wx.TextCtrlNameStr, 
     194                     kill_focus_callback=None, 
     195                     set_focus_callback=None, 
     196                     mouse_up_callback=None, 
     197                     text_enter_callback = None): 
    187198              
    188             wx.TextCtrl.__init__(self, parent, id, value, pos, size, style, validator, name) 
     199            wx.TextCtrl.__init__(self, parent, id, value, pos, 
     200                                  size, style, validator, name) 
    189201             
    190202            # Bind appropriate events 
     
    382394        if self.model_list_box is None: 
    383395            return 
    384         if len(self.model_list_box)>0: 
    385             self._populate_box( self.formfactorbox,self.model_list_box["Shapes"]) 
     396        if len(self.model_list_box) > 0: 
     397            self._populate_box(self.formfactorbox, 
     398                               self.model_list_box["Shapes"]) 
    386399        
    387         if len(self.model_list_box)>0: 
    388             self._populate_box( self.structurebox, 
     400        if len(self.model_list_box) > 0: 
     401            self._populate_box(self.structurebox, 
    389402                                self.model_list_box["Structure Factors"]) 
    390             self.structurebox.Insert("None", 0,None) 
     403            self.structurebox.Insert("None", 0, None) 
    391404            self.structurebox.SetSelection(0) 
    392405            self.structurebox.Hide() 
     
    410423        boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL) 
    411424        #---------------------------------------------------- 
    412         self.disable_disp = wx.RadioButton(self, -1, 'Off', (10, 10), style=wx.RB_GROUP) 
     425        self.disable_disp = wx.RadioButton(self, -1, 'Off', (10, 10), 
     426                                            style=wx.RB_GROUP) 
    413427        self.enable_disp = wx.RadioButton(self, -1, 'On', (10, 30)) 
    414428        
    415429         
    416         self.Bind(wx.EVT_RADIOBUTTON, self._set_dipers_Param, id=self.disable_disp.GetId()) 
    417         self.Bind(wx.EVT_RADIOBUTTON, self._set_dipers_Param, id=self.enable_disp.GetId()) 
     430        self.Bind(wx.EVT_RADIOBUTTON, self._set_dipers_Param, 
     431                     id=self.disable_disp.GetId()) 
     432        self.Bind(wx.EVT_RADIOBUTTON, self._set_dipers_Param, 
     433                   id=self.enable_disp.GetId()) 
    418434        #MAC needs SetValue 
    419435        self.disable_disp.SetValue(True) 
     
    481497                ## Redraw the model ??? 
    482498                self._draw_model() 
    483         # Go through the list of dispersion check boxes to identify which one has changed  
     499        # Go through the list of dispersion check boxes to identify 
     500        # which one has changed  
    484501        for p in self.disp_cb_dict: 
    485502            self.state.disp_cb_dict[p]=  self.disp_cb_dict[p].GetValue() 
     
    488505                if self.disp_cb_dict[p].GetValue() == True: 
    489506                     
    490                     ##Temp. FIX for V1.0 regarding changing checkbox to radiobutton. 
    491                     ##This (self._reset_dispersity) should be removed when the array dispersion is fixed.                 
     507                    ##Temp. FIX for V1.0 regarding changing checkbox  
     508                    #to radiobutton. 
     509                    ##This (self._reset_dispersity) should be removed  
     510                    #when the array dispersion is fixed.                 
    492511                    self._reset_dispersity() 
    493512 
     
    509528                    except: 
    510529                        msg="Could not read input file" 
    511                         wx.PostEvent(self.parent.parent, StatusEvent(status= msg)) 
     530                        wx.PostEvent(self.parent.parent,  
     531                                     StatusEvent(status=msg)) 
    512532                        return 
    513533                     
     
    516536                    if self.values is None or self.weights is None or \ 
    517537                         self.values ==[] or self.weights ==[]: 
    518                         wx.PostEvent(self.parent.parent, StatusEvent(status=\ 
    519                             "The loaded %s distrubtion is corrupted or empty" % p)) 
     538                        msg = "The loaded %s distrubtion is" 
     539                        msg + " corrupted or empty" % p 
     540                        wx.PostEvent(self.parent.parent,  
     541                                     StatusEvent(status=msg)) 
    520542                        return 
    521543                         
    522544                    # Tell the user that we are about to apply the distribution 
    523                     wx.PostEvent(self.parent.parent, StatusEvent(status=\ 
    524                             "Applying loaded %s distribution: %s" % (p, path)))   
     545                    msg = "Applying loaded %s distribution: %s" % (p, path) 
     546                    wx.PostEvent(self.parent.parent, StatusEvent(status=msg))   
    525547                     
    526548                    # Create the dispersion objects 
     
    529551                    disp_model.set_weights(self.values, self.weights) 
    530552                    
    531                     # Store the object to make it persist outside the scope of this method 
     553                    # Store the object to make it persist outside the 
     554                    # scope of this method 
    532555                    #TODO: refactor model to clean this up? 
    533556                    self._disp_obj_dict[p] = disp_model 
    534557                    self.state._disp_obj_dict [p]= disp_model 
    535                     self.state.values=[] 
    536                     self.state.weights=[] 
     558                    self.state.values = [] 
     559                    self.state.weights = [] 
    537560                    self.state.values = copy.deepcopy(self.values) 
    538561                    self.state.weights = copy.deepcopy(self.weights) 
    539                     # Set the new model as the dispersion object for the selected parameter 
     562                    # Set the new model as the dispersion object for the  
     563                    #selected parameter 
    540564                    self.model.set_dispersion(p, disp_model) 
    541                     # Store a reference to the weights in the model object so that 
     565                    # Store a reference to the weights in the model object  
     566                    #so that 
    542567                    # it's not lost when we use the model within another thread. 
    543568                    #TODO: total hack - fix this 
     
    545570 
    546571                    self.model._persistency_dict = {} 
    547                     self.model._persistency_dict[p] = [self.values, self.weights] 
    548                     self.state.model._persistency_dict[p] = [self.values, self.weights] 
     572                    self.model._persistency_dict[p] = \ 
     573                                                    [self.values, self.weights] 
     574                    self.state.model._persistency_dict[p] = \ 
     575                                                    [self.values,self.weights] 
    549576                else: 
    550577                    self._reset_dispersity() 
     
    760787        self.state.smearer = copy.deepcopy(self.smearer) 
    761788        if hasattr(self,"enable_smearer"): 
    762             self.state.enable_smearer = copy.deepcopy(self.enable_smearer.GetValue()) 
    763             self.state.disable_smearer = copy.deepcopy(self.disable_smearer.GetValue()) 
    764  
    765         self.state.pinhole_smearer = copy.deepcopy(self.pinhole_smearer.GetValue()) 
     789            self.state.enable_smearer = \ 
     790                                copy.deepcopy(self.enable_smearer.GetValue()) 
     791            self.state.disable_smearer = \ 
     792                                copy.deepcopy(self.disable_smearer.GetValue()) 
     793 
     794        self.state.pinhole_smearer = \ 
     795                                copy.deepcopy(self.pinhole_smearer.GetValue()) 
    766796        self.state.slit_smearer = copy.deepcopy(self.slit_smearer.GetValue())   
    767797                   
     
    805835         
    806836        self._copy_parameters_state(self.parameters, self.state.parameters) 
    807         self._copy_parameters_state(self.fittable_param, self.state.fittable_param) 
     837        self._copy_parameters_state(self.fittable_param, 
     838                                     self.state.fittable_param) 
    808839        self._copy_parameters_state(self.fixed_param, self.state.fixed_param) 
    809840        #save chisqr 
     
    845876        self.state.smearer = copy.deepcopy(self.smearer) 
    846877        if hasattr(self,"enable_smearer"): 
    847             self.state.enable_smearer = copy.deepcopy(self.enable_smearer.GetValue()) 
    848             self.state.disable_smearer = copy.deepcopy(self.disable_smearer.GetValue()) 
    849              
    850         self.state.pinhole_smearer = copy.deepcopy(self.pinhole_smearer.GetValue()) 
     878            self.state.enable_smearer = \ 
     879                                copy.deepcopy(self.enable_smearer.GetValue()) 
     880            self.state.disable_smearer = \ 
     881                                copy.deepcopy(self.disable_smearer.GetValue()) 
     882             
     883        self.state.pinhole_smearer = \ 
     884                                copy.deepcopy(self.pinhole_smearer.GetValue()) 
    851885        self.state.slit_smearer = copy.deepcopy(self.slit_smearer.GetValue())   
    852886             
     
    854888            self.state.disp_box = self.disp_box.GetCurrentSelection() 
    855889 
    856             if len(self.disp_cb_dict)>0: 
    857                 for k , v in self.disp_cb_dict.iteritems(): 
     890            if len(self.disp_cb_dict) > 0: 
     891                for k, v in self.disp_cb_dict.iteritems(): 
    858892          
    859                     if v ==None : 
    860                         self.state.disp_cb_dict[k]= v 
     893                    if v == None : 
     894                        self.state.disp_cb_dict[k] = v 
    861895                    else: 
    862896                        try: 
    863                             self.state.disp_cb_dict[k]=v.GetValue() 
     897                            self.state.disp_cb_dict[k] = v.GetValue() 
    864898                        except: 
    865                             self.state.disp_cb_dict[k]= None 
     899                            self.state.disp_cb_dict[k] = None 
    866900            
    867             if len(self._disp_obj_dict)>0: 
     901            if len(self._disp_obj_dict) > 0: 
    868902                for k , v in self._disp_obj_dict.iteritems(): 
    869903       
    870                     self.state._disp_obj_dict[k]= v 
     904                    self.state._disp_obj_dict[k] = v 
    871905                         
    872906             
     
    883917                                     self.state.orientation_params_disp) 
    884918        self._copy_parameters_state(self.parameters, self.state.parameters) 
    885         self._copy_parameters_state(self.fittable_param, self.state.fittable_param) 
     919        self._copy_parameters_state(self.fittable_param, 
     920                                             self.state.fittable_param) 
    886921        self._copy_parameters_state(self.fixed_param, self.state.fixed_param) 
    887922     
     
    909944            state of the graphic interface 
    910945        """ 
    911         if state ==None: 
     946        if state == None: 
    912947            #self._undo.Enable(False) 
    913948            return  
     
    961996            n= self.disp_box.GetCurrentSelection() 
    962997            dispersity= self.disp_box.GetClientData(n) 
    963             name= dispersity.__name__      
     998            name = dispersity.__name__      
    964999 
    9651000            self._set_dipers_Param(event=None) 
    9661001        
    967             if name=="ArrayDispersion": 
     1002            if name == "ArrayDispersion": 
    9681003                 
    9691004                for item in self.disp_cb_dict.keys(): 
    9701005                     
    971                     if hasattr(self.disp_cb_dict[item],"SetValue") : 
    972                         self.disp_cb_dict[item].SetValue(state.disp_cb_dict[item]) 
     1006                    if hasattr(self.disp_cb_dict[item], "SetValue") : 
     1007                        self.disp_cb_dict[item].SetValue(\ 
     1008                                                    state.disp_cb_dict[item]) 
    9731009                        # Create the dispersion objects 
    9741010                        from sans.models.dispersion_models import ArrayDispersion 
    9751011                        disp_model = ArrayDispersion() 
    976                         if hasattr(state,"values")and self.disp_cb_dict[item].GetValue()==True: 
     1012                        if hasattr(state,"values")and\ 
     1013                                 self.disp_cb_dict[item].GetValue() == True: 
    9771014                            if len(state.values)>0: 
    9781015                                self.values=state.values 
    9791016                                self.weights=state.weights 
    980                                 disp_model.set_weights(self.values, state.weights) 
     1017                                disp_model.set_weights(self.values, 
     1018                                                        state.weights) 
    9811019                            else: 
    9821020                                self._reset_dispersity() 
    9831021                         
    9841022                        self._disp_obj_dict[item] = disp_model 
    985                         # Set the new model as the dispersion object for the selected parameter 
     1023                        # Set the new model as the dispersion object  
     1024                        #for the selected parameter 
    9861025                        self.model.set_dispersion(item, disp_model) 
    9871026                     
    988                         self.model._persistency_dict[item] = [state.values, state.weights] 
     1027                        self.model._persistency_dict[item] = \ 
     1028                                                [state.values, state.weights] 
    9891029                     
    9901030            else: 
    9911031                keys = self.model.getParamList() 
    9921032                for item in keys: 
    993                     if item in self.disp_list and not self.model.details.has_key(item): 
    994                         self.model.details[item]=["",None,None] 
     1033                    if item in self.disp_list and \ 
     1034                        not self.model.details.has_key(item): 
     1035                        self.model.details[item] = ["", None, None] 
    9951036                for k,v in self.state.disp_cb_dict.iteritems(): 
    9961037                    self.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)  
     
    10011042        ## smearing info  restore 
    10021043        if hasattr(self, "enable_smearer"): 
    1003             ## set smearing value whether or not the data contain the smearing info 
     1044            ## set smearing value whether or not the data  
     1045            #contain the smearing info 
    10041046            self.enable_smearer.SetValue(state.enable_smearer) 
    10051047            self.disable_smearer.SetValue(state.disable_smearer) 
     
    11031145                        from sans.models.dispersion_models import ArrayDispersion 
    11041146                        disp_model = ArrayDispersion() 
    1105                         if hasattr(state,"values")and self.disp_cb_dict[item].GetValue()==True: 
    1106                             if len(state.values)>0: 
    1107                                 self.values=state.values 
    1108                                 self.weights=state.weights 
    1109                                 disp_model.set_weights(self.values, state.weights) 
     1147                        if hasattr(state,"values") and\ 
     1148                             self.disp_cb_dict[item].GetValue()==True: 
     1149                            if len(state.values) > 0: 
     1150                                self.values = state.values 
     1151                                self.weights = state.weights 
     1152                                disp_model.set_weights(self.values, 
     1153                                                        state.weights) 
    11101154                            else: 
    11111155                                self._reset_dispersity() 
    11121156                         
    11131157                        self._disp_obj_dict[item] = disp_model 
    1114                         # Set the new model as the dispersion object for the selected parameter 
     1158                        # Set the new model as the dispersion 
     1159                        #object for the selected parameter 
    11151160                        self.model.set_dispersion(item, disp_model) 
    11161161                     
    1117                         self.model._persistency_dict[item] = [state.values, state.weights] 
     1162                        self.model._persistency_dict[item] = [state.values, 
     1163                                                               state.weights] 
    11181164                     
    11191165            else: 
    11201166                keys = self.model.getParamList() 
    11211167                for item in keys: 
    1122                     if item in self.disp_list and not self.model.details.has_key(item): 
     1168                    if item in self.disp_list and \ 
     1169                            not self.model.details.has_key(item): 
    11231170                        self.model.details[item]=["",None,None] 
    11241171                for k,v in self.state.disp_cb_dict.iteritems(): 
     
    11311178        ## smearing info  restore 
    11321179        if hasattr(self,"enable_smearer"): 
    1133             ## set smearing value whether or not the data contain the smearing info 
     1180            ## set smearing value whether or not the data  
     1181            #contain the smearing info 
    11341182            self.enable_smearer.SetValue(state.enable_smearer) 
    11351183            self.disable_smearer.SetValue(state.disable_smearer) 
     
    11611209        import os 
    11621210        dlg = wx.FileDialog(self, "Choose a weight file", 
    1163                                 self._default_save_location , "", "*.*", wx.OPEN) 
     1211                                self._default_save_location , "",  
     1212                                "*.*", wx.OPEN) 
    11641213        path = None 
    11651214        if dlg.ShowModal() == wx.ID_OK: 
     
    11761225            ## Add item in the context menu 
    11771226            id = wx.NewId() 
    1178             self.popUpMenu.Append(id,name, 'Save model and state %g'%self.number_saved_state) 
     1227            msg = 'Save model and state %g' % self.number_saved_state 
     1228            self.popUpMenu.Append(id, name, msg) 
    11791229            wx.EVT_MENU(self, id, self.onResetModel) 
    11801230     
     
    12101260        self.state.qmin = self.qmin_x 
    12111261        self.state.qmax = self.qmax_x  
    1212         if self.npts!=None: 
    1213             self.state.npts= self.num_points 
    1214              
     1262        if self.npts != None: 
     1263            self.state.npts = self.num_points 
    12151264             
    12161265    def _onparamEnter_helper(self): 
     
    12211270        # Flag to register when a parameter has changed.    
    12221271        is_modified = False 
    1223         self.fitrange =True 
     1272        self.fitrange = True 
    12241273        is_2Ddata = False 
    12251274        #self._undo.Enable(True) 
    12261275        # check if 2d data 
    1227         if self.data.__class__.__name__ =="Data2D": 
     1276        if self.data.__class__.__name__ == "Data2D": 
    12281277            is_2Ddata = True 
    12291278        if self.model !=None: 
    12301279            try: 
    1231                 is_modified =self._check_value_enter( self.fittable_param ,is_modified) 
    1232                 is_modified =self._check_value_enter( self.fixed_param ,is_modified) 
    1233                 is_modified =self._check_value_enter( self.parameters ,is_modified)  
     1280                is_modified = self._check_value_enter(self.fittable_param, 
     1281                                                     is_modified) 
     1282                is_modified = self._check_value_enter(self.fixed_param, 
     1283                                                      is_modified) 
     1284                is_modified = self._check_value_enter(self.parameters, 
     1285                                                      is_modified)  
    12341286            except: 
    12351287                pass 
     
    13121364                        flag = self.update_pinhole_smear() 
    13131365                    else: 
    1314                         self.manager.set_smearer_nodraw(smearer=temp_smearer, qmin= float(self.qmin_x), 
     1366                        self.manager.set_smearer_nodraw(smearer=temp_smearer, 
     1367                                                     qmin=float(self.qmin_x), 
     1368                                                      qmax=float(self.qmax_x)) 
     1369                elif not self._is_2D(): 
     1370                    self.manager.set_smearer(smearer=temp_smearer, 
     1371                                              qmin=float(self.qmin_x), 
    13151372                                                 qmax= float(self.qmax_x)) 
    1316                 elif not self._is_2D(): 
    1317                     self.manager.set_smearer(smearer=temp_smearer, qmin= float(self.qmin_x), 
    1318                                                  qmax= float(self.qmax_x)) 
    1319                     index_data = ((self.qmin_x <= self.data.x)&(self.data.x <= self.qmax_x)) 
    1320                     self.Npts_fit.SetValue(str(len(self.data.x[index_data==True]))) 
     1373                    index_data = ((self.qmin_x <= self.data.x)&\ 
     1374                                  (self.data.x <= self.qmax_x)) 
     1375                    val = str(len(self.data.x[index_data==True])) 
     1376                    self.Npts_fit.SetValue(val) 
    13211377                    flag = True 
    13221378                if self._is_2D(): 
     
    13381394 
    13391395        if not flag: 
    1340             msg= "Cannot Plot or Fit :Must select a model or Fitting range is not valid!!!  " 
    1341             wx.PostEvent(self.parent.parent, StatusEvent(status = msg )) 
     1396            msg = "Cannot Plot or Fit :Must select a " 
     1397            msg += " model or Fitting range is not valid!!!  " 
     1398            wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
    13421399         
    13431400        self.save_current_state() 
     
    13511408        return is_modified 
    13521409                        
    1353     def _reset_parameters_state(self, listtorestore,statelist): 
     1410    def _reset_parameters_state(self, listtorestore, statelist): 
    13541411        """ 
    13551412        Reset the parameters at the given state 
    13561413        """ 
    1357         if len(statelist)==0 or  len(listtorestore)==0 : 
     1414        if len(statelist) == 0 or len(listtorestore) == 0: 
    13581415            return 
    1359         if len(statelist)!=  len(listtorestore) : 
     1416        if len(statelist) !=  len(listtorestore): 
    13601417            return 
    13611418 
     
    14421499                
    14431500            statelist.append([checkbox_state, parameter_name, parameter_value, 
    1444                               static_text ,[error_state,error_value], 
    1445                                 [min_state,min_value],[max_state , max_value],unit]) 
     1501                              static_text ,[error_state, error_value], 
     1502                                [min_state, min_value], 
     1503                                [max_state, max_value], unit]) 
    14461504            
    14471505    def _set_model_sizer_selection(self, model): 
     
    14531511        if hasattr(model ,"s_model"): 
    14541512             
    1455             class_name= model.s_model.__class__ 
    1456             name= model.s_model.name 
    1457             flag= name != "NoStructure" 
    1458             if flag and (class_name in self.model_list_box["Structure Factors"]): 
     1513            class_name = model.s_model.__class__ 
     1514            name = model.s_model.name 
     1515            flag = (name != "NoStructure") 
     1516            if flag and \ 
     1517                (class_name in self.model_list_box["Structure Factors"]): 
    14591518                self.structurebox.Show() 
    14601519                self.text2.Show()                 
     
    14631522                items = self.structurebox.GetItems() 
    14641523                self.sizer1.Layout() 
    1465                 self.SetScrollbars(20,20,25,65) 
     1524                self.SetScrollbars(20, 20, 25 ,65) 
    14661525                for i in range(len(items)): 
    14671526                    if items[i]== str(name): 
Note: See TracChangeset for help on using the changeset viewer.