Changeset 6bbeacd4 in sasview for sansview/perspectives/fitting


Ignore:
Timestamp:
Feb 28, 2011 4:04:10 PM (14 years ago)
Author:
Gervaise Alina <gervyh@…>
Branches:
master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, costrafo411, magnetic_scatt, release-4.1.1, release-4.1.2, release-4.2.2, release_4.0.1, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
a07e72f
Parents:
1584fff
Message:

remove other type of data

Location:
sansview/perspectives/fitting
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • sansview/perspectives/fitting/basepage.py

    r01b6bd0 r6bbeacd4  
    2121 
    2222_BOX_WIDTH = 76 
    23 _QMIN_DEFAULT = 0.001 
    24 _QMAX_DEFAULT = 0.13 
     23_QMIN_DEFAULT = 0.0005 
     24_QMAX_DEFAULT = 0.5 
    2525_NPTS_DEFAULT = 50 
    2626#Control panel width  
    … …  
    3333    FONT_VARIANT = 1 
    3434    ON_MAC = True 
    35      
     35 
     36 
     37 
    3638class BasicPage(ScrolledPanel, PanelBase): 
    3739    """ 
    … …  
    3941    """ 
    4042     ## Internal name for the AUI manager 
    41     window_name = "Basic Page" 
     43    window_name = "Fit Page" 
    4244    ## Title to appear on top of the window 
    43     window_caption = "Basic page " 
    44      
    45     def __init__(self, parent, page_info, **kwargs): 
     45    window_caption = "Fit Page " 
     46     
     47    def __init__(self, parent,color='blue', **kwargs): 
    4648        """ 
    4749        """ 
    … …  
    5153        #Set window's font size  
    5254        self.SetWindowVariant(variant=FONT_VARIANT) 
    53         
     55       
     56        self.SetBackgroundColour(color) 
    5457        ## parent of the page 
    5558        self.parent = parent 
    … …  
    6265        self.data = None 
    6366        self.mask = None 
     67        self.id = None 
    6468        ## Q range 
    65         self.qmax_x = None 
    66         self.qmin_x = None 
    67         self.num_points= _NPTS_DEFAULT 
     69        self.qmax_x = _QMAX_DEFAULT 
     70        self.qmin_x = _QMIN_DEFAULT 
     71        self.npts_x = _NPTS_DEFAULT 
    6872        ## total number of point: float 
    6973        self.npts = None 
    … …  
    8690        self.state = PageState(parent=parent) 
    8791        ## dictionary containing list of models 
    88         self.model_list_box = None 
    89         self.set_page_info(page_info=page_info) 
     92        self.model_list_box = {} 
     93        
    9094        ## Data member to store the dispersion object created 
    9195        self._disp_obj_dict = {} 
    … …  
    136140        ## Create context menu for page 
    137141        self.popUpMenu = wx.Menu() 
    138         #id = wx.NewId() 
    139         #self._undo = wx.MenuItem(self.popUpMenu,id, "Undo", 
    140         #"cancel the previous action") 
    141         #self.popUpMenu.AppendItem(self._undo) 
    142         #self._undo.Enable(False) 
    143         #wx.EVT_MENU(self, id, self.onUndo) 
    144          
    145         #id = wx.NewId() 
    146         #self._redo = wx.MenuItem(self.popUpMenu,id,"Redo", 
    147         #" Restore the previous action") 
    148         #self.popUpMenu.AppendItem(self._redo) 
    149         #self._redo.Enable(False) 
    150         #wx.EVT_MENU(self, id, self.onRedo)        
    151         #self.popUpMenu.AppendSeparator() 
    152         #if sys.platform.count("win32")>0:         
     142     
    153143        id = wx.NewId() 
    154144        self._keep = wx.MenuItem(self.popUpMenu,id,"BookMark", 
    … …  
    174164        ## layout 
    175165        self.set_layout() 
     166         
     167     
    176168         
    177169    def on_set_focus(self, event): 
    … …  
    305297        Cancel the previous action 
    306298        """ 
    307         #print "enable undo" 
    308299        event = PreviousStateEvent(page = self) 
    309300        wx.PostEvent(self.parent, event) 
    … …  
    313304        Restore the previous action cancelled  
    314305        """ 
    315         #print "enable redo" 
    316306        event = NextStateEvent(page= self) 
    317307        wx.PostEvent(self.parent, event) 
    … …  
    394384        self.model_list_box = dict 
    395385        self.state.model_list_box = self.model_list_box 
     386        self.initialize_combox() 
    396387         
    397388    def initialize_combox(self):  
    … …  
    12541245        Reset the plotting range to a given state 
    12551246        """ 
    1256         if self.check_invalid_panel(): 
    1257             return 
    1258         self.qmin.SetValue(str(state.qmin)) 
     1247        # if self.check_invalid_panel(): 
     1248        #    return 
     1249        self.qmin_tctrl.SetValue(str(state.qmin)) 
    12591250        self.qmax.SetValue(str(state.qmax))  
    12601251 
    … …  
    12811272        self.state.qmin = self.qmin_x 
    12821273        self.state.qmax = self.qmax_x  
    1283         if self.npts != None: 
    1284             self.state.npts = self.num_points 
     1274        self.state.npts = self.npts_x 
    12851275             
    12861276    def _onparamEnter_helper(self): 
    … …  
    13121302            # If qmin and qmax have been modified, update qmin and qmax and  
    13131303            # set the is_modified flag to True 
    1314             if self._validate_qrange(self.qmin, self.qmax): 
    1315                 tempmin = float(self.qmin.GetValue()) 
     1304            if self._validate_qrange(self.qmin_tcrl, self.qmax): 
     1305                tempmin = float(self.qmin_tcrl.GetValue()) 
    13161306                if tempmin != self.qmin_x: 
    13171307                    self.qmin_x = tempmin 
    … …  
    13671357            # If qmin and qmax have been modified, update qmin and qmax and  
    13681358            # set the is_modified flag to True 
    1369             self.fitrange = self._validate_qrange(self.qmin, self.qmax) 
     1359            self.fitrange = self._validate_qrange(self.qmin_tcrl, self.qmax) 
    13701360            if self.fitrange: 
    1371                 tempmin = float(self.qmin.GetValue()) 
     1361                tempmin = float(self.qmin_tcrl.GetValue()) 
    13721362                if tempmin != self.qmin_x: 
    13731363                    self.qmin_x = tempmin 
    … …  
    13851375                        flag = self.update_pinhole_smear() 
    13861376                    else: 
    1387                         self._manager.set_smearer_nodraw(smearer=temp_smearer, 
     1377                        self._manager.set_smearer(smearer=temp_smearer, 
     1378                                                  id=self.id, 
    13881379                                                     qmin=float(self.qmin_x), 
    1389                                                       qmax=float(self.qmax_x)) 
     1380                                                      qmax=float(self.qmax_x), 
     1381                                                      draw=False) 
    13901382                elif not self._is_2D(): 
    13911383                    self._manager.set_smearer(smearer=temp_smearer, 
    13921384                                              qmin=float(self.qmin_x), 
     1385                                              id=self.id,  
    13931386                                                 qmax= float(self.qmax_x)) 
    13941387                    index_data = ((self.qmin_x <= self.data.x)&\ 
    … …  
    16461639        to build a call to the fitting perspective manager. 
    16471640        """ 
    1648         if self.check_invalid_panel(): 
    1649             return 
     1641        #if self.check_invalid_panel(): 
     1642        #    return 
    16501643        if self.model !=None: 
    16511644            temp_smear=None 
    … …  
    16531646                if not self.disable_smearer.GetValue(): 
    16541647                    temp_smear= self.current_smearer 
    1655              
    16561648            self._manager.draw_model(self.model,  
    16571649                                    data=self.data, 
    … …  
    16591651                                    qmin=float(self.qmin_x),  
    16601652                                    qmax=float(self.qmax_x), 
    1661                                     qstep= float(self.num_points), 
     1653                                    qstep= float(self.npts_x), 
     1654                                    id=self.id, 
    16621655                                    enable2D=self.enable2D) 
    16631656         
    … …  
    18431836        Show combox box associate with type of model selected 
    18441837        """ 
    1845         if self.check_invalid_panel(): 
    1846             self.shape_rbutton.SetValue(True) 
    1847             return 
     1838        #if self.check_invalid_panel(): 
     1839        #    self.shape_rbutton.SetValue(True) 
     1840        #    return 
    18481841 
    18491842        self._show_combox_helper() 
    … …  
    18711864                combobox.Append(name,models) 
    18721865        return 0 
    1873  
     1866     
    18741867    def _onQrangeEnter(self, event): 
     1868        """ 
     1869        Check validity of value enter in the Q range field 
     1870         
     1871        """ 
     1872        tcrtl = event.GetEventObject() 
     1873        #Clear msg if previously shown. 
     1874        msg = "" 
     1875        wx.PostEvent(self.parent, StatusEvent(status=msg)) 
     1876        # Flag to register when a parameter has changed. 
     1877        is_modified = False 
     1878        if tcrtl.GetValue().lstrip().rstrip() != "": 
     1879            try: 
     1880                value = float(tcrtl.GetValue()) 
     1881                tcrtl.SetBackgroundColour(wx.WHITE) 
     1882                # If qmin and qmax have been modified, update qmin and qmax 
     1883                if self._validate_qrange(self.qmin_tcrl, self.qmax): 
     1884                    tempmin = float(self.qmin_tcrl.GetValue()) 
     1885                    if tempmin != self.qmin_x: 
     1886                        self.qmin_x = tempmin 
     1887                    tempmax = float(self.qmax.GetValue()) 
     1888                    if tempmax != self.qmax_x: 
     1889                        self.qmax_x = tempmax 
     1890                else: 
     1891                    tcrtl.SetBackgroundColour("pink") 
     1892                    msg = "Model Error:wrong value entered : %s" % sys.exc_value 
     1893                    wx.PostEvent(self.parent, StatusEvent(status=msg)) 
     1894                    return  
     1895            except: 
     1896                tcrtl.SetBackgroundColour("pink") 
     1897                msg = "Model Error:wrong value entered : %s" % sys.exc_value 
     1898                wx.PostEvent(self.parent, StatusEvent(status=msg)) 
     1899                return  
     1900            #Check if # of points for theory model are valid(>0). 
     1901            if self.npts != None: 
     1902                if check_float(self.npts): 
     1903                    temp_npts = float(self.npts.GetValue()) 
     1904                    if temp_npts !=  self.num_points: 
     1905                        self.num_points = temp_npts 
     1906                        is_modified = True 
     1907                else: 
     1908                    msg = "Cannot Plot :No npts in that Qrange!!!  " 
     1909                    wx.PostEvent(self.parent, StatusEvent(status=msg)) 
     1910        else: 
     1911           tcrtl.SetBackgroundColour("pink") 
     1912           msg = "Model Error:wrong value entered!!!" 
     1913           wx.PostEvent(self.parent, StatusEvent(status=msg)) 
     1914        #self._undo.Enable(True) 
     1915        self.save_current_state() 
     1916        event = PageInfoEvent(page=self) 
     1917        wx.PostEvent(self.parent, event) 
     1918        self.state_change = False 
     1919        #Draw the model for a different range 
     1920        self._draw_model() 
     1921                    
     1922    def _theory_qrange_enter(self, event): 
    18751923        """ 
    18761924        Check validity of value enter in the Q range field 
    … …  
    18891937 
    18901938                # If qmin and qmax have been modified, update qmin and qmax 
    1891                 if self._validate_qrange( self.qmin, self.qmax): 
    1892                     tempmin = float(self.qmin.GetValue()) 
    1893                     if tempmin != self.qmin_x: 
    1894                         self.qmin_x = tempmin 
    1895                     tempmax = float(self.qmax.GetValue()) 
     1939                if self._validate_qrange(self.theory_qmin, self.theory_qmax): 
     1940                    tempmin = float(self.theory_qmin.GetValue()) 
     1941                    if tempmin != self.theory_qmin_x: 
     1942                        self.theory_qmin_x = tempmin 
     1943                    tempmax = float(self.theory_qmax.GetValue()) 
    18961944                    if tempmax != self.qmax_x: 
    1897                         self.qmax_x = tempmax 
     1945                        self.theory_qmax_x = tempmax 
    18981946                else: 
    18991947                    tcrtl.SetBackgroundColour("pink") 
    19001948                    msg= "Model Error:wrong value entered : %s"% sys.exc_value 
    1901                     wx.PostEvent(self.parent.parent, StatusEvent(status = msg )) 
     1949                    wx.PostEvent(self._manager.parent, StatusEvent(status = msg )) 
    19021950                    return   
    19031951            except: 
    19041952                tcrtl.SetBackgroundColour("pink") 
    19051953                msg= "Model Error:wrong value entered : %s"% sys.exc_value 
    1906                 wx.PostEvent(self.parent.parent, StatusEvent(status = msg )) 
     1954                wx.PostEvent(self._manager.parent, StatusEvent(status = msg )) 
    19071955                return  
    19081956            #Check if # of points for theory model are valid(>0). 
    1909             if self.npts != None: 
    1910                 if check_float(self.npts): 
    1911                     temp_npts = float(self.npts.GetValue()) 
     1957            if self.theory_npts != None: 
     1958                if check_float(self.theory_npts): 
     1959                    temp_npts = float(self.theory_npts.GetValue()) 
    19121960                    if temp_npts !=  self.num_points: 
    19131961                        self.num_points = temp_npts 
    … …  
    19181966        else: 
    19191967           tcrtl.SetBackgroundColour("pink") 
    1920            msg= "Model Error:wrong value entered!!!" 
     1968           msg = "Model Error:wrong value entered!!!" 
    19211969           wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
    19221970        #self._undo.Enable(True) 
    … …  
    20682116                            self.data.qy_data * self.data.qy_data ) 
    20692117        #get unmasked index 
    2070         index_data = (float(self.qmin.GetValue()) <= radius) & \ 
     2118        index_data = (float(self.qmin_tcrl.GetValue()) <= radius) & \ 
    20712119                        (radius <= float(self.qmax.GetValue())) 
    20722120        index_data = (index_data) & (self.data.mask)  
    … …  
    20752123        if len(index_data[index_data]) < 10: 
    20762124            # change the color pink. 
    2077             self.qmin.SetBackgroundColour("pink") 
    2078             self.qmin.Refresh() 
     2125            self.qmin_tcrl.SetBackgroundColour("pink") 
     2126            self.qmin_tcrl.Refresh() 
    20792127            self.qmax.SetBackgroundColour("pink") 
    20802128            self.qmax.Refresh() 
    … …  
    21882236        Redraw the model with the default dispersity (Gaussian) 
    21892237        """ 
    2190         if self.check_invalid_panel(): 
    2191             return  
     2238        #if self.check_invalid_panel(): 
     2239        #    return  
    21922240        ## On selction if no model exists. 
    21932241        if self.model ==None: 
    … …  
    24122460        event = PageInfoEvent(page = self) 
    24132461        wx.PostEvent(self.parent, event) 
    2414          
    2415     def _set_range_sizer(self, title, box_sizer=None, object1=None,object=None): 
    2416         """ 
    2417         Fill the Q range sizer 
    2418         """ 
    2419         #2D data? default 
    2420         is_2Ddata = False 
    2421          
    2422         #check if it is 2D data 
    2423         if self.data.__class__.__name__ == 'Data2D': 
    2424             is_2Ddata = True 
    2425              
    2426         self.sizer5.Clear(True) 
    2427         #-------------------------------------------------------------- 
    2428         if box_sizer == None: 
    2429             box_description= wx.StaticBox(self, -1,str(title)) 
    2430             boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL) 
    2431         else: 
    2432             #for MAC 
    2433             boxsizer1 = box_sizer 
    2434  
    2435         self.qmin    = self.ModelTextCtrl(self, -1,size=(_BOX_WIDTH,20),style=wx.TE_PROCESS_ENTER, 
    2436                                             text_enter_callback = self._onQrangeEnter) 
    2437         self.qmin.SetValue(str(self.qmin_x)) 
    2438         self.qmin.SetToolTipString("Minimun value of Q in linear scale.") 
    2439       
    2440         self.qmax    = self.ModelTextCtrl(self, -1,size=(_BOX_WIDTH,20),style=wx.TE_PROCESS_ENTER, 
    2441                                             text_enter_callback = self._onQrangeEnter) 
    2442         self.qmax.SetValue(str(self.qmax_x)) 
    2443         self.qmax.SetToolTipString("Maximum value of Q in linear scale.") 
    2444          
    2445         id = wx.NewId() 
    2446         self.reset_qrange =wx.Button(self,id,'Reset',size=(77,20)) 
    2447        
    2448         self.reset_qrange.Bind(wx.EVT_BUTTON, self.on_reset_clicked,id=id) 
    2449         self.reset_qrange.SetToolTipString("Reset Q range to the default values") 
    2450       
    2451         sizer_horizontal=wx.BoxSizer(wx.HORIZONTAL) 
    2452         sizer= wx.GridSizer(2, 4,2, 6) 
    2453  
    2454         self.btEditMask = wx.Button(self,wx.NewId(),'Editor', size=(88,23)) 
    2455         self.btEditMask.Bind(wx.EVT_BUTTON, self._onMask,id= self.btEditMask.GetId()) 
    2456         self.btEditMask.SetToolTipString("Edit Mask.") 
    2457         self.EditMask_title = wx.StaticText(self, -1, ' Masking(2D)') 
    2458  
    2459         sizer.Add(wx.StaticText(self, -1, '    Q range'))      
    2460         sizer.Add(wx.StaticText(self, -1, ' Min[1/A]')) 
    2461         sizer.Add(wx.StaticText(self, -1, ' Max[1/A]')) 
    2462         sizer.Add(self.EditMask_title) 
    2463         sizer.Add(self.reset_qrange)    
    2464          
    2465         sizer.Add(self.qmin) 
    2466         sizer.Add(self.qmax) 
    2467         sizer.Add(self.btEditMask) 
    2468         
    2469         if object1!=None: 
    2470              
    2471             boxsizer1.Add(object1)  
    2472             boxsizer1.Add((10,10)) 
    2473         boxsizer1.Add(sizer) 
    2474         if object!=None: 
    2475             boxsizer1.Add((10,15)) 
    2476             boxsizer1.Add(object) 
    2477         if is_2Ddata: 
    2478             self.btEditMask.Enable()   
    2479             self.EditMask_title.Enable()  
    2480         else: 
    2481             self.btEditMask.Disable()   
    2482             self.EditMask_title.Disable() 
    2483         ## save state 
    2484         self.save_current_state() 
    2485         #---------------------------------------------------------------- 
    2486         self.sizer5.Add(boxsizer1,0, wx.EXPAND | wx.ALL, 10) 
    2487         self.sizer5.Layout() 
    2488  
     2462    
    24892463    def _lay_out(self): 
    24902464        """ 
    … …  
    25112485        """ 
    25122486        flag = True 
    2513         if self.check_invalid_panel(): 
    2514             return 
     2487        #if self.check_invalid_panel(): 
     2488        #    return 
    25152489        ##For 3 different cases: Data2D, Data1D, and theory 
    25162490        if self.data.__class__.__name__ == "Data2D": 
    … …  
    25522526        else: 
    25532527            # set relative text ctrs. 
    2554             self.qmin.SetValue(str(self.qmin_x)) 
     2528            self.qmin_tcrl.SetValue(str(self.qmin_x)) 
    25552529            self.qmax.SetValue(str(self.qmax_x)) 
    25562530            self.set_npts2fit() 
    … …  
    25692543        self._draw_model() 
    25702544 
    2571  
    25722545    def on_model_help_clicked(self,event): 
    25732546        """ 
    … …  
    25752548        """ 
    25762549        from help_panel import  HelpWindow 
    2577         import sans.models as models  
    2578          
    2579         # Get models help model_function path 
    2580         path = models.get_data_path(media='media') 
    2581         model_path = os.path.join(path,"model_functions.html") 
     2550         
    25822551        if self.model == None: 
    25832552            name = 'FuncHelp' 
    … …  
    25852554            name = self.model.origin_name 
    25862555 
    2587         frame = HelpWindow(None, -1,  pageToOpen=model_path)     
     2556        frame = HelpWindow(None, -1,  pageToOpen="media/model_functions.html")     
    25882557        frame.Show(True) 
    25892558        if frame.rhelp.HasAnchor(name): 
    … …  
    25922561           msg= "Model does not contains an available description " 
    25932562           msg +="Please try searching in the Help window" 
    2594            wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))       
    2595                      
     2563           wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))                     
    25962564                 

  • sansview/perspectives/fitting/fit_thread.py

    r5062bbf r6bbeacd4  
    1010                   handler, 
    1111                  pars=None, 
    12                  cpage=None, 
    1312                 completefn = None, 
    1413                 updatefn   = None, 
    … …  
    2322        self.handler = handler 
    2423        self.fitter = fn 
    25         self.cpage= cpage 
    2624        self.pars = pars 
    2725        self.starttime = 0 
    … …  
    4947            self.updatefn() 
    5048            self.complete(result= result, 
    51                           pars = self.pars, 
    52                           cpage= self.cpage) 
     49                          pars = self.pars) 
    5350            
    5451        except KeyboardInterrupt, msg: 

  • sansview/perspectives/fitting/fitpage.py

    r2b0f822 r6bbeacd4  
    3838    """ 
    3939     
    40     def __init__(self,parent, page_info): 
     40    def __init__(self,parent, color='rand'): 
    4141        """  
    4242        Initialization of the Panel 
    4343        """ 
    44         BasicPage.__init__(self, parent, page_info) 
     44        BasicPage.__init__(self, parent, color=color) 
    4545  
    4646        ## draw sizer 
    … …  
    5151        self._get_defult_custom_smear() 
    5252        self._fill_range_sizer()  
    53          
    54         if self.data is None: 
    55             self.formfactorbox.Disable() 
    56             self.structurebox.Disable() 
    57         else: 
    58             self.smearer = smear_selection(self.data, self.model) 
    59             if self.smearer ==None: 
    60                 self.enable_smearer.Disable() 
     53        self._set_smear(self.data) 
    6154        ## to update the panel according to the fit engine type selected 
    6255        self.Bind(EVT_FITTER_TYPE,self._on_engine_change) 
    … …  
    158151        self.Layout() 
    159152        self.Refresh() 
    160  
     153     
     154   
     155         
    161156    def _fill_range_sizer(self): 
    162157        """ 
    … …  
    267262        self.Npts_total.SetToolTipString(" Total Npts : total number of data points") 
    268263        box_description_1= wx.StaticText(self, -1,'    Chi2/Npts') 
    269         box_description_2= wx.StaticText(self, -1,'  Npts') 
    270         box_description_3= wx.StaticText(self, -1,'  Total Npts') 
     264        box_description_2= wx.StaticText(self, -1,'Fitted Npts') 
     265        box_description_3= wx.StaticText(self, -1,'Data Npts') 
    271266        box_description_4= wx.StaticText(self, -1,' ') 
    272267         
    … …  
    357352        else: self._show_smear_sizer() 
    358353        boxsizer_range.Add(self.sizer_set_masking) 
    359              
    360         #Set sizer for Fitting section 
    361         self._set_range_sizer( title=title,box_sizer=boxsizer_range, object1=sizer_chi2, object= sizer_fit) 
    362          
     354         #2D data? default 
     355        is_2Ddata = False 
     356         
     357        #check if it is 2D data 
     358        if self.data.__class__.__name__ == 'Data2D': 
     359            is_2Ddata = True 
     360             
     361        self.sizer5.Clear(True) 
     362      
     363        self.qmin_tcrl  = self.ModelTextCtrl(self, -1,size=(_BOX_WIDTH,20), 
     364                                          style=wx.TE_PROCESS_ENTER, 
     365                                    text_enter_callback = self._onQrangeEnter) 
     366        self.qmin_tcrl.SetValue(str(self.qmin_x)) 
     367        self.qmin_tcrl.SetToolTipString("Minimun value of Q in linear scale.") 
     368      
     369        self.qmax  = self.ModelTextCtrl(self, -1,size=(_BOX_WIDTH,20), 
     370                                          style=wx.TE_PROCESS_ENTER, 
     371                                        text_enter_callback=self._onQrangeEnter) 
     372        self.qmax.SetValue(str(self.qmax_x)) 
     373        self.qmax.SetToolTipString("Maximum value of Q in linear scale.") 
     374         
     375        self.theory_npts_tcrtl  = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH, 20),  
     376                        style=wx.TE_PROCESS_ENTER,  
     377                        text_enter_callback=self._onQrangeEnter) 
     378        self.theory_npts_tcrtl.SetValue(format_number(self.npts_x)) 
     379        self.theory_npts_tcrtl.SetToolTipString("Number of point to plot.") 
     380        id = wx.NewId() 
     381        self.reset_qrange =wx.Button(self,id,'Reset',size=(77,20)) 
     382       
     383        self.reset_qrange.Bind(wx.EVT_BUTTON, self.on_reset_clicked,id=id) 
     384        self.reset_qrange.SetToolTipString("Reset Q range to the default values") 
     385      
     386        sizer_horizontal=wx.BoxSizer(wx.HORIZONTAL) 
     387        sizer= wx.GridSizer(2, 5,0, 0) 
     388 
     389        self.btEditMask = wx.Button(self,wx.NewId(),'Editor', size=(88,23)) 
     390        self.btEditMask.Bind(wx.EVT_BUTTON, self._onMask,id= self.btEditMask.GetId()) 
     391        self.btEditMask.SetToolTipString("Edit Mask.") 
     392        self.EditMask_title = wx.StaticText(self, -1, ' Masking(2D)') 
     393 
     394        sizer.Add(wx.StaticText(self, -1, 'Q range'))      
     395        sizer.Add(wx.StaticText(self, -1, ' Min[1/A]')) 
     396        sizer.Add(wx.StaticText(self, -1, ' Max[1/A]')) 
     397        sizer.Add(wx.StaticText(self, -1, ' Theory Npts')) 
     398        sizer.Add(self.EditMask_title) 
     399        sizer.Add(self.reset_qrange)    
     400        sizer.Add(self.qmin_tcrl) 
     401        sizer.Add(self.qmax) 
     402        sizer.Add(self.theory_npts_tcrtl) 
     403        sizer.Add(self.btEditMask) 
     404        boxsizer_range.Add(sizer_chi2)  
     405        boxsizer_range.Add((10,10)) 
     406        boxsizer_range.Add(sizer) 
     407         
     408        boxsizer_range.Add((10,15)) 
     409        boxsizer_range.Add(sizer_fit) 
     410        if is_2Ddata: 
     411            self.btEditMask.Enable()   
     412            self.EditMask_title.Enable()  
     413        else: 
     414            self.btEditMask.Disable()   
     415            self.EditMask_title.Disable() 
     416        ## save state 
     417        self.save_current_state() 
     418        self.sizer5.Add(boxsizer_range,0, wx.EXPAND | wx.ALL, 10) 
     419        self.sizer5.Layout() 
     420 
    363421    def _fill_datainfo_sizer(self): 
    364422        """ 
    … …  
    385443                ## Maximum value of data   
    386444                data_max = math.sqrt(x*x + y*y) 
    387          
     445            ## set q range to plot 
     446            self.qmin_x = data_min 
     447            self.qmax_x = data_max 
    388448        box_description= wx.StaticBox(self, -1, 'Data') 
    389449        boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL) 
    … …  
    416476        sizer_range.Add(self.maximum_q,0, wx.LEFT, 10) 
    417477 
    418         ## set q range to plot 
    419         self.qmin_x = data_min 
    420         self.qmax_x = data_max 
     478      
    421479 
    422480        boxsizer1.Add(sizer_data,0, wx.ALL, 10) 
    … …  
    800858        """ 
    801859        #make sure all parameter values are updated. 
    802         if self.check_invalid_panel(): 
    803             return 
     860        #if self.check_invalid_panel(): 
     861        #    return 
    804862        if self.model ==None: 
    805863            msg="Please select a Model first..." 
    … …  
    828886        # Remove or do not allow fitting on the Q=0 point, especially  
    829887        # when y(q=0)=None at x[0].          
    830         self.qmin_x = float(self.qmin.GetValue()) 
     888        self.qmin_x = float(self.qmin_tcrl.GetValue()) 
    831889        self.qmax_x = float( self.qmax.GetValue()) 
    832         self._manager._reset_schedule_problem( value=0) 
    833         self._manager.schedule_for_fit( value=1,page=self,fitproblem =None)  
    834         self._manager.set_fit_range(page= self,qmin= self.qmin_x,  
     890        self._manager._reset_schedule_problem(id=self.id, value=0) 
     891        self._manager.schedule_for_fit(id=id,value=1,page=self,fitproblem =None)  
     892        self._manager.set_fit_range(id=self.id,qmin= self.qmin_x,  
    835893                                   qmax= self.qmax_x) 
    836894         
    … …  
    889947            self._set_save_flag(True) 
    890948            # Reset smearer, model and data 
    891             self.set_data(self.data) 
    892             # update smearer sizer 
    893             self.onSmear(None) 
     949            self._set_smear(self.data) 
    894950            try: 
     951                # update smearer sizer 
     952                self.onSmear(None) 
    895953                temp_smear = None 
    896954                if self.enable_smearer.GetValue(): 
    897955                    # Set the smearer environments 
    898                     temp_smear= self.smearer 
    899                 #self.compute_chisqr(temp_smear) 
     956                    temp_smear = self.smearer 
    900957            except: 
    901958                ## error occured on chisqr computation 
    … …  
    903960            ## event to post model to fit to fitting plugins 
    904961            (ModelEventbox, EVT_MODEL_BOX) = wx.lib.newevent.NewEvent() 
    905             if self.data is not None and \ 
    906                     self.data.__class__.__name__ !="Data2D": 
    907                 ## set smearing value whether or not  
    908                 #    the data contain the smearing info 
    909                 evt = ModelEventbox(model = self.model,  
    910                                         smearer = temp_smear,  
    911                                         qmin = float(self.qmin_x), 
    912                                      qmax = float(self.qmax_x))  
    913             else:    
    914                  evt = ModelEventbox(model = self.model) 
    915            
    916             self._manager._on_model_panel(evt = evt) 
     962            
     963            ## set smearing value whether or not  
     964            #    the data contain the smearing info 
     965            evt = ModelEventbox(model=self.model,  
     966                                        smearer=temp_smear,  
     967                                        qmin=float(self.qmin_x), 
     968                                        id=self.id, 
     969                                     qmax=float(self.qmax_x))  
     970    
     971            self._manager._on_model_panel(evt=evt) 
    917972            self.state.model = self.model.clone() 
    918973            self.state.model.name = self.model.name 
    919974            if event is not None: 
    920975                self._draw_model() 
    921         if event !=None: 
    922             #self._undo.Enable(True) 
     976        if event != None: 
     977             
    923978            ## post state to fit panel 
    924979            event = PageInfoEvent(page = self) 
    … …  
    9651020                elif self.data.__class__.__name__ !="Data2D": 
    9661021                    self._manager.set_smearer(smearer=temp_smearer,  
     1022                                              id=self.id, 
    9671023                                             qmin= float(self.qmin_x), 
    968                                             qmax= float(self.qmax_x))  
     1024                                            qmax= float(self.qmax_x), 
     1025                                            draw=True)  
    9691026                if flag:    
    9701027                    #self.compute_chisqr(smearer= temp_smearer) 
    … …  
    9921049        Check validity of value enter in the parameters range field 
    9931050        """ 
    994         if self.check_invalid_panel(): 
    995             return 
     1051        #if self.check_invalid_panel(): 
     1052        #    return 
    9961053        tcrtl= event.GetEventObject() 
    9971054        #Clear msg if previously shown. 
    … …  
    10251082        Check validity of value enter in the Q range field 
    10261083        """ 
    1027         if self.check_invalid_panel(): 
    1028             return 
     1084        #if self.check_invalid_panel(): 
     1085        #    return 
    10291086        tcrtl= event.GetEventObject() 
    10301087        #Clear msg if previously shown. 
    … …  
    10391096 
    10401097                # If qmin and qmax have been modified, update qmin and qmax 
    1041                 if self._validate_qrange( self.qmin, self.qmax): 
    1042                     tempmin = float(self.qmin.GetValue()) 
     1098                if self._validate_qrange( self.qmin_tcrl, self.qmax): 
     1099                    tempmin = float(self.qmin_tcrl.GetValue()) 
    10431100                    if tempmin != self.qmin_x: 
    10441101                        self.qmin_x = tempmin 
    … …  
    10771134                    self.set_npts2fit()  
    10781135            else: 
    1079                 index_data = ((self.qmin_x <= self.data.x)& \ 
    1080                               (self.data.x <= self.qmax_x)) 
    1081                 self.Npts_fit.SetValue(str(len(self.data.x[index_data]))) 
     1136                if self.data is not None: 
     1137                     
     1138                    index_data = ((self.qmin_x <= self.data.x)& \ 
     1139                                  (self.data.x <= self.qmax_x)) 
     1140                    self.Npts_fit.SetValue(str(len(self.data.x[index_data]))) 
    10821141 
    10831142            
    … …  
    13731432            self.panel.ShowMessage(msg) 
    13741433         
     1434    def _set_smear(self, data): 
     1435        """ 
     1436        """ 
     1437        if data is None: 
     1438            return 
     1439        self.smearer = smear_selection(self.data, self.model) 
     1440        self.disable_smearer.SetValue(True) 
     1441        if self.smearer == None: 
     1442            self.enable_smearer.Disable() 
     1443        else: 
     1444            self.enable_smearer.Enable() 
     1445             
    13751446    def set_data(self, data): 
    13761447        """ 
    13771448        reset the current data  
    13781449        """ 
     1450        flag = False 
     1451        if self.data is None and data is not None: 
     1452            self.window_name = str(data.name) 
     1453            ## Title to appear on top of the window 
     1454            self.window_caption = str(data.name) 
     1455            flag = True 
    13791456        self.data = data 
    13801457        if self.data is None: 
    … …  
    13821459            data_max = "" 
    13831460            data_name = "" 
    1384             self.formfactorbox.Disable() 
    1385             self.structurebox.Disable() 
    13861461            self._set_bookmark_flag(False) 
    13871462            self._set_save_flag(False) 
    … …  
    13891464            self._set_bookmark_flag(True) 
    13901465            self._set_save_flag(True) 
    1391             self.smearer = smear_selection(self.data, self.model) 
    1392             self.disable_smearer.SetValue(True) 
    1393             if self.smearer == None: 
    1394                 self.enable_smearer.Disable() 
    1395             else: 
    1396                 self.enable_smearer.Enable() 
    1397              
     1466            self._set_smear(data) 
    13981467            # more disables for 2D 
    13991468            if self.data.__class__.__name__ =="Data2D": 
    … …  
    14341503        self.minimum_q.SetValue(str(data_min)) 
    14351504        self.maximum_q.SetValue(str(data_max)) 
    1436         self.qmin.SetValue(str(data_min)) 
     1505        self.qmin_tcrl.SetValue(str(data_min)) 
    14371506        self.qmax.SetValue(str(data_max)) 
    1438         self.qmin.SetBackgroundColour("white") 
     1507        self.qmin_tcrl.SetBackgroundColour("white") 
    14391508        self.qmax.SetBackgroundColour("white") 
    14401509        self.state.data = data 
    14411510        self.state.qmin = self.qmin_x 
    14421511        self.state.qmax = self.qmax_x 
     1512        #update model plot with new data information 
     1513        if flag: 
     1514            self._draw_model() 
    14431515         
    14441516    def reset_page(self, state,first=False): 
    … …  
    14731545         
    14741546        """ 
     1547        if self.data is None: 
     1548            return 
    14751549        npts2fit = 0 
    14761550        qmin,qmax = self.get_range() 
    … …  
    16531727        """ 
    16541728 
    1655         if self.check_invalid_panel(): 
    1656             return 
     1729        #if self.check_invalid_panel(): 
     1730        #    return 
    16571731        if self.model ==None: 
    16581732            self.disable_smearer.SetValue(True) 
    … …  
    17991873            get_pin_max.SetBackgroundColour("white") 
    18001874        ## set smearing value whether or not the data contain the smearing info 
    1801         self._manager.set_smearer(smearer=self.current_smearer, qmin= \ 
    1802                                  float(self.qmin_x),qmax= float(self.qmax_x)) 
     1875        self._manager.set_smearer(smearer=self.current_smearer, 
     1876                                 qmin=float(self.qmin_x), 
     1877                                 qmax= float(self.qmax_x), 
     1878                                 id=self.id) 
    18031879        return msg 
    18041880         
    … …  
    18301906        """ 
    18311907  
    1832         if self.check_invalid_panel(): 
    1833             return 
     1908        #if self.check_invalid_panel(): 
     1909        #    return 
    18341910 
    18351911        if self.model ==None: 
    … …  
    19692045        #temp_smearer = self.current_smearer 
    19702046        ## set smearing value whether or not the data contain the smearing info 
    1971         self._manager.set_smearer(smearer=self.current_smearer, qmin= \ 
    1972                                  float(self.qmin_x), qmax= float(self.qmax_x))  
     2047        self._manager.set_smearer(smearer=self.current_smearer,  
     2048                                 qmin=float(self.qmin_x),  
     2049                                 qmax= float(self.qmax_x), 
     2050                                 id=self.id)  
    19732051        return msg 
    19742052     
    … …  
    20012079        if event != None:  
    20022080            event.Skip()     
    2003         if self.check_invalid_panel(): 
     2081        if self.data is None: 
    20042082            return 
     2083         
    20052084        if self.model == None: 
    20062085            self.disable_smearer.SetValue(True) 
    … …  
    20132092        # Need update param values 
    20142093        self._update_paramv_on_fit() 
    2015                
     2094         
    20162095        temp_smearer = None 
    20172096        self._get_smear_info() 
    … …  
    20542133        self.Layout() 
    20552134        ## set smearing value whether or not the data contain the smearing info 
    2056         self._manager.set_smearer(smearer=temp_smearer, qmin= float(self.qmin_x), 
    2057                                      qmax= float(self.qmax_x))  
    2058  
     2135        self._manager.set_smearer(id=self.id, smearer=temp_smearer, qmin= float(self.qmin_x), 
     2136                        qmax= float(self.qmax_x), draw=True)  
     2137         
    20592138        ##Calculate chi2 
    20602139        #self.compute_chisqr(smearer= temp_smearer) 

  • sansview/perspectives/fitting/fitpanel.py

    r90a7bbd r6bbeacd4  
    33import string  
    44import wx 
    5 import wx.aui 
     5import wx.lib.flatnotebook as fnb 
    66 
    77from sans.guiframe.panel_base import PanelBase 
    88from sans.guiframe.events import PanelOnFocusEvent 
     9from sans.guiframe.events import StatusEvent 
    910import basepage 
    10  
     11import models 
    1112_BOX_WIDTH = 80 
    1213 
    1314 
    14 class PageInfo(object): 
    15     """ 
    16     this class contains the minimum numbers of data members 
    17     a fitpage or model page need to be initialized. 
    18     """ 
    19     data = None 
    20     model =  None 
    21     manager = None 
    22     event_owner= None 
    23     model_list_box = None 
    24     name = None 
    25     ## Internal name for the AUI manager 
    26     window_name = "Page" 
    27     ## Title to appear on top of the window 
    28     window_caption = "Page" 
    29     #type of page can be real data , theory 1D or therory2D 
    30     type = "Data" 
    31     def __init__(self, model=None, data=None, manager=None, 
    32                   event_owner=None, model_list_box=None, name=None): 
    33         """ 
    34         Initialize data members 
    35         """ 
    36         self.data = data 
    37         self.model= model 
    38         self._manager= manager 
    39         self.event_owner= event_owner 
    40         self.model_list_box = model_list_box 
    41         self.name=None 
    42         self.window_name = "Page" 
    43         self.window_caption = "Page" 
    44         self.type = "Data" 
    45          
    46 class FitPanel(wx.aui.AuiNotebook, PanelBase):     
     15class FitPanel(fnb.FlatNotebook, PanelBase):     
    4716 
    4817    """ 
    … …  
    5928    CENTER_PANE = True 
    6029     
    61     def __init__(self, parent, *args, **kwargs): 
    62         """ 
    63         """ 
    64         wx.aui.AuiNotebook.__init__(self, parent, -1, 
     30    def __init__(self, parent, manager=None, *args, **kwargs): 
     31        """ 
     32        """ 
     33        fnb.FlatNotebook.__init__(self, parent, -1, 
    6534                    style= wx.aui.AUI_NB_WINDOWLIST_BUTTON| 
    6635                    wx.aui.AUI_NB_DEFAULT_STYLE| 
    6736                    wx.CLIP_CHILDREN) 
    6837        PanelBase.__init__(self, parent) 
    69      
    70         self._manager = None 
     38        self.SetWindowStyleFlag(style=fnb.FNB_FANCY_TABS) 
     39        self._manager = manager 
    7140        self.parent = parent 
    7241        self.event_owner = None 
    73          
    74         pageClosedEvent = wx.aui.EVT_AUINOTEBOOK_PAGE_CLOSE 
    75         self.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CLOSE, self.on_close_page) 
    76         
    7742        #dictionary of miodel {model class name, model class} 
    78         self.model_list_box = {} 
    79         ## save the title of the last page tab added 
     43        self.menu_mng = models.ModelManager() 
     44        self.model_list_box = self.menu_mng.get_model_list().get_list() 
     45        #pageClosedEvent = fnb.EVT_FLATNOTEBOOK_PAGE_CLOSING  
     46        self.Bind(fnb.EVT_FLATNOTEBOOK_PAGE_CLOSING , self.on_close_page) 
     47         ## save the title of the last page tab added 
    8048        self.fit_page_name = {} 
    8149        ## list of existing fit page 
    … …  
    9159        #add default pages 
    9260        self.add_default_pages() 
    93       
    94         # increment number for model name 
    95         self.count = 0 
    96         #updating the panel 
    97         self.Update() 
    98         self.Center() 
     61     
     62    def get_page_by_id(self, id):   
     63        """ 
     64        """ 
     65        if id not in self.opened_pages: 
     66            msg = "Fitpanel cannot find ID: %s in self.opened_pages" % str(id) 
     67            raise ValueError, msg 
     68        else: 
     69            return self.opened_pages[id] 
    9970         
    10071    def on_page_changing(self, event): 
     72        """ 
     73        """ 
    10174        pos = self.GetSelection() 
    10275        if pos != -1: 
    10376            selected_page = self.GetPage(pos) 
    10477            wx.PostEvent(self.parent, PanelOnFocusEvent(panel=selected_page)) 
     78             
    10579    def on_set_focus(self, event): 
    10680        """ 
    … …  
    136110        from hint_fitpage import HintFitPage 
    137111        self.hint_page = HintFitPage(self)  
    138         self.AddPage(page=self.hint_page, caption="Hint") 
     112        self.AddPage(self.hint_page,"Hint") 
    139113        self.hint_page.set_manager(self._manager) 
    140         #Add the first fit page 
    141         self.add_empty_page() 
    142  
    143      
     114   
    144115    def close_all(self): 
    145116        """ 
    … …  
    170141        page_is_opened = False 
    171142        if state is not None: 
    172             page_info = self.get_page_info(data=state.data) 
    173             for name, panel in self.opened_pages.values(): 
     143            for id, panel in self.opened_pages.values(): 
    174144                #Don't return any panel is the exact same page is created 
    175                 if name == page_info.window_name: 
     145                if id == panel.id: 
    176146                    # the page is still opened 
    177147                    panel.reset_page(state=state) 
    … …  
    182152                # add data associated to the page created 
    183153                if panel is not None:   
    184                     self._manager.store_page(page=panel, data=state.data) 
     154                    self._manager.store_page(page=panel.id, data=state.data) 
    185155                    panel.reset_page(state=state) 
    186156                    panel.save_current_state() 
    … …  
    241211                page.set_manager(self._manager) 
    242212 
    243          
    244     def set_owner(self,owner): 
    245         """  
    246         set and owner for fitpanel 
    247          
    248         :param owner: the class responsible of plotting 
    249          
    250         """ 
    251         self.event_owner = owner 
    252      
    253213    def set_model_list(self, dict): 
    254214         """  
    … …  
    265225         
    266226        """ 
    267         return self.GetPage(self.GetSelection() ) 
     227        return self.GetPage(self.GetSelection()) 
    268228     
    269229    def add_sim_page(self): 
    … …  
    274234        page_finder= self._manager.get_page_finder() 
    275235        self.sim_page = SimultaneousFitPage(self,page_finder=page_finder, id=-1) 
    276          
    277         self.AddPage(self.sim_page,caption="Simultaneous Fit",select=True) 
     236        self.sim_page.id = wx.NewId() 
     237        self.AddPage(self.sim_page,"Simultaneous Fit", True) 
    278238        self.sim_page.set_manager(self._manager) 
    279239        return self.sim_page 
    280240         
    281     def get_page_info(self, data=None): 
    282         """ 
    283         fill information required to add a page in the fit panel 
    284         """ 
    285         name = "Fit Page" 
    286         type = 'empty' 
    287         if data is not None: 
    288             if data.is_data: 
    289                 name = data.name  
    290                 type = 'Data' 
    291             else: 
    292                 if data.__class__.__name__ == "Data2D": 
    293                     name = 'Model 2D Fit' 
    294                     type = 'Theory2D' 
    295                 else: 
    296                     name = 'Model 1D Fit' 
    297                     type = 'Theory1D' 
    298         page_info = PageInfo(data=data, name=name) 
    299         page_info.event_owner = self.event_owner  
    300         page_info.manager = self._manager 
    301         page_info.window_name = name 
    302         page_info.window_caption = name 
    303         page_info.type = type 
    304         return page_info 
     241  
     242    def add_empty_page(self): 
     243        """ 
     244        add an empty page 
     245        """ 
     246        from fitpage import FitPage 
     247        panel = FitPage(parent=self) 
     248        panel.id = wx.NewId() 
     249        panel.populate_box(dict=self.model_list_box) 
     250        panel.set_manager(self._manager) 
     251        self.AddPage(panel, panel.window_name, select=True) 
     252        self.opened_pages[panel.id] = panel 
     253        return panel  
    305254    
    306     def add_empty_page(self): 
    307         """ 
    308         add an empty page 
    309         """ 
    310         page_info = self.get_page_info() 
    311         from fitpage import FitPage 
    312         panel = FitPage(parent=self, page_info=page_info) 
    313         panel.set_manager(self._manager) 
    314         self.AddPage(page=panel, caption=page_info.window_name, select=True) 
    315         self.opened_pages[page_info.type] = [page_info.window_name, panel] 
    316         return panel  
    317      
    318     def add_page(self, page_info): 
    319         """ 
    320         add a new page 
    321         """ 
    322         from fitpage import FitPage 
    323         panel = FitPage(parent=self, page_info=page_info) 
    324         panel.set_manager(self._manager) 
    325         self.AddPage(page=panel, caption=page_info.window_name, select=True) 
    326         index = self.GetPageIndex(panel) 
    327         self.change_page_content(data=page_info.data, index=index) 
    328         return panel 
    329      
    330     def change_page_content(self, data, index): 
    331         """ 
    332         replace the contains of an existing page 
    333         """ 
    334         page_info = self.get_page_info(data=data) 
    335         self.SetPageText(index, page_info.window_name) 
    336         panel = self.GetPage(index) 
    337         panel.set_data(data) 
    338         if panel.model_list_box is None or len(panel.model_list_box) == 0:  
    339             page_info.model_list_box = self.model_list_box.get_list() 
    340             panel.populate_box(dict=page_info.model_list_box) 
    341             panel.initialize_combox() 
    342         panel.set_page_info(page_info=page_info) 
    343         self.opened_pages[page_info.type] = [page_info.window_name, panel] 
    344         return panel 
    345      
    346     def replace_page(self, index, page_info, type): 
    347         """ 
    348         replace an existing page 
    349         """ 
    350         self.DeletePage(index) 
    351         del self.opened_pages[type] 
    352         return self.add_page(page_info=page_info) 
    353          
    354     def add_fit_page(self, data, reset=False): 
     255     
     256    def set_data(self, data): 
    355257        """  
    356258        Add a fitting page on the notebook contained by fitpanel 
    … …  
    363265        if data is None: 
    364266            return None 
    365         page_info = self.get_page_info(data=data) 
    366         type = page_info.type 
    367         npages = len(self.opened_pages.keys()) 
    368         #check if only and empty page is opened 
    369         if len(self.opened_pages.keys()) > 0: 
    370             first_page_type = self.opened_pages.keys()[0] 
    371             if npages == 1 and first_page_type in ['empty']: 
    372                 #replace the first empty page 
    373                 name, panel = self.opened_pages[first_page_type] 
    374                 index = self.GetPageIndex(panel) 
    375                 panel = self.change_page_content(data=data, index=index) 
    376                 del self.opened_pages[first_page_type] 
    377                 return panel 
    378         if type in self.opened_pages.keys(): 
    379             #this type of page is already created but it is a theory 
    380             # meaning the same page is just to fit different data 
    381             if not type.lower() in ['data']: 
    382                 #delete the previous theory page and add a new one 
    383                 name, panel = self.opened_pages[type] 
    384                 #self._manager.reset_plot_panel(panel.get_data()) 
    385                 #delete the existing page and replace it 
    386                 index = self.GetPageIndex(panel) 
    387                 panel = self.replace_page(index=index, page_info=page_info, type=type) 
    388                 return panel  
    389             else: 
    390                 for name, panel in self.opened_pages.values(): 
    391                     #Don't return any panel is the exact same page is created 
    392                     if name == page_info.window_name: 
    393                         return None 
    394                     else: 
    395                         panel = self.add_page(page_info=page_info) 
    396                         return panel         
    397         else: 
    398             #a new type of page is created 
    399             panel = self.add_page(page_info=page_info) 
    400             return panel 
    401          
    402     def  _onGetstate(self, event): 
     267        for page in self.opened_pages.values(): 
     268            #check if the selected data existing in the fitpanel 
     269            pos = self.GetPageIndex(page) 
     270            if page.get_data() is None: 
     271                page.set_data(data) 
     272                self.SetPageText(pos, str(data.name)) 
     273                self.SetSelection(pos) 
     274                return page 
     275            elif page.get_data().id == data.id: 
     276                msg = "Data already existing in the fitting panel" 
     277                wx.PostEvent(self._manager.parent,  
     278                             StatusEvent(status=msg, info='warning'))   
     279                self.SetSelection(pos) 
     280                return page 
     281         
     282        page = self.add_empty_page() 
     283        page.id = wx.NewId() 
     284        page.set_data(data) 
     285        self.SetPageText(pos, str(data.name)) 
     286        self.opened_pages[page.id] = page 
     287        return page 
     288        
     289    def _onGetstate(self, event): 
    403290        """ 
    404291        copy the state of a page 
    405292        """ 
    406         page= event.page 
    407         if page.window_name in self.fit_page_name: 
    408             self.fit_page_name[page.window_name].appendItem(page.createMemento())  
     293        page = event.page 
     294        if page.id in self.fit_page_name: 
     295           self.fit_page_name[page.id].appendItem(page.createMemento())  
    409296             
    410297    def _onUndo(self, event ): 
    … …  
    413300        """ 
    414301        page = event.page  
    415         if page.window_name in self.fit_page_name: 
    416             if self.fit_page_name[page.window_name].getCurrentPosition()==0: 
     302        if page.id in self.fit_page_name: 
     303            if self.fit_page_name[page.id].getCurrentPosition()==0: 
    417304                state = None 
    418305            else: 
    419                 state = self.fit_page_name[page.window_name].getPreviousItem() 
     306                state = self.fit_page_name[page.id].getPreviousItem() 
    420307                page._redo.Enable(True) 
    421308            page.reset_page(state) 
    … …  
    426313        """        
    427314        page = event.page  
    428         if page.window_name in self.fit_page_name: 
    429             length= len(self.fit_page_name[page.window_name]) 
    430             if self.fit_page_name[page.window_name].getCurrentPosition()== length -1: 
     315        if page.id in self.fit_page_name: 
     316            length= len(self.fit_page_name[page.id]) 
     317            if self.fit_page_name[page.id].getCurrentPosition()== length -1: 
    431318                state = None 
    432319                page._redo.Enable(False) 
    433320                page._redo.Enable(True) 
    434321            else: 
    435                 state = self.fit_page_name[page.window_name].getNextItem() 
     322                state =self.fit_page_name[page.id].getNextItem() 
    436323            page.reset_page(state)   
    437324                  
    … …  
    441328        """ 
    442329        #remove hint page 
    443         if selected_page == self.hint_page: 
     330        if selected_page.id == self.hint_page.id: 
    444331            return 
    445332        ## removing sim_page 
    … …  
    461348        if selected_page in page_finder: 
    462349            #Delete the name of the page into the list of open page 
    463             for type, list in self.opened_pages.iteritems(): 
     350            for id, list in self.opened_pages.iteritems(): 
    464351                #Don't return any panel is the exact same page is created 
    465                 name = str(list[0]) 
    466                 if flag and selected_page.window_name == name: 
    467                     if type.lower() in ['theory1d', 'theory2d']: 
    468                         self._manager.remove_plot(selected_page, theory=True) 
    469                     else: 
    470                         self._manager.remove_plot(selected_page, theory=False) 
     352                 
     353                if flag and selected_page.id == id: 
     354                    self._manager.remove_plot(id, theory=False) 
    471355                    break  
    472356            del page_finder[selected_page] 
    … …  
    480364                 
    481365        #Delete the name of the page into the list of open page 
    482         for type, list in self.opened_pages.iteritems(): 
     366        for id, list in self.opened_pages.iteritems(): 
    483367            #Don't return any panel is the exact same page is created 
    484             name = str(list[0]) 
    485             if selected_page.window_name == name: 
     368             
     369            if selected_page.id == id: 
    486370                del self.opened_pages[type] 
    487371                break  

  • sansview/perspectives/fitting/fitproblem.py

    r5062bbf r6bbeacd4  
    1111        """ 
    1212        ## data used for fitting 
    13         self.fit_data=None 
     13        self.fit_data = None 
     14        self.theory_data = None 
    1415        ## the current model 
    1516        self.model = None 
    … …  
    1718        ## if 1 this fit problem will be selected to fit , if 0  
    1819        ## it will not be selected for fit 
    19         self.schedule=0 
     20        self.schedule = 0 
    2021        ##list containing parameter name and value 
    21         self.list_param=[] 
     22        self.list_param = [] 
    2223        ## smear object to smear or not data1D 
    23         self.smearer= None 
    24         ## same as fit_data but with more info for plotting 
    25         ## axis unit info and so on see plottables definition 
    26         self.plotted_data=None 
     24        self.smearer = None 
     25        self.fit_tab_caption = '' 
    2726        ## fitting range 
    2827        self.qmin = None 
    … …  
    4039        obj.model = model 
    4140        obj.fit_data = copy.deepcopy(self.fit_data) 
     41        obj.theory_data = copy.deepcopy(self.theory_data) 
    4242        obj.model = copy.deepcopy(self.model) 
    4343        obj.schedule = copy.deepcopy(self.schedule) 
    … …  
    103103        return self.model_index 
    104104     
    105     def add_plotted_data(self,data): 
     105    def set_theory_data(self, data): 
    106106        """  
    107107        save a copy of the data select to fit 
    … …  
    110110         
    111111        """ 
    112         self.plotted_data = data 
     112        self.theory_data = data 
    113113         
    114114 
    115     def get_plotted_data(self): 
     115    def get_theory_data(self): 
    116116        """ 
    117117        :return: list of data dList 
    118118         
    119119        """ 
    120         return self.plotted_data 
     120        return self.theory_data 
    121121 
    122     def add_fit_data(self,data): 
     122    def set_fit_data(self,data): 
    123123        """  
    124124        save a copy of the data select to fit 
    … …  
    181181        """ 
    182182        self.list_param=[] 
     183         
     184    def set_fit_tab_caption(self, caption): 
     185        """ 
     186        """ 
     187        self.fit_tab_caption = str(caption) 
     188         
     189    def get_fit_tab_caption(self): 
     190        """ 
     191        """ 
     192        return self.fit_tab_caption 
    183193    
     194    

  • sansview/perspectives/fitting/fitting.py

    r81f00d7 r6bbeacd4  
    2929from sans.guiframe.dataFitting import Data2D 
    3030from sans.guiframe.dataFitting import Data1D 
    31 from sans.guiframe.dataFitting import Theory1D 
    32 from sans.guiframe.events import NewPlotEvent, StatusEvent   
     31from sans.guiframe.events import NewPlotEvent  
     32from sans.guiframe.events import StatusEvent   
    3333from sans.guiframe.events import EVT_SLICER_PANEL 
    3434from sans.guiframe.events import EVT_REMOVE_DATA 
    35 from sans.guiframe.events import ERR_DATA 
    3635from sans.guiframe.events import EVT_SLICER_PARS_UPDATE 
     36from sans.guiframe.gui_style import GUIFRAME_ID 
     37from sans.guiframe.plugin_base import PluginBase  
    3738 
    3839 
    … …  
    5051MAX_NBR_DATA = 4 
    5152 
     53 
    5254(PageInfoEvent, EVT_PAGE_INFO)   = wx.lib.newevent.NewEvent() 
    5355 
    54  
    55 class PlotInfo: 
    56     """ 
    57     store some plotting field 
    58     """ 
    59     _xunit = 'A^{-1}' 
    60     _xaxis= "\\rm{Q}" 
    61     _yunit = "cm^{-1}" 
    62     _yaxis= "\\rm{Intensity} " 
    63     id = "Model" 
    64     group_id = "Model" 
    65     title= None 
    66     info= None 
    67      
    68 from sans.guiframe.plugin_base import PluginBase     
     56    
    6957 
    7058class Plugin(PluginBase): 
    … …  
    10593        #keep reference of the simultaneous fit page 
    10694        self.sim_page = None 
    107         #dictionary containing data name and error on dy of that data  
    108         self.err_dy = {} 
    109         self.theory_data = None   
     95    
    11096        #Create a reader for fit page's state 
    11197        self.state_reader = None  
    … …  
    114100        self.state_index = 0 
    115101        self.sfile_ext = None 
     102        # take care of saving  data, model and page associated with each other 
     103        self.page_finder = {} 
    116104        # Log startup 
    117105        logging.info("Fitting plug-in started")  
    … …  
    146134        self.menu1.AppendSeparator() 
    147135        id1 = wx.NewId() 
    148         simul_help = "Allow to edit fit engine with multiple model and data" 
     136        simul_help = "Simultaneous Fit" 
    149137        self.menu1.Append(id1, '&Simultaneous Page',simul_help) 
    150138        wx.EVT_MENU(owner, id1, self.on_add_sim_page) 
    151         
    152         #menu for model 
    153         menu2 = wx.Menu() 
    154         self.menu_mng.populate_menu(menu2, owner) 
    155         id2 = wx.NewId() 
    156         owner.Bind(models.EVT_MODEL,self._on_model_menu) 
    157        
    158         self.fit_panel.set_owner(owner) 
    159         self.fit_panel.set_model_list(self.menu_mng.get_model_list()) 
     139         
     140        id1 = wx.NewId() 
     141        simul_help = "Add new fit page" 
     142        self.menu1.Append(id1, '&Create New Page',simul_help) 
     143        wx.EVT_MENU(owner, id1, self.on_add_new_page) 
     144         
     145        #self.fit_panel.set_model_list(self.menu_mng.get_model_list()) 
    160146    
    161147        #create  menubar items 
    … …  
    181167        frame.Show(True) 
    182168         
    183     def get_context_menu(self, graph=None): 
     169    def get_context_menu(self, plotpanel=None): 
    184170        """ 
    185171        Get the context menu items available for P(r).them allow fitting option 
    … …  
    194180                 
    195181        """ 
    196         self.graph = graph 
     182        graph = plotpanel.graph 
    197183        fit_option = "Select data for fitting" 
    198184        fit_hint =  "Dialog with fitting parameters " 
    199         
    200         for item in graph.plottables: 
    201             if item.__class__.__name__ is "Data2D": 
    202                  
    203                 if hasattr(item,"is_data"): 
    204                     if item.is_data: 
    205                         return [[fit_option, fit_hint, self._onSelect]] 
    206                     else: 
    207                         return []  
    208                 return [[fit_option, fit_hint, self._onSelect]] 
    209             else: 
    210                 if item.name == graph.selected_plottable : 
    211                     if item.name in ["$I_{obs}(q)$","$I_{fit}(q)$", 
    212                                      "$P_{fit}(r)$"]: 
    213                         return []  
    214                     if hasattr(item, "group_id"): 
    215                         # if is_data is true , this in an actual data loaded 
    216                         #else it is a data created from a theory model 
    217                         if hasattr(item,"is_data"): 
    218                             if item.is_data: 
    219                                 return [[fit_option, fit_hint, 
    220                                           self._onSelect]] 
    221                             else: 
    222                                 return []  
    223                         else: 
    224                            return [[fit_option, fit_hint, self._onSelect]] 
     185         
     186        if graph.selected_plottable not in plotpanel.plots: 
     187            return [] 
     188        item = plotpanel.plots[graph.selected_plottable] 
     189        if item.__class__.__name__ is "Data2D":  
     190            if hasattr(item,"is_data"): 
     191                if item.is_data: 
     192                    return [[fit_option, fit_hint, self._onSelect]] 
     193                else: 
     194                    return []  
     195            return [[fit_option, fit_hint, self._onSelect]] 
     196        else: 
     197             
     198            # if is_data is true , this in an actual data loaded 
     199            #else it is a data created from a theory model 
     200            if hasattr(item,"is_data"): 
     201                if item.is_data: 
     202                    return [[fit_option, fit_hint, 
     203                              self._onSelect]] 
     204                else: 
     205                    return []  
    225206        return []    
    226207 
    … …  
    233214        #self.parent.Bind(EVT_FITSTATE_UPDATE, self.on_set_state_helper) 
    234215        # Creation of the fit panel 
    235         self.fit_panel = FitPanel(self.parent, -1) 
     216        self.fit_panel = FitPanel(parent=self.parent, manager=self) 
     217        self.on_add_new_page(event=None) 
    236218        #Set the manager for the main panel 
    237219        self.fit_panel.set_manager(self) 
    … …  
    239221        self.perspective = [] 
    240222        self.perspective.append(self.fit_panel.window_name) 
    241         # take care of saving  data, model and page associated with each other 
    242         self.page_finder = {} 
     223        
    243224        #index number to create random model name 
    244225        self.index_model = 0 
    245226        self.index_theory= 0 
    246227        self.parent.Bind(EVT_SLICER_PANEL, self._on_slicer_event) 
    247         self.parent.Bind(ERR_DATA, self._on_data_error) 
     228        
    248229        self.parent.Bind(EVT_REMOVE_DATA, self._closed_fitpage) 
    249230        self.parent.Bind(EVT_SLICER_PARS_UPDATE, self._onEVT_SLICER_PANEL) 
    … …  
    333314                #set state 
    334315                data = self.parent.create_gui_data(state.data) 
     316                 
    335317                data.group_id = state.data.group_id 
    336318                wx.PostEvent(self.parent, NewPlotEvent(plot=data, 
    … …  
    343325                data = self.parent.create_gui_data(state.data) 
    344326                data.group_id = state.data.group_id 
    345                 page_info = self.fit_panel.get_page_info(data=data) 
    346                 panel = self.fit_panel.add_page(page_info) 
    347                 self.store_page(page=panel, data=data) 
     327                self.add_fit_page(data) 
     328                caption = panel.window_name 
     329                self.store_data(page=panel.id, data=data, caption=caption) 
    348330                self.mypanels.append(panel)  
    349331                 
    350                 
    351332            # get ready for the next set_state 
    352333            self.state_index += 1 
    … …  
    371352        self.state_reader.write(filename=filepath, fitstate=fitstate) 
    372353         
    373     def copy_data(self, item, dy=None): 
    374         """ 
    375         receive a data 1D and the list of errors on dy 
    376         and create a new data1D data 
    377      
    378         """ 
    379         id = None 
    380         if hasattr(item,"id"): 
    381             id = item.id 
    382  
    383         data= Data1D(x=item.x, y=item.y,dx=None, dy=None) 
    384         data.copy_from_datainfo(item) 
    385         item.clone_without_data(clone=data)     
    386         data.dy = deepcopy(dy) 
    387         data.name = item.name 
    388         ## allow to highlight data when plotted 
    389         data.interactive = deepcopy(item.interactive) 
    390         ## when 2 data have the same id override the 1 st plotted 
    391         data.id = id 
    392         data.group_id = item.group_id 
    393         return data 
    394      
    395     def set_fit_range(self, page, qmin, qmax): 
     354    def set_fit_range(self, id, qmin, qmax): 
    396355        """ 
    397356        Set the fitting range of a given page 
    398357        """ 
    399         if page in self.page_finder.iterkeys(): 
    400             fitproblem= self.page_finder[page] 
    401             fitproblem.set_range(qmin= qmin, qmax= qmax) 
     358        self.page_finder[id].set_range(qmin=qmin, qmax=qmax) 
    402359                     
    403     def schedule_for_fit(self,value=0,page=None,fitproblem =None):   
     360    def schedule_for_fit(self,value=0, id=None,fitproblem =None):   
    404361        """ 
    405362        Set the fit problem field to 0 or 1 to schedule that problem to fit. 
    … …  
    414371            fitproblem.schedule_tofit(value) 
    415372        else: 
    416             if page in self.page_finder.iterkeys(): 
    417                 fitproblem= self.page_finder[page] 
    418                 fitproblem.schedule_tofit(value) 
     373            self.page_finder[id].schedule_tofit(value) 
    419374           
    420375    def get_page_finder(self): 
    … …  
    435390          
    436391        """   
    437         sim_page= self.sim_page 
    438         for page, value in self.page_finder.iteritems(): 
    439             if page != sim_page: 
    440                 list=value.get_model() 
     392        sim_page_id = self.sim_page.id 
     393        for id, value in self.page_finder.iteritems(): 
     394            if id != sim_page_id: 
     395                list = value.get_model() 
    441396                model = list[0] 
    442                 if model.name== modelname: 
    443                     value.set_model_param(names,values) 
     397                if model.name == modelname: 
     398                    value.set_model_param(names, values) 
    444399                    break 
    445400          
    … …  
    471426            wx.PostEvent(self.parent, StatusEvent(status="Fitting  \ 
    472427                is cancelled" , type="stop")) 
    473             
    474     def set_smearer_nodraw(self,smearer, qmin=None, qmax=None): 
     428   
     429    def set_smearer(self, id, smearer, qmin=None, qmax=None, draw=True): 
    475430        """ 
    476431        Get a smear object and store it to a fit problem 
    … …  
    478433        :param smearer: smear object to allow smearing data 
    479434         
    480         """   
    481         self.current_pg=self.fit_panel.get_current_page() 
    482         self.page_finder[self.current_pg].set_smearer(smearer) 
    483         ## draw model 1D with smeared data 
    484         data =  self.page_finder[self.current_pg].get_fit_data() 
    485         model = self.page_finder[self.current_pg].get_model() 
    486         ## if user has already selected a model to plot 
    487         ## redraw the model with data smeared 
    488         smear =self.page_finder[self.current_pg].get_smearer()    
    489              
    490     def set_smearer(self,smearer, qmin=None, qmax=None): 
    491         """ 
    492         Get a smear object and store it to a fit problem 
    493          
    494         :param smearer: smear object to allow smearing data 
    495          
    496435        """    
    497         self.current_pg=self.fit_panel.get_current_page() 
    498         self.page_finder[self.current_pg].set_smearer(smearer) 
    499         ## draw model 1D with smeared data 
    500         data =  self.page_finder[self.current_pg].get_fit_data() 
    501         model = self.page_finder[self.current_pg].get_model() 
    502         ## if user has already selected a model to plot 
    503         ## redraw the model with data smeared 
    504  
    505         smear = self.page_finder[self.current_pg].get_smearer() 
    506         if model != None: 
    507             self.draw_model(model=model, data=data, smearer=smear, 
     436        if id not in self.page_finder.keys(): 
     437            msg = "Cannot find ID: %s in page_finder" % str(id) 
     438            raise ValueError, msg 
     439        self.page_finder[id].set_smearer(smearer) 
     440        if draw: 
     441            ## draw model 1D with smeared data 
     442            data =  self.page_finder[id].get_fit_data() 
     443            model = self.page_finder[id].get_model() 
     444            if model is None: 
     445                return 
     446            ## if user has already selected a model to plot 
     447            ## redraw the model with data smeared 
     448            smear = self.page_finder[id].get_smearer() 
     449            self.draw_model(model=model, data=data, id=id, smearer=smear, 
    508450                qmin=qmin, qmax=qmax) 
    509451 
    510     def draw_model(self, model, data=None, smearer=None, 
     452    def draw_model(self, model, id, data=None, smearer=None, 
    511453                   enable1D=True, enable2D=False, 
    512454                   qmin=DEFAULT_QMIN, qmax=DEFAULT_QMAX, qstep=DEFAULT_NPTS): 
    … …  
    527469        if data.__class__.__name__ != "Data2D":     
    528470            ## draw model 1D with no loaded data 
     471             
    529472            self._draw_model1D(model=model,  
    530473                               data=data, 
     474                               id=id, 
    531475                               enable1D=enable1D,  
    532476                               smearer=smearer, 
    … …  
    537481            ## draw model 2D with no initial data 
    538482             self._draw_model2D(model=model, 
     483                                id=id, 
    539484                                data=data, 
    540485                                enable2D=enable2D, 
    … …  
    570515        fproblemId = 0 
    571516        self.current_pg = None 
    572         for page, value in self.page_finder.iteritems(): 
     517        for id, value in self.page_finder.iteritems(): 
    573518            try: 
    574519                if value.get_scheduled() == 1: 
    … …  
    576521                    pars = [] 
    577522                    templist = [] 
     523                    page = self.fit_panel.get_page_by_id(id) 
    578524                    templist = page.get_param_list() 
    579525                    for element in templist: 
    … …  
    584530                                      id=fproblemId, title=engineType)  
    585531                    fproblemId += 1  
    586                     self.current_pg = page 
     532                    self.current_page_id = page 
    587533            except: 
    588                 msg= "%s error: %s" % (engineType, sys.exc_value) 
    589                 wx.PostEvent(self.parent, StatusEvent(status=msg, info="error", 
    590                                                       type="stop")) 
    591                 return  
     534                raise 
     535                #msg= "%s error: %s" % (engineType, sys.exc_value) 
     536                #wx.PostEvent(self.parent, StatusEvent(status=msg, info="error", 
     537                #                                      type="stop")) 
     538                #return  
    592539        ## If a thread is already started, stop it 
    593540        #if self.calc_fit!= None and self.calc_fit.isrunning(): 
    … …  
    600547                                    handler = handler, 
    601548                                    fn=self.fitter, 
    602                                    cpage=self.current_pg, 
    603549                                   pars=pars, 
    604550                                   updatefn=handler.update_fit, 
    … …  
    625571            time.sleep(0.4) 
    626572             
    627     def remove_plot(self, page, theory=False): 
     573    def remove_plot(self, id, theory=False): 
    628574        """ 
    629575        remove model plot when a fit page is closed 
    630576        """ 
    631         fitproblem = self.page_finder[page] 
     577        fitproblem = self.page_finder[id] 
    632578        data = fitproblem.get_fit_data() 
    633579        model = fitproblem.get_model() 
     580        id = None 
    634581        if model is not None: 
    635             name = model.name 
    636             new_plot = Theory1D(x=[], y=[], dy=None) 
    637             new_plot.name = name 
    638             new_plot.xaxis(data._xaxis, data._xunit) 
    639             new_plot.yaxis(data._yaxis, data._yunit) 
    640             new_plot.group_id = data.group_id 
    641             new_plot.id = data.id + name 
    642             wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot, 
    643                                                    title=data.name)) 
     582            id = data.id + name 
    644583        if theory: 
    645             new_plot_data = Data1D(x=[], y=[], dx=None, dy=None) 
    646             new_plot_data.name = data.name 
    647             new_plot_data.xaxis(data._xaxis, data._xunit) 
    648             new_plot_data.yaxis(data._yaxis, data._yunit) 
    649             new_plot_data.group_id = data.group_id 
    650             new_plot_data.id = data.id  
    651             wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot_data, 
    652                                                     title=data.name)) 
    653     def create_fittable_data2D(self, data): 
    654         """ 
    655         check if the current data is a data 2d and add dy to that data 
    656          
    657         :return: Data2D 
    658          
    659         """ 
    660         if data.__class__.__name__ != "Data2D": 
    661             raise ValueError, " create_fittable_data2D expects a Data2D" 
    662         ## Data2D case 
    663         new_data = deepcopy(data) 
    664         if not hasattr(data, "is_data"): 
    665             new_data.group_id += "data2D" 
    666             new_data.id +="data2D" 
    667             new_data.is_data = False 
    668             title = new_data.name 
    669             title += " Fit" 
    670             wx.PostEvent(self.parent, NewPlotEvent(plot=new_data, 
    671                                                     title=str(title))) 
    672         else: 
    673             new_data.is_data = True 
    674         return new_data 
    675          
    676     def create_fittable_data1D(self, data): 
    677         """ 
    678         check if the current data is a theory 1d and add dy to that data 
    679          
    680         :return: Data1D 
    681          
    682         """ 
    683         class_name = data.__class__.__name__ 
    684         if not class_name in ["Data1D", "Theory1D"]: 
    685             raise ValueError, "create_fittable_data1D expects Data1D" 
    686        
    687         #get the appropriate dy  
    688         dy = deepcopy(data.dy) 
    689         if len(self.err_dy) > 0: 
    690             if data.name in  self.err_dy.iterkeys(): 
    691                 dy = self.err_dy[data.name]    
    692         if data.__class__.__name__ == "Theory1D": 
    693             new_data = self.copy_data(data, dy) 
    694             new_data.group_id = str(new_data.group_id)+"data1D" 
    695             new_data.id = str(new_data.id)+"data1D" 
    696             new_data.is_data = False 
    697             title = new_data.name 
    698             title = 'Data created from Theory' 
    699             wx.PostEvent(self.parent, NewPlotEvent(plot=new_data, 
    700                                                     title=str(title), 
    701                                                    reset=True)) 
    702         else: 
    703             new_data = self.copy_data(data, dy)  
    704             new_data.id = data.id  
    705             new_data.is_data = True 
    706         return new_data 
     584            id = data.id  
     585        group_id = data.group_id[len(data.group_id)-1] 
     586        wx.PostEvent(self.parent, NewPlotEvent(id=id, 
     587                                                   group_id=group_id, 
     588                                                   remove=True)) 
    707589            
    708     def store_page(self, page, data): 
     590    def store_data(self, id, data=None, caption=None): 
    709591        """ 
    710592        Helper to save page reference into the plug-in 
    … …  
    713595         
    714596        """ 
    715         page.set_data(data)  
    716597        #create a fitproblem storing all link to data,model,page creation 
    717         if not page in self.page_finder.keys(): 
    718             self.page_finder[page] = FitProblem() 
    719         self.page_finder[page].add_fit_data(data) 
    720          
    721     def add_fit_page(self, data): 
    722         """ 
    723         given a data, ask to the fitting panel to create a new fitting page, 
    724         get this page and store it into the page_finder of this plug-in 
     598        if not id in self.page_finder.keys(): 
     599            self.page_finder[id] = FitProblem() 
     600        self.page_finder[id].set_fit_data(data) 
     601        self.page_finder[id].set_fit_tab_caption(caption) 
     602         
     603    def on_add_new_page(self, event=None): 
     604        """ 
     605        ask fit panel to create a new empty page 
    725606        """ 
    726607        try: 
    727             page = self.fit_panel.add_fit_page(data) 
    728              
     608            page = self.fit_panel.add_empty_page() 
     609            page_caption = page.window_name 
    729610            # add data associated to the page created 
    730611            if page != None:   
    731                 self.store_page(page=page, data=data) 
     612                self.store_data(id=page.id, caption=page_caption, 
     613                                data=page.get_data()) 
    732614                wx.PostEvent(self.parent, StatusEvent(status="Page Created", 
    733615                                               info="info")) 
    … …  
    737619                                                       info="warning")) 
    738620        except: 
    739             msg = "Creating Fit page: %s"%sys.exc_value 
    740             wx.PostEvent(self.parent, StatusEvent(status=msg, info="error")) 
    741         
     621            raise 
     622            #msg = "Creating Fit page: %s"%sys.exc_value 
     623            #wx.PostEvent(self.parent, StatusEvent(status=msg, info="error")) 
     624         
     625         
     626    def add_fit_page(self, data): 
     627        """ 
     628        given a data, ask to the fitting panel to create a new fitting page, 
     629        get this page and store it into the page_finder of this plug-in 
     630        """ 
     631        page = self.fit_panel.set_data(data) 
     632        page_caption = page.window_name 
     633        #append Data1D to the panel containing its theory 
     634        #if theory already plotted 
     635        if page.id in self.page_finder: 
     636            theory_data = self.page_finder[page.id].get_theory_data() 
     637            if issubclass(data.__class__, Data2D): 
     638                data.group_id.append(wx.NewId()) 
     639            else: 
     640                if theory_data is not None: 
     641                    group_id = theory_data.group_id[len(theory_data.group_id)-1] 
     642                    if group_id not in data.group_id: 
     643                        data.group_id.append(group_id) 
     644        self.store_data(id=page.id, data=data, caption=page.window_name) 
     645        if self.sim_page is not None: 
     646            self.sim_page.draw_page() 
     647             
    742648    def _onEVT_SLICER_PANEL(self, event): 
    743649        """ 
    … …  
    794700                    page = self.fit_panel.add_fit_page(data= data,reset=True) 
    795701                    if fitproblem != None: 
    796                         self.page_finder[page]=fitproblem 
     702                        self.page_finder[id] = fitproblem 
    797703                        if self.sim_page != None: 
    798704                            self.sim_page.draw_page() 
    … …  
    808714        unschedule or schedule all fitproblem to be fit 
    809715        """ 
    810         for page, fitproblem in self.page_finder.iteritems(): 
     716        for fitproblem in self.page_finder.values(): 
    811717            fitproblem.schedule_tofit(value) 
    812718             
    … …  
    845751            value.clear_model_param() 
    846752        except: 
    847             msg = title + " error: %s" % sys.exc_value 
    848             wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop")) 
     753            raise 
     754            #msg = title + " error: %s" % sys.exc_value 
     755            #wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop")) 
    849756           
    850757    def _onSelect(self,event): 
    … …  
    858765            if plottable.__class__.__name__ in ["Data1D", "Theory1D"]: 
    859766                if plottable.name == self.panel.graph.selected_plottable: 
    860                     data = self.create_fittable_data1D(data=plottable) 
     767                    data = plottable 
    861768                    self.add_fit_page(data=data) 
    862769                    return 
    863770            else: 
    864                 data = self.create_fittable_data2D(data=plottable) 
     771                data = plottable 
    865772                self.add_fit_page(data=data) 
    866773             
    867     def _single_fit_completed(self,result,pars,cpage, elapsed=None): 
     774    def _single_fit_completed(self,result, pars, elapsed=None): 
    868775        """ 
    869776        Display fit result on one page of the notebook. 
    … …  
    889796                             StatusEvent(status=msg, type="stop")) 
    890797                return 
    891             for page, value in self.page_finder.iteritems(): 
    892                 if page == cpage : 
     798            page_id = None 
     799            for id, value in self.page_finder.iteritems():    
     800                if value.get_scheduled()==1: 
    893801                    model = value.get_model() 
     802                    page_id = id 
    894803                    break 
    895804            param_name = [] 
    … …  
    897806            for name in pars: 
    898807                param_name.append(name) 
    899  
     808                 
     809            cpage = self.fit_panel.get_page_by_id(page_id) 
    900810            cpage.onsetValues(result.fitness,  
    901811                              param_name, result.pvec,result.stderr) 
    … …  
    908818            return 
    909819        
    910     def _simul_fit_completed(self, result, pars=None, cpage=None, elapsed=None): 
     820    def _simul_fit_completed(self, result, pars=None, elapsed=None): 
    911821        """ 
    912822        Parameter estimation completed,  
    … …  
    925835                return 
    926836            if not numpy.isfinite(result.fitness) or numpy.any(result.pvec ==None )or not numpy.all(numpy.isfinite(result.pvec) ): 
    927                 msg= "Single Fitting did not converge!!!" 
     837                msg= "Simultaneous Fitting did not converge!!!" 
    928838                wx.PostEvent(self.parent, StatusEvent(status=msg,type="stop")) 
    929839                return 
    930840               
    931             for page, value in self.page_finder.iteritems():    
    932                 if value.get_scheduled()==1: 
     841            for id, value in self.page_finder.iteritems():    
     842                if value.get_scheduled() == 1: 
    933843                    model = value.get_model() 
    934844                    data =  value.get_fit_data() 
    … …  
    949859 
    950860                    # Display result on each page  
    951                     page.onsetValues(result.fitness, 
     861                    cpage = self.fit_panel.get_page_by_id(id) 
     862                    cpage.onsetValues(result.fitness, 
    952863                                      small_param_name, 
    953864                                      small_out,small_cov) 
    954865        except: 
    955              msg= "Simultaneous Fit completed" 
    956              msg +=" but Following error occurred:%s"%sys.exc_value 
    957              wx.PostEvent(self.parent, StatusEvent(status=msg,type="stop")) 
    958              return  
     866            raise 
     867            #msg= "Simultaneous Fit completed" 
     868            #msg +=" but Following error occurred:%s"%sys.exc_value 
     869            #wx.PostEvent(self.parent, StatusEvent(status=msg,type="stop")) 
     870            #return  
    959871              
    960872    def _on_show_panel(self, event): 
    961873        """ 
    962874        """ 
    963         #print "_on_show_panel: fitting" 
    964875        pass 
    965876         
    … …  
    1044955        event = fitpage.FitterTypeEvent() 
    1045956        event.type = self._fit_engine 
    1046         for key in self.page_finder.keys(): 
    1047             wx.PostEvent(key, event) 
     957        wx.PostEvent(self.fit_panel, event) 
    1048958        
    1049959    def _on_model_panel(self, evt): 
    … …  
    1055965        """ 
    1056966        model = evt.model 
     967        id = evt.id  
     968        qmin = evt.qmin 
     969        qmax = evt.qmax 
     970        smearer = evt.smearer 
    1057971        if model == None: 
    1058972            return 
    1059         smearer = None 
    1060         qmin = None 
    1061         qmax = None 
    1062         if hasattr(evt, "qmin"): 
    1063             qmin = evt.qmin 
    1064         if hasattr(evt, "qmax"): 
    1065             qmax = evt.qmax 
    1066         if hasattr(evt, "smearer"): 
    1067             smearer = evt.smearer 
    1068         model.origin_name = model.name 
    1069         self.current_pg = self.fit_panel.get_current_page()  
    1070         ## make sure nothing is done on self.sim_page 
    1071         ## example trying to call set_panel on self.sim_page 
    1072         if self.current_pg != self.sim_page : 
    1073             if self.page_finder[self.current_pg].get_model() is None: 
    1074                 model.name = "M" + str(self.index_model) 
    1075                 self.index_model += 1   
    1076             else: 
    1077                 model.name= self.page_finder[self.current_pg].get_model().name 
    1078             data = self.page_finder[self.current_pg].get_fit_data() 
    1079             # save the name containing the data name with the appropriate model 
    1080             self.page_finder[self.current_pg].set_model(model) 
    1081             qmin, qmax= self.current_pg.get_range() 
    1082             self.page_finder[self.current_pg].set_range(qmin=qmin, qmax=qmax) 
    1083             
    1084             if self.sim_page != None: 
    1085                 self.sim_page.draw_page() 
    1086          
    1087     def _on_model_menu(self, evt): 
    1088         """ 
    1089         Plot a theory from a model selected from the menu 
    1090          
    1091         :param evt: wx.menu event 
    1092          
    1093         """ 
    1094         model = evt.model 
    1095         Plugin.on_perspective(self,event=evt) 
    1096         # Create a model page. If a new page is created, the model 
    1097         # will be plotted automatically. If a page already exists, 
    1098         # the content will be updated and the plot refreshed 
    1099         self.fit_panel.add_model_page(model, topmenu=True) 
    1100  
     973        
     974        if self.page_finder[id].get_model() is None: 
     975            model.name = "M" + str(self.index_model) 
     976            self.index_model += 1   
     977        else: 
     978            model.name = self.page_finder[id].get_model().name 
     979        # save the name containing the data name with the appropriate model 
     980        self.page_finder[id].set_model(model) 
     981        self.page_finder[id].set_range(qmin=qmin, qmax=qmax) 
     982        if self.sim_page is not None: 
     983            self.sim_page.draw_page() 
     984         
    1101985    def _update1D(self,x, output): 
    1102986        """ 
    … …  
    1108992        #self.calc_thread.ready(0.01) 
    1109993     
    1110     def _fill_default_model2D(self, theory, qmax,qstep, qmin=None): 
     994    def _fill_default_model2D(self, theory,id, qmax,qstep, qmin=None): 
    1111995        """ 
    1112996        fill Data2D with default value  
    … …  
    11911075        theory.ymin = ymin  
    11921076        theory.ymax = ymax  
    1193         theory.group_id = "Model" 
    1194         theory.id = "Model" 
    1195          
    1196     def _get_plotting_info(self, data=None): 
    1197         """ 
    1198         get plotting info from data if data !=None else use some default 
    1199         """ 
    1200         my_info = PlotInfo() 
    1201         if data !=None: 
    1202             if hasattr(data,"info"): 
    1203                 x_name, x_units = data.get_xaxis()  
    1204                 y_name, y_units = data.get_yaxis()  
     1077        theory.group_id = str(id) + "Model2D" 
     1078        theory.id = str(id) + "Mode2D" 
     1079   
    12051080                 
    1206                 my_info._xunit = x_units 
    1207                 my_info._xaxis = x_name 
    1208                 my_info._yunit = y_units 
    1209                 my_info._yaxis = y_name 
    1210                  
    1211             my_info.title= data.name 
    1212             if hasattr(data, "info"): 
    1213                 my_info.info= data.info 
    1214             if hasattr(data, "group_id"): 
    1215                 my_info.group_id= data.group_id 
    1216         return my_info 
    1217                  
    1218     def _complete1D(self, x,y, elapsed,index,model,data=None): 
     1081    def _complete1D(self, x,y, id, elapsed,index,model,data=None): 
    12191082        """ 
    12201083        Complete plotting 1D data 
    12211084        """  
    12221085        try: 
    1223             new_plot = Theory1D(x=x, y=y) 
    1224             my_info = self._get_plotting_info( data) 
    1225             new_plot.name = model.name 
    1226             new_plot.id = my_info.id 
    1227             new_plot.group_id = my_info.group_id 
    1228              
    1229             new_plot.xaxis(my_info._xaxis,  my_info._xunit) 
    1230             new_plot.yaxis(my_info._yaxis, my_info._yunit) 
     1086            new_plot = Data1D(x=x, y=y) 
     1087            new_plot.symbol = GUIFRAME_ID.CURVE_SYMBOL_NUM 
    12311088            if data != None: 
    1232                 if new_plot.id == data.id: 
    1233                     new_plot.id += "Model" 
    1234                 new_plot.is_data =False  
     1089                _xaxis, _xunit = data.get_xaxis()  
     1090                _yaxis, _yunit = data.get_yaxis()  
     1091                new_plot.title = data.name 
     1092                #if the theory is already plotted use the same group id  
     1093                #to replot 
     1094                if id in self.page_finder: 
     1095                    theory_data = self.page_finder[id].get_theory_data() 
     1096                    if theory_data is not None: 
     1097                        print "theory_data", theory_data.group_id 
     1098                        group_id = theory_data.group_id[len(theory_data.group_id)-1] 
     1099                        if group_id not in data.group_id: 
     1100                            data.group_id.append(group_id) 
     1101                        print "data", data.group_id 
     1102                #data is plotted before the theory, then take its group_id 
     1103                #assign to the new theory 
     1104                group_id = data.group_id[len(data.group_id)-1] 
     1105                if group_id not in new_plot.group_id: 
     1106                    new_plot.group_id.append(group_id) 
     1107            else: 
     1108                _xaxis, _xunit = "\\rm{Q}", 'A^{-1}' 
     1109                _yaxis, _yunit = "\\rm{Intensity} ", "cm^{-1}" 
     1110                new_plot.title = "Analytical model 1D " 
     1111                #find a group id to plot theory without data 
     1112                group_id =  str(id) + " Model1D"   
     1113                if group_id not in new_plot.group_id: 
     1114                    new_plot.group_id.append(group_id) 
     1115                new_plot.is_data = False  
     1116            new_plot.id =  str(id) + " Model1D"   
     1117            #find if this theory was already plotted and replace that plot given 
     1118            #the same id 
     1119            if id in self.page_finder: 
     1120                theory_data = self.page_finder[id].get_theory_data() 
     1121                if theory_data is not None: 
     1122                    temp_id = theory_data.id 
     1123                    new_plot.id = temp_id 
     1124            new_plot.name = model.name + " ["+ str(model.__class__.__name__)+ "]" 
     1125            new_plot.xaxis(_xaxis, _xunit) 
     1126            new_plot.yaxis(_yaxis, _yunit) 
     1127            self.page_finder[id].set_theory_data(new_plot) 
    12351128            
    1236             title = new_plot.name 
    1237             # x, y are only in range of index  
    1238             self.theory_data = new_plot 
    1239             #new_plot.perspective = self.get_perspective() 
    1240             # Pass the reset flag to let the plotting event handler 
    1241             # know that we are replacing the whole plot 
    1242             if title is None: 
    1243                 title = "Analytical model 1D " 
    12441129            if data is None: 
    12451130                wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot, 
    1246                              title=str(title), reset=True)) 
     1131                             title=str(new_plot.title))) 
    12471132            else: 
    12481133                wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot, 
    1249                                                        title= str(title))) 
    1250             # Chisqr in fitpage 
    1251             current_pg = self.fit_panel.get_current_page() 
     1134                                            title= str(new_plot.title))) 
     1135            current_pg = self.fit_panel.get_page_by_id(id) 
    12521136            wx.PostEvent(current_pg, 
    1253                          Chi2UpdateEvent(output=self._cal_chisqr(data=data, 
    1254                                                                  index=index))) 
     1137                Chi2UpdateEvent(output=self._cal_chisqr(data=data, 
     1138                                                        id=id, 
     1139                                                        index=index))) 
    12551140            msg = "Plot 1D  complete !" 
    12561141            wx.PostEvent( self.parent, StatusEvent(status=msg, type="stop" )) 
    12571142        except: 
    1258             msg = " Error occurred when drawing %s Model 1D: " % new_plot.name 
    1259             msg += " %s"  % sys.exc_value 
    1260             wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop")) 
     1143            raise 
     1144            #msg = " Error occurred when drawing %s Model 1D: " % new_plot.name 
     1145            #msg += " %s"  % sys.exc_value 
     1146            #wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop")) 
    12611147    
    12621148    def _update2D(self, output,time=None): 
    … …  
    12691155        #self.calc_thread.ready(0.01) 
    12701156     
    1271     def _complete2D(self, image, data, model, elapsed, index, qmin, 
     1157    def _complete2D(self, image, data, model, id,  elapsed, index, qmin, 
    12721158                     qmax, qstep=DEFAULT_NPTS): 
    12731159        """ 
    … …  
    12831169            self._fill_default_model2D(theory=theory,  
    12841170                                       qmax=qmax,  
     1171                                       id=id, 
    12851172                                       qstep=qstep, 
    12861173                                        qmin= qmin) 
    1287          
     1174            
    12881175        else: 
    1289             theory.id = data.id + "Model" 
    1290             theory.group_id = data.name + "Model" 
     1176            theory.id = str(id) + "Model2D" 
     1177            theory.group_id = str(id) + "Model2D" 
     1178          
    12911179            theory.x_bins = data.x_bins 
    12921180            theory.y_bins = data.y_bins 
    … …  
    13051193            theory.xmin = data.xmin 
    13061194            theory.xmax = data.xmax 
    1307         self.theory_data = theory 
     1195        theory.title = "Analytical model 2D " 
     1196        self.page_finder[id].set_theory_data(theory) 
     1197         
    13081198        ## plot 
    13091199        wx.PostEvent(self.parent, NewPlotEvent(plot=theory, 
    1310                          title="Analytical model 2D ", reset=True)) 
     1200                         title=theory.title)) 
    13111201        # Chisqr in fitpage 
    1312         current_pg = self.fit_panel.get_current_page() 
     1202        current_pg = self.fit_panel.get_page_by_id(id) 
    13131203        wx.PostEvent(current_pg, 
    1314             Chi2UpdateEvent(output=self._cal_chisqr(data=data, index=index))) 
     1204            Chi2UpdateEvent(output=self._cal_chisqr(data=data, id=id, index=index))) 
    13151205        msg = "Plot 2D complete !" 
    13161206        wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop")) 
    1317       
    1318     def _on_data_error(self, event): 
    1319         """ 
    1320         receives and event from plotting plu-gins to store the data name and  
    1321         their errors of y coordinates for 1Data hide and show error 
    1322         """ 
    1323         self.err_dy = event.err_dy 
    1324           
    1325     def _draw_model2D(self, model, data=None, smearer=None, 
     1207     
     1208    def _draw_model2D(self, model, id, data=None, smearer=None, 
    13261209                      description=None, enable2D=False, 
    13271210                      qmin=DEFAULT_QMIN, qmax=DEFAULT_QMAX, 
    … …  
    13461229                               num=qstep, 
    13471230                               endpoint=True) 
     1231        if model is None: 
     1232            msg = "Panel with ID: %s does not contained model" % str(id) 
     1233            raise ValueError, msg 
    13481234        ## use data info instead 
    13491235        if data is not None: 
    … …  
    13661252                                    model=model,  
    13671253                                    data=data, 
     1254                                    id=id, 
    13681255                                    smearer=smearer, 
    13691256                                    qmin=qmin, 
    … …  
    13751262 
    13761263        except: 
    1377             msg = " Error occurred when drawing %s Model 2D: " % model.name 
    1378             msg += " %s" % sys.exc_value 
    1379             wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    1380  
    1381     def _draw_model1D(self, model, data=None, smearer=None, 
     1264            raise 
     1265            #msg = " Error occurred when drawing %s Model 2D: " % model.name 
     1266            #msg += " %s" % sys.exc_value 
     1267            #wx.PostEvent(self.parent, StatusEvent(status=msg)) 
     1268 
     1269    def _draw_model1D(self, model, id, data=None, smearer=None, 
    13821270                qmin=DEFAULT_QMIN, qmax=DEFAULT_QMAX,  
    13831271                qstep=DEFAULT_NPTS, enable1D=True): 
    … …  
    14121300            self.calc_1D = Calc1D(x=x, 
    14131301                                  data=data, 
    1414                                   model=model,  
     1302                                  model=model, 
     1303                                  id=id,  
    14151304                                  qmin=qmin, 
    14161305                                  qmax=qmax, 
    … …  
    14251314            wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    14261315 
    1427     def _cal_chisqr(self, data=None, index=None):  
     1316    def _cal_chisqr(self, id, data=None, index=None):  
    14281317        """ 
    14291318        Get handy Chisqr using the output from draw1D and 2D,  
    … …  
    14431332            index = index & (data.err_data != 0)   
    14441333            fn = data.data[index]  
    1445             gn = self.theory_data.data[index] 
     1334            theory_data = self.page_finder[id].get_theory_data() 
     1335            gn = theory_data.data[index] 
    14461336            en = data.err_data[index] 
    14471337        else: 
    … …  
    14571347                dy[dy==0] = 1   
    14581348            fn = data.y[index]  
    1459             gn = self.theory_data.y 
     1349            theory_data = self.page_finder[id].get_theory_data() 
     1350            gn = theory_data.y 
    14601351            en = dy[index] 
    14611352        # residual 

  • sansview/perspectives/fitting/model_thread.py

    r5062bbf r6bbeacd4  
    1515    """ 
    1616    def __init__(self, x, y, data,model,smearer,qmin, qmax,qstep, 
     17                 id , 
    1718                 completefn = None, 
    1819                 updatefn   = None, 
    … …  
    3132        self.y = y 
    3233        self.data= data 
     34        self.page_id = id 
    3335        # the model on to calculate 
    3436        self.model = model 
    … …  
    115117 
    116118        elapsed = time.time()-self.starttime 
    117         self.complete( image = output, 
    118                        data = self.data ,  
    119                        model = self.model, 
    120                        elapsed = elapsed, 
    121                        index = index_model, 
    122                        qmin = self.qmin, 
    123                        qmax = self.qmax, 
    124                        qstep = self.qstep ) 
     119        self.complete(image=output, 
     120                       data=self.data,  
     121                       id=self.page_id, 
     122                       model=self.model, 
     123                       elapsed=elapsed, 
     124                       index=index_model, 
     125                       qmin=self.qmin, 
     126                       qmax=self.qmax, 
     127                       qstep=self.qstep) 
    125128         
    126129 
    … …  
    130133    """ 
    131134    def __init__(self, x, model, 
     135                 id, 
    132136                 data=None, 
    133137                 qmin=None, 
    … …  
    150154        self.qmax= qmax 
    151155        self.model = model 
     156        self.page_id = id 
    152157        self.smearer= smearer 
    153158        self.starttime = 0 
    … …  
    172177        
    173178        self.complete(x=self.x[index], y=output[index],  
     179                      id=self.page_id, 
    174180                      elapsed=elapsed,index=index, model=self.model, 
    175181                                        data=self.data) 

  • sansview/perspectives/fitting/models.py

    r6886000 r6bbeacd4  
    163163    ## Event owner (guiframe) 
    164164    event_owner = None 
    165      
     165    def __init__(self): 
     166        """ 
     167        """ 
     168        self._getModelList() 
     169         
    166170    def _getModelList(self): 
    167171        """ 
    … …  
    552556         
    553557        """ 
     558        self.model_combobox.set_list("Shapes", self.shape_list) 
     559        self.model_combobox.set_list("Shape-Independent", self.shape_indep_list) 
     560        self.model_combobox.set_list("Structure Factors", self.struct_list) 
     561        self.model_combobox.set_list("Customized Models", self.plugins) 
     562        self.model_combobox.set_list("P(Q)*S(Q)", self.multiplication_factor) 
    554563        self.model_combobox.set_list("multiplication", self.multiplication_factor) 
    555564        self.model_combobox.set_list("Multi-Functions", self.multi_func_list) 

  • sansview/perspectives/fitting/simfitpage.py

    r4ce74917 r6bbeacd4  
    5050        ##Font size 
    5151        self.SetWindowVariant(variant = FONT_VARIANT) 
    52          
     52        self.id = None 
    5353        self.parent = parent 
    5454        ## store page_finder 
    5555        self.page_finder = page_finder 
    5656        ## list contaning info to set constraint  
    57         ## look like self.constraint_dict[page]= page  
     57        ## look like self.constraint_dict[page_id]= page  
    5858        self.constraint_dict={} 
    5959        ## item list  self.constraints_list=[combobox1, combobox2,=,textcrtl, button ] 
    … …  
    135135            self._set_constraint() 
    136136        ## get the fit range of very fit problem         
    137         for page, value in self.page_finder.iteritems(): 
    138             qmin, qmax= page.get_range() 
     137        for id, value in self.page_finder.iteritems(): 
     138            qmin, qmax= self.page_finder[id].get_range() 
    139139            value.set_range(qmin, qmax) 
    140140        ## model was actually selected from this page to be fit 
    … …  
    162162        check all models names 
    163163        """ 
    164         self.model_toFit=[]  
    165         if self.cb1.GetValue()==True: 
     164        self.model_toFit = []  
     165        if self.cb1.GetValue()== True: 
    166166            for item in self.model_list: 
    167167                item[0].SetValue(True) 
    … …  
    270270        for item in self.model_toFit: 
    271271            model = item[3] 
    272             page= item[2] 
    273             self.constraint_dict[page] = model 
     272            page_id= item[2] 
     273            self.constraint_dict[page_id] = model 
    274274                    
    275275    def _display_constraint(self, event): 
    … …  
    333333        btRemove.SetToolTipString("Remove constraint.") 
    334334        
    335         for page,model in self.constraint_dict.iteritems(): 
     335        for id,model in self.constraint_dict.iteritems(): 
    336336            ## check if all parameters have been selected for constraint 
    337337            ## then do not allow add constraint on parameters 
    … …  
    364364        hide buttons related constraint  
    365365        """   
    366         for page in  self.page_finder.iterkeys(): 
    367             self.page_finder[page].clear_model_param() 
     366        for id in  self.page_finder.iterkeys(): 
     367            self.page_finder[id].clear_model_param() 
    368368                
    369369        self.nb_constraint =0      
    … …  
    539539                msg+= " to set constraint! " 
    540540                wx.PostEvent(self.parent.Parent, StatusEvent(status= msg )) 
    541             for page , value in self.constraint_dict.iteritems(): 
     541            for id, value in self.constraint_dict.iteritems(): 
    542542                if model == value: 
    543543                    if constraint == "": 
    … …  
    546546                        wx.PostEvent(self.parent.Parent, StatusEvent(status= msg )) 
    547547                        constraint = None 
    548                     self.page_finder[page].set_model_param(param,constraint) 
     548                    self.page_finder[id].set_model_param(param,constraint) 
    549549                    break 
    550550     
    … …  
    575575        sizer.Add(data_used,(iy, ix),(1,1), 
    576576                            wx.EXPAND|wx.ADJUST_MINSIZE, 0)  
    577          
    578         for page, value in self.page_finder.iteritems(): 
     577        ix += 1  
     578        tab_used = wx.StaticText(self, -1, '  Fit Tab') 
     579        tab_used.SetBackgroundColour('grey') 
     580        sizer.Add(tab_used,(iy, ix),(1,1), 
     581                            wx.EXPAND|wx.ADJUST_MINSIZE, 0)  
     582        for id, value in self.page_finder.iteritems(): 
    579583            try: 
    580584                ix = 0 
    581585                iy += 1  
    582586                model = value.get_model() 
    583                 cb = wx.CheckBox(self, -1, str(model.name)) 
     587                name = '_' 
     588                if model is not None: 
     589                    name = str(model.name) 
     590                cb = wx.CheckBox(self, -1, name) 
    584591                cb.SetValue(False) 
     592                cb.Enable(model is not None) 
    585593                sizer.Add( cb,( iy,ix),(1,1),  wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15) 
    586594                wx.EVT_CHECKBOX(self, cb.GetId(), self.check_model_name) 
    587                  
    588595                ix += 2  
    589596                type = model.__class__.__name__ 
    590597                model_type = wx.StaticText(self, -1, str(type)) 
    591598                sizer.Add(model_type,( iy,ix),(1,1),  wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
     599                data = value.get_fit_data() 
     600                name = '-' 
     601                if data is not None: 
     602                    name = str(data.name) 
     603                data_used = wx.StaticText(self, -1, name) 
     604                ix += 1  
     605                sizer.Add(data_used,( iy,ix),(1,1),  wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
     606                     
     607                ix += 1  
     608                caption = value.get_fit_tab_caption() 
     609                tab_caption_used= wx.StaticText(self, -1, str(caption)) 
     610                sizer.Add(tab_caption_used,( iy,ix),(1,1),  wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
    592611                 
    593                 ix += 1  
    594                 data = value.get_fit_data() 
    595                 data_used= wx.StaticText(self, -1, str(data.name)) 
    596                 sizer.Add(data_used,( iy,ix),(1,1),  wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
    597                  
    598                 self.model_list.append([cb,value,page,model]) 
     612                self.model_list.append([cb,value,id,model]) 
    599613                 
    600614            except: 
    601                 pass 
     615                raise 
     616                #pass 
    602617        iy += 1 
    603618        sizer.Add((20,20),( iy,ix),(1,1),  wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15) 
Note: See TracChangeset for help on using the changeset viewer.