Changeset 66ff250 in sasview for sansview/perspectives/fitting


Ignore:
Timestamp:
Mar 18, 2011 6:20:50 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:
e4957fb
Parents:
511c6810
Message:

working on fit stop

Location:
sansview/perspectives/fitting
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • sansview/perspectives/fitting/basepage.py

    rf95301b r66ff250  
    6565        self.data = None 
    6666        self.mask = None 
    67         self.id = None 
     67        self.uid = None 
    6868        ## Q range 
    6969        self.qmin = None 
    … …  
    14481448        is_modified = False 
    14491449 
    1450         wx.PostEvent(self._manager.parent, StatusEvent(status=" \ 
    1451         updating ... ",type="update")) 
     1450        #wx.PostEvent(self._manager.parent, StatusEvent(status=" \ 
     1451        #updating ... ",type="update")) 
    14521452 
    14531453        ##So make sure that update param values on_Fit. 
    … …  
    14821482                    else: 
    14831483                        self._manager.set_smearer(smearer=temp_smearer, 
    1484                                                   id=self.id, 
     1484                                                  uid=self.uid, 
    14851485                                                     qmin=float(self.qmin_x), 
    14861486                                                      qmax=float(self.qmax_x), 
    … …  
    14891489                    self._manager.set_smearer(smearer=temp_smearer, 
    14901490                                              qmin=float(self.qmin_x), 
    1491                                               id=self.id,  
     1491                                              uid=self.uid,  
    14921492                                                 qmax= float(self.qmax_x)) 
    14931493                    index_data = ((self.qmin_x <= self.data.x)&\ 
    … …  
    17591759                                    qmax=float(self.qmax_x), 
    17601760                                    qstep= float(self.npts_x), 
    1761                                     id=self.id, 
     1761                                    page_id=self.uid, 
    17621762                                    toggle_mode_on=toggle_mode_on,  
    17631763                                    state = self.state, 

  • sansview/perspectives/fitting/console.py

    re8bf1ed r66ff250  
    1818    improvement_delta = 5 
    1919    """Number of seconds between improvement updates""" 
    20     def __init__(self,parent, quiet=False,progress_delta=60,improvement_delta=5): 
     20    def __init__(self, parent, manager=None, 
     21                 quiet=False,progress_delta=60,improvement_delta=5): 
    2122        """ 
    2223        If quiet is true, only print out final summary, not progress and 
    … …  
    2728        """ 
    2829        self.parent= parent 
     30        self.manager = manager 
    2931        self.progress_time = time.time() 
    3032        self.progress_percent = 0 
    … …  
    5254            self.improvement_time = t 
    5355             
    54             wx.PostEvent(self.parent, StatusEvent(status=\ 
    55             "%d%% complete ..."%(p),type="progress")) 
     56            #wx.PostEvent(self.parent, StatusEvent(status=\ 
     57            # "%d%% complete ..."%(p),type="progress")) 
    5658        
    5759        # Update percent complete 
    … …  
    6365                self.progress_percent = p 
    6466                self.progress_time = t 
    65                 wx.PostEvent(self.parent, StatusEvent(status=\ 
    66                                                       "%d%% complete ..."%(p), 
    67                                                       type="progress")) 
     67                #wx.PostEvent(self.parent, StatusEvent(status=\ 
     68                #                                      "%d%% complete ..."%(p), 
     69                #                                      type="progress")) 
    6870        
    6971            elif 2 < dp <= 5: 
    7072                if p//5 != self.progress_percent//5: 
    71                     wx.PostEvent(self.parent, StatusEvent(status=\ 
    72                        "%d%% complete ..."%(5*(p//5)),type="progress")) 
     73                    #wx.PostEvent(self.parent, StatusEvent(status=\ 
     74                    #   "%d%% complete ..."%(5*(p//5)),type="progress")) 
    7375                    self.progress_percent = p 
    7476                    self.progress_time = t 
    … …  
    7779                    self.progress_percent = p 
    7880                    self.progress_time = t 
    79                     wx.PostEvent(self.parent, StatusEvent(status=\ 
    80                    "%d%% complete ..."%(10*(p//10)),type="progress")) 
     81                    #wx.PostEvent(self.parent, StatusEvent(status=\ 
     82                   #"%d%% complete ..."%(10*(p//10)),type="progress")) 
    8183         
    8284    def improvement(self): 
    … …  
    9395        if self.isbetter: 
    9496            self.result.print_summary() 
    95         message = "fit Error" 
    96         message = str(msg)+ " \n %s"%self.result.__str__() 
    97         wx.PostEvent(self.parent, StatusEvent(status=message, 
    98                                               info="error", type="stop")) 
     97        #message = "fit Error" 
     98        #message = str(msg)+ " \n %s"%self.result.__str__() 
     99        #wx.PostEvent(self.parent, StatusEvent(status=message, 
     100        #                                      info="error", type="stop")) 
    99101             
    100102    def finalize(self): 
    … …  
    110112            self.result.print_summary() 
    111113             
     114         
    112115    def update_fit(self, msg=""): 
    113116        """ 
    114117        """ 
    115         self.elapsed_time = time.time() - self.elapsed_time 
    116         msg = " Updating fit ...\n result:\n %s \n"%self.result.__str__() 
    117         wx.PostEvent(self.parent, StatusEvent(status=msg, info="info", 
    118                                               type="progress")) 
    119         time.sleep(0.01) 
     118        #self.elapsed_time = time.time() - self.elapsed_time 
     119        #msg = " Updating fit ...\n result:\n %s \n"%self.result.__str__() 
     120        #wx.PostEvent(self.parent, StatusEvent(status=msg, info="info", 
     121        #                                  type="progress")) 
     122        #if self.manager is not None: 
     123        #    self.manager.update_fit(msg=msg, result=self.result) 
     124        #time.sleep(0.01) 
    120125         
    121126    def starting_fit(self): 
    122127        """ 
    123128        """ 
    124         wx.PostEvent(self.parent, StatusEvent(status="Starting the Fit...", 
    125                                         info="info",type="progress")) 
     129        #wx.PostEvent(self.parent, StatusEvent(status="Starting the Fit...", 
     130        #                                info="info",type="progress")) 
    126131         
    127132    def set_result(self, result): 
    … …  
    129134        """ 
    130135        self.result = result 
     136     
     137    def get_result(self): 
     138        """ 
     139        """ 
     140        return self.result 
    131141         
    132142     

  • sansview/perspectives/fitting/fit_thread.py

    r6bbeacd4 r66ff250  
    11 
     2import sys 
     3from data_util.calcthread import CalcThread 
    24 
    3 from data_util.calcthread import CalcThread 
    45 
    56class FitThread(CalcThread): 
    … …  
    89    def __init__(self, parent, 
    910                  fn, 
     11                  page_id, 
    1012                   handler, 
    1113                  pars=None, 
    … …  
    2325        self.fitter = fn 
    2426        self.pars = pars 
     27        self.page_id = page_id 
    2528        self.starttime = 0 
    2629        self.updatefn = updatefn 
    … …  
    3538        except KeyboardInterrupt: 
    3639            raise KeyboardInterrupt 
    37          
     40        
    3841    def compute(self): 
    3942        """ 
    … …  
    4144        """ 
    4245        try:  
    43             self.handler.starting_fit() 
    44             self.updatefn() 
     46            #self.handler.starting_fit() 
    4547            #Result from the fit 
    4648            result = self.fitter.fit(handler=self.handler, curr_thread=self) 
    47             self.updatefn() 
    4849            self.complete(result= result, 
     50                          page_id=self.page_id, 
    4951                          pars = self.pars) 
    5052            
    … …  
    5456            #print "keyboard exception" 
    5557            #Stop on exception during fitting. Todo: need to put some mssg and reset progress bar. 
    56             self.handler.error(msg=msg) 
     58            raise 
     59            #if self.handler is not None: 
     60            #    self.handler.error(msg=msg) 
     61        except: 
     62            raise 
     63            #if self.handler is not None: 
     64            #    self.handler.error(msg=str(sys.exc_value)) 
     65            
    5766         
     67     

  • sansview/perspectives/fitting/fitpage.py

    rf95301b r66ff250  
    1313from sans.guiframe.utils import format_number,check_float 
    1414 
    15  
    16  
    17 ## event to know the selected fit engine 
    18 (FitterTypeEvent, EVT_FITTER_TYPE)   = wx.lib.newevent.NewEvent() 
    19 (FitStopEvent, EVT_FIT_STOP)   = wx.lib.newevent.NewEvent() 
    2015(Chi2UpdateEvent, EVT_CHI2_UPDATE)   = wx.lib.newevent.NewEvent() 
    2116_BOX_WIDTH = 76 
    … …  
    5247        self._fill_range_sizer()  
    5348        self._set_smear(self.data) 
    54         ## to update the panel according to the fit engine type selected 
    55         self.Bind(EVT_FITTER_TYPE,self._on_engine_change) 
    56         self.Bind(EVT_FIT_STOP,self._on_fit_complete) 
    5749        self.Bind(EVT_CHI2_UPDATE, self.on_complete_chisqr) 
    5850        self._set_bookmark_flag(False) 
    5951        self._set_save_flag(False) 
    6052 
    61     def _on_fit_complete(self, event): 
     53    def _on_fit_complete(self): 
    6254        """ 
    6355        When fit is complete ,reset the fit button label. 
    6456        """ 
    65         #self.btFit.SetLabel("Fit") 
    66         #self.btFit.Unbind(event=wx.EVT_BUTTON, id=self.btFit.GetId()) 
    67         #self.btFit.Bind(event=wx.EVT_BUTTON, handler=self._onFit,id=self.btFit.GetId()) 
    68         pass 
     57        self.btFit.SetLabel("Fit") 
     58        self.bind_fit_button() 
    6959         
    7060    def _is_2D(self): 
    … …  
    7565         
    7666        """ 
    77          
    7867        if self.data.__class__.__name__ =="Data2D": 
    7968            return True 
    8069        return False 
    8170             
    82     def _on_engine_change(self, event): 
    83         """ 
    84         get an event containing the current name of the fit engine type 
    85          
    86         :param event: FitterTypeEvent containing  the name of the current engine 
    87          
    88         """ 
    89         self.engine_type = event.type 
     71    def _on_engine_change(self, name): 
     72        """ 
     73        get the current name of the fit engine type 
     74         and update the panel accordingly 
     75        """ 
     76         
     77        self.engine_type = str(name) 
    9078        self.state.engine_type = self.engine_type 
    91         if len(self.parameters)==0: 
     79        if len(self.parameters) == 0: 
    9280            self.Layout() 
    9381            return 
    94         if event.type =="park": 
    95             self.btFit.SetLabel("Fit") 
    96  
     82        #if self.engine_type =="park": 
     83        #    self.btFit.SetLabel("Fit") 
     84        #    self.bind_fit_button() 
    9785        for item in self.parameters: 
    98             if event.type =="scipy" : 
     86            if self.engine_type =="scipy" : 
    9987                item[5].SetValue("") 
    10088                item[5].Hide() 
    … …  
    11098                self.text2_max.Show(True) 
    11199        for item in self.fittable_param: 
    112             if item[5]!=None and item[6]!=None and not item in self.orientation_params_disp: 
    113                 if event.type =="scipy" and not item in self.orientation_params: 
     100            if item[5]!=None and item[6]!=None and not \ 
     101                item in self.orientation_params_disp: 
     102                if self.engine_type =="scipy" and \ 
     103                    not item in self.orientation_params: 
    114104                    item[5].SetValue("") 
    115105                    item[5].Hide() 
    … …  
    130120        for item in self.orientation_params: 
    131121            if item[5]!=None and item[6]!=None: 
    132                 if event.type =="scipy" or self.data.__class__.__name__ !="Data2D": 
     122                if self.engine_type =="scipy" or \ 
     123                self.data.__class__.__name__ !="Data2D": 
    133124                    item[5].SetValue("") 
    134125                    item[5].Hide() 
    … …  
    141132        for item in self.orientation_params_disp:          
    142133            if item[5]!=None and item[6]!=None: 
    143                 if event.type =="scipy" or self.data.__class__.__name__ !="Data2D": 
     134                if self.engine_type =="scipy" or \ 
     135                    self.data.__class__.__name__ !="Data2D": 
    144136                    item[5].SetValue("") 
    145137                    item[5].Hide() 
    … …  
    151143        self.Layout() 
    152144        self.Refresh() 
    153      
     145         
    154146   
    155147         
    … …  
    965957        self.qmin_x = float(self.qmin.GetValue()) 
    966958        self.qmax_x = float( self.qmax.GetValue()) 
    967         self._manager._reset_schedule_problem(id=self.id, value=0) 
    968         self._manager.schedule_for_fit(id=self.id,value=1, fitproblem =None)  
    969         self._manager.set_fit_range(id=self.id,qmin= self.qmin_x,  
     959        self._manager._reset_schedule_problem(value=0) 
     960        self._manager.schedule_for_fit(uid=self.uid,value=1, fitproblem =None)  
     961        self._manager.set_fit_range(uid=self.uid,qmin= self.qmin_x,  
    970962                                   qmax= self.qmax_x) 
    971963         
    972964        #single fit  
    973965        self._manager.onFit() 
    974         ## allow stopping the fit  
     966        self.btFit.SetLabel("Stop") 
     967        self.bind_fit_button() 
     968            
     969    def bind_fit_button(self): 
     970        """ 
     971        bind the fit button to either fit handler or stop fit handler 
     972        """ 
     973        self.btFit.Unbind(event=wx.EVT_BUTTON, id= self.btFit.GetId()) 
     974        if self.btFit.GetLabel().lower() == "stop": 
     975            self.btFit.Bind(event=wx.EVT_BUTTON, handler=self._StopFit, 
     976                             id=self.btFit.GetId()) 
     977        elif self.btFit.GetLabel().lower() == "fit": 
     978            self.btFit.Bind(event=wx.EVT_BUTTON, handler=self._onFit,  
     979                            id=self.btFit.GetId()) 
     980        else: 
     981            msg = "FitPage: fit button has unknown label" 
     982            raise ValuerError, msg 
     983        self._manager._reset_schedule_problem(value=0) 
     984           
     985 
     986    def _StopFit(self, event): 
     987        """ 
     988        Stop fit  
     989        """ 
    975990        #if self.engine_type=="scipy": 
    976         #    self.btFit.SetLabel("Stop") 
    977         #    self.btFit.Unbind(event=wx.EVT_BUTTON, id= self.btFit.GetId()) 
    978         #    self.btFit.Bind(event= wx.EVT_BUTTON,  
    979         #            handler=self._StopFit, id=self.btFit.GetId()) 
    980         #else: 
    981         #    self.btFit.SetLabel("Fit") 
    982         #    self.btFit.Bind(event= wx.EVT_BUTTON,  
    983         #                handler=self._onFit, id=self.btFit.GetId()) 
    984             
    985     def _StopFit(self, event): 
    986         """ 
    987         Stop fit  
    988         """ 
    989         self.btFit.SetLabel("Fit") 
    990         if self.engine_type=="scipy": 
    991             self._manager.stop_fit() 
    992         self.btFit.Unbind(event=wx.EVT_BUTTON, id=self.btFit.GetId()) 
    993         self.btFit.Bind(event=wx.EVT_BUTTON, handler=self._onFit, 
    994                         id=self.btFit.GetId()) 
    995          
    996              
     991        self._manager.stop_fit(self.uid) 
     992        self._manager._reset_schedule_problem(value=0) 
     993        self._on_fit_complete() 
     994          
    997995    def _on_select_model(self, event=None):  
    998996        """ 
    … …  
    10331031                    temp_smear = self.smearer 
    10341032            except: 
     1033                raise 
    10351034                ## error occured on chisqr computation 
    1036                 pass 
     1035                #pass 
    10371036            ## event to post model to fit to fitting plugins 
    10381037            (ModelEventbox, EVT_MODEL_BOX) = wx.lib.newevent.NewEvent() 
    … …  
    10431042                                        smearer=temp_smear,  
    10441043                                        qmin=float(self.qmin_x), 
    1045                                         id=self.id, 
     1044                                        uid=self.uid, 
    10461045                                     qmax=float(self.qmax_x))  
    10471046    
    … …  
    10751074        tcrtl = event.GetEventObject() 
    10761075         
    1077         wx.PostEvent(self._manager.parent, StatusEvent(status=" \ 
    1078                                 updating ... ",type="update")) 
     1076        #wx.PostEvent(self._manager.parent, StatusEvent(status=" \ 
     1077        #                        updating ... ",type="update")) 
    10791078        #Clear msg if previously shown. 
    10801079        msg= "" 
    … …  
    10981097                elif self.data.__class__.__name__ !="Data2D": 
    10991098                    self._manager.set_smearer(smearer=temp_smearer,  
    1100                                               id=self.id, 
     1099                                              uid=self.uid, 
    11011100                                             qmin= float(self.qmin_x), 
    11021101                                            qmax= float(self.qmax_x), 
    … …  
    22292228        self.Layout() 
    22302229        ## set smearing value whether or not the data contain the smearing info 
    2231         self._manager.set_smearer(id=self.id, smearer=temp_smearer, qmin= float(self.qmin_x), 
     2230        self._manager.set_smearer(uid=self.uid, smearer=temp_smearer, qmin= float(self.qmin_x), 
    22322231                        qmax= float(self.qmax_x), draw=True)  
    22332232         

  • sansview/perspectives/fitting/fitpanel.py

    rf95301b r66ff250  
    88from sans.guiframe.events import PanelOnFocusEvent 
    99from sans.guiframe.events import StatusEvent 
     10 
    1011import basepage 
    1112import models 
    … …  
    5152        #page of simultaneous fit  
    5253        self.sim_page = None 
     54        self.fit_engine_type = "scipy" 
    5355        ## get the state of a page 
    5456        self.Bind(basepage.EVT_PAGE_INFO, self._onGetstate) 
    … …  
    5658        self.Bind(basepage.EVT_NEXT_STATE, self._onRedo) 
    5759        self.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED, self.on_page_changing) 
    58         
     60       
    5961        #add default pages 
    6062        self.add_default_pages() 
    6163     
     64    def _on_engine_change(self, name='scipy'): 
     65        """ 
     66        """ 
     67        for panel in self.opened_pages.values(): 
     68            self.set_engine_helper(panel=panel, name=name) 
     69             
     70    def set_engine_helper(self, panel, name='scipy'): 
     71        """ 
     72        """ 
     73        self.fit_engine_type = name 
     74        if panel != self.sim_page: 
     75            panel._on_engine_change(name=self.fit_engine_type) 
     76                 
    6277    def update_model_list(self): 
    6378        """ 
    … …  
    6782         
    6883         
    69     def get_page_by_id(self, id):   
    70         """ 
    71         """ 
    72         if id not in self.opened_pages: 
    73             msg = "Fitpanel cannot find ID: %s in self.opened_pages" % str(id) 
     84    def get_page_by_id(self, uid):   
     85        """ 
     86        """ 
     87        if uid not in self.opened_pages: 
     88            msg = "Fitpanel cannot find ID: %s in self.opened_pages" % str(uid) 
    7489            raise ValueError, msg 
    7590        else: 
    76             return self.opened_pages[id] 
     91            return self.opened_pages[uid] 
    7792         
    7893    def on_page_changing(self, event): 
    … …  
    157172        page_is_opened = False 
    158173        if state is not None: 
    159             for id, panel in self.opened_pages.iteritems(): 
     174            for uid, panel in self.opened_pages.iteritems(): 
    160175                #Don't return any panel is the exact same page is created 
    161                 if id == panel.id: 
     176                if uid == panel.uid: 
    162177                    # the page is still opened 
    163178                    panel.reset_page(state=state) 
    … …  
    168183                # add data associated to the page created 
    169184                if panel is not None:   
    170                     self._manager.store_page(page=panel.id, data=state.data) 
     185                    self._manager.store_page(page=panel.uid, data=state.data) 
    171186                    panel.reset_page(state=state) 
    172187                    panel.save_current_state() 
    … …  
    250265        page_finder= self._manager.get_page_finder() 
    251266        self.sim_page = SimultaneousFitPage(self,page_finder=page_finder, id=-1) 
    252         self.sim_page.id = wx.NewId() 
     267        self.sim_page.uid = wx.NewId() 
    253268        self.AddPage(self.sim_page,"Simultaneous Fit", True) 
    254269        self.sim_page.set_manager(self._manager) 
    … …  
    262277        from fitpage import FitPage 
    263278        panel = FitPage(parent=self) 
    264         panel.id = wx.NewId() 
     279        panel.uid = wx.NewId() 
    265280        panel.populate_box(dict=self.model_list_box) 
    266281        panel.set_manager(self._manager) 
    267282        caption = str(panel.window_name) + " " + str(self._manager.index_model) 
    268283        self.AddPage(panel, caption, select=True) 
    269         self.opened_pages[panel.id] = panel 
     284        self.opened_pages[panel.uid] = panel 
     285        self.set_engine_helper(panel=panel) 
    270286        return panel  
    271287     
    … …  
    308324        page = self.add_empty_page() 
    309325        pos = self.GetPageIndex(page) 
    310         page.id = wx.NewId() 
    311326        page.set_data(data) 
    312327        self.SetPageText(pos, str(data.name)) 
    313         self.opened_pages[page.id] = page 
     328        self.opened_pages[page.uid] = page 
    314329         
    315330        return page 
    … …  
    320335        """ 
    321336        page = event.page 
    322         if page.id in self.fit_page_name: 
    323            self.fit_page_name[page.id].appendItem(page.createMemento())  
     337        if page.uid in self.fit_page_name: 
     338           self.fit_page_name[page.uid].appendItem(page.createMemento())  
    324339             
    325340    def _onUndo(self, event ): 
    … …  
    328343        """ 
    329344        page = event.page  
    330         if page.id in self.fit_page_name: 
    331             if self.fit_page_name[page.id].getCurrentPosition()==0: 
     345        if page.uid in self.fit_page_name: 
     346            if self.fit_page_name[page.uid].getCurrentPosition()==0: 
    332347                state = None 
    333348            else: 
    334                 state = self.fit_page_name[page.id].getPreviousItem() 
     349                state = self.fit_page_name[page.uid].getPreviousItem() 
    335350                page._redo.Enable(True) 
    336351            page.reset_page(state) 
    … …  
    341356        """        
    342357        page = event.page  
    343         if page.id in self.fit_page_name: 
    344             length= len(self.fit_page_name[page.id]) 
    345             if self.fit_page_name[page.id].getCurrentPosition()== length -1: 
     358        if page.uid in self.fit_page_name: 
     359            length= len(self.fit_page_name[page.uid]) 
     360            if self.fit_page_name[page.uid].getCurrentPosition()== length -1: 
    346361                state = None 
    347362                page._redo.Enable(False) 
    348363                page._redo.Enable(True) 
    349364            else: 
    350                 state =self.fit_page_name[page.id].getNextItem() 
     365                state =self.fit_page_name[page.uid].getNextItem() 
    351366            page.reset_page(state)   
    352367                  
    … …  
    376391        if selected_page in page_finder: 
    377392            #Delete the name of the page into the list of open page 
    378             for id, list in self.opened_pages.iteritems(): 
     393            for uid, list in self.opened_pages.iteritems(): 
    379394                #Don't return any panel is the exact same page is created 
    380395                 
    381                 if flag and selected_page.id == id: 
    382                     self._manager.remove_plot(id, theory=False) 
     396                if flag and selected_page.uid == uid: 
     397                    self._manager.remove_plot(uid, theory=False) 
    383398                    break  
    384399            del page_finder[selected_page] 
    … …  
    392407                 
    393408        #Delete the name of the page into the list of open page 
    394         for id, list in self.opened_pages.iteritems(): 
     409        for uid, list in self.opened_pages.iteritems(): 
    395410            #Don't return any panel is the exact same page is created 
    396411             
    397             if selected_page.id == id: 
    398                 del self.opened_pages[selected_page.id] 
     412            if selected_page.uid == uid: 
     413                del self.opened_pages[selected_page.uid] 
    399414                break  
    400415      

  • sansview/perspectives/fitting/fitting.py

    rf95301b r66ff250  
    2323import fitpage 
    2424 
     25 
    2526from DataLoader.loader import Loader 
    2627from sans.guiframe.dataFitting import Data2D 
    … …  
    6768        self.calc_2D = None 
    6869        self.calc_1D = None 
    69         self.calc_fit = None 
     70        self.fit_thread_list = {} 
    7071         
    7172        # Start with a good default 
    … …  
    278279                                                       title=str(data.title))) 
    279280        except: 
    280             msg = "Fitting Set_data: " + str(sys.exc_value) 
    281             wx.PostEvent(self.parent, StatusEvent(status=msg, info="error")) 
     281            raise 
     282            #msg = "Fitting Set_data: " + str(sys.exc_value) 
     283            #wx.PostEvent(self.parent, StatusEvent(status=msg, info="error")) 
    282284             
    283285    def set_theory(self,  theory_list=None): 
    … …  
    378380        self.state_reader.write(filename=filepath, fitstate=fitstate) 
    379381         
    380     def set_fit_range(self, id, qmin, qmax): 
     382    def set_fit_range(self, uid, qmin, qmax): 
    381383        """ 
    382384        Set the fitting range of a given page 
    383385        """ 
    384         self.page_finder[id].set_range(qmin=qmin, qmax=qmax) 
     386        self.page_finder[uid].set_range(qmin=qmin, qmax=qmax) 
    385387                     
    386     def schedule_for_fit(self,value=0, id=None,fitproblem =None):   
     388    def schedule_for_fit(self,value=0, uid=None,fitproblem =None):   
    387389        """ 
    388390        Set the fit problem field to 0 or 1 to schedule that problem to fit. 
    … …  
    397399            fitproblem.schedule_tofit(value) 
    398400        else: 
    399             self.page_finder[id].schedule_tofit(value) 
     401            self.page_finder[uid].schedule_tofit(value) 
    400402           
    401403    def get_page_finder(self): 
    … …  
    416418          
    417419        """   
    418         sim_page_id = self.sim_page.id 
    419         for id, value in self.page_finder.iteritems(): 
    420             if id != sim_page_id: 
     420        sim_page_id = self.sim_page.uid 
     421        for uid, value in self.page_finder.iteritems(): 
     422            if uid != sim_page_id: 
    421423                list = value.get_model() 
    422424                model = list[0] 
    … …  
    444446            return model_name,param_name 
    445447         
    446     def stop_fit(self): 
     448    def stop_fit(self, uid): 
    447449        """ 
    448450        Stop the fit engine 
    449451        """ 
    450         if self.calc_fit!= None and self.calc_fit.isrunning(): 
    451             self.calc_fit.stop() 
    452             wx.PostEvent(self.parent, StatusEvent(status="Fitting  \ 
    453                 is cancelled" , type="stop")) 
     452        if uid in self.fit_thread_list.keys(): 
     453            calc_fit = self.fit_thread_list[uid] 
     454            if calc_fit is not  None and calc_fit.isrunning(): 
     455                calc_fit.stop() 
     456                msg = "Fit stop!" 
     457                wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop")) 
     458        #set the fit button label of page when fit stop is trigger from 
     459        #simultaneous fit pane 
     460        if  self.sim_page is not None and uid == self.sim_page.uid: 
     461            for uid, value in self.page_finder.iteritems(): 
     462                if value.get_scheduled() == 1: 
     463                    if uid in self.fit_panel.opened_pages.keys(): 
     464                        panel = self.fit_panel.opened_pages[uid] 
     465                        panel. _on_fit_complete() 
    454466   
    455     def set_smearer(self, id, smearer, qmin=None, qmax=None, draw=True): 
     467    def set_smearer(self, uid, smearer, qmin=None, qmax=None, draw=True): 
    456468        """ 
    457469        Get a smear object and store it to a fit problem 
    … …  
    460472         
    461473        """    
    462         if id not in self.page_finder.keys(): 
    463             msg = "Cannot find ID: %s in page_finder" % str(id) 
     474        if uid not in self.page_finder.keys(): 
     475            msg = "Cannot find ID: %s in page_finder" % str(uid) 
    464476            raise ValueError, msg 
    465         self.page_finder[id].set_smearer(smearer) 
     477        self.page_finder[uid].set_smearer(smearer) 
    466478        if draw: 
    467479            ## draw model 1D with smeared data 
    468             data =  self.page_finder[id].get_fit_data() 
    469             model = self.page_finder[id].get_model() 
     480            data =  self.page_finder[uid].get_fit_data() 
     481            model = self.page_finder[uid].get_model() 
    470482            if model is None: 
    471483                return 
    472484            ## if user has already selected a model to plot 
    473485            ## redraw the model with data smeared 
    474             smear = self.page_finder[id].get_smearer() 
    475             self.draw_model(model=model, data=data, id=id, smearer=smear, 
     486            smear = self.page_finder[uid].get_smearer() 
     487            self.draw_model(model=model, data=data, page_id=uid, smearer=smear, 
    476488                qmin=qmin, qmax=qmax) 
    477489 
    478     def draw_model(self, model, id, data=None, smearer=None, 
     490    def draw_model(self, model, page_id, data=None, smearer=None, 
    479491                   enable1D=True, enable2D=False, 
    480492                   state=None, 
    … …  
    500512            self._draw_model1D(model=model,  
    501513                               data=data, 
    502                                id=id, 
     514                               page_id=page_id, 
    503515                               enable1D=enable1D,  
    504516                               smearer=smearer, 
    … …  
    511523            ## draw model 2D with no initial data 
    512524             self._draw_model2D(model=model, 
    513                                 id=id, 
     525                                page_id=page_id, 
    514526                                data=data, 
    515527                                enable2D=enable2D, 
    … …  
    527539        ##  count the number of fitproblem schedule to fit  
    528540        fitproblem_count = 0 
    529         for value in self.page_finder.itervalues(): 
     541        for value in self.page_finder.values(): 
    530542            if value.get_scheduled() == 1: 
    531543                fitproblem_count += 1 
    … …  
    538550           
    539551        from sans.fit.Fitting import Fit 
    540         self.fitter = Fit(self._fit_engine) 
     552        fitter = Fit(self._fit_engine) 
    541553         
    542554        if self._fit_engine == "park": 
    … …  
    547559        fproblemId = 0 
    548560        self.current_pg = None 
    549         for id, value in self.page_finder.iteritems(): 
     561        list_page_id = [] 
     562        for page_id, value in self.page_finder.iteritems(): 
    550563            try: 
    551564                if value.get_scheduled() == 1: 
    … …  
    553566                    pars = [] 
    554567                    templist = [] 
    555                     page = self.fit_panel.get_page_by_id(id) 
     568                     
     569                    page = self.fit_panel.get_page_by_id(page_id) 
    556570                    templist = page.get_param_list() 
    557571                    for element in templist: 
    … …  
    560574                    #Set Engine  (model , data) related to the page on  
    561575                    self._fit_helper(value=value, pars=pars, 
    562                                       id=fproblemId, title=engineType)  
     576                                     fitter=fitter, 
     577                                      fitproblem_id=fproblemId, 
     578                                      title=engineType)  
     579                    list_page_id.append(page_id) 
    563580                    fproblemId += 1  
    564                     self.current_page_id = page 
     581                    current_page_id = page_id 
    565582            except: 
    566583                raise 
    … …  
    573590        #    self.calc_fit.stop() 
    574591         #Handler used for park engine displayed message 
    575         handler = ConsoleUpdate(parent=self.parent,improvement_delta=0.1) 
     592        handler = ConsoleUpdate(parent=self.parent, 
     593                                manager=self, 
     594                                improvement_delta=0.1) 
     595         
    576596        ## perform single fit 
    577597        if fitproblem_count == 1: 
    578598            calc_fit = FitThread(parent=self.parent, 
    579599                                    handler = handler, 
    580                                     fn=self.fitter, 
     600                                    fn=fitter, 
    581601                                   pars=pars, 
    582                                    updatefn=handler.update_fit, 
     602                                   page_id=list_page_id, 
    583603                                   completefn=self._single_fit_completed) 
    584604        else: 
     605            current_page_id = self.sim_page.uid 
    585606            ## Perform more than 1 fit at the time 
    586607            calc_fit = FitThread(parent=self.parent, 
    587608                                handler=handler, 
    588                                     fn= self.fitter, 
    589                                    completefn= self._simul_fit_completed, 
    590                                   updatefn=handler.update_fit) 
    591          
     609                                    fn=fitter, 
     610                                    page_id=list_page_id, 
     611                                   completefn= self._simul_fit_completed) 
     612        self.fit_thread_list[current_page_id] = calc_fit 
    592613        calc_fit.queue() 
    593614        self.ready_fit(calc_fit=calc_fit) 
    594615       
     616             
    595617    def ready_fit(self, calc_fit): 
    596618        """ 
    … …  
    603625            time.sleep(0.4) 
    604626             
    605     def remove_plot(self, id, theory=False): 
     627    def remove_plot(self, uid, theory=False): 
    606628        """ 
    607629        remove model plot when a fit page is closed 
    608630        """ 
    609         fitproblem = self.page_finder[id] 
     631        fitproblem = self.page_finder[uid] 
    610632        data = fitproblem.get_fit_data() 
    611633        model = fitproblem.get_model() 
    612         id = None 
     634        plot_id = None 
    613635        if model is not None: 
    614             id = data.id + name 
     636            plot_id = data.id + name 
    615637        if theory: 
    616             id = data.id  
     638            plot_id = data.id  
    617639        group_id = data.group_id 
    618         wx.PostEvent(self.parent, NewPlotEvent(id=id, 
     640        wx.PostEvent(self.parent, NewPlotEvent(id=plot_id, 
    619641                                                   group_id=group_id, 
    620642                                                   action='remove')) 
    621643            
    622     def store_data(self, id, data=None, caption=None): 
     644    def store_data(self, uid, data=None, caption=None): 
    623645        """ 
    624646        Helper to save page reference into the plug-in 
    … …  
    628650        """ 
    629651        #create a fitproblem storing all link to data,model,page creation 
    630         if not id in self.page_finder.keys(): 
    631             self.page_finder[id] = FitProblem() 
    632         self.page_finder[id].set_fit_data(data) 
    633         self.page_finder[id].set_fit_tab_caption(caption) 
     652        if not uid in self.page_finder.keys(): 
     653            self.page_finder[uid] = FitProblem() 
     654        self.page_finder[uid].set_fit_data(data) 
     655        self.page_finder[uid].set_fit_tab_caption(caption) 
    634656         
    635657    def on_add_new_page(self, event=None): 
    … …  
    642664            # add data associated to the page created 
    643665            if page != None:   
    644                 self.store_data(id=page.id, caption=page_caption, 
     666                self.store_data(uid=page.uid, caption=page_caption, 
    645667                                data=page.get_data()) 
    646668                wx.PostEvent(self.parent, StatusEvent(status="Page Created", 
    … …  
    665687        #append Data1D to the panel containing its theory 
    666688        #if theory already plotted 
    667         if page.id in self.page_finder: 
    668             theory_data = self.page_finder[page.id].get_theory_data() 
     689        if page.uid in self.page_finder: 
     690            theory_data = self.page_finder[page.uid].get_theory_data() 
    669691            if issubclass(data.__class__, Data2D): 
    670692                data.group_id = wx.NewId() 
    671693                if theory_data is not None: 
    672                     group_id = str(page.id) + " Model1D" 
     694                    group_id = str(page.uid) + " Model1D" 
    673695                    wx.PostEvent(self.parent,  
    674696                             NewPlotEvent(group_id=group_id, 
    … …  
    677699            else: 
    678700                if theory_data is not None: 
    679                     group_id = str(page.id) + " Model2D" 
     701                    group_id = str(page.uid) + " Model2D" 
    680702                    data.group_id = theory_data.group_id 
    681703                    wx.PostEvent(self.parent,  
    … …  
    684706                    self.parent.update_data(prev_data=theory_data, new_data=data)    
    685707               
    686         self.store_data(id=page.id, data=data, caption=page.window_name) 
     708        self.store_data(uid=page.uid, data=data, caption=page.window_name) 
    687709        if self.sim_page is not None: 
    688710            self.sim_page.draw_page() 
    … …  
    709731        if event is None or event.data is None: 
    710732            return 
    711         
    712733        if hasattr(event.data,"is_data"): 
    713734            if not event.data.is_data or \ 
    714                 event.data.__class__.__name__=="Data1D": 
     735                event.data.__class__.__name__ == "Data1D": 
    715736                self.fit_panel.close_page_with_data(event.data)  
    716737         
    717     def _add_page_onmenu(self, name,fitproblem=None): 
     738    def _add_page_onmenu(self, name, fitproblem=None): 
    718739        """ 
    719740        Add name of a closed page of fitpanel in a menu  
    … …  
    729750            self.menu1.Append(event_id, name, "Show %s fit panel" % name) 
    730751            self.closed_page_dict[name]= [event_id, fitproblem] 
    731             wx.EVT_MENU(self.parent,event_id, self._open_closed_page) 
     752            wx.EVT_MENU(self.parent, event_id, self._open_closed_page) 
    732753         
    733754    def _open_closed_page(self, event):     
    … …  
    737758        for name, value in self.closed_page_dict.iteritems(): 
    738759            if event.GetId() in value: 
    739                 id,fitproblem = value 
     760                uid,fitproblem = value 
    740761                if name !="Model": 
    741762                    data= fitproblem.get_fit_data() 
    742763                    page = self.fit_panel.add_fit_page(data=data, reset=True) 
    743764                    if fitproblem != None: 
    744                         self.page_finder[id] = fitproblem 
     765                        self.page_finder[uid] = fitproblem 
    745766                        if self.sim_page != None: 
    746767                            self.sim_page.draw_page() 
    … …  
    752773                    break 
    753774     
    754     def _reset_schedule_problem(self, id, value=0): 
     775    def _reset_schedule_problem(self, value=0): 
    755776        """ 
    756777        unschedule or schedule all fitproblem to be fit 
    757778        """ 
    758779        for page_id in self.page_finder.keys(): 
    759             self.page_finder[id].schedule_tofit(value) 
    760              
    761     def _fit_helper(self, pars, value, id, title="Single Fit " ): 
     780            self.page_finder[page_id].schedule_tofit(value) 
     781             
     782    def _fit_helper(self, pars, value, fitproblem_id,fitter, title="Single Fit " ): 
    762783        """ 
    763784        helper for fitting 
    … …  
    767788        smearer = value.get_smearer() 
    768789        qmin, qmax = value.get_range() 
    769         self.fit_id = id 
     790        self.fit_id = fitproblem_id 
    770791        #Create list of parameters for fitting used 
    771792        templist = [] 
    … …  
    783804                    
    784805            #Do the single fit 
    785             self.fitter.set_model(model, self.fit_id, 
     806            fitter.set_model(model, self.fit_id, 
    786807                                   pars, constraints=listOfConstraint) 
    787808             
    788             self.fitter.set_data(data=metadata, id=self.fit_id, 
     809            fitter.set_data(data=metadata, id=self.fit_id, 
    789810                                 smearer=smearer, qmin=qmin, qmax=qmax) 
    790811            
    791             self.fitter.select_problem_for_fit(id=self.fit_id, 
     812            fitter.select_problem_for_fit(id=self.fit_id, 
    792813                                               value=value.get_scheduled()) 
    793814            value.clear_model_param() 
    … …  
    814835                self.add_fit_page(data=data) 
    815836             
    816     def _single_fit_completed(self,result, pars, elapsed=None): 
     837    def update_fit(self, result=None, msg=""): 
     838        """ 
     839        """ 
     840        print "update_fit result", result 
     841         
     842    def _single_fit_completed(self, result, pars, page_id, elapsed=None): 
    817843        """ 
    818844        Display fit result on one page of the notebook. 
    … …  
    826852        """      
    827853        try: 
    828             if result ==None: 
     854            if result == None: 
    829855                msg= "Simple Fitting Stop !!!" 
    830856                wx.PostEvent(self.parent, StatusEvent(status=msg,info="warning", 
    … …  
    838864                             StatusEvent(status=msg, type="stop")) 
    839865                return 
    840             page_id = None 
    841             for id, value in self.page_finder.iteritems():    
    842                 if value.get_scheduled()==1: 
    843                     model = value.get_model() 
    844                     page_id = id 
    845                     break 
    846             param_name = [] 
    847             i = 0 
    848             for name in pars: 
    849                 param_name.append(name) 
    850                  
    851             cpage = self.fit_panel.get_page_by_id(page_id) 
    852             cpage.onsetValues(result.fitness,  
    853                               param_name, result.pvec,result.stderr) 
     866            for uid in page_id: 
     867                value = self.page_finder[uid]    
     868                model = value.get_model() 
     869                page_id = uid 
     870                     
     871                param_name = [] 
     872                for name in pars: 
     873                    param_name.append(name) 
     874                     
     875                cpage = self.fit_panel.get_page_by_id(uid) 
     876                cpage.onsetValues(result.fitness,  
     877                                  param_name, result.pvec,result.stderr) 
     878                cpage._on_fit_complete() 
    854879            
    855880        except: 
    856             msg = "Single Fit completed but Following" 
    857             msg += " error occurred:%s" % sys.exc_value 
    858             wx.PostEvent(self.parent, StatusEvent(status=msg, info="error", 
    859                                                   type="stop")) 
     881            raise 
     882            #msg = "Single Fit completed but Following" 
     883            #msg += " error occurred:%s" % sys.exc_value 
     884            #wx.PostEvent(self.parent, StatusEvent(status=msg, info="error", 
     885            #                                      type="stop")) 
    860886            return 
    861887        
    862     def _simul_fit_completed(self, result, pars=None, elapsed=None): 
     888    def _simul_fit_completed(self, result, page_id,pars=None, elapsed=None): 
    863889        """ 
    864890        Parameter estimation completed,  
    … …  
    869895         
    870896        """ 
     897        if page_id is None: 
     898            page_id = [] 
    871899        ## fit more than 1 model at the same time  
    872900        try: 
    873901            msg = ""  
    874             if result ==None: 
    875                 msg= "Complex Fitting Stop !!!" 
    876                 wx.PostEvent(self.parent, StatusEvent(status=msg,type="stop")) 
     902            if result == None: 
     903                msg = "Complex Fitting Stop !!!" 
     904                wx.PostEvent(self.parent, StatusEvent(status=msg, 
     905                                                      type="stop")) 
    877906                return 
    878             if not numpy.isfinite(result.fitness) or numpy.any(result.pvec ==None )or not numpy.all(numpy.isfinite(result.pvec) ): 
     907            if not numpy.isfinite(result.fitness) or \ 
     908                numpy.any(result.pvec == None) or not \ 
     909                numpy.all(numpy.isfinite(result.pvec)): 
    879910                msg= "Simultaneous Fitting did not converge!!!" 
    880911                wx.PostEvent(self.parent, StatusEvent(status=msg,type="stop")) 
    881912                return 
    882913               
    883             for id, value in self.page_finder.iteritems():    
    884                 if value.get_scheduled() == 1: 
    885                     model = value.get_model() 
    886                     data =  value.get_fit_data() 
    887                     small_param_name = [] 
    888                     small_out = [] 
    889                     small_cov = [] 
    890                     i = 0 
    891                     #Separate result in to data corresponding to each page 
    892                     for p in result.parameters: 
    893                         model_name,param_name = self.split_string(p.name)   
    894                         if model.name == model_name: 
    895                             p_name= model.name+"."+param_name 
    896                             if p.name == p_name:       
    897                                 if p.value != None and numpy.isfinite(p.value): 
    898                                     small_out.append(p.value ) 
    899                                     small_param_name.append(param_name) 
    900                                     small_cov.append(p.stderr) 
    901  
    902                     # Display result on each page  
    903                     cpage = self.fit_panel.get_page_by_id(id) 
    904                     cpage.onsetValues(result.fitness, 
    905                                       small_param_name, 
    906                                       small_out,small_cov) 
     914            for uid in page_id:    
     915                value = self.page_finder[uid] 
     916                model = value.get_model() 
     917                data =  value.get_fit_data() 
     918                small_param_name = [] 
     919                small_out = [] 
     920                small_cov = [] 
     921                #Separate result in to data corresponding to each page 
     922                for p in result.parameters: 
     923                    model_name, param_name = self.split_string(p.name)   
     924                    if model.name == model_name: 
     925                        p_name= model.name+"."+param_name 
     926                        if p.name == p_name:       
     927                            if p.value != None and numpy.isfinite(p.value): 
     928                                small_out.append(p.value) 
     929                                small_param_name.append(param_name) 
     930                                small_cov.append(p.stderr) 
     931                # Display result on each page  
     932                cpage = self.fit_panel.get_page_by_id(uid) 
     933                cpage.onsetValues(result.fitness, 
     934                                  small_param_name, 
     935                                  small_out,small_cov) 
     936                cpage._on_fit_complete() 
    907937        except: 
    908             raise 
    909             #msg= "Simultaneous Fit completed" 
    910             #msg +=" but Following error occurred:%s"%sys.exc_value 
    911             #wx.PostEvent(self.parent, StatusEvent(status=msg,type="stop")) 
    912             #return  
    913               
     938            msg = "Simultaneous Fit completed" 
     939            msg += " but Following error occurred:%s" % sys.exc_value 
     940            wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop")) 
     941    
    914942    def _on_show_panel(self, event): 
    915943        """ 
    … …  
    9921020        wx.PostEvent(self.parent,  
    9931021                     StatusEvent(status=msg)) 
    994         ## Bind every open fit page with a newevent to  
    995         #know the current fitting engine 
    996         #import fitpage 
    997         event = fitpage.FitterTypeEvent() 
    998         event.type = self._fit_engine 
    999         wx.PostEvent(self.fit_panel, event) 
     1022        ## send the current engine type to fitpanel 
     1023        self.fit_panel._on_engine_change(name=self._fit_engine) 
    10001024        
    10011025    def _on_model_panel(self, evt): 
    … …  
    10071031        """ 
    10081032        model = evt.model 
    1009         id = evt.id  
     1033        uid = evt.uid  
    10101034        qmin = evt.qmin 
    10111035        qmax = evt.qmax 
    … …  
    10151039            return 
    10161040        
    1017         if self.page_finder[id].get_model() is None: 
     1041        if self.page_finder[uid].get_model() is None: 
    10181042            model.name = "M" + str(self.index_model) 
    10191043            self.index_model += 1   
    10201044        else: 
    1021             model.name = self.page_finder[id].get_model().name 
     1045            model.name = self.page_finder[uid].get_model().name 
    10221046        # save the name containing the data name with the appropriate model 
    1023         self.page_finder[id].set_model(model) 
    1024         self.page_finder[id].set_range(qmin=qmin, qmax=qmax) 
     1047        self.page_finder[uid].set_model(model) 
     1048        self.page_finder[uid].set_range(qmin=qmin, qmax=qmax) 
    10251049        if self.sim_page is not None: 
    10261050            self.sim_page.draw_page() 
    … …  
    10301054        Update the output of plotting model 1D 
    10311055        """ 
    1032         msg = "Plot updating ... " 
    1033         wx.PostEvent(self.parent, StatusEvent(status=msg,type="update")) 
    1034         self.ready_fit() 
     1056        #msg = "Plot updating ... " 
     1057        #wx.PostEvent(self.parent, StatusEvent(status=msg,type="update")) 
     1058        #self.ready_fit() 
    10351059        #self.calc_thread.ready(0.01) 
    10361060     
    1037     def _fill_default_model2D(self, theory,id, qmax,qstep, qmin=None): 
     1061    def _fill_default_model2D(self, theory, page_id, qmax,qstep, qmin=None): 
    10381062        """ 
    10391063        fill Data2D with default value  
    … …  
    11181142        theory.ymin = ymin  
    11191143        theory.ymax = ymax  
    1120         theory.group_id = str(id) + " Model2D" 
    1121         theory.id = str(id) + " Model2D" 
     1144        theory.group_id = str(page_id) + " Model2D" 
     1145        theory.id = str(page_id) + " Model2D" 
    11221146   
    1123     def _complete1D(self, x,y, id, elapsed,index,model, 
     1147    def _complete1D(self, x,y, page_id, elapsed,index,model, 
    11241148                    toggle_mode_on=False,state=None, data=None): 
    11251149        """ 
    … …  
    11361160                #if the theory is already plotted use the same group id  
    11371161                #to replot 
    1138                 if id in self.page_finder: 
    1139                     theory_data = self.page_finder[id].get_theory_data() 
     1162                if page_id in self.page_finder: 
     1163                    theory_data = self.page_finder[page_id].get_theory_data() 
    11401164                    if theory_data is not None: 
    11411165                       data.group_id = theory_data.group_id 
    … …  
    11491173                new_plot.title = "Analytical model 1D " 
    11501174                #find a group id to plot theory without data 
    1151                 new_plot.group_id =  str(id) + " Model1D"   
    1152             new_plot.id =  str(id) + " Model1D"   
     1175                new_plot.group_id =  str(page_id) + " Model1D"   
     1176            new_plot.id =  str(page_id) + " Model1D"   
    11531177             
    11541178            #find if this theory was already plotted and replace that plot given 
    11551179            #the same id 
    1156             if id in self.page_finder: 
    1157                 theory_data = self.page_finder[id].get_theory_data() 
    1158                 if theory_data is not None: 
    1159                     new_plot.id = theory_data.id 
     1180             
     1181            theory_data = self.page_finder[page_id].get_theory_data() 
     1182            if theory_data is not None: 
     1183                new_plot.id = theory_data.id 
    11601184              
    11611185            new_plot.name = model.name + " ["+ str(model.__class__.__name__)+ "]" 
    … …  
    11631187            new_plot.yaxis(_yaxis, _yunit) 
    11641188            if toggle_mode_on: 
    1165                 new_plot.id =  str(id) + " Model"  
     1189                new_plot.id =  str(page_id) + " Model"  
    11661190                wx.PostEvent(self.parent,  
    1167                              NewPlotEvent(group_id=str(id) + " Model2D", 
     1191                             NewPlotEvent(group_id=str(page_id) + " Model2D", 
    11681192                                               action="Hide")) 
    11691193            
    1170             self.page_finder[id].set_theory_data(new_plot) 
    1171             theory_data = self.page_finder[id].get_theory_data() 
     1194            self.page_finder[page_id].set_theory_data(new_plot) 
     1195            theory_data = self.page_finder[page_id].get_theory_data() 
    11721196            if data is None: 
    11731197                name = "Data generates by Fitting " 
    … …  
    11811205                                       theory=theory_data, 
    11821206                                       state=state)      
    1183             current_pg = self.fit_panel.get_page_by_id(id) 
     1207            current_pg = self.fit_panel.get_page_by_id(page_id) 
    11841208            title = new_plot.title 
    11851209            wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot, 
    … …  
    11881212            wx.PostEvent(current_pg, 
    11891213                Chi2UpdateEvent(output=self._cal_chisqr(data=data, 
    1190                                                         id=id, 
     1214                                                        page_id=page_id, 
    11911215                                                        index=index))) 
    11921216            msg = "Plot 1D  complete !" 
    … …  
    12021226        Update the output of plotting model 
    12031227        """ 
    1204         wx.PostEvent(self.parent, StatusEvent(status="Plot \ 
     1228        #wx.PostEvent(self.parent, StatusEvent(status="Plot \ 
    12051229        #updating ... ", type="update")) 
    1206         self.ready_fit() 
     1230        #self.ready_fit() 
    12071231        #self.calc_thread.ready(0.01) 
    12081232     
    1209     def _complete2D(self, image, data, model, id,  elapsed, index, qmin, 
     1233    def _complete2D(self, image, data, model, page_id,  elapsed, index, qmin, 
    12101234                     qmax, toggle_mode_on=False,state=None,qstep=DEFAULT_NPTS): 
    12111235        """ 
    … …  
    12211245            self._fill_default_model2D(theory=new_plot,  
    12221246                                       qmax=qmax,  
    1223                                        id=id, 
     1247                                       page_id=page_id, 
    12241248                                       qstep=qstep, 
    12251249                                        qmin= qmin) 
    12261250            
    12271251        else: 
    1228             new_plot.id = str(id) + " Model2D" 
    1229             new_plot.group_id = str(id) + " Model2D" 
     1252            new_plot.id = str(page_id) + " Model2D" 
     1253            new_plot.group_id = str(page_id) + " Model2D" 
    12301254            new_plot.x_bins = data.x_bins 
    12311255            new_plot.y_bins = data.y_bins 
    … …  
    12501274        theory_data.name = "Unknown" 
    12511275        if toggle_mode_on: 
    1252             new_plot.id = str(id) + " Model"       
     1276            new_plot.id = str(page_id) + " Model"       
    12531277            wx.PostEvent(self.parent,  
    1254                              NewPlotEvent(group_id=str(id) + " Model1D", 
     1278                             NewPlotEvent(group_id=str(page_id) + " Model1D", 
    12551279                                               action="Hide")) 
    12561280         
    1257         self.page_finder[id].set_theory_data(new_plot) 
    1258         theory_data = self.page_finder[id].get_theory_data() 
     1281        self.page_finder[page_id].set_theory_data(new_plot) 
     1282        theory_data = self.page_finder[page_id].get_theory_data() 
    12591283        if data is None: 
    12601284            name = "Data generates by Fitting " 
    … …  
    12671291                                       theory=theory_data, 
    12681292                                       state=state)   
    1269         current_pg = self.fit_panel.get_page_by_id(id) 
     1293        current_pg = self.fit_panel.get_page_by_id(page_id) 
    12701294        title = new_plot.title 
    12711295        wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot, 
    … …  
    12731297        # Chisqr in fitpage 
    12741298        wx.PostEvent(current_pg, 
    1275             Chi2UpdateEvent(output=self._cal_chisqr(data=data, id=id, index=index))) 
     1299            Chi2UpdateEvent(output=self._cal_chisqr(data=data, 
     1300                                                     page_id=page_id, 
     1301                                                     index=index))) 
    12761302        msg = "Plot 2D complete !" 
    12771303        wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop")) 
    12781304     
    1279     def _draw_model2D(self, model, id, data=None, smearer=None, 
     1305    def _draw_model2D(self, model, page_id, data=None, smearer=None, 
    12801306                      description=None, enable2D=False, 
    12811307                      state=None, 
    … …  
    13031329                               endpoint=True) 
    13041330        if model is None: 
    1305             msg = "Panel with ID: %s does not contained model" % str(id) 
     1331            msg = "Panel with ID: %s does not contained model" % str(page_id) 
    13061332            raise ValueError, msg 
    13071333        ## use data info instead 
    … …  
    13251351                                    model=model,  
    13261352                                    data=data, 
    1327                                     id=id, 
     1353                                    page_id=page_id, 
    13281354                                    smearer=smearer, 
    13291355                                    qmin=qmin, 
    … …  
    13321358                                    toggle_mode_on=toggle_mode_on, 
    13331359                                    state=state, 
    1334                                     completefn=self._complete2D, 
    1335                                     updatefn=self._update2D) 
     1360                                    completefn=self._complete2D)#, 
     1361                                    #updatefn=self._update2D) 
    13361362            self.calc_2D.queue() 
    13371363 
    … …  
    13421368            #wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    13431369 
    1344     def _draw_model1D(self, model, id, data=None, smearer=None, 
     1370    def _draw_model1D(self, model, page_id, data=None, smearer=None, 
    13451371                qmin=DEFAULT_QMIN, qmax=DEFAULT_QMAX,  
    13461372                state=None, 
    … …  
    13781404                                  data=data, 
    13791405                                  model=model, 
    1380                                   id=id,  
     1406                                  page_id=page_id,  
    13811407                                  qmin=qmin, 
    13821408                                  qmax=qmax, 
    … …  
    13841410                                  state=state, 
    13851411                                  toggle_mode_on=toggle_mode_on, 
    1386                                   completefn=self._complete1D, 
    1387                                   updatefn=self._update1D) 
     1412                                  completefn=self._complete1D)#, 
     1413                                  #updatefn=self._update1D) 
    13881414            self.calc_1D.queue() 
    13891415 
    … …  
    13931419            wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    13941420 
    1395     def _cal_chisqr(self, id, data=None, index=None):  
     1421    def _cal_chisqr(self, page_id, data=None, index=None):  
    13961422        """ 
    13971423        Get handy Chisqr using the output from draw1D and 2D,  
    … …  
    14111437            index = index & (data.err_data != 0)   
    14121438            fn = data.data[index]  
    1413             theory_data = self.page_finder[id].get_theory_data() 
     1439            theory_data = self.page_finder[page_id].get_theory_data() 
    14141440            gn = theory_data.data[index] 
    14151441            en = data.err_data[index] 
    … …  
    14261452                dy[dy==0] = 1   
    14271453            fn = data.y[index]  
    1428             theory_data = self.page_finder[id].get_theory_data() 
     1454            theory_data = self.page_finder[page_id].get_theory_data() 
    14291455            gn = theory_data.y 
    14301456            en = dy[index] 

  • sansview/perspectives/fitting/model_thread.py

    rfa65e99 r66ff250  
    1515    """ 
    1616    def __init__(self, x, y, data,model,smearer,qmin, qmax,qstep, 
    17                  id , 
     17                 page_id , 
    1818                 state=None, 
    1919                 toggle_mode_on=False, 
    … …  
    3434        self.y = y 
    3535        self.data= data 
    36         self.page_id = id 
     36        self.page_id = page_id 
    3737        self.state = None 
    3838        # the model on to calculate 
    … …  
    122122        self.complete(image=output, 
    123123                       data=self.data,  
    124                        id=self.page_id, 
     124                       page_id=self.page_id, 
    125125                       model=self.model, 
    126126                       state=self.state, 
    … …  
    138138    """ 
    139139    def __init__(self, x, model, 
    140                  id, 
     140                 page_id, 
    141141                 data=None, 
    142142                 qmin=None, 
    … …  
    163163        self.toggle_mode_on = toggle_mode_on 
    164164        self.state = state 
    165         self.page_id = id 
     165        self.page_id = page_id 
    166166        self.smearer = smearer 
    167167        self.starttime = 0 
    … …  
    186186        
    187187        self.complete(x=self.x[index], y=output[index],  
    188                       id=self.page_id, 
     188                      page_id=self.page_id, 
    189189                      state=self.state, 
    190190                      toggle_mode_on=self.toggle_mode_on, 

  • sansview/perspectives/fitting/simfitpage.py

    r6bbeacd4 r66ff250  
    6565        ## number of constraint 
    6666        self.nb_constraint= 0 
     67        self.id = wx.NewId() 
    6768        ## draw page 
    6869        self.define_page_structure() 
    … …  
    140141        ## model was actually selected from this page to be fit 
    141142        if len(self.model_toFit) >= 1 : 
    142             self.manager._reset_schedule_problem( value=0) 
     143            self.manager._reset_schedule_problem(value=0) 
    143144            for item in self.model_list: 
    144145                if item[0].GetValue(): 
Note: See TracChangeset for help on using the changeset viewer.