Changeset ef26c83 in sasview for fittingview/src/sans/perspectives


Ignore:
Timestamp:
Apr 30, 2012 10:48:29 AM (13 years ago)
Author:
Mathieu Doucet <doucetm@…>
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:
8df5faa
Parents:
ac2b835
Message:

Pep-8-ification

File:
1 edited

Legend:

Unmodified
Added
Removed
  • fittingview/src/sans/perspectives/fitting/basepage.py

    rf992a06 ref26c83  
    55import numpy 
    66import time 
    7 import copy  
     7import copy 
    88import math 
    99import string 
    1010from wx.lib.scrolledpanel import ScrolledPanel 
    1111from sans.guiframe.panel_base import PanelBase 
    12 from sans.guiframe.utils import format_number,check_float 
     12from sans.guiframe.utils import format_number, check_float 
    1313from sans.guiframe.events import PanelOnFocusEvent 
    1414from sans.guiframe.events import StatusEvent 
     
    2222from pagestate import PageState 
    2323 
    24 (PageInfoEvent, EVT_PAGE_INFO)   = wx.lib.newevent.NewEvent() 
    25 (PreviousStateEvent, EVT_PREVIOUS_STATE)   = wx.lib.newevent.NewEvent() 
    26 (NextStateEvent, EVT_NEXT_STATE)   = wx.lib.newevent.NewEvent() 
     24(PageInfoEvent, EVT_PAGE_INFO) = wx.lib.newevent.NewEvent() 
     25(PreviousStateEvent, EVT_PREVIOUS_STATE) = wx.lib.newevent.NewEvent() 
     26(NextStateEvent, EVT_NEXT_STATE) = wx.lib.newevent.NewEvent() 
    2727 
    2828_BOX_WIDTH = 76 
     
    3030_QMAX_DEFAULT = 0.5 
    3131_NPTS_DEFAULT = 50 
    32 #Control panel width  
    33 if sys.platform.count("win32")> 0: 
     32#Control panel width 
     33if sys.platform.count("win32") > 0: 
    3434    PANEL_WIDTH = 450 
    3535    FONT_VARIANT = 0 
     
    4141 
    4242 
    43  
    4443class BasicPage(ScrolledPanel, PanelBase): 
    4544    """ 
    4645    This class provide general structure of  fitpanel page 
    4746    """ 
    48      ## Internal name for the AUI manager 
     47    ## Internal name for the AUI manager 
    4948    window_name = "Fit Page" 
    5049    ## Title to appear on top of the window 
    5150    window_caption = "Fit Page " 
    5251     
    53     def __init__(self, parent,color='blue', **kwargs): 
     52    def __init__(self, parent, color='blue', **kwargs): 
    5453        """ 
    5554        """ 
     
    5756        PanelBase.__init__(self, parent) 
    5857        self.SetupScrolling() 
    59         #Set window's font size  
     58        #Set window's font size 
    6059        self.SetWindowVariant(variant=FONT_VARIANT) 
    6160       
     
    6665        ## owner of the page (fitting plugin) 
    6766        self.event_owner = None 
    68          ## current model 
     67        ## current model 
    6968        self.model = None 
    7069        self.index_model = None 
     
    9493        ## 2D smear accuracy default 
    9594        self.smear2d_accuracy = 'Low' 
    96         ## slit smear:  
     95        ## slit smear: 
    9796        self.dxl = None 
    9897        self.dxw = None 
    99         ## pinhole smear  
     98        ## pinhole smear 
    10099        self.dx_min = None 
    101100        self.dx_max = None 
     
    110109        self._disp_obj_dict = {} 
    111110        ## selected parameters to apply dispersion 
    112         self.disp_cb_dict ={} 
     111        self.disp_cb_dict = {} 
    113112        ## smearer object 
    114113        self.enable2D = False 
     
    152151        self.number_saved_state = 0 
    153152        ## dictionary of saved state 
    154         self.saved_states = {}  
     153        self.saved_states = {} 
    155154        ## Create context menu for page 
    156155        self.popUpMenu = wx.Menu() 
    157156     
    158157        id = wx.NewId() 
    159         self._keep = wx.MenuItem(self.popUpMenu,id,"Add bookmark", 
     158        self._keep = wx.MenuItem(self.popUpMenu, id, "Add bookmark", 
    160159                                 " Keep the panel status to recall it later") 
    161160        self.popUpMenu.AppendItem(self._keep) 
     
    167166     
    168167        ## Default locations 
    169         self._default_save_location = os.getcwd()      
     168        self._default_save_location = os.getcwd() 
    170169        ## save initial state on context menu 
    171170        #self.onSave(event=None) 
     
    177176        ## create the basic structure of the panel with empty sizer 
    178177        self.define_page_structure() 
    179         ## drawing Initial dispersion parameters sizer  
     178        ## drawing Initial dispersion parameters sizer 
    180179        self.set_dispers_sizer() 
    181180         
     
    191190    def create_default_data(self): 
    192191        """ 
    193         Given the user selection, creates a 1D or 2D data  
     192        Given the user selection, creates a 1D or 2D data 
    194193        Only when the page is on theory mode. 
    195194        """ 
     
    206205                    self._manager.page_finder[self.uid].set_fit_data(data=[self.data]) 
    207206            self.on_smear_helper(update=True) 
    208             self.state.enable_smearer= self.enable_smearer.GetValue() 
    209             self.state.disable_smearer=self.disable_smearer.GetValue() 
     207            self.state.enable_smearer = self.enable_smearer.GetValue() 
     208            self.state.disable_smearer = self.disable_smearer.GetValue() 
    210209            self.state.pinhole_smearer = self.pinhole_smearer.GetValue() 
    211210            self.state.slit_smearer = self.slit_smearer.GetValue() 
     
    213212    def _create_default_1d_data(self): 
    214213        """ 
    215         Create default data for fitting perspective  
     214        Create default data for fitting perspective 
    216215        Only when the page is on theory mode. 
    217216        :warning: This data is never plotted. 
    218217         
    219218        """ 
    220         x = numpy.linspace(start=self.qmin_x, stop=self.qmax_x,  
     219        x = numpy.linspace(start=self.qmin_x, stop=self.qmax_x, 
    221220                           num=self.npts_x, endpoint=True) 
    222221        self.data = Data1D(x=x) 
    223         self.data.xaxis('\\rm{Q}',"A^{-1}") 
     222        self.data.xaxis('\\rm{Q}', "A^{-1}") 
    224223        self.data.yaxis('\\rm{Intensity}', "cm^{-1}") 
    225224        self.data.is_data = False 
    226         self.data.id = str(self.uid) + " data"  
    227         self.data.group_id = str(self.uid) + " Model1D"  
     225        self.data.id = str(self.uid) + " data" 
     226        self.data.group_id = str(self.uid) + " Model1D" 
    228227        
    229228    def _create_default_2d_data(self): 
     
    238237        self.data.yaxis('\\rm{Q_{y}}', 'A^{-1}') 
    239238        self.data.is_data = False 
    240         self.data.id = str(self.uid) + " data"  
    241         self.data.group_id = str(self.uid) + " Model2D"  
    242         ## Default values     
    243         self.data.detector.append(Detector())   
     239        self.data.id = str(self.uid) + " data" 
     240        self.data.group_id = str(self.uid) + " Model2D" 
     241        ## Default values 
     242        self.data.detector.append(Detector()) 
    244243        index = len(self.data.detector) - 1 
    245         self.data.detector[index].distance = 8000   # mm         
    246         self.data.source.wavelength= 6         # A       
     244        self.data.detector[index].distance = 8000   # mm 
     245        self.data.source.wavelength = 6             # A 
    247246        self.data.detector[index].pixel_size.x = 5  # mm 
    248247        self.data.detector[index].pixel_size.y = 5  # mm 
     
    250249        self.data.detector[index].beam_center.y = qmax 
    251250        ## create x_bins and y_bins of the model 2D 
    252         pixel_width_x = self.data.detector[index].pixel_size.x 
    253         pixel_width_y = self.data.detector[index].pixel_size.y 
    254         center_x = self.data.detector[index].beam_center.x/pixel_width_x 
    255         center_y = self.data.detector[index].beam_center.y/pixel_width_y 
    256         # theory default: assume the beam  
     251        #pixel_width_x = self.data.detector[index].pixel_size.x 
     252        #pixel_width_y = self.data.detector[index].pixel_size.y 
     253        #center_x = self.data.detector[index].beam_center.x/pixel_width_x 
     254        #center_y = self.data.detector[index].beam_center.y/pixel_width_y 
     255        # theory default: assume the beam 
    257256        #center is located at the center of sqr detector 
    258         xmax = qmax  
     257        xmax = qmax 
    259258        xmin = -qmax 
    260259        ymax = qmax 
     
    262261        qstep = self.npts_x 
    263262 
    264         x = numpy.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True)   
     263        x = numpy.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True) 
    265264        y = numpy.linspace(start=ymin, stop=ymax, num=qstep, endpoint=True) 
    266265        ## use data info instead 
    267266        new_x = numpy.tile(x, (len(y), 1)) 
    268267        new_y = numpy.tile(y, (len(x), 1)) 
    269         new_y = new_y.swapaxes(0,1) 
     268        new_y = new_y.swapaxes(0, 1) 
    270269        # all data reuire now in 1d array 
    271270        qx_data = new_x.flatten() 
    272271        qy_data = new_y.flatten() 
    273         q_data = numpy.sqrt(qx_data*qx_data + qy_data*qy_data) 
     272        q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data) 
    274273        # set all True (standing for unmasked) as default 
    275274        mask = numpy.ones(len(qx_data), dtype=bool) 
    276275        # calculate the range of qx and qy: this way, 
    277276        # it is a little more independent 
    278         x_size = xmax - xmin 
    279         y_size = ymax - ymin 
     277        #x_size = xmax - xmin 
     278        #y_size = ymax - ymin 
    280279        # store x and y bin centers in q space 
    281         x_bins  = x 
    282         y_bins  = y  
     280        x_bins = x 
     281        y_bins = y 
    283282        # bin size: x- & y-directions 
    284         xstep = x_size/len(x_bins-1) 
    285         ystep = y_size/len(y_bins-1) 
     283        #xstep = x_size / len(x_bins - 1) 
     284        #ystep = y_size / len(y_bins - 1) 
    286285   
    287286        self.data.source = Source() 
    288287        self.data.data = numpy.ones(len(mask)) 
    289288        self.data.err_data = numpy.ones(len(mask)) 
    290         self.data.qx_data = qx_data  
    291         self.data.qy_data = qy_data   
    292         self.data.q_data = q_data  
    293         self.data.mask = mask             
    294         self.data.x_bins = x_bins   
    295         self.data.y_bins = y_bins    
     289        self.data.qx_data = qx_data 
     290        self.data.qy_data = qy_data 
     291        self.data.q_data = q_data 
     292        self.data.mask = mask 
     293        self.data.x_bins = x_bins 
     294        self.data.y_bins = y_bins 
    296295        # max and min taking account of the bin sizes 
    297         self.data.xmin = xmin  
     296        self.data.xmin = xmin 
    298297        self.data.xmax = xmax 
    299         self.data.ymin = ymin  
    300         self.data.ymax = ymax  
     298        self.data.ymin = ymin 
     299        self.data.ymax = ymax 
    301300 
    302301    def on_set_focus(self, event): 
     
    314313        if self._manager.menu1 != None: 
    315314            chain_menu = self._manager.menu1.FindItemById(\ 
    316                                                     self._manager.id_reset_flag) 
     315                                                   self._manager.id_reset_flag) 
    317316            chain_menu.Enable(self.batch_on) 
    318317            sim_menu = self._manager.menu1.FindItemById(self._manager.id_simfit) 
    319318            flag = self.data.is_data\ 
    320                             and (self.model!=None) 
     319                            and (self.model != None) 
    321320            sim_menu.Enable(not self.batch_on and flag) 
    322321            batch_menu = self._manager.menu1.FindItemById(self._manager.id_batchfit) 
    323             batch_menu.Enable(self.batch_on and flag)  
     322            batch_menu.Enable(self.batch_on and flag) 
    324323     
    325324    class ModelTextCtrl(wx.TextCtrl): 
     
    340339        _on_set_focus_callback = None 
    341340         
    342         def __init__(self, parent, id=-1,  
    343                      value=wx.EmptyString,  
    344                      pos=wx.DefaultPosition,  
     341        def __init__(self, parent, id=-1, 
     342                     value=wx.EmptyString, 
     343                     pos=wx.DefaultPosition, 
    345344                     size=wx.DefaultSize, 
    346                      style=0,  
     345                     style=0, 
    347346                     validator=wx.DefaultValidator, 
    348347                     name=wx.TextCtrlNameStr, 
     
    350349                     set_focus_callback=None, 
    351350                     mouse_up_callback=None, 
    352                      text_enter_callback = None): 
     351                     text_enter_callback=None): 
    353352              
    354353            wx.TextCtrl.__init__(self, parent, id, value, pos, 
     
    360359            self.Bind(wx.EVT_SET_FOCUS, self._on_set_focus) 
    361360            self.Bind(wx.EVT_KILL_FOCUS, self._silent_kill_focus \ 
    362                       if kill_focus_callback is None else kill_focus_callback)                 
     361                      if kill_focus_callback is None else kill_focus_callback) 
    363362            self.Bind(wx.EVT_TEXT_ENTER, parent._onparamEnter \ 
    364363                      if text_enter_callback is None else text_enter_callback) 
    365             if not ON_MAC : 
    366                 self.Bind(wx.EVT_LEFT_UP,    self._highlight_text \ 
     364            if not ON_MAC: 
     365                self.Bind(wx.EVT_LEFT_UP, self._highlight_text \ 
    367366                          if mouse_up_callback is None else mouse_up_callback) 
    368367             
     
    379378            return self._on_set_focus_callback(event) 
    380379         
    381   
    382              
    383380        def _highlight_text(self, event): 
    384381            """ 
     
    390387            # Make sure the mouse event is available to other listeners 
    391388            event.Skip() 
    392             control  = event.GetEventObject() 
     389            control = event.GetEventObject() 
    393390            if self.full_selection: 
    394391                self.full_selection = False 
    395392                # Check that we have a TextCtrl 
    396393                if issubclass(control.__class__, wx.TextCtrl): 
    397                     # Check whether text has been selected,  
     394                    # Check whether text has been selected, 
    398395                    # if not, select the whole string 
    399396                    (start, end) = control.GetSelection() 
    400                     if start==end: 
    401                         control.SetSelection(-1,-1) 
     397                    if start == end: 
     398                        control.SetSelection(-1, -1) 
    402399                         
    403         def _silent_kill_focus(self,event): 
     400        def _silent_kill_focus(self, event): 
    404401            """ 
    405402            Save the state of the page 
     
    413410        set some page important information at once 
    414411        """ 
    415        ##window_name 
     412        ##window_name 
    416413        self.window_name = page_info.window_name 
    417414        ##window_caption 
    418415        self.window_caption = page_info.window_caption 
    419416        ## manager is the fitting plugin 
    420         self._manager= page_info.manager 
     417        self._manager = page_info.manager 
    421418        ## owner of the page (fitting plugin) 
    422         self.event_owner= page_info.event_owner 
    423          ## current model 
     419        self.event_owner = page_info.event_owner 
     420        ## current model 
    424421        self.model = page_info.model 
    425422        ## data 
     
    430427        self.populate_box(dict=self.model_list_box) 
    431428         
    432     def onContextMenu(self, event):  
     429    def onContextMenu(self, event): 
    433430        """ 
    434431        Retrieve the state selected state 
     
    440437        pos = self.ScreenToClient(pos) 
    441438        
    442         self.PopupMenu(self.popUpMenu, pos)  
     439        self.PopupMenu(self.popUpMenu, pos) 
    443440       
    444          
    445441    def onUndo(self, event): 
    446442        """ 
    447443        Cancel the previous action 
    448444        """ 
    449         event = PreviousStateEvent(page = self) 
     445        event = PreviousStateEvent(page=self) 
    450446        wx.PostEvent(self.parent, event) 
    451447         
    452448    def onRedo(self, event): 
    453449        """ 
    454         Restore the previous action cancelled  
    455         """ 
    456         event = NextStateEvent(page= self) 
     450        Restore the previous action cancelled 
     451        """ 
     452        event = NextStateEvent(page=self) 
    457453        wx.PostEvent(self.parent, event) 
    458454     
     
    461457        Create empty sizer for a panel 
    462458        """ 
    463         self.vbox  = wx.BoxSizer(wx.VERTICAL) 
     459        self.vbox = wx.BoxSizer(wx.VERTICAL) 
    464460        self.sizer0 = wx.BoxSizer(wx.VERTICAL) 
    465461        self.sizer1 = wx.BoxSizer(wx.VERTICAL) 
     
    470466        self.sizer6 = wx.BoxSizer(wx.VERTICAL) 
    471467         
    472         self.sizer0.SetMinSize((PANEL_WIDTH,-1)) 
    473         self.sizer1.SetMinSize((PANEL_WIDTH,-1)) 
    474         self.sizer2.SetMinSize((PANEL_WIDTH,-1)) 
    475         self.sizer3.SetMinSize((PANEL_WIDTH,-1)) 
    476         self.sizer4.SetMinSize((PANEL_WIDTH,-1)) 
    477         self.sizer5.SetMinSize((PANEL_WIDTH,-1)) 
    478         self.sizer6.SetMinSize((PANEL_WIDTH,-1)) 
     468        self.sizer0.SetMinSize((PANEL_WIDTH, -1)) 
     469        self.sizer1.SetMinSize((PANEL_WIDTH, -1)) 
     470        self.sizer2.SetMinSize((PANEL_WIDTH, -1)) 
     471        self.sizer3.SetMinSize((PANEL_WIDTH, -1)) 
     472        self.sizer4.SetMinSize((PANEL_WIDTH, -1)) 
     473        self.sizer5.SetMinSize((PANEL_WIDTH, -1)) 
     474        self.sizer6.SetMinSize((PANEL_WIDTH, -1)) 
    479475         
    480476        self.vbox.Add(self.sizer0) 
     
    491487        """ 
    492488        self.vbox.Layout() 
    493         self.vbox.Fit(self)  
     489        self.vbox.Fit(self) 
    494490        self.SetSizer(self.vbox) 
    495491        self.Centre() 
    496492  
    497     def set_owner(self,owner): 
    498         """  
     493    def set_owner(self, owner): 
     494        """ 
    499495        set owner of fitpage 
    500496         
     
    502498         
    503499        """ 
    504         self.event_owner = owner     
     500        self.event_owner = owner 
    505501        self.state.event_owner = owner 
    506502         
     
    512508    def get_data(self): 
    513509        """ 
    514         return the current data  
    515         """ 
    516         return self.data   
     510        return the current data 
     511        """ 
     512        return self.data 
    517513     
    518514    def get_data_list(self): 
    519515        """ 
    520         return the current data  
    521         """ 
    522         return self.data_list   
     516        return the current data 
     517        """ 
     518        return self.data_list 
    523519     
    524520    def set_manager(self, manager): 
     
    529525         
    530526        """ 
    531         self._manager = manager   
     527        self._manager = manager 
    532528        self.state.manager = manager 
    533529         
     
    543539        self.initialize_combox() 
    544540         
    545     def initialize_combox(self):  
    546         """ 
    547         put default value in the combobox  
     541    def initialize_combox(self): 
     542        """ 
     543        put default value in the combobox 
    548544        """   
    549545        ## fill combox box 
     
    568564                self.text2.Show() 
    569565                self.structurebox.Enable() 
    570                 self.text2.Enable()             
     566                self.text2.Enable() 
    571567                 
    572568    def set_dispers_sizer(self): 
     
    575571        """ 
    576572        self.sizer4.Clear(True) 
    577         name="Polydispersity and Orientational Distribution" 
    578         box_description= wx.StaticBox(self, -1,name) 
     573        name = "Polydispersity and Orientational Distribution" 
     574        box_description = wx.StaticBox(self, -1, name) 
    579575        box_description.SetForegroundColour(wx.BLUE) 
    580576        boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL) 
     
    585581        # best size for MAC and PC 
    586582        if ON_MAC: 
    587             size_q = (30, 20)       
     583            size_q = (30, 20) 
    588584        else: 
    589             size_q = (20, 15)     
    590         self.disp_help_bt = wx.Button(self,wx.NewId(),'?',  
    591                                       style = wx.BU_EXACTFIT, 
     585            size_q = (20, 15) 
     586        self.disp_help_bt = wx.Button(self, wx.NewId(), '?', 
     587                                      style=wx.BU_EXACTFIT, 
    592588                                      size=size_q) 
    593         self.disp_help_bt.Bind(wx.EVT_BUTTON,  
    594                         self.on_pd_help_clicked,id= self.disp_help_bt.GetId()) 
    595         self.disp_help_bt.SetToolTipString("Helps for Polydispersion.")        
     589        self.disp_help_bt.Bind(wx.EVT_BUTTON, 
     590                        self.on_pd_help_clicked, id=self.disp_help_bt.GetId()) 
     591        self.disp_help_bt.SetToolTipString("Helps for Polydispersion.") 
    596592         
    597593        self.Bind(wx.EVT_RADIOBUTTON, self._set_dipers_Param, 
     
    602598        self.disable_disp.SetValue(True) 
    603599        sizer_dispersion = wx.BoxSizer(wx.HORIZONTAL) 
    604         sizer_dispersion.Add((20,20)) 
    605         name=""#Polydispersity and \nOrientational Distribution " 
    606         sizer_dispersion.Add(wx.StaticText(self,-1,name)) 
    607         sizer_dispersion.Add(self.enable_disp ) 
    608         sizer_dispersion.Add((20,20)) 
    609         sizer_dispersion.Add(self.disable_disp ) 
    610         sizer_dispersion.Add((25,20)) 
     600        sizer_dispersion.Add((20, 20)) 
     601        name = ""  # Polydispersity and \nOrientational Distribution " 
     602        sizer_dispersion.Add(wx.StaticText(self, -1, name)) 
     603        sizer_dispersion.Add(self.enable_disp) 
     604        sizer_dispersion.Add((20, 20)) 
     605        sizer_dispersion.Add(self.disable_disp) 
     606        sizer_dispersion.Add((25, 20)) 
    611607        sizer_dispersion.Add(self.disp_help_bt) 
    612608         
    613         ## fill a sizer for dispersion          
    614         boxsizer1.Add( sizer_dispersion,0, 
    615                 wx.TOP|wx.BOTTOM|wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE,border=5) 
    616         #boxsizer1.Add( (10,10) ) 
    617         #boxsizer1.Add( sizer_select_dispers ) 
    618         self.sizer4_4 = wx.GridBagSizer(6,5) 
    619  
    620         boxsizer1.Add( self.sizer4_4  ) 
     609        ## fill a sizer for dispersion 
     610        boxsizer1.Add(sizer_dispersion, 0, 
     611                wx.TOP | wx.BOTTOM | wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 
     612                border=5) 
     613        self.sizer4_4 = wx.GridBagSizer(6, 5) 
     614 
     615        boxsizer1.Add(self.sizer4_4) 
    621616        #----------------------------------------------------- 
    622         self.sizer4.Add(boxsizer1,0, wx.EXPAND | wx.ALL, 10) 
     617        self.sizer4.Add(boxsizer1, 0, wx.EXPAND | wx.ALL, 10) 
    623618        self.sizer4_4.Layout() 
    624619        self.sizer4.Layout() 
     
    627622        self.Refresh() 
    628623        ## saving the state of enable dispersity button 
    629         self.state.enable_disp= self.enable_disp.GetValue() 
    630         self.state.disable_disp= self.disable_disp.GetValue() 
     624        self.state.enable_disp = self.enable_disp.GetValue() 
     625        self.state.disable_disp = self.disable_disp.GetValue() 
    631626        self.SetupScrolling() 
    632  
    633627     
    634628    def onResetModel(self, event): 
     
    637631        """ 
    638632        menu = event.GetEventObject() 
    639         ## post help message for the selected model  
     633        ## post help message for the selected model 
    640634        msg = menu.GetHelpString(event.GetId()) 
    641         msg +=" reloaded" 
     635        msg += " reloaded" 
    642636        wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
    643637        self.Show(False) 
     
    650644            ## reset state of checkbox,textcrtl  and  regular parameters value 
    651645             
    652             self.reset_page(previous_state)    
     646            self.reset_page(previous_state) 
    653647        self.state.m_name = self.m_name 
    654648        self.Show(True) 
     
    657651        """ 
    658652        Report the current fit results 
    659         """    
     653        """ 
    660654        # Get plot image from plotpanel 
    661655        images, canvases = self.get_images() 
     
    663657        self.state.report(images, canvases) 
    664658         
    665           
    666     def on_save(self, event):    
     659    def on_save(self, event): 
    667660        """ 
    668661        Save the current state into file 
    669         """   
     662        """ 
    670663        self.save_current_state() 
    671664        new_state = self.state.clone() 
    672665        # Ask the user the location of the file to write to. 
    673666        path = None 
    674         if self.parent !=  None: 
     667        if self.parent != None: 
    675668            self._default_save_location = \ 
    676669                        self.parent.parent._default_save_location 
     
    691684        #the manager write the state into file 
    692685        self._manager.save_fit_state(filepath=fName, fitstate=new_state) 
    693         return new_state   
     686        return new_state 
    694687     
    695688    def on_copy(self, event): 
     
    702695        wx.CallAfter(self.get_copy) 
    703696         
    704         # messages depending on the flag 
    705         #self._copy_info(None) 
    706          
    707697    def on_paste(self, event): 
    708698        """ 
     
    711701        if event != None: 
    712702            event.Skip() 
    713         # It seems MAC needs wxCallAfter for the setvalues  
    714         # for multiple textctrl items, otherwise it tends to crash once a while. 
     703        # It seems MAC needs wxCallAfter for the setvalues 
     704        # for multiple textctrl items, otherwise it tends to crash once a while 
    715705        wx.CallAfter(self.get_paste) 
    716706        # messages depending on the flag 
     
    735725            infor = "error" 
    736726        # inform msg to wx 
    737         wx.PostEvent( self.parent.parent,  
    738                       StatusEvent(status= msg, info=infor)) 
     727        wx.PostEvent(self.parent.parent, 
     728                    StatusEvent(status=msg, info=infor)) 
    739729         
    740730    def _get_time_stamp(self): 
     
    742732        return time and date stings 
    743733        """ 
    744         # date and time  
    745         year, month, day,hour,minute,second,tda,ty,tm_isdst= time.localtime() 
    746         current_time= str(hour)+":"+str(minute)+":"+str(second) 
    747         current_date= str( month)+"/"+str(day)+"/"+str(year) 
     734        # date and time 
     735        year, month, day, hour, minute, second, tda, ty, tm_isdst \ 
     736            = time.localtime() 
     737        current_time = str(hour) + ":" + str(minute) + ":" + str(second) 
     738        current_date = str(month) + "/" + str(day) + "/" + str(year) 
    748739        return current_time, current_date 
    749740       
     
    752743        save history of the data and model 
    753744        """ 
    754         if self.model==None: 
    755             msg="Can not bookmark; Please select Data and Model first..." 
     745        if self.model == None: 
     746            msg = "Can not bookmark; Please select Data and Model first..." 
    756747            wx.MessageBox(msg, 'Info') 
    757             return  
     748            return 
    758749        self.save_current_state() 
    759750        new_state = self.state.clone() 
     
    761752        self.number_saved_state += 1 
    762753        current_time, current_date = self._get_time_stamp() 
    763         #name= self.model.name+"[%g]"%self.number_saved_state  
    764         name = "Fitting: %g]" % self.number_saved_state  
    765         name += self.model.__class__.__name__  
     754        #name= self.model.name+"[%g]"%self.number_saved_state 
     755        name = "Fitting: %g]" % self.number_saved_state 
     756        name += self.model.__class__.__name__ 
    766757        name += "bookmarked at %s on %s" % (current_time, current_date) 
    767         self.saved_states[name]= new_state 
     758        self.saved_states[name] = new_state 
    768759         
    769760        ## Add item in the context menu 
    770         msg =  "Model saved at %s on %s"%(current_time, current_date) 
    771          ## post help message for the selected model  
    772         msg +=" Saved! right click on this page to retrieve this model" 
    773         wx.PostEvent(self.parent.parent, StatusEvent(status = msg )) 
     761        msg = "Model saved at %s on %s" % (current_time, current_date) 
     762        ## post help message for the selected model 
     763        msg += " Saved! right click on this page to retrieve this model" 
     764        wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
    774765         
    775766        id = wx.NewId() 
    776         self.popUpMenu.Append(id,name,str(msg)) 
     767        self.popUpMenu.Append(id, name, str(msg)) 
    777768        wx.EVT_MENU(self, id, self.onResetModel) 
    778         wx.PostEvent(self.parent.parent,  
    779                      AppendBookmarkEvent(title=name,  
    780                                          hint=str(msg), handler=self._back_to_bookmark)) 
    781     def _back_to_bookmark(self, event):  
     769        wx.PostEvent(self.parent.parent, 
     770                     AppendBookmarkEvent(title=name, 
     771                                         hint=str(msg), 
     772                                         handler=self._back_to_bookmark)) 
     773     
     774    def _back_to_bookmark(self, event): 
    782775        """ 
    783776        Back to bookmark 
     
    786779        self.onResetModel(event) 
    787780        self._draw_model() 
    788         #self.save_current_state() 
    789          
    790781         
    791782    def old_on_bookmark(self, event): 
     
    793784        save history of the data and model 
    794785        """ 
    795         if self.model==None: 
    796             msg="Can not bookmark; Please select Data and Model first..." 
     786        if self.model == None: 
     787            msg = "Can not bookmark; Please select Data and Model first..." 
    797788            wx.MessageBox(msg, 'Info') 
    798             return  
    799         if hasattr(self,"enable_disp"): 
     789            return 
     790        if hasattr(self, "enable_disp"): 
    800791            self.state.enable_disp = copy.deepcopy(self.enable_disp.GetValue()) 
    801792        if hasattr(self, "disp_box"): 
    802793            self.state.disp_box = copy.deepcopy(self.disp_box.GetSelection()) 
    803794 
    804         self.state.model.name= self.model.name 
     795        self.state.model.name = self.model.name 
    805796         
    806797        #Remember fit engine_type for fit panel 
    807         if self.engine_type == None:  
     798        if self.engine_type == None: 
    808799            self.engine_type = "scipy" 
    809         if self._manager !=None: 
     800        if self._manager != None: 
    810801            self._manager._on_change_engine(engine=self.engine_type) 
    811802         
     
    818809        ##Add model state on context menu 
    819810        self.number_saved_state += 1 
    820         #name= self.model.name+"[%g]"%self.number_saved_state  
    821         name= self.model.__class__.__name__+"[%g]"%self.number_saved_state  
    822         self.saved_states[name]= new_state 
     811        name = self.model.__class__.__name__ + "[%g]" % self.number_saved_state 
     812        self.saved_states[name] = new_state 
    823813         
    824814        ## Add item in the context menu 
    825815         
    826         year, month, day,hour,minute,second,tda,ty,tm_isdst= time.localtime() 
    827         my_time= str(hour)+" : "+str(minute)+" : "+str(second)+" " 
    828         date= str( month)+"|"+str(day)+"|"+str(year) 
    829         msg=  "Model saved at %s on %s"%(my_time, date) 
    830          ## post help message for the selected model  
    831         msg +=" Saved! right click on this page to retrieve this model" 
    832         wx.PostEvent(self.parent.parent, StatusEvent(status = msg )) 
     816        year, month, day, hour, minute, second, tda, ty, tm_isdst \ 
     817            = time.localtime() 
     818        my_time = str(hour) + " : " + str(minute) + " : " + str(second) + " " 
     819        date = str(month) + "|" + str(day) + "|" + str(year) 
     820        msg = "Model saved at %s on %s" % (my_time, date) 
     821        ## post help message for the selected model 
     822        msg += " Saved! right click on this page to retrieve this model" 
     823        wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
    833824         
    834825        id = wx.NewId() 
    835         self.popUpMenu.Append(id,name,str(msg)) 
     826        self.popUpMenu.Append(id, name, str(msg)) 
    836827        wx.EVT_MENU(self, id, self.onResetModel) 
    837828         
    838829    def onSetFocus(self, evt): 
    839830        """ 
    840         highlight the current textcrtl and hide the error text control shown  
     831        highlight the current textcrtl and hide the error text control shown 
    841832        after fitting 
    842833        """ 
     
    851842        """ 
    852843        try: 
    853             if path==None: 
    854                 wx.PostEvent(self.parent.parent, StatusEvent(status=\ 
    855                             " Selected Distribution was not loaded: %s"%path)) 
     844            if path == None: 
     845                wx.PostEvent(self.parent.parent, 
     846        StatusEvent(status=" Selected Distribution was not loaded: %s" % path)) 
    856847                return None, None 
    857848            input_f = open(path, 'r') 
     
    860851             
    861852            angles = [] 
    862             weights=[] 
     853            weights = [] 
    863854            for line in lines: 
    864855                toks = line.split() 
     
    873864            return numpy.array(angles), numpy.array(weights) 
    874865        except: 
    875             raise  
     866            raise 
    876867 
    877868    def createMemento(self): 
     
    880871        """ 
    881872        return self.state.clone() 
    882      
    883873     
    884874    def save_current_state(self): 
     
    888878        self.state.engine_type = copy.deepcopy(self.engine_type) 
    889879        ## save model option 
    890         if self.model!= None: 
    891             self.disp_list= self.model.getDispParamList() 
    892             self.state.disp_list= copy.deepcopy(self.disp_list) 
     880        if self.model != None: 
     881            self.disp_list = self.model.getDispParamList() 
     882            self.state.disp_list = copy.deepcopy(self.disp_list) 
    893883            self.state.model = self.model.clone() 
    894884        #save radiobutton state for model selection 
     
    898888        self.state.plugin_rbutton = self.plugin_rbutton.GetValue() 
    899889        #model combobox 
    900         self.state.structurebox = self.structurebox.GetLabel()#.GetSelection() 
    901         self.state.formfactorbox = self.formfactorbox.GetLabel()#.GetSelection() 
     890        self.state.structurebox = self.structurebox.GetLabel() 
     891        self.state.formfactorbox = self.formfactorbox.GetLabel() 
    902892         
    903893        self.state.enable2D = copy.deepcopy(self.enable2D) 
    904         self.state.values= copy.deepcopy(self.values) 
    905         self.state.weights = copy.deepcopy( self.weights) 
    906         ## save data     
    907         self.state.data= copy.deepcopy(self.data) 
     894        self.state.values = copy.deepcopy(self.values) 
     895        self.state.weights = copy.deepcopy(self.weights) 
     896        ## save data 
     897        self.state.data = copy.deepcopy(self.data) 
    908898        self.state.qmax_x = self.qmax_x 
    909899        self.state.qmin_x = self.qmin_x 
     
    914904        self.state.dq_l = self.dq_l 
    915905        self.state.dq_r = self.dq_r 
    916         if hasattr(self,"enable_disp"): 
    917             self.state.enable_disp= self.enable_disp.GetValue() 
     906        if hasattr(self, "enable_disp"): 
     907            self.state.enable_disp = self.enable_disp.GetValue() 
    918908            self.state.disable_disp = self.disable_disp.GetValue() 
    919909             
    920910        self.state.smearer = copy.deepcopy(self.current_smearer) 
    921         if hasattr(self,"enable_smearer"): 
     911        if hasattr(self, "enable_smearer"): 
    922912            self.state.enable_smearer = \ 
    923913                                copy.deepcopy(self.enable_smearer.GetValue()) 
     
    927917        self.state.pinhole_smearer = \ 
    928918                                copy.deepcopy(self.pinhole_smearer.GetValue()) 
    929         self.state.slit_smearer = copy.deepcopy(self.slit_smearer.GetValue())   
     919        self.state.slit_smearer = copy.deepcopy(self.slit_smearer.GetValue()) 
    930920                   
    931         if len(self._disp_obj_dict)>0: 
    932             for k , v in self._disp_obj_dict.iteritems(): 
    933                 self.state._disp_obj_dict[k]= v 
    934                          
    935              
     921        if len(self._disp_obj_dict) > 0: 
     922            for k, v in self._disp_obj_dict.iteritems(): 
     923                self.state._disp_obj_dict[k] = v 
     924 
    936925            self.state.values = copy.deepcopy(self.values) 
    937926            self.state.weights = copy.deepcopy(self.weights) 
     
    946935        self.state.str_parameters = [] 
    947936 
    948          
    949937        ## save checkbutton state and txtcrtl values 
    950         self._copy_parameters_state(self.str_parameters,  
     938        self._copy_parameters_state(self.str_parameters, 
    951939                                    self.state.str_parameters) 
    952940        self._copy_parameters_state(self.orientation_params, 
     
    967955        """ 
    968956        ## save model option 
    969         if self.model!= None: 
    970             self.disp_list= self.model.getDispParamList() 
    971             self.state.disp_list= copy.deepcopy(self.disp_list) 
     957        if self.model != None: 
     958            self.disp_list = self.model.getDispParamList() 
     959            self.state.disp_list = copy.deepcopy(self.disp_list) 
    972960            self.state.model = self.model.clone() 
    973961        if hasattr(self, "engine_type"): 
     
    975963             
    976964        self.state.enable2D = copy.deepcopy(self.enable2D) 
    977         self.state.values= copy.deepcopy(self.values) 
    978         self.state.weights = copy.deepcopy( self.weights) 
    979         ## save data     
    980         self.state.data= copy.deepcopy(self.data) 
    981          
    982         if hasattr(self,"enable_disp"): 
    983             self.state.enable_disp= self.enable_disp.GetValue() 
     965        self.state.values = copy.deepcopy(self.values) 
     966        self.state.weights = copy.deepcopy(self.weights) 
     967        ## save data 
     968        self.state.data = copy.deepcopy(self.data) 
     969         
     970        if hasattr(self, "enable_disp"): 
     971            self.state.enable_disp = self.enable_disp.GetValue() 
    984972            self.state.disable_disp = self.disable_disp.GetValue() 
    985973             
    986974        self.state.smearer = copy.deepcopy(self.current_smearer) 
    987         if hasattr(self,"enable_smearer"): 
     975        if hasattr(self, "enable_smearer"): 
    988976            self.state.enable_smearer = \ 
    989977                                copy.deepcopy(self.enable_smearer.GetValue()) 
     
    993981        self.state.pinhole_smearer = \ 
    994982                                copy.deepcopy(self.pinhole_smearer.GetValue()) 
    995         self.state.slit_smearer = copy.deepcopy(self.slit_smearer.GetValue())   
     983        self.state.slit_smearer = copy.deepcopy(self.slit_smearer.GetValue()) 
    996984        self.state.dI_noweight = copy.deepcopy(self.dI_noweight.GetValue()) 
    997985        self.state.dI_didata = copy.deepcopy(self.dI_didata.GetValue()) 
    998986        self.state.dI_sqrdata = copy.deepcopy(self.dI_sqrdata.GetValue()) 
    999         self.state.dI_idata = copy.deepcopy(self.dI_idata.GetValue())   
    1000         if hasattr(self,"disp_box"): 
     987        self.state.dI_idata = copy.deepcopy(self.dI_idata.GetValue()) 
     988        if hasattr(self, "disp_box"): 
    1001989            self.state.disp_box = self.disp_box.GetCurrentSelection() 
    1002990 
     
    1004992                for k, v in self.disp_cb_dict.iteritems(): 
    1005993          
    1006                     if v == None : 
     994                    if v == None: 
    1007995                        self.state.disp_cb_dict[k] = v 
    1008996                    else: 
     
    10131001            
    10141002            if len(self._disp_obj_dict) > 0: 
    1015                 for k , v in self._disp_obj_dict.iteritems(): 
    1016        
     1003                for k, v in self._disp_obj_dict.iteritems(): 
    10171004                    self.state._disp_obj_dict[k] = v 
    10181005                         
    1019              
    10201006            self.state.values = copy.deepcopy(self.values) 
    10211007            self.state.weights = copy.deepcopy(self.weights) 
     
    10341020        self._copy_parameters_state(self.fixed_param, self.state.fixed_param) 
    10351021     
    1036            
    1037     def check_invalid_panel(self):   
     1022    def check_invalid_panel(self): 
    10381023        """ 
    10391024        check if the user can already perform some action with this panel 
    1040         """  
    1041         flag = False 
     1025        """ 
    10421026        if self.data is None: 
    10431027            self.disable_smearer.SetValue(True) 
     
    10551039       
    10561040        ## set the state of the radio box 
    1057         self.shape_rbutton.SetValue(state.shape_rbutton ) 
     1041        self.shape_rbutton.SetValue(state.shape_rbutton) 
    10581042        self.shape_indep_rbutton.SetValue(state.shape_indep_rbutton) 
    10591043        self.struct_rbutton.SetValue(state.struct_rbutton) 
     
    10921076            self.multifactorbox.SetSelection(state.multi_factor) 
    10931077             
    1094          ## reset state of checkbox,textcrtl  and  regular parameters value 
     1078        ## reset state of checkbox,textcrtl  and  regular parameters value 
    10951079        self._reset_parameters_state(self.orientation_params_disp, 
    10961080                                     state.orientation_params_disp) 
     
    10991083        self._reset_parameters_state(self.str_parameters, 
    11001084                                     state.str_parameters) 
    1101         self._reset_parameters_state(self.parameters,state.parameters) 
    1102          ## display dispersion info layer         
     1085        self._reset_parameters_state(self.parameters, state.parameters) 
     1086        ## display dispersion info layer 
    11031087        self.enable_disp.SetValue(state.enable_disp) 
    11041088        self.disable_disp.SetValue(state.disable_disp) 
    11051089         
    11061090        if hasattr(self, "disp_box"): 
    1107              
    1108             self.disp_box.SetSelection(state.disp_box)  
    1109             n= self.disp_box.GetCurrentSelection() 
    1110             dispersity= self.disp_box.GetClientData(n) 
    1111             name = dispersity.__name__      
     1091            self.disp_box.SetSelection(state.disp_box) 
     1092            n = self.disp_box.GetCurrentSelection() 
     1093            dispersity = self.disp_box.GetClientData(n) 
     1094            name = dispersity.__name__ 
    11121095 
    11131096            self._set_dipers_Param(event=None) 
     
    11171100                for item in self.disp_cb_dict.keys(): 
    11181101                     
    1119                     if hasattr(self.disp_cb_dict[item], "SetValue") : 
     1102                    if hasattr(self.disp_cb_dict[item], "SetValue"): 
    11201103                        self.disp_cb_dict[item].SetValue(\ 
    11211104                                                    state.disp_cb_dict[item]) 
     
    11231106                        from sans.models.dispersion_models import ArrayDispersion 
    11241107                        disp_model = ArrayDispersion() 
    1125                         if hasattr(state,"values")and\ 
     1108                        if hasattr(state, "values") and \ 
    11261109                                 self.disp_cb_dict[item].GetValue() == True: 
    1127                             if len(state.values)>0: 
    1128                                 self.values=state.values 
    1129                                 self.weights=state.weights 
     1110                            if len(state.values) > 0: 
     1111                                self.values = state.values 
     1112                                self.weights = state.weights 
    11301113                                disp_model.set_weights(self.values, 
    1131                                                         state.weights) 
     1114                                                       state.weights) 
    11321115                            else: 
    11331116                                self._reset_dispersity() 
    11341117                         
    11351118                        self._disp_obj_dict[item] = disp_model 
    1136                         # Set the new model as the dispersion object  
     1119                        # Set the new model as the dispersion object 
    11371120                        #for the selected parameter 
    11381121                        self.model.set_dispersion(item, disp_model) 
     
    11451128                for item in keys: 
    11461129                    if item in self.disp_list and \ 
    1147                         not self.model.details.has_key(item): 
     1130                        not item in self.model.details: 
    11481131                        self.model.details[item] = ["", None, None] 
    1149                 for k,v in self.state.disp_cb_dict.iteritems(): 
    1150                     self.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)  
     1132                for k, v in self.state.disp_cb_dict.iteritems(): 
     1133                    self.disp_cb_dict = copy.deepcopy(state.disp_cb_dict) 
    11511134                    self.state.disp_cb_dict = copy.deepcopy(state.disp_cb_dict) 
    1152          ## smearing info  restore 
     1135        ## smearing info  restore 
    11531136        if hasattr(self, "enable_smearer"): 
    1154             ## set smearing value whether or not the data  
     1137            ## set smearing value whether or not the data 
    11551138            #contain the smearing info 
    11561139            self.enable_smearer.SetValue(state.enable_smearer) 
    11571140            self.disable_smearer.SetValue(state.disable_smearer) 
    1158             self.onSmear(event=None)            
     1141            self.onSmear(event=None) 
    11591142        self.pinhole_smearer.SetValue(state.pinhole_smearer) 
    11601143        self.slit_smearer.SetValue(state.slit_smearer) 
     
    11661149         
    11671150        ## we have two more options for smearing 
    1168         if self.pinhole_smearer.GetValue(): self.onPinholeSmear(event=None) 
    1169         elif self.slit_smearer.GetValue(): self.onSlitSmear(event=None) 
     1151        if self.pinhole_smearer.GetValue(): 
     1152            self.onPinholeSmear(event=None) 
     1153        elif self.slit_smearer.GetValue(): 
     1154            self.onSlitSmear(event=None) 
    11701155        
    11711156        ## reset state of checkbox,textcrtl  and dispersity parameters value 
    1172         self._reset_parameters_state(self.fittable_param,state.fittable_param) 
    1173         self._reset_parameters_state(self.fixed_param,state.fixed_param) 
     1157        self._reset_parameters_state(self.fittable_param, state.fittable_param) 
     1158        self._reset_parameters_state(self.fixed_param, state.fixed_param) 
    11741159         
    11751160        ## draw the model with previous parameters value 
    11761161        self._onparamEnter_helper() 
    1177         self.select_param(event=None)  
     1162        self.select_param(event=None) 
    11781163        #Save state_fit 
    11791164        self.save_current_state_fit() 
     
    11911176        """ 
    11921177        if state == None: 
    1193             #self._undo.Enable(False) 
    1194             return  
     1178            return 
    11951179        # set data, etc. from the state 
    11961180        # reset page between theory and fitting from bookmarking 
     
    12001184        data = state.data 
    12011185 
    1202         #if data != None: 
    1203          
    12041186        if data == None: 
    12051187            data_min = state.qmin 
     
    12071189            self.qmin_x = data_min 
    12081190            self.qmax_x = data_max 
    1209             #self.minimum_q.SetValue(str(data_min)) 
    1210             #self.maximum_q.SetValue(str(data_max)) 
    12111191            self.qmin.SetValue(str(data_min)) 
    12121192            self.qmax.SetValue(str(data_max)) 
     
    12181198            self.set_data(data) 
    12191199             
    1220         self.enable2D= state.enable2D 
     1200        self.enable2D = state.enable2D 
    12211201        self.engine_type = state.engine_type 
    12221202 
     
    12251205       
    12261206        ## set the state of the radio box 
    1227         self.shape_rbutton.SetValue(state.shape_rbutton ) 
     1207        self.shape_rbutton.SetValue(state.shape_rbutton) 
    12281208        self.shape_indep_rbutton.SetValue(state.shape_indep_rbutton) 
    12291209        self.struct_rbutton.SetValue(state.struct_rbutton) 
     
    12391219            formfactor_pos = 0 
    12401220            for ind_form in range(self.formfactorbox.GetCount()): 
    1241                 if self.formfactorbox.GetString(ind_form).count(state.formfactorcombobox)>0: 
     1221                if self.formfactorbox.GetString(ind_form).count(state.formfactorcombobox) > 0: 
    12421222                    formfactor_pos = int(ind_form) 
    12431223                    break 
     
    12511231            structfactor_pos = 0 
    12521232            for ind_struct in range(self.structurebox.GetCount()): 
    1253                 if self.structurebox.GetString(ind_struct).count(state.structurecombobox)>0: 
     1233                if self.structurebox.GetString(ind_struct).count(state.structurecombobox) > 0: 
    12541234                    structfactor_pos = int(ind_struct) 
    12551235                    break 
     
    12621242        #reset the fitting engine type 
    12631243        self.engine_type = state.engine_type 
    1264         #draw the pnael according to the new model parameter  
     1244        #draw the pnael according to the new model parameter 
    12651245        self._on_select_model(event=None) 
    12661246             
     
    12731253        # else: 
    12741254                 
    1275         if self._manager !=None and self.engine_type != None: 
     1255        if self._manager != None and self.engine_type != None: 
    12761256            self._manager._on_change_engine(engine=self.engine_type) 
    12771257        ## set the select all check box to the a given state 
     
    12851265        self._reset_parameters_state(self.str_parameters, 
    12861266                                     state.str_parameters) 
    1287         self._reset_parameters_state(self.parameters,state.parameters)     
    1288          ## display dispersion info layer         
     1267        self._reset_parameters_state(self.parameters, state.parameters) 
     1268        ## display dispersion info layer 
    12891269        self.enable_disp.SetValue(state.enable_disp) 
    12901270        self.disable_disp.SetValue(state.disable_disp) 
     
    12941274            self._set_dipers_Param(event=None) 
    12951275            self._reset_page_disp_helper(state) 
    1296         ##plotting range restore     
     1276        ##plotting range restore 
    12971277        self._reset_plotting_range(state) 
    12981278        ## smearing info  restore 
    12991279        if hasattr(self, "enable_smearer"): 
    1300             ## set smearing value whether or not the data  
     1280            ## set smearing value whether or not the data 
    13011281            #contain the smearing info 
    13021282            self.enable_smearer.SetValue(state.enable_smearer) 
    13031283            self.disable_smearer.SetValue(state.disable_smearer) 
    1304             self.onSmear(event=None)            
     1284            self.onSmear(event=None) 
    13051285        self.pinhole_smearer.SetValue(state.pinhole_smearer) 
    13061286        self.slit_smearer.SetValue(state.slit_smearer) 
     
    13181298  
    13191299        ## we have two more options for smearing 
    1320         if self.pinhole_smearer.GetValue(): self.onPinholeSmear(event=None) 
    1321         elif self.slit_smearer.GetValue(): self.onSlitSmear(event=None) 
     1300        if self.pinhole_smearer.GetValue(): 
     1301            self.onPinholeSmear(event=None) 
     1302        elif self.slit_smearer.GetValue(): 
     1303            self.onSlitSmear(event=None) 
    13221304         
    13231305        ## reset state of checkbox,textcrtl  and dispersity parameters value 
    1324         self._reset_parameters_state(self.fittable_param,state.fittable_param) 
    1325         self._reset_parameters_state(self.fixed_param,state.fixed_param) 
     1306        self._reset_parameters_state(self.fittable_param, state.fittable_param) 
     1307        self._reset_parameters_state(self.fixed_param, state.fixed_param) 
    13261308         
    13271309        ## draw the model with previous parameters value 
     
    13331315         
    13341316        ## set the value of the current state to the state given as parameter 
    1335         self.state = state.clone()  
     1317        self.state = state.clone() 
    13361318        self.state.m_name = self.m_name 
    13371319     
     
    13431325        for item in keys: 
    13441326            if item in self.disp_list and \ 
    1345                 not self.model.details.has_key(item): 
     1327                not item in self.model.details: 
    13461328                self.model.details[item] = ["", None, None] 
    13471329        #for k,v in self.state.disp_cb_dict.iteritems(): 
    1348         self.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)  
     1330        self.disp_cb_dict = copy.deepcopy(state.disp_cb_dict) 
    13491331        self.state.disp_cb_dict = copy.deepcopy(state.disp_cb_dict) 
    13501332        self.values = copy.deepcopy(state.values) 
     
    13551337            # it will be sent as a string here, then converted to model object. 
    13561338            if disp.__class__.__name__ == 'str': 
    1357                 com_str  = "from sans.models.dispersion_models " 
     1339                com_str = "from sans.models.dispersion_models " 
    13581340                com_str += "import %s as disp_func" 
    13591341                exec com_str % disp 
     
    13621344                disp_model = disp 
    13631345 
    1364             self._disp_obj_dict[key] = disp_model  
     1346            self._disp_obj_dict[key] = disp_model 
    13651347            param_name = key.split('.')[0] 
    13661348            # Try to set dispersion only when available 
    1367             # for eg., pass the orient. angles for 1D Cal  
     1349            # for eg., pass the orient. angles for 1D Cal 
    13681350            try: 
    13691351                self.model.set_dispersion(param_name, disp_model) 
     
    13761358                if list[1] == key and list[7] != None: 
    13771359                    list[7].SetSelection(selection) 
    1378                     # For the array disp_model, set the values and weights  
     1360                    # For the array disp_model, set the values and weights 
    13791361                    if selection == 1: 
    1380                         disp_model.set_weights(self.values[key],  
    1381                                               self.weights[key]) 
     1362                        disp_model.set_weights(self.values[key], 
     1363                                               self.weights[key]) 
    13821364                        try: 
    13831365                            # Diables all fittable params for array 
     
    14011383        # Make sure the check box updated when all checked 
    14021384        if self.cb1.GetValue(): 
    1403             self.select_all_param(None)         
     1385            self.select_all_param(None) 
    14041386       
    14051387    def _selectDlg(self): 
     
    14071389        open a dialog file to selected the customized dispersity  
    14081390        """ 
    1409         import os 
    1410         if self.parent !=  None: 
     1391        if self.parent != None: 
    14111392            self._default_save_location = \ 
    14121393                        self.parent.parent._default_save_location 
    14131394        dlg = wx.FileDialog(self, "Choose a weight file", 
    1414                                 self._default_save_location , "",  
     1395                                self._default_save_location, "", 
    14151396                                "*.*", wx.OPEN) 
    14161397        path = None 
     
    14361417        Reset the plotting range to a given state 
    14371418        """ 
    1438         # if self.check_invalid_panel(): 
    1439         #    return 
    14401419        self.qmin.SetValue(str(state.qmin)) 
    1441         self.qmax.SetValue(str(state.qmax))  
     1420        self.qmax.SetValue(str(state.qmax)) 
    14421421 
    14431422    def _save_typeOfmodel(self): 
     
    14491428        self.state.struct_rbutton = self.struct_rbutton.GetValue() 
    14501429        self.state.plugin_rbutton = self.plugin_rbutton.GetValue() 
    1451         self.state.structurebox= self.structurebox.GetLabel()#.GetCurrentSelection() 
    1452         self.state.formfactorbox = self.formfactorbox.GetLabel()#.GetCurrentSelection() 
     1430        self.state.structurebox = self.structurebox.GetLabel() 
     1431        self.state.formfactorbox = self.formfactorbox.GetLabel() 
    14531432        
    1454         #self._undo.Enable(True) 
    14551433        ## post state to fit panel 
    1456         event = PageInfoEvent(page = self) 
     1434        event = PageInfoEvent(page=self) 
    14571435        wx.PostEvent(self.parent, event) 
    14581436         
    1459     def _save_plotting_range(self ): 
    1460         """ 
    1461         save the state of plotting range  
     1437    def _save_plotting_range(self): 
     1438        """ 
     1439        save the state of plotting range 
    14621440        """ 
    14631441        self.state.qmin = self.qmin_x 
    1464         self.state.qmax = self.qmax_x  
     1442        self.state.qmax = self.qmax_x 
    14651443        self.state.npts = self.npts_x 
    14661444             
    14671445    def _onparamEnter_helper(self): 
    14681446        """ 
    1469         check if values entered by the user are changed and valid to replot  
     1447        check if values entered by the user are changed and valid to replot 
    14701448        model 
    14711449        """ 
    1472         # Flag to register when a parameter has changed.    
     1450        # Flag to register when a parameter has changed. 
    14731451        is_modified = False 
    14741452        self.fitrange = True 
     
    14781456        if self.data.__class__.__name__ == "Data2D": 
    14791457            is_2Ddata = True 
    1480         if self.model !=None: 
     1458        if self.model != None: 
    14811459            try: 
    14821460                is_modified = self._check_value_enter(self.fittable_param, 
     
    14851463                                                      is_modified) 
    14861464                is_modified = self._check_value_enter(self.parameters, 
    1487                                                       is_modified)  
     1465                                                      is_modified) 
    14881466            except: 
    14891467                pass 
    14901468 
    14911469            # Here we should check whether the boundaries have been modified. 
    1492             # If qmin and qmax have been modified, update qmin and qmax and  
     1470            # If qmin and qmax have been modified, update qmin and qmax and 
    14931471            # set the is_modified flag to True 
    14941472            if self._validate_qrange(self.qmin, self.qmax): 
     
    15031481             
    15041482                if is_2Ddata: 
    1505                     # set mask    
     1483                    # set mask 
    15061484                    is_modified = self._validate_Npts() 
    15071485                     
    15081486            else: 
    1509                 self.fitrange = False     
     1487                self.fitrange = False 
    15101488                 
    15111489            if not self.data.is_data: 
     
    15151493            if not self.fitrange: 
    15161494                #self.btFit.Disable() 
    1517                 if is_2Ddata: self.btEditMask.Disable() 
     1495                if is_2Ddata: 
     1496                    self.btEditMask.Disable() 
    15181497            else: 
    1519                 #self.btFit.Enable(True) 
    1520                 if is_2Ddata  and self.data.is_data and not self.batch_on:  
     1498                if is_2Ddata and self.data.is_data and not self.batch_on: 
    15211499                    self.btEditMask.Enable(True) 
    15221500            if is_modified and self.fitrange: 
    1523                 #if self.data == None: 
    15241501                # Theory case: need to get npts value to draw 
    15251502                self.npts_x = float(self.Npts_total.GetValue()) 
    15261503                self.create_default_data() 
    1527                 self.state_change= True 
    1528                 self._draw_model()  
     1504                self.state_change = True 
     1505                self._draw_model() 
    15291506                self.Refresh() 
    15301507        return is_modified 
     
    15441521        ##So make sure that update param values on_Fit. 
    15451522        #self._undo.Enable(True) 
    1546         if self.model !=None:    
     1523        if self.model != None: 
    15471524            if self.Npts_total.GetValue() != self.Npts_fit.GetValue(): 
    15481525                if not self.data.is_data: 
    15491526                    self._manager.page_finder[self.uid].set_fit_data(data=\ 
    1550                                                                     [self.data])       
     1527                                                                [self.data]) 
    15511528            ##Check the values 
    1552             self._check_value_enter( self.fittable_param ,is_modified) 
    1553             self._check_value_enter( self.fixed_param ,is_modified) 
    1554             self._check_value_enter( self.parameters ,is_modified) 
     1529            self._check_value_enter(self.fittable_param, is_modified) 
     1530            self._check_value_enter(self.fixed_param, is_modified) 
     1531            self._check_value_enter(self.parameters, is_modified) 
    15551532 
    15561533            # If qmin and qmax have been modified, update qmin and qmax and  
    1557              # Here we should check whether the boundaries have been modified. 
     1534            # Here we should check whether the boundaries have been modified. 
    15581535            # If qmin and qmax have been modified, update qmin and qmax and  
    15591536            # set the is_modified flag to True 
     
    15671544                    self.qmax_x = tempmax 
    15681545                if tempmax == tempmin: 
    1569                     flag = False     
     1546                    flag = False 
    15701547                temp_smearer = None 
    15711548                if not self.disable_smearer.GetValue(): 
    1572                     temp_smearer= self.current_smearer 
     1549                    temp_smearer = self.current_smearer 
    15731550                    if self.slit_smearer.GetValue(): 
    15741551                        flag = self.update_slit_smear() 
     
    15791556                                                  uid=self.uid, 
    15801557                                                  fid=self.data.id, 
    1581                                                      qmin=float(self.qmin_x), 
    1582                                                       qmax=float(self.qmax_x), 
     1558                                                  qmin=float(self.qmin_x), 
     1559                                                  qmax=float(self.qmax_x), 
    15831560                            enable_smearer=not self.disable_smearer.GetValue(), 
    15841561                                                      draw=False) 
     
    15861563                    self._manager.set_smearer(smearer=temp_smearer, 
    15871564                                              qmin=float(self.qmin_x), 
    1588                                               uid=self.uid,  
     1565                                              uid=self.uid, 
    15891566                                              fid=self.data.id, 
    1590                                                  qmax= float(self.qmax_x), 
     1567                                              qmax=float(self.qmax_x), 
    15911568                            enable_smearer=not self.disable_smearer.GetValue(), 
    15921569                                                 draw=False) 
    15931570                    if self.data != None: 
    1594                         index_data = ((self.qmin_x <= self.data.x)&\ 
     1571                        index_data = ((self.qmin_x <= self.data.x) & \ 
    15951572                                      (self.data.x <= self.qmax_x)) 
    1596                         val = str(len(self.data.x[index_data==True])) 
     1573                        val = str(len(self.data.x[index_data == True])) 
    15971574                        self.Npts_fit.SetValue(val) 
    15981575                    else: 
     
    16051582                    flag = True 
    16061583                if self._is_2D(): 
    1607                     # only 2D case set mask   
     1584                    # only 2D case set mask 
    16081585                    flag = self._validate_Npts() 
    16091586                    if not flag: 
    16101587                        return flag 
    1611             else: flag = False 
    1612         else:  
     1588            else: 
     1589                flag = False 
     1590        else: 
    16131591            flag = False 
    16141592 
    1615         #For invalid q range, disable the mask editor and fit button, vs.     
     1593        #For invalid q range, disable the mask editor and fit button, vs. 
    16161594        if not self.fitrange: 
    1617             #self.btFit.Disable() 
    16181595            if self._is_2D(): 
    16191596                self.btEditMask.Disable() 
    16201597        else: 
    1621             #self.btFit.Enable(True) 
    16221598            if self._is_2D() and  self.data.is_data and not self.batch_on: 
    16231599                self.btEditMask.Enable(True) 
     
    16331609            pass 
    16341610    
    1635         return flag                            
     1611        return flag 
    16361612                
    16371613    def _is_modified(self, is_modified): 
     
    16471623        if len(statelist) == 0 or len(listtorestore) == 0: 
    16481624            return 
    1649         if len(statelist) !=  len(listtorestore): 
     1625        if len(statelist) != len(listtorestore): 
    16501626            return 
    16511627 
     
    16541630            item_page_info = statelist[j] 
    16551631            ##change the state of the check box for simple parameters 
    1656             if item_page[0]!=None:    
     1632            if item_page[0] != None: 
    16571633                item_page[0].SetValue(item_page_info[0]) 
    1658             if item_page[2]!=None: 
     1634            if item_page[2] != None: 
    16591635                item_page[2].SetValue(item_page_info[2]) 
    16601636                if item_page[2].__class__.__name__ == "ComboBox": 
    1661                    if self.model.fun_list.has_key(item_page_info[2]): 
    1662                        fun_val = self.model.fun_list[item_page_info[2]] 
    1663                        self.model.setParam(item_page_info[1],fun_val) 
    1664             if item_page[3]!=None: 
     1637                    if item_page_info[2] in self.model.fun_list: 
     1638                        fun_val = self.model.fun_list[item_page_info[2]] 
     1639                        self.model.setParam(item_page_info[1], fun_val) 
     1640            if item_page[3] != None: 
    16651641                ## show or hide text +/- 
    16661642                if item_page_info[2]: 
     
    16681644                else: 
    16691645                    item_page[3].Hide() 
    1670             if item_page[4]!=None: 
     1646            if item_page[4] != None: 
    16711647                ## show of hide the text crtl for fitting error 
    16721648                if item_page_info[4][0]: 
     
    16751651                else: 
    16761652                    item_page[3].Hide() 
    1677             if item_page[5]!=None: 
     1653            if item_page[5] != None: 
    16781654                ## show of hide the text crtl for fitting error 
    16791655                item_page[5].Show(item_page_info[5][0]) 
    16801656                item_page[5].SetValue(item_page_info[5][1]) 
    16811657                 
    1682             if item_page[6]!=None: 
     1658            if item_page[6] != None: 
    16831659                ## show of hide the text crtl for fitting error 
    16841660                item_page[6].Show(item_page_info[6][0]) 
    16851661                item_page[6].SetValue(item_page_info[6][1]) 
    1686  
    16871662                     
    16881663    def _reset_strparam_state(self, listtorestore, statelist): 
     
    17001675            ##change the state of the check box for simple parameters 
    17011676             
    1702             if item_page[0] != None:    
     1677            if item_page[0] != None: 
    17031678                item_page[0].SetValue(format_number(item_page_info[0], True)) 
    17041679 
     
    17071682                value = item_page_info[2] 
    17081683                selection = value 
    1709                 if self.model.fun_list.has_key(value): 
     1684                if value in self.model.fun_list: 
    17101685                    selection = self.model.fun_list[value] 
    17111686                item_page[2].SetValue(selection) 
     
    17141689    def _copy_parameters_state(self, listtocopy, statelist): 
    17151690        """ 
    1716         copy the state of button  
     1691        copy the state of button 
    17171692         
    17181693        :param listtocopy: the list of check button to copy 
     
    17201695         
    17211696        """ 
    1722         if len(listtocopy)==0: 
     1697        if len(listtocopy) == 0: 
    17231698            return 
    17241699        
     
    17261701   
    17271702            checkbox_state = None 
    1728             if item[0]!= None: 
    1729                 checkbox_state= item[0].GetValue() 
     1703            if item[0] != None: 
     1704                checkbox_state = item[0].GetValue() 
    17301705            parameter_name = item[1] 
    17311706            parameter_value = None 
    1732             if item[2]!=None: 
     1707            if item[2] != None: 
    17331708                parameter_value = item[2].GetValue() 
    17341709            static_text = None 
    1735             if item[3]!=None: 
     1710            if item[3] != None: 
    17361711                static_text = item[3].IsShown() 
    17371712            error_value = None 
    17381713            error_state = None 
    1739             if item[4]!= None: 
     1714            if item[4] != None: 
    17401715                error_value = item[4].GetValue() 
    17411716                error_state = item[4].IsShown() 
     
    17431718            min_value = None 
    17441719            min_state = None 
    1745             if item[5]!= None: 
     1720            if item[5] != None: 
    17461721                min_value = item[5].GetValue() 
    17471722                min_state = item[5].IsShown() 
     
    17491724            max_value = None 
    17501725            max_state = None 
    1751             if item[6]!= None: 
     1726            if item[6] != None: 
    17521727                max_value = item[6].GetValue() 
    17531728                max_state = item[6].IsShown() 
    1754             unit=None 
    1755             if item[7]!=None: 
     1729            unit = None 
     1730            if item[7] != None: 
    17561731                unit = item[7].GetLabel() 
    17571732                
    17581733            statelist.append([checkbox_state, parameter_name, parameter_value, 
    1759                               static_text ,[error_state, error_value], 
    1760                                 [min_state, min_value], 
    1761                                 [max_state, max_value], unit]) 
     1734                              static_text, [error_state, error_value], 
     1735                              [min_state, min_value], 
     1736                              [max_state, max_value], unit]) 
    17621737            
    17631738    def _set_model_sizer_selection(self, model): 
     
    17671742        if model == None: 
    17681743            return 
    1769         if hasattr(model ,"s_model"): 
     1744        if hasattr(model, "s_model"): 
    17701745             
    17711746            class_name = model.s_model.__class__ 
     
    17751750                (class_name in self.model_list_box["Structure Factors"]): 
    17761751                self.structurebox.Show() 
    1777                 self.text2.Show()                 
     1752                self.text2.Show() 
    17781753                self.structurebox.Enable() 
    17791754                self.text2.Enable() 
     
    17821757                 
    17831758                for i in range(len(items)): 
    1784                     if items[i]== str(name): 
     1759                    if items[i] == str(name): 
    17851760                        self.structurebox.SetSelection(i) 
    17861761                        break 
    17871762                     
    1788         if hasattr(model ,"p_model"): 
     1763        if hasattr(model, "p_model"): 
    17891764            class_name = model.p_model.__class__ 
    17901765            name = model.p_model.name 
     
    17921767             
    17931768            for k, list in self.model_list_box.iteritems(): 
    1794                 if k in["P(Q)*S(Q)","Shapes" ] and class_name in self.model_list_box["Shapes"]: 
     1769                if k in["P(Q)*S(Q)", "Shapes"] and \ 
     1770                    class_name in self.model_list_box["Shapes"]: 
    17951771                    self.shape_rbutton.SetValue(True) 
    17961772                    ## fill the form factor list with new model 
    1797                     self._populate_box(self.formfactorbox,self.model_list_box["Shapes"]) 
     1773                    self._populate_box(self.formfactorbox, 
     1774                                       self.model_list_box["Shapes"]) 
    17981775                    items = self.formfactorbox.GetItems() 
    17991776                    ## set comboxbox to the selected item 
    18001777                    for i in range(len(items)): 
    1801                         if items[i]== str(name): 
     1778                        if items[i] == str(name): 
    18021779                            self.formfactorbox.SetSelection(i) 
    18031780                            break 
     
    18061783                    self.shape_indep_rbutton.SetValue(True) 
    18071784                elif k == "Structure Factors": 
    1808                      self.struct_rbutton.SetValue(True) 
    1809                 elif  k == "Multi-Functions": 
     1785                    self.struct_rbutton.SetValue(True) 
     1786                elif k == "Multi-Functions": 
    18101787                    continue 
    18111788                else: 
     
    18181795                    ## set comboxbox to the selected item 
    18191796                    for i in range(len(items)): 
    1820                         if items[i]== str(name): 
     1797                        if items[i] == str(name): 
    18211798                            self.formfactorbox.SetSelection(i) 
    18221799                            break 
    18231800                    break 
    18241801        else: 
    1825  
    18261802            ## Select the model from the menu 
    18271803            class_name = model.__class__ 
     
    18301806            items = self.formfactorbox.GetItems() 
    18311807     
    1832             for k, list in self.model_list_box.iteritems():           
    1833                 if k in["P(Q)*S(Q)","Shapes" ] and class_name in self.model_list_box["Shapes"]: 
     1808            for k, list in self.model_list_box.iteritems(): 
     1809                if k in["P(Q)*S(Q)", "Shapes"] and \ 
     1810                    class_name in self.model_list_box["Shapes"]: 
    18341811                    if class_name in self.model_list_box["P(Q)*S(Q)"]: 
    18351812                        self.structurebox.Show() 
     
    18471824                    self.shape_rbutton.SetValue(True) 
    18481825                    ## fill the form factor list with new model 
    1849                     self._populate_box(self.formfactorbox,self.model_list_box["Shapes"]) 
     1826                    self._populate_box(self.formfactorbox, 
     1827                                       self.model_list_box["Shapes"]) 
    18501828                    items = self.formfactorbox.GetItems() 
    18511829                    ## set comboxbox to the selected item 
    18521830                    for i in range(len(items)): 
    1853                         if items[i]== str(name): 
     1831                        if items[i] == str(name): 
    18541832                            self.formfactorbox.SetSelection(i) 
    18551833                            break 
     
    18591837                elif k == "Structure Factors": 
    18601838                    self.struct_rbutton.SetValue(True) 
    1861                 elif  k == "Multi-Functions": 
     1839                elif k == "Multi-Functions": 
    18621840                    continue 
    18631841                else: 
     
    18661844                    self.structurebox.SetSelection(0) 
    18671845                    self.structurebox.Disable() 
    1868                     self.text2.Disable()                     
     1846                    self.text2.Disable() 
    18691847                    ## fill the form factor list with new model 
    18701848                    self._populate_box(self.formfactorbox, list) 
     
    18721850                    ## set comboxbox to the selected item 
    18731851                    for i in range(len(items)): 
    1874                         if items[i]== str(name): 
     1852                        if items[i] == str(name): 
    18751853                            self.formfactorbox.SetSelection(i) 
    18761854                            break 
     
    18971875        #if self.check_invalid_panel(): 
    18981876        #    return 
    1899         if self.model !=None: 
    1900             temp_smear=None 
     1877        if self.model != None: 
     1878            temp_smear = None 
    19011879            if hasattr(self, "enable_smearer"): 
    19021880                if not self.disable_smearer.GetValue(): 
    1903                     temp_smear= self.current_smearer 
     1881                    temp_smear = self.current_smearer 
    19041882            # compute weight for the current data 
    19051883            from .utils import get_weight 
     
    19081886            toggle_mode_on = self.model_view.IsEnabled() 
    19091887            is_2d = self._is_2D() 
    1910             self._manager.draw_model(self.model,  
     1888            self._manager.draw_model(self.model, 
    19111889                                    data=self.data, 
    1912                                     smearer= temp_smear, 
    1913                                     qmin=float(self.qmin_x),  
     1890                                    smearer=temp_smear, 
     1891                                    qmin=float(self.qmin_x), 
    19141892                                    qmax=float(self.qmax_x), 
    19151893                                    page_id=self.uid, 
    1916                                     toggle_mode_on=toggle_mode_on,  
    1917                                     state = self.state, 
     1894                                    toggle_mode_on=toggle_mode_on, 
     1895                                    state=self.state, 
    19181896                                    enable2D=is_2d, 
    19191897                                    update_chisqr=update_chisqr, 
     
    19211899                                    weight=weight) 
    19221900         
    1923         
    19241901    def _on_show_sld(self, event=None): 
    19251902        """ 
     
    19271904        """ 
    19281905        # get profile data 
    1929         x,y=self.model.getProfile() 
     1906        x, y = self.model.getProfile() 
    19301907 
    19311908        from danse.common.plottools import Data1D 
     
    19331910        from sans.guiframe.local_perspectives.plotting.profile_dialog \ 
    19341911        import SLDPanel 
    1935         sld_data = Data1D(x,y) 
     1912        sld_data = Data1D(x, y) 
    19361913        sld_data.name = 'SLD' 
    19371914        sld_data.axes = self.sld_axes 
    1938         self.panel = SLDPanel(self, data=sld_data, axes =self.sld_axes,id =-1) 
    1939         self.panel.ShowModal()     
    1940          
    1941     def _set_multfactor_combobox(self, multiplicity=10):    
     1915        self.panel = SLDPanel(self, data=sld_data, axes=self.sld_axes, id=-1) 
     1916        self.panel.ShowModal() 
     1917         
     1918    def _set_multfactor_combobox(self, multiplicity=10): 
    19421919        """ 
    19431920        Set comboBox for muitfactor of CoreMultiShellModel 
     
    19451922        """ 
    19461923        # build content of the combobox 
    1947         for idx in range(0,multiplicity): 
    1948             self.multifactorbox.Append(str(idx),int(idx)) 
    1949             #self.multifactorbox.SetSelection(1)  
     1924        for idx in range(0, multiplicity): 
     1925            self.multifactorbox.Append(str(idx), int(idx)) 
    19501926        self._hide_multfactor_combobox() 
    19511927         
    1952     def _show_multfactor_combobox(self):    
     1928    def _show_multfactor_combobox(self): 
    19531929        """ 
    19541930        Show the comboBox of muitfactor of CoreMultiShellModel 
    1955         """  
     1931        """ 
    19561932        if not self.mutifactor_text.IsShown(): 
    19571933            self.mutifactor_text.Show(True) 
    19581934            self.mutifactor_text1.Show(True) 
    19591935        if not self.multifactorbox.IsShown(): 
    1960             self.multifactorbox.Show(True)   
     1936            self.multifactorbox.Show(True) 
    19611937              
    1962     def _hide_multfactor_combobox(self):    
     1938    def _hide_multfactor_combobox(self): 
    19631939        """ 
    19641940        Hide the comboBox of muitfactor of CoreMultiShellModel 
    1965         """  
     1941        """ 
    19661942        if self.mutifactor_text.IsShown(): 
    19671943            self.mutifactor_text.Hide() 
    19681944            self.mutifactor_text1.Hide() 
    19691945        if self.multifactorbox.IsShown(): 
    1970             self.multifactorbox.Hide()    
    1971  
    1972          
     1946            self.multifactorbox.Hide() 
     1947 
    19731948    def _show_combox_helper(self): 
    19741949        """ 
     
    19801955            self.structurebox.Disable() 
    19811956            self.formfactorbox.Clear() 
    1982             self._populate_box( self.formfactorbox,self.model_list_box["Shapes"]) 
     1957            self._populate_box(self.formfactorbox, 
     1958                               self.model_list_box["Shapes"]) 
    19831959        if self.shape_indep_rbutton.GetValue(): 
    19841960            ##fill the combobox with shape independent  factor list 
     
    19861962            self.structurebox.Disable() 
    19871963            self.formfactorbox.Clear() 
    1988             self._populate_box( self.formfactorbox, 
    1989                                 self.model_list_box["Shape-Independent"]) 
     1964            self._populate_box(self.formfactorbox, 
     1965                             self.model_list_box["Shape-Independent"]) 
    19901966        if self.struct_rbutton.GetValue(): 
    19911967            ##fill the combobox with structure factor list 
     
    19931969            self.structurebox.Disable() 
    19941970            self.formfactorbox.Clear() 
    1995             self._populate_box( self.formfactorbox, 
    1996                                 self.model_list_box["Structure Factors"]) 
     1971            self._populate_box(self.formfactorbox, 
     1972                               self.model_list_box["Structure Factors"]) 
    19971973        if self.plugin_rbutton.GetValue(): 
    19981974            ##fill the combobox with form factor list 
    19991975            self.structurebox.Disable() 
    20001976            self.formfactorbox.Clear() 
    2001             self._populate_box( self.formfactorbox, 
    2002                                 self.model_list_box["Customized Models"]) 
     1977            self._populate_box(self.formfactorbox, 
     1978                               self.model_list_box["Customized Models"]) 
    20031979         
    20041980    def _show_combox(self, event=None): 
     
    20061982        Show combox box associate with type of model selected 
    20071983        """ 
    2008         #if self.check_invalid_panel(): 
    2009         #    self.shape_rbutton.SetValue(True) 
    2010         #    return 
    20111984        self.Show(False) 
    20121985        self._show_combox_helper() 
     
    20282001        mlist = [] 
    20292002        for models in list: 
    2030             model= models() 
     2003            model = models() 
    20312004            name = model.__class__.__name__ 
    2032             if models.__name__!="NoStructure": 
     2005            if models.__name__ != "NoStructure": 
    20332006                if hasattr(model, "name"): 
    20342007                    name = model.name 
    2035                 mlist.append( (name, models) ) 
     2008                mlist.append((name, models)) 
    20362009                 
    20372010        # Sort the models 
    20382011        mlist_sorted = mlist 
    20392012        for item in mlist_sorted: 
    2040             combobox.Append(item[0],item[1]) 
     2013            combobox.Append(item[0], item[1]) 
    20412014        return 0 
    20422015     
     
    20662039                else: 
    20672040                    tcrtl.SetBackgroundColour("pink") 
    2068                     msg = "Model Error:wrong value entered : %s" % sys.exc_value 
     2041                    msg = "Model Error:wrong value entered: %s" % sys.exc_value 
    20692042                    wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    2070                     return  
     2043                    return 
    20712044            except: 
    20722045                tcrtl.SetBackgroundColour("pink") 
    2073                 msg = "Model Error:wrong value entered : %s" % sys.exc_value 
     2046                msg = "Model Error:wrong value entered: %s" % sys.exc_value 
    20742047                wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    2075                 return  
     2048                return 
    20762049            #Check if # of points for theory model are valid(>0). 
    20772050            if self.npts != None: 
    20782051                if check_float(self.npts): 
    20792052                    temp_npts = float(self.npts.GetValue()) 
    2080                     if temp_npts !=  self.num_points: 
     2053                    if temp_npts != self.num_points: 
    20812054                        self.num_points = temp_npts 
    20822055                        is_modified = True 
     
    20852058                    wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    20862059        else: 
    2087            tcrtl.SetBackgroundColour("pink") 
    2088            msg = "Model Error:wrong value entered!!!" 
    2089            wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    2090         #self._undo.Enable(True) 
     2060            tcrtl.SetBackgroundColour("pink") 
     2061            msg = "Model Error:wrong value entered!!!" 
     2062            wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    20912063        self.save_current_state() 
    20922064        event = PageInfoEvent(page=self) 
     
    21032075        """ 
    21042076         
    2105         tcrtl= event.GetEventObject() 
     2077        tcrtl = event.GetEventObject() 
    21062078        #Clear msg if previously shown. 
    2107         msg= "" 
    2108         wx.PostEvent(self.parent.parent, StatusEvent(status = msg )) 
     2079        msg = "" 
     2080        wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
    21092081        # Flag to register when a parameter has changed. 
    21102082        is_modified = False 
    2111         if tcrtl.GetValue().lstrip().rstrip()!="": 
     2083        if tcrtl.GetValue().lstrip().rstrip() != "": 
    21122084            try: 
    21132085                value = float(tcrtl.GetValue()) 
     
    21242096                else: 
    21252097                    tcrtl.SetBackgroundColour("pink") 
    2126                     msg= "Model Error:wrong value entered : %s"% sys.exc_value 
    2127                     wx.PostEvent(self._manager.parent, StatusEvent(status = msg )) 
    2128                     return   
     2098                    msg = "Model Error:wrong value entered: %s" % sys.exc_value 
     2099                    wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
     2100                    return 
    21292101            except: 
    21302102                tcrtl.SetBackgroundColour("pink") 
    2131                 msg= "Model Error:wrong value entered : %s"% sys.exc_value 
    2132                 wx.PostEvent(self._manager.parent, StatusEvent(status = msg )) 
    2133                 return  
     2103                msg = "Model Error:wrong value entered: %s" % sys.exc_value 
     2104                wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
     2105                return 
    21342106            #Check if # of points for theory model are valid(>0). 
    2135             if self.Npts_total.IsEditable() : 
     2107            if self.Npts_total.IsEditable(): 
    21362108                if check_float(self.Npts_total): 
    21372109                    temp_npts = float(self.Npts_total.GetValue()) 
    2138                     if temp_npts !=  self.num_points: 
     2110                    if temp_npts != self.num_points: 
    21392111                        self.num_points = temp_npts 
    21402112                        is_modified = True 
    21412113                else: 
    2142                     msg= "Cannot Plot :No npts in that Qrange!!!  " 
    2143                     wx.PostEvent(self.parent.parent, StatusEvent(status = msg )) 
     2114                    msg = "Cannot Plot :No npts in that Qrange!!!  " 
     2115                    wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
    21442116        else: 
    2145            tcrtl.SetBackgroundColour("pink") 
    2146            msg = "Model Error:wrong value entered!!!" 
    2147            wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
    2148         #self._undo.Enable(True) 
     2117            tcrtl.SetBackgroundColour("pink") 
     2118            msg = "Model Error:wrong value entered!!!" 
     2119            wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
    21492120        self.save_current_state() 
    2150         event = PageInfoEvent(page = self) 
     2121        event = PageInfoEvent(page=self) 
    21512122        wx.PostEvent(self.parent, event) 
    2152         self.state_change= False 
     2123        self.state_change = False 
    21532124        #Draw the model for a different range 
    21542125        self.create_default_data() 
    21552126        self._draw_model() 
    21562127                    
    2157     def _on_select_model_helper(self):  
     2128    def _on_select_model_helper(self): 
    21582129        """ 
    21592130        call back for model selection 
     
    21612132        ## reset dictionary containing reference to dispersion 
    21622133        self._disp_obj_dict = {} 
    2163         self.disp_cb_dict ={} 
     2134        self.disp_cb_dict = {} 
    21642135        self.temp_multi_functional = False 
    21652136        f_id = self.formfactorbox.GetCurrentSelection() 
     
    21712142        if not form_factor in  self.model_list_box["multiplication"]: 
    21722143            self.structurebox.Hide() 
    2173             self.text2.Hide()            
     2144            self.text2.Hide() 
    21742145            self.structurebox.Disable() 
    21752146            self.structurebox.SetSelection(0) 
     
    21812152            self.text2.Enable() 
    21822153             
    2183         if form_factor != None:     
    2184             # set multifactor for Mutifunctional models     
     2154        if form_factor != None: 
     2155            # set multifactor for Mutifunctional models 
    21852156            if form_factor().__class__ in self.model_list_box["Multi-Functions"]: 
    21862157                m_id = self.multifactorbox.GetCurrentSelection() 
    21872158                multiplicity = form_factor().multiplicity_info[0] 
    21882159                self.multifactorbox.Clear() 
    2189                 #self.mutifactor_text.SetLabel(form_factor().details[]) 
    21902160                self._set_multfactor_combobox(multiplicity) 
    21912161                self._show_multfactor_combobox() 
    2192                 #ToDo:  this info should be called directly from the model  
    2193                 text = form_factor().multiplicity_info[1]#'No. of Shells: ' 
    2194  
    2195                 #self.mutifactor_text.Clear() 
     2162                #ToDo:  this info should be called directly from the model 
     2163                text = form_factor().multiplicity_info[1]  # 'No. of Shells: ' 
     2164 
    21962165                self.mutifactor_text.SetLabel(text) 
    2197                 if m_id > multiplicity -1: 
     2166                if m_id > multiplicity - 1: 
    21982167                    # default value 
    21992168                    m_id = 1 
    22002169                     
    22012170                self.multi_factor = self.multifactorbox.GetClientData(m_id) 
    2202                 if self.multi_factor == None: self.multi_factor =0 
     2171                if self.multi_factor == None: 
     2172                    self.multi_factor = 0 
    22032173                form_factor = form_factor(int(self.multi_factor)) 
    22042174                self.multifactorbox.SetSelection(m_id) 
     
    22232193            self._hide_multfactor_combobox() 
    22242194            self.show_sld_button.Hide() 
    2225             self.multi_factor = None   
     2195            self.multi_factor = None 
    22262196               
    22272197        s_id = self.structurebox.GetCurrentSelection() 
    2228         struct_factor = self.structurebox.GetClientData( s_id ) 
    2229          
    2230         if  struct_factor !=None: 
     2198        struct_factor = self.structurebox.GetClientData(s_id) 
     2199         
     2200        if  struct_factor != None: 
    22312201            from sans.models.MultiplicationModel import MultiplicationModel 
    2232             self.model= MultiplicationModel(form_factor,struct_factor()) 
     2202            self.model = MultiplicationModel(form_factor, struct_factor()) 
    22332203            # multifunctional form factor 
    22342204            if len(form_factor.non_fittable) > 0: 
     
    22362206        else: 
    22372207            if form_factor != None: 
    2238                 self.model= form_factor 
     2208                self.model = form_factor 
    22392209            else: 
    22402210                self.model = None 
     
    22422212             
    22432213        ## post state to fit panel 
    2244         self.state.parameters =[] 
    2245         self.state.model =self.model 
     2214        self.state.parameters = [] 
     2215        self.state.model = self.model 
    22462216        self.state.qmin = self.qmin_x 
    22472217        self.state.multi_factor = self.multi_factor 
    2248         self.disp_list =self.model.getDispParamList() 
     2218        self.disp_list = self.model.getDispParamList() 
    22492219        self.state.disp_list = self.disp_list 
    22502220        self.on_set_focus(None) 
    2251         self.Layout()      
     2221        self.Layout() 
    22522222         
    22532223    def _validate_qrange(self, qmin_ctrl, qmax_ctrl): 
     
    22592229        :param qmax_ctrl: text control for Qmax 
    22602230         
    2261         :return: True is the Q range is value, False otherwise  
     2231        :return: True is the Q range is value, False otherwise 
    22622232         
    22632233        """ 
     
    22702240            qmax = float(qmax_ctrl.GetValue()) 
    22712241            if qmin < qmax: 
    2272                 #Make sure to set both colours white.   
     2242                #Make sure to set both colours white. 
    22732243                qmin_ctrl.SetBackgroundColour(wx.WHITE) 
    22742244                qmin_ctrl.Refresh() 
     
    22802250                qmax_ctrl.SetBackgroundColour("pink") 
    22812251                qmax_ctrl.Refresh() 
    2282                 msg= "Invalid Q range: Q min must be smaller than Q max" 
    2283                 wx.PostEvent(self.parent.parent, StatusEvent(status = msg)) 
     2252                msg = "Invalid Q range: Q min must be smaller than Q max" 
     2253                wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
    22842254                return False 
    22852255        return True 
    22862256     
    2287     def _validate_Npts(self):   
     2257    def _validate_Npts(self): 
    22882258        """ 
    22892259        Validate the number of points for fitting is more than 10 points. 
     
    22972267        for data in self.data_list: 
    22982268            # q value from qx and qy 
    2299             radius= numpy.sqrt( data.qx_data * data.qx_data +  
    2300                                 data.qy_data * data.qy_data ) 
     2269            radius = numpy.sqrt(data.qx_data * data.qx_data + 
     2270                                data.qy_data * data.qy_data) 
    23012271            #get unmasked index 
    23022272            index_data = (float(self.qmin.GetValue()) <= radius) & \ 
    23032273                            (radius <= float(self.qmax.GetValue())) 
    2304             index_data = (index_data) & (data.mask)  
     2274            index_data = (index_data) & (data.mask) 
    23052275            index_data = (index_data) & (numpy.isfinite(data.data)) 
    23062276 
     
    23112281                self.qmax.SetBackgroundColour("pink") 
    23122282                self.qmax.Refresh() 
    2313                 msg= "Npts of Data Error :No or too little npts of %s."% data.name 
    2314                 wx.PostEvent(self.parent.parent, StatusEvent(status = msg )) 
     2283                msg = "Npts of Data Error :No or too little npts of %s." % data.name 
     2284                wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
    23152285                self.fitrange = False 
    23162286                flag = False 
    23172287            else: 
    2318                 self.Npts_fit.SetValue(str(len(index_data[index_data==True]))) 
     2288                self.Npts_fit.SetValue(str(len(index_data[index_data == True]))) 
    23192289                self.fitrange = True 
    23202290             
    23212291        return flag 
    23222292 
    2323     def _validate_Npts_1D(self):   
     2293    def _validate_Npts_1D(self): 
    23242294        """ 
    23252295        Validate the number of points for fitting is more than 5 points. 
     
    23332303        for data in self.data_list: 
    23342304            # q value from qx and qy 
    2335             radius= data.x 
     2305            radius = data.x 
    23362306            #get unmasked index 
    23372307            index_data = (float(self.qmin.GetValue()) <= radius) & \ 
     
    23452315                self.qmax.SetBackgroundColour("pink") 
    23462316                self.qmax.Refresh() 
    2347                 msg= "Npts of Data Error :No or too little npts of %s."% data.name 
    2348                 wx.PostEvent(self.parent.parent, StatusEvent(status = msg )) 
     2317                msg = "Npts of Data Error :No or too little npts of %s." % data.name 
     2318                wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
    23492319                self.fitrange = False 
    23502320                flag = False 
    23512321            else: 
    2352                 self.Npts_fit.SetValue(str(len(index_data[index_data==True]))) 
     2322                self.Npts_fit.SetValue(str(len(index_data[index_data == True]))) 
    23532323                self.fitrange = True 
    23542324             
    23552325        return flag 
    2356  
    2357  
    23582326     
    23592327    def _check_value_enter(self, list, modified): 
     
    23622330        :Note: each item of the list should be as follow: 
    23632331            item=[check button state, parameter's name, 
    2364                 paramater's value, string="+/-",  
    2365                 parameter's error of fit,  
    2366                 parameter's minimum value,  
    2367                 parrameter's maximum value ,  
     2332                paramater's value, string="+/-", 
     2333                parameter's error of fit, 
     2334                parameter's minimum value, 
     2335                parrameter's maximum value , 
    23682336                parameter's units] 
    2369         """   
    2370         is_modified =  modified 
    2371         if len(list)==0: 
     2337        """ 
     2338        is_modified = modified 
     2339        if len(list) == 0: 
    23722340            return is_modified 
    23732341        for item in list: 
    23742342            #skip angle parameters for 1D 
    2375             if not self.enable2D:#self.data.__class__.__name__ !="Data2D": 
     2343            if not self.enable2D: 
    23762344                if item in self.orientation_params: 
    23772345                    continue 
     
    23792347            name = str(item[1]) 
    23802348             
    2381             if string.find(name,".npts") ==-1 and \ 
    2382                                         string.find(name,".nsigmas")==-1:       
    2383                 ## check model parameters range              
    2384                 param_min= None 
    2385                 param_max= None 
     2349            if string.find(name, ".npts") == -1 and \ 
     2350                                        string.find(name, ".nsigmas") == -1: 
     2351                ## check model parameters range 
     2352                param_min = None 
     2353                param_max = None 
    23862354                
    23872355                ## check minimun value 
    2388                 if item[5]!= None and item[5]!= "": 
    2389                     if item[5].GetValue().lstrip().rstrip()!="": 
     2356                if item[5] != None and item[5] != "": 
     2357                    if item[5].GetValue().lstrip().rstrip() != "": 
    23902358                        try: 
    2391                              
    23922359                            param_min = float(item[5].GetValue()) 
    2393                             if not self._validate_qrange(item[5],item[2]): 
     2360                            if not self._validate_qrange(item[5], item[2]): 
    23942361                                if numpy.isfinite(param_min): 
    23952362                                    item[2].SetValue(format_number(param_min)) 
     
    24002367                        except: 
    24012368                            msg = "Wrong Fit parameter range entered " 
    2402                             wx.PostEvent(self.parent.parent,  
    2403                                          StatusEvent(status = msg)) 
     2369                            wx.PostEvent(self.parent.parent, 
     2370                                         StatusEvent(status=msg)) 
    24042371                            raise ValueError, msg 
    24052372                        is_modified = True 
    24062373                ## check maximum value 
    2407                 if item[6]!= None and item[6]!= "": 
    2408                     if item[6].GetValue().lstrip().rstrip()!="": 
    2409                         try:                           
     2374                if item[6] != None and item[6] != "": 
     2375                    if item[6].GetValue().lstrip().rstrip() != "": 
     2376                        try: 
    24102377                            param_max = float(item[6].GetValue()) 
    2411                             if not self._validate_qrange(item[2],item[6]): 
     2378                            if not self._validate_qrange(item[2], item[6]): 
    24122379                                if numpy.isfinite(param_max): 
    2413                                     item[2].SetValue(format_number(param_max))   
     2380                                    item[2].SetValue(format_number(param_max)) 
    24142381                             
    24152382                            item[6].SetBackgroundColour(wx.WHITE) 
     
    24172384                        except: 
    24182385                            msg = "Wrong Fit parameter range entered " 
    2419                             wx.PostEvent(self.parent.parent,  
    2420                                          StatusEvent(status = msg)) 
     2386                            wx.PostEvent(self.parent.parent, 
     2387                                         StatusEvent(status=msg)) 
    24212388                            raise ValueError, msg 
    24222389                        is_modified = True 
    24232390                 
    2424  
    2425                 if param_min != None and param_max !=None: 
     2391                if param_min != None and param_max != None: 
    24262392                    if not self._validate_qrange(item[5], item[6]): 
    2427                         msg= "Wrong Fit range entered for parameter " 
    2428                         msg+= "name %s of model %s "%(name, self.model.name) 
    2429                         wx.PostEvent(self.parent.parent,  
    2430                                      StatusEvent(status = msg)) 
     2393                        msg = "Wrong Fit range entered for parameter " 
     2394                        msg += "name %s of model %s " % (name, self.model.name) 
     2395                        wx.PostEvent(self.parent.parent, 
     2396                                     StatusEvent(status=msg)) 
    24312397                 
    2432                 if name in self.model.details.keys():    
     2398                if name in self.model.details.keys(): 
    24332399                        self.model.details[name][1:3] = param_min, param_max 
    24342400                        is_modified = True 
    2435                
    24362401                else: 
    2437                         self.model.details [name] = ["", param_min, param_max]  
     2402                        self.model.details[name] = ["", param_min, param_max] 
    24382403                        is_modified = True 
    2439             try:    
     2404            try: 
    24402405                # Check if the textctr is enabled 
    24412406                if item[2].IsEnabled(): 
    2442                     value= float(item[2].GetValue()) 
     2407                    value = float(item[2].GetValue()) 
    24432408                    item[2].SetBackgroundColour("white") 
    24442409                    # If the value of the parameter has changed, 
     
    24472412                                                numpy.isfinite(value): 
    24482413                        self.model.setParam(name, value) 
    2449                          
    24502414            except: 
    24512415                item[2].SetBackgroundColour("pink") 
    24522416                msg = "Wrong Fit parameter value entered " 
    2453                 wx.PostEvent(self.parent.parent, StatusEvent(status = msg)) 
     2417                wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
    24542418                 
    2455         return is_modified  
    2456          
    2457   
     2419        return is_modified 
     2420         
    24582421    def _set_dipers_Param(self, event): 
    24592422        """ 
    24602423        respond to self.enable_disp and self.disable_disp radio box. 
    2461         The dispersity object is reset inside the model into Gaussian.  
    2462         When the user select yes , this method display a combo box for more selection 
    2463         when the user selects No,the combo box disappears. 
     2424        The dispersity object is reset inside the model into Gaussian. 
     2425        When the user select yes , this method display a combo box for 
     2426        more selection when the user selects No,the combo box disappears. 
    24642427        Redraw the model with the default dispersity (Gaussian) 
    24652428        """ 
    2466         #if self.check_invalid_panel(): 
    2467         #    return  
    24682429        ## On selction if no model exists. 
    2469         if self.model ==None: 
     2430        if self.model == None: 
    24702431            self.disable_disp.SetValue(True) 
    2471             msg="Please select a Model first..." 
     2432            msg = "Please select a Model first..." 
    24722433            wx.MessageBox(msg, 'Info') 
    2473             wx.PostEvent(self._manager.parent, StatusEvent(status=\ 
    2474                             "Polydispersion: %s"%msg)) 
     2434            wx.PostEvent(self._manager.parent, 
     2435                         StatusEvent(status="Polydispersion: %s" % msg)) 
    24752436            return 
    24762437 
    24772438        self._reset_dispersity() 
    24782439     
    2479         if self.model ==None: 
     2440        if self.model == None: 
    24802441            self.model_disp.Hide() 
    24812442            self.sizer4_4.Clear(True) 
     
    24852446            ## layout for model containing no dispersity parameters 
    24862447             
    2487             self.disp_list= self.model.getDispParamList() 
     2448            self.disp_list = self.model.getDispParamList() 
    24882449              
    2489             if len(self.disp_list)==0 and len(self.disp_cb_dict)==0: 
    2490                 self._layout_sizer_noDipers()   
     2450            if len(self.disp_list) == 0 and len(self.disp_cb_dict) == 0: 
     2451                self._layout_sizer_noDipers() 
    24912452            else: 
    2492                 ## set gaussian sizer  
     2453                ## set gaussian sizer 
    24932454                self._on_select_Disp(event=None) 
    24942455        else: 
    24952456            self.sizer4_4.Clear(True) 
    24962457             
    2497         ## post state to fit panel  
     2458        ## post state to fit panel 
    24982459        self.save_current_state() 
    2499         if event !=None: 
    2500             #self._undo.Enable(True) 
    2501             event = PageInfoEvent(page = self) 
     2460        if event != None: 
     2461            event = PageInfoEvent(page=self) 
    25022462            wx.PostEvent(self.parent, event) 
    25032463        #draw the model with the current dispersity 
     
    25062466        self.sizer5.Layout() 
    25072467        self.Layout() 
    2508         self.Refresh()       
     2468        self.Refresh() 
    25092469           
    2510          
    25112470    def _layout_sizer_noDipers(self): 
    25122471        """ 
    25132472        Draw a sizer with no dispersity info 
    25142473        """ 
    2515         ix=0 
    2516         iy=1 
    2517         self.fittable_param=[] 
    2518         self.fixed_param=[] 
    2519         self.orientation_params_disp=[] 
     2474        ix = 0 
     2475        iy = 1 
     2476        self.fittable_param = [] 
     2477        self.fixed_param = [] 
     2478        self.orientation_params_disp = [] 
    25202479         
    25212480        self.sizer4_4.Clear(True) 
    25222481        text = "No polydispersity available for this model" 
    2523         text = "No polydispersity available for this model" 
    25242482        model_disp = wx.StaticText(self, -1, text) 
    2525         self.sizer4_4.Add(model_disp,( iy, ix),(1,1),   
    2526                             wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 10) 
     2483        self.sizer4_4.Add(model_disp, (iy, ix), (1, 1), 
     2484                          wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 10) 
    25272485        self.sizer4_4.Layout() 
    25282486        self.sizer4.Layout() 
     
    25322490        put gaussian dispersity into current model 
    25332491        """ 
    2534         if len(self.param_toFit)>0: 
     2492        if len(self.param_toFit) > 0: 
    25352493            for item in self.fittable_param: 
    25362494                if item in self.param_toFit: 
     
    25412499                    self.param_toFit.remove(item) 
    25422500          
    2543         self.fittable_param=[] 
    2544         self.fixed_param=[] 
    2545         self.orientation_params_disp=[] 
    2546         self.values={} 
    2547         self.weights={} 
     2501        self.fittable_param = [] 
     2502        self.fixed_param = [] 
     2503        self.orientation_params_disp = [] 
     2504        self.values = {} 
     2505        self.weights = {} 
    25482506       
    2549         from sans.models.dispersion_models import GaussianDispersion, ArrayDispersion 
    2550         if len(self.disp_cb_dict)==0: 
     2507        from sans.models.dispersion_models import GaussianDispersion 
     2508        if len(self.disp_cb_dict) == 0: 
    25512509            self.save_current_state() 
    25522510            self.sizer4_4.Clear(True) 
    25532511            self.Layout() 
    2554   
    2555             return  
    2556         if (len(self.disp_cb_dict)>0) : 
     2512            return 
     2513        if (len(self.disp_cb_dict) > 0): 
    25572514            for p in self.disp_cb_dict: 
    2558                 # The parameter was un-selected. Go back to Gaussian model (with 0 pts)                     
     2515                # The parameter was un-selected. 
     2516                # Go back to Gaussian model (with 0 pts) 
    25592517                disp_model = GaussianDispersion() 
    25602518                
    25612519                self._disp_obj_dict[p] = disp_model 
    2562                 # Set the new model as the dispersion object for the selected parameter 
     2520                # Set the new model as the dispersion object 
     2521                # for the selected parameter 
    25632522                try: 
    2564                    self.model.set_dispersion(p, disp_model) 
     2523                    self.model.set_dispersion(p, disp_model) 
    25652524                except: 
    25662525 
     
    25692528        ## save state into 
    25702529        self.save_current_state() 
    2571         self.Layout()   
     2530        self.Layout() 
    25722531        self.Refresh() 
    25732532                   
    2574     def _on_select_Disp(self,event): 
     2533    def _on_select_Disp(self, event): 
    25752534        """ 
    25762535        allow selecting different dispersion 
     
    25802539 
    25812540        ## Redraw the model 
    2582         self._draw_model()  
     2541        self._draw_model() 
    25832542        #self._undo.Enable(True) 
    2584         event = PageInfoEvent(page = self) 
     2543        event = PageInfoEvent(page=self) 
    25852544        wx.PostEvent(self.parent, event) 
    25862545         
     
    25892548        self.SetupScrolling() 
    25902549     
    2591     def _on_disp_func(self, event=None):  
     2550    def _on_disp_func(self, event=None): 
    25922551        """ 
    25932552        Select a distribution function for the polydispersion 
    25942553         
    2595         :Param event: ComboBox event  
     2554        :Param event: ComboBox event 
    25962555        """ 
    25972556        # get ready for new event 
     
    25992558            event.Skip() 
    26002559        # Get event object 
    2601         disp_box =  event.GetEventObject()  
     2560        disp_box = event.GetEventObject() 
    26022561 
    26032562        # Try to select a Distr. function 
    2604         try:    
     2563        try: 
    26052564            disp_box.SetBackgroundColour("white") 
    26062565            selection = disp_box.GetCurrentSelection() 
    26072566            param_name = disp_box.Name.split('.')[0] 
    26082567            disp_name = disp_box.GetValue() 
    2609             dispersity= disp_box.GetClientData(selection) 
     2568            dispersity = disp_box.GetClientData(selection) 
    26102569     
    26112570            #disp_model =  GaussianDispersion() 
     
    26172576            # Check Disp. function whether or not it is 'array' 
    26182577            if disp_name.lower() == "array": 
    2619                 value2= "" 
    2620                 value3= "" 
     2578                value2 = "" 
     2579                value3 = "" 
    26212580                value1 = self._set_array_disp(name=name1, disp=disp_model) 
    26222581            else: 
     
    26252584                self._disp_obj_dict[name1] = disp_model 
    26262585                self.model.set_dispersion(param_name, disp_model) 
    2627                 self.state._disp_obj_dict[name1]= disp_model 
     2586                self.state._disp_obj_dict[name1] = disp_model 
    26282587  
    2629                 value1= str(format_number(self.model.getParam(name1), True)) 
    2630                 value2= str(format_number(self.model.getParam(name2))) 
    2631                 value3= str(format_number(self.model.getParam(name3))) 
     2588                value1 = str(format_number(self.model.getParam(name1), True)) 
     2589                value2 = str(format_number(self.model.getParam(name2))) 
     2590                value3 = str(format_number(self.model.getParam(name3))) 
    26322591            # Reset fittable polydispersin parameter value 
    26332592            for item in self.fittable_param: 
    2634                  if item[1] == name1: 
    2635                     item[2].SetValue(value1)  
     2593                if item[1] == name1: 
     2594                    item[2].SetValue(value1) 
    26362595                    item[5].SetValue("") 
    26372596                    item[6].SetValue("") 
     
    26492608                        item[2].Enable() 
    26502609                        item[5].Enable() 
    2651                         item[6].Enable()                        
     2610                        item[6].Enable() 
    26522611                    break 
    26532612            # Reset fixed polydispersion params 
     
    26612620                        item[2].Enable() 
    26622621                if item[1] == name3: 
    2663                     item[2].SetValue(value3)  
     2622                    item[2].SetValue(value3) 
    26642623                    # Disable Nsigs for array 
    26652624                    if disp_name.lower() == "array": 
     
    26742633 
    26752634            # update params 
    2676             self._update_paramv_on_fit()  
     2635            self._update_paramv_on_fit() 
    26772636            # draw 
    26782637            self._draw_model() 
     
    26862645            # Focus on Fit button so that users can see the pinky box 
    26872646            self.btFit.SetFocus() 
    2688             wx.PostEvent(self.parent.parent,  
     2647            wx.PostEvent(self.parent.parent, 
    26892648                         StatusEvent(status=msg, info="error")) 
    2690          
    26912649         
    26922650    def _set_array_disp(self, name=None, disp=None): 
     
    26972655        :param disp: the polydisperion object 
    26982656        """ 
    2699         # The user wants this parameter to be averaged.  
     2657        # The user wants this parameter to be averaged. 
    27002658        # Pop up the file selection dialog. 
    27012659        path = self._selectDlg() 
     
    27132671                             self._default_save_location 
    27142672 
    2715         basename  = os.path.basename(path) 
    2716         values,weights = self.read_file(path) 
     2673        basename = os.path.basename(path) 
     2674        values, weights = self.read_file(path) 
    27172675         
    27182676        # If any of the two arrays is empty, notify the user that we won't 
    27192677        # proceed 
    2720         if len(self.param_toFit)>0: 
     2678        if len(self.param_toFit) > 0: 
    27212679            if name in self.param_toFit: 
    27222680                self.param_toFit.remove(name) 
     
    27242682        # Tell the user that we are about to apply the distribution 
    27252683        msg = "Applying loaded %s distribution: %s" % (name, path) 
    2726         wx.PostEvent(self.parent.parent, StatusEvent(status=msg))   
     2684        wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
    27272685        self._set_array_disp_model(name=name, disp=disp, 
    27282686                                    values=values, weights=weights) 
    27292687        return basename 
    27302688     
    2731     def _set_array_disp_model(self, name=None, disp=None,  
     2689    def _set_array_disp_model(self, name=None, disp=None, 
    27322690                              values=[], weights=[]): 
    27332691        """ 
     
    27402698        self._disp_obj_dict[name] = disp 
    27412699        self.model.set_dispersion(name.split('.')[0], disp) 
    2742         self.state._disp_obj_dict[name]= disp 
     2700        self.state._disp_obj_dict[name] = disp 
    27432701        self.values[name] = values 
    27442702        self.weights[name] = weights 
     
    27512709        self.state.weights = copy.deepcopy(self.weights) 
    27522710 
    2753         # Set the new model as the dispersion object for the  
     2711        # Set the new model as the dispersion object for the 
    27542712        #selected parameter 
    27552713        #self.model.set_dispersion(p, disp_model) 
    2756         # Store a reference to the weights in the model object  
     2714        # Store a reference to the weights in the model object 
    27572715        #so that 
    27582716        # it's not lost when we use the model within another thread. 
    27592717        #TODO: total hack - fix this 
    2760         self.state.model= self.model.clone() 
     2718        self.state.model = self.model.clone() 
    27612719        self.model._persistency_dict[name.split('.')[0]] = \ 
    27622720                                        [values, weights] 
    27632721        self.state.model._persistency_dict[name.split('.')[0]] = \ 
    2764                                         [values,weights] 
     2722                                        [values, weights] 
    27652723                                         
    2766  
    2767     def _del_array_values(self, name=None):   
     2724    def _del_array_values(self, name=None): 
    27682725        """ 
    27692726        Reset array dispersion 
    27702727         
    2771         :param name: name of the parameter for the dispersion to be set  
     2728        :param name: name of the parameter for the dispersion to be set 
    27722729        """ 
    27732730        # Try to delete values and weight of the names array dic if exists 
     
    27782735            del self.state.values[name] 
    27792736            del self.state.weights[name] 
    2780             del self.model._persistency_dict[name.split('.')[0]]  
     2737            del self.model._persistency_dict[name.split('.')[0]] 
    27812738            del self.state.model._persistency_dict[name.split('.')[0]] 
    27822739        except: 
     
    27922749        self._sleep4sec() 
    27932750        self.Layout() 
    2794         return  
     2751        return 
    27952752     
    27962753    def _sleep4sec(self): 
    27972754        """ 
    27982755            sleep for 1 sec only applied on Mac 
    2799             Note: This 1sec helps for Mac not to crash on self.:ayout after self._draw_model 
     2756            Note: This 1sec helps for Mac not to crash on self. 
     2757            Layout after self._draw_model 
    28002758        """ 
    28012759        if ON_MAC == True: 
    28022760            time.sleep(1) 
    28032761             
    2804     def _find_polyfunc_selection(self, disp_func = None): 
    2805         """ 
    2806         FInd Comboox selection from disp_func  
     2762    def _find_polyfunc_selection(self, disp_func=None): 
     2763        """ 
     2764        FInd Comboox selection from disp_func 
    28072765         
    28082766        :param disp_function: dispersion distr. function 
    28092767        """ 
    28102768        # List of the poly_model name in the combobox 
    2811         list = ["RectangleDispersion", "ArrayDispersion",  
    2812                     "LogNormalDispersion", "GaussianDispersion",  
    2813                     "SchulzDispersion"] 
     2769        list = ["RectangleDispersion", "ArrayDispersion", 
     2770                "LogNormalDispersion", "GaussianDispersion", 
     2771                "SchulzDispersion"] 
    28142772 
    28152773        # Find the selection 
     
    28182776            return selection 
    28192777        except: 
    2820              return 3 
     2778            return 3 
    28212779                             
    2822     def on_reset_clicked(self,event): 
     2780    def on_reset_clicked(self, event): 
    28232781        """ 
    28242782        On 'Reset' button  for Q range clicked 
    28252783        """ 
    28262784        flag = True 
    2827         #if self.check_invalid_panel(): 
    2828         #    return 
    28292785        ##For 3 different cases: Data2D, Data1D, and theory 
    28302786        if self.model == None: 
    2831             msg="Please select a model first..." 
     2787            msg = "Please select a model first..." 
    28322788            wx.MessageBox(msg, 'Info') 
    28332789            flag = False 
     
    28352791             
    28362792        elif self.data.__class__.__name__ == "Data2D": 
    2837             data_min= 0 
    2838             x= max(math.fabs(self.data.xmin), math.fabs(self.data.xmax))  
    2839             y= max(math.fabs(self.data.ymin), math.fabs(self.data.ymax)) 
     2793            data_min = 0 
     2794            x = max(math.fabs(self.data.xmin), math.fabs(self.data.xmax)) 
     2795            y = max(math.fabs(self.data.ymin), math.fabs(self.data.ymax)) 
    28402796            self.qmin_x = data_min 
    28412797            self.qmax_x = math.sqrt(x*x + y*y) 
     
    28432799            # check smearing 
    28442800            if not self.disable_smearer.GetValue(): 
    2845                 temp_smearer= self.current_smearer 
    2846                 ## set smearing value whether or not the data contain the smearing info 
     2801                ## set smearing value whether or 
     2802                # not the data contain the smearing info 
    28472803                if self.pinhole_smearer.GetValue(): 
    28482804                    flag = self.update_pinhole_smear() 
     
    28532809            self.qmin_x = _QMIN_DEFAULT 
    28542810            self.qmax_x = _QMAX_DEFAULT 
    2855             self.num_points = _NPTS_DEFAULT             
     2811            self.num_points = _NPTS_DEFAULT 
    28562812            self.state.npts = self.num_points 
    28572813             
     
    28612817            # check smearing 
    28622818            if not self.disable_smearer.GetValue(): 
    2863                 temp_smearer= self.current_smearer 
    2864                 ## set smearing value whether or not the data contain the smearing info 
     2819                ## set smearing value whether or 
     2820                # not the data contain the smearing info 
    28652821                if self.slit_smearer.GetValue(): 
    28662822                    flag = self.update_slit_smear() 
     
    28732829             
    28742830        if flag == False: 
    2875             msg= "Cannot Plot :Must enter a number!!!  " 
    2876             wx.PostEvent(self.parent.parent, StatusEvent(status = msg )) 
     2831            msg = "Cannot Plot :Must enter a number!!!  " 
     2832            wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
    28772833        else: 
    28782834            # set relative text ctrs. 
     
    28802836            self.qmax.SetValue(str(self.qmax_x)) 
    28812837            self.set_npts2fit() 
    2882             # At this point, some button and variables satatus (disabled?) should be checked  
    2883             # such as color that should be reset to white in case that it was pink. 
     2838            # At this point, some button and variables satatus (disabled?) 
     2839            # should be checked such as color that should be reset to 
     2840            # white in case that it was pink. 
    28842841            self._onparamEnter_helper() 
    28852842 
     
    28902847        #reset the q range values 
    28912848        self._reset_plotting_range(self.state) 
    2892         #self.compute_chisqr(smearer=self.current_smearer) 
    2893         #Re draw plot 
    28942849        self._draw_model() 
    28952850         
     
    29082863        # loops through the panels [dic] 
    29092864        for item1, item2 in gui_manager.plot_panels.iteritems(): 
    2910              data_title = self.data.group_id 
    2911              data_name = str(self.data.name).split(" [")[0] 
     2865            data_title = self.data.group_id 
    29122866            # try to get all plots belonging to this control panel 
    2913              try: 
    2914                  title = '' 
    2915                  # check titles (main plot)  
    2916                  if hasattr(item2,"data2D"): 
    2917                      title = item2.data2D.title 
    2918                  # and data_names (model plot[2D], and residuals) 
    2919                  if item2.group_id == data_title or \ 
     2867            try: 
     2868                if item2.group_id == data_title or \ 
    29202869                        item2.group_id.count("res" + str(self.graph_id)) or \ 
    29212870                        item2.group_id.count(str(self.uid)) > 0: 
    2922                      #panel = gui_manager._mgr.GetPane(item2.window_name) 
    2923                      # append to the list 
    2924                      graphs.append(item2.figure)  
    2925                      canvases.append(item2.canvas)      
    2926              except: 
    2927                  # Not for control panels 
    2928                  pass 
     2871                    # append to the list 
     2872                    graphs.append(item2.figure) 
     2873                    canvases.append(item2.canvas) 
     2874            except: 
     2875                # Not for control panels 
     2876                pass 
    29292877        # return the list of graphs 
    29302878        return graphs, canvases 
    29312879 
    2932     def on_model_help_clicked(self,event): 
     2880    def on_model_help_clicked(self, event): 
    29332881        """ 
    29342882        on 'More details' button 
     
    29392887        # Get models help model_function path 
    29402888        path = get_data_path(media='media') 
    2941         model_path = os.path.join(path,"model_functions.html") 
     2889        model_path = os.path.join(path, "model_functions.html") 
    29422890        if self.model == None: 
    29432891            name = 'FuncHelp' 
    29442892        else: 
    29452893            name = self.formfactorbox.GetValue() 
    2946             #name = self.model.__class__.__name__ 
    2947         frame = HelpWindow(None, -1,  pageToOpen=model_path)     
     2894        frame = HelpWindow(None, -1, pageToOpen=model_path) 
    29482895        if frame.rhelp.HasAnchor(name): 
    29492896            frame.Show(True) 
    29502897            frame.rhelp.ScrollToAnchor(name) 
    29512898        else: 
    2952            #msg= "Sorry, no information is available for this model" 
    2953            #wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))   
    2954            if self.model != None: 
    2955                frame.Destroy()  
    2956                msg = 'Model description:\n' 
    2957                if str(self.model.description).rstrip().lstrip() == '': 
    2958                    msg += "Sorry, no information is available for this model.\n" 
    2959                else: 
    2960                    msg += self.model.description + '\n' 
    2961                info = "Info" 
    2962                wx.MessageBox(msg, info) 
    2963            else: 
    2964                frame.Show(True)    
     2899            if self.model != None: 
     2900                frame.Destroy() 
     2901                msg = 'Model description:\n' 
     2902                if str(self.model.description).rstrip().lstrip() == '': 
     2903                    msg += "Sorry, no information is available for this model." 
     2904                else: 
     2905                    msg += self.model.description + '\n' 
     2906                info = "Info" 
     2907                wx.MessageBox(msg, info) 
     2908            else: 
     2909                frame.Show(True) 
    29652910     
    29662911    def on_pd_help_clicked(self, event): 
     
    29692914        """ 
    29702915        from help_panel import  HelpWindow 
    2971         import sans.models as models  
     2916        import sans.models as models 
    29722917         
    29732918        # Get models help model_function path 
    29742919        path = models.get_data_path(media='media') 
    2975         pd_path = os.path.join(path,"pd_help.html") 
    2976  
    2977         frame = HelpWindow(None, -1,  pageToOpen=pd_path)     
     2920        pd_path = os.path.join(path, "pd_help.html") 
     2921 
     2922        frame = HelpWindow(None, -1, pageToOpen=pd_path) 
    29782923        frame.Show(True) 
    29792924         
     
    29972942        Get copy params to clipboard 
    29982943        """ 
    2999         content = self.get_copy_params()  
     2944        content = self.get_copy_params() 
    30002945        flag = self.set_clipboard(content) 
    3001         self._copy_info(flag)  
    3002         return flag  
    3003              
    3004     def get_copy_params(self):  
     2946        self._copy_info(flag) 
     2947        return flag 
     2948             
     2949    def get_copy_params(self): 
    30052950        """ 
    30062951        Get the string copies of the param names and values in the tap 
    3007         """   
     2952        """ 
    30082953        content = 'sansview_parameter_values:' 
    3009         # Do it if params exist         
    3010         if  self.parameters !=[]: 
    3011              
    3012             # go through the parameters  
    3013             string = self._get_copy_helper(self.parameters,  
     2954        # Do it if params exist 
     2955        if  self.parameters != []: 
     2956             
     2957            # go through the parameters 
     2958            string = self._get_copy_helper(self.parameters, 
    30142959                                           self.orientation_params) 
    30152960            content += string 
    30162961             
    30172962            # go through the fittables 
    3018             string = self._get_copy_helper(self.fittable_param,  
     2963            string = self._get_copy_helper(self.fittable_param, 
    30192964                                           self.orientation_params_disp) 
    30202965            content += string 
    30212966 
    30222967            # go through the fixed params 
    3023             string = self._get_copy_helper(self.fixed_param,  
     2968            string = self._get_copy_helper(self.fixed_param, 
    30242969                                           self.orientation_params_disp) 
    30252970            content += string 
    30262971                 
    30272972            # go through the str params 
    3028             string = self._get_copy_helper(self.str_parameters,  
     2973            string = self._get_copy_helper(self.str_parameters, 
    30292974                                           self.orientation_params) 
    30302975            content += string 
     
    30332978            return False 
    30342979     
    3035     def set_clipboard(self, content=None):  
     2980    def set_clipboard(self, content=None): 
    30362981        """ 
    30372982        Put the string to the clipboard 
    3038         """    
     2983        """ 
    30392984        if not content: 
    30402985            return False 
     
    30553000        content = '' 
    30563001        # go through the str params 
    3057         for item in param:  
     3002        for item in param: 
    30583003            # copy only the params shown 
    30593004            if not item[2].IsShown(): 
     
    31003045            except: 
    31013046                pass 
    3102             #if disfunc.count('array') == 0: 
    3103             content +=  name + ',' + str(check) + ',' + value + disfunc + ':' 
     3047            content += name + ',' + str(check) + ',' + value + disfunc + ':' 
    31043048 
    31053049        return content 
    31063050    
    3107     def get_clipboard(self):    
     3051    def get_clipboard(self): 
    31083052        """ 
    31093053        Get strings in the clipboard 
    31103054        """ 
    3111         text = ""   
    3112         # Get text from the clip board         
     3055        text = "" 
     3056        # Get text from the clip board 
    31133057        if wx.TheClipboard.Open(): 
    31143058            if wx.TheClipboard.IsSupported(wx.DataFormat(wx.DF_TEXT)): 
     
    31313075        return flag 
    31323076         
    3133     def get_paste_params(self, text=''):  
     3077    def get_paste_params(self, text=''): 
    31343078        """ 
    31353079        Get the string copies of the param names and values in the tap 
    3136         """   
    3137         context = {}     
    3138         # put the text into dictionary     
     3080        """ 
     3081        context = {} 
     3082        # put the text into dictionary 
    31393083        lines = text.split(':') 
    31403084        if lines[0] != 'sansview_parameter_values': 
     
    31543098                context[name].append(poly_func) 
    31553099                try: 
    3156                     # take the vals and weights for  array  
     3100                    # take the vals and weights for  array 
    31573101                    array_values = item[4].split(' ') 
    31583102                    array_weights = item[5].split(' ') 
     
    31683112                context[name].append(poly_func) 
    31693113 
    3170         # Do it if params exist         
     3114        # Do it if params exist 
    31713115        if  self.parameters != []: 
    3172             # go through the parameters   
    3173             self._get_paste_helper(self.parameters,  
     3116            # go through the parameters 
     3117            self._get_paste_helper(self.parameters, 
    31743118                                   self.orientation_params, context) 
    31753119 
    31763120            # go through the fittables 
    3177             self._get_paste_helper(self.fittable_param,  
    3178                                    self.orientation_params_disp,  
     3121            self._get_paste_helper(self.fittable_param, 
     3122                                   self.orientation_params_disp, 
    31793123                                   context) 
    31803124 
    31813125            # go through the fixed params 
    3182             self._get_paste_helper(self.fixed_param,  
     3126            self._get_paste_helper(self.fixed_param, 
    31833127                                   self.orientation_params_disp, context) 
    31843128             
    31853129            # go through the str params 
    3186             self._get_paste_helper(self.str_parameters,  
     3130            self._get_paste_helper(self.str_parameters, 
    31873131                                   self.orientation_params, context) 
    31883132                 
     
    31963140        : param param:  parameters 
    31973141        : param orient_param: oritational params 
    3198         : param content: dictionary [ name, value: name1.value1,...]  
     3142        : param content: dictionary [ name, value: name1.value1,...] 
    31993143        """ 
    32003144        # go through the str params 
    3201         for item in param:  
     3145        for item in param: 
    32023146            # 2D 
    32033147            if self.data.__class__.__name__ == "Data2D": 
     
    32183162                        item[2].Enable(False) 
    32193163                    if item[2].__class__.__name__ == "ComboBox": 
    3220                         if self.model.fun_list.has_key(content[name][1]): 
     3164                        if content[name][1] in self.model.fun_list: 
    32213165                            fun_val = self.model.fun_list[content[name][1]] 
    32223166                            self.model.setParam(name, fun_val) 
     
    32393183                    if name in content.keys(): 
    32403184                        check = content[name][0] 
    3241                         # Avoid changing combox content which needs special care 
     3185                        # Avoid changing combox content 
    32423186                        value = content[name][1:] 
    32433187                        pd = value[0] 
     
    32543198                            item[2].Enable(False) 
    32553199                        if item[2].__class__.__name__ == "ComboBox": 
    3256                             if self.model.fun_list.has_key(value[0]): 
     3200                            if value[0] in self.model.fun_list: 
    32573201                                fun_val = self.model.fun_list[value[0]] 
    32583202                                self.model.setParam(name, fun_val) 
    32593203                                # save state 
    3260                                 #self._copy_parameters_state(self.str_parameters,  
    3261                                 #    self.state.str_parameters) 
    32623204                        self._paste_poly_help(item, value) 
    32633205                        if check == 'True': 
     
    32943236                        if len(pd_vals) == len(pd_weights): 
    32953237                            self._set_disp_array_cb(item=item) 
    3296                             self._set_array_disp_model(name=name,  
     3238                            self._set_array_disp_model(name=name, 
    32973239                                                       disp=disp_model, 
    3298                                                        values=pd_vals,  
     3240                                                       values=pd_vals, 
    32993241                                                       weights=pd_weights) 
    33003242                            is_array = True 
    33013243                except: 
    3302                     pass  
     3244                    pass 
    33033245                if not is_array: 
    33043246                    self._disp_obj_dict[name] = disp_model 
    3305                     self.model.set_dispersion(name,  
     3247                    self.model.set_dispersion(name, 
    33063248                                              disp_model) 
    33073249                    self.state._disp_obj_dict[name] = \ 
     
    33093251                    self.model.set_dispersion(param_name, disp_model) 
    33103252                    self.state.values = self.values 
    3311                     self.state.weights = self.weights     
     3253                    self.state.weights = self.weights 
    33123254                    self.model._persistency_dict[param_name] = \ 
    3313                                             [self.state.values,  
     3255                                            [self.state.values, 
    33143256                                             self.state.weights] 
    33153257                          
    33163258            except: 
    3317                 print "Error in BasePage._paste_poly_help: %s" % sys.exc_value  
     3259                print "Error in BasePage._paste_poly_help: %s" % sys.exc_value 
    33183260     
    33193261    def _set_disp_array_cb(self, item): 
     
    33383280        print "BasicPage.update_pinhole_smear was called: skipping" 
    33393281        return 
    3340  
    3341          
Note: See TracChangeset for help on using the changeset viewer.