← Previous Change
Next Change →

Changeset 2f189dc in sasview for sansview/perspectives/fitting

Timestamp:

Mar 26, 2010 2:41:45 PM (15 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:

Parents:

Message:

refactore fitpanel and removing the bug introduce while changing add fitpage use case

Location:

sansview/perspectives/fitting

Files:

: 4 edited

basepage.py (modified) (1 diff)
fitpanel.py (modified) (11 diffs)
fitproblem.py (modified) (2 diffs)
fitting.py (modified) (5 diffs)

Legend:

: Unmodified
: Added
: Removed

sansview/perspectives/fitting/basepage.py

-                      re575db9
+                      r2f189dc
         self.state.event_owner = owner
+    def get_data(self):
+        """
+            return the current data
+        """
+        return self.data
     def set_manager(self, manager):
         """

sansview/perspectives/fitting/fitpanel.py

-                      r3244cbe1
+                      r2f189dc
             self._current = int(value)
 class ListOfState(list):
     def __init__(self, *args, **kw):
 …
     def getCurrentPosition(self):
         return self.iterator.currentPosition()
 class PageInfo(object):
     """
 …
     ## Title to appear on top of the window
     window_caption = "Page"
+    def __init__(self, model=None,data=None, manager=None,
+                  event_owner=None,model_list_box=None , name=None):
+    #type of page can be real data , theory 1D or therory2D
+    type = "Data"
+    def __init__(self, model=None, data=None, manager=None,
+                  event_owner=None, model_list_box=None, name=None):
         """
             Initialize data members
 …
         self.window_name = "Page"
         self.window_caption = "Page"
+        self.type = "Data"
 class FitPanel(AuiNotebook):
 …
         pageClosedEvent = wx.aui.EVT_AUINOTEBOOK_PAGE_CLOSE
         self.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CLOSE, self.onClosePage)
+        self.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CLOSE, self.on_close_page)
         #dictionary of miodel {model class name, model class}
+        self.model_list_box={}
+        ##dictionary of page info
+        self.page_info_dict={}
+        self.model_list_box = {}
         ## save the title of the last page tab added
         self.fit_page_name={}
+        self.fit_page_name = {}
         ## list of existing fit page
+        self.list_fitpage_name=[]
+        #model page info
+        self.model_page_number = None
+        ## fit page number for model plot
+        self.fit_page1D_number = None
+        self.fit_page2D_number = None
+        self.model_page = None
+        self.opened_pages = {}
+        #page of simultaneous fit
         self.sim_page = None
-        self.default_page = None
-        self.check_first_data = False
         ## get the state of a page
         self.Bind(basepage.EVT_PAGE_INFO, self._onGetstate)
 …
         self.AddPage(page=self.hint_page, caption="Hint")
         #Add the first fit page
         self.default_page = self.add_fit_page(data=None)
+        self.add_empty_page()
         # increment number for model name
 …
         self.Update()
         self.Center()
+    def onClosePage(self, event):
+    def on_close_page(self, event):
         """
              close page and remove all references to the closed page
 …
             return
         selected_page = self.GetPage(self.GetSelection())
+        #remove default page
+        if selected_page == self.default_page:
+            self.default_page = None
+            return
+        #remove hint page
+        if selected_page == self.hint_page:
+            return
+        ## removing sim_page
+        if selected_page == self.sim_page :
+            self.manager.sim_page=None
+            return
+        ## closing other pages
+        state = selected_page.createMemento()
+        page_name = selected_page.window_name
+        page_finder = self.manager.get_page_finder()
+        fitproblem = None
+        ## removing model page
+        if selected_page == self.model_page:
+            #fitproblem = selected_page.model.clone()
+            self.model_page = None
+            self.count =0
+            ## page on menu
+            #self.manager._add_page_onmenu(page_name, fitproblem)
+        else:
+            if selected_page in page_finder:
+                #fitproblem= page_finder[selected_page].clone()
+                if self.GetPageIndex(selected_page)==self.fit_page1D_number:
+                    self.fit_page1D_number=None
+                if self.GetPageIndex(selected_page)==self.fit_page2D_number:
+                    self.fit_page2D_number=None
+                ## page on menu
+                #self.manager._add_page_onmenu(page_name, fitproblem)
+                del page_finder[selected_page]
+            ##remove the check box link to the model name of this page (selected_page)
+            try:
+                self.sim_page.draw_page()
+            except:
+                ## that page is already deleted no need to remove check box on
+                ##non existing page
+                pass
+        #Delete the name of the page into the list of open page
+        if selected_page.window_name in self.list_fitpage_name:
+            self.list_fitpage_name.remove(selected_page.window_name)
+        self._close_helper(selected_page=selected_page)
+    def close_page_with_data(self, deleted_data):
+        """
+            close a fit page when its data is completely remove from the graph
+        """
+        for index in range(self.GetPageCount()):
+            selected_page = self.GetPage(index)
+            if hasattr(selected_page,"get_data"):
+                data = selected_page.get_data()
+                if data.name == deleted_data.name:
+                    self._close_helper(selected_page)
+                    self.DeletePage(index)
+                    break
     def set_manager(self, manager):
 …
         return self.sim_page
+    def add_fit_page( self,data=None, reset=False ):
+    def get_page_info(self, data=None):
+        """
+            fill information required to add a page in the fit panel
+        """
+        name = "Fit Page"
+        type = 'empty'
+        if data is not None:
+            if data.is_data:
+                name = data.name
+                type = 'Data'
+            else:
+                if data.__class__.__name__ == "Data2D":
+                    name = 'Model 2D Fit'
+                    type = 'Theory2D'
+                else:
+                    name = 'Model 1D Fit'
+                    type = 'Theory1D'
+        page_info = PageInfo(data=data, name=name)
+        page_info.event_owner = self.event_owner
+        page_info.manager = self.manager
+        page_info.window_name = name
+        page_info.window_caption = name
+        page_info.type = type
+        return page_info
+    def add_empty_page(self):
+        """
+            add an empty page
+        """
+        page_info = self.get_page_info()
+        from fitpage import FitPage
+        panel = FitPage(parent=self, page_info=page_info)
+        self.AddPage(page=panel, caption=page_info.window_name, select=True)
+        self.opened_pages[page_info.type] = [page_info.window_name, panel]
+        return panel
+    def add_page(self, page_info):
+        """
+            add a new page
+        """
+        from fitpage import FitPage
+        panel = FitPage(parent=self, page_info=page_info)
+        self.AddPage(page=panel, caption=page_info.window_name, select=True)
+        index = self.GetPageIndex(panel)
+        self.change_page_content(data=page_info.data, index=index)
+        return panel
+    def change_page_content(self, data, index):
+        """
+            replace the contains of an existing page
+        """
+        page_info = self.get_page_info(data=data)
+        self.SetPageText(index, page_info.window_name)
+        panel = self.GetPage(index)
+        panel.set_data(data)
+        if panel.model_list_box is None or len(panel.model_list_box) == 0:
+            page_info.model_list_box = self.model_list_box.get_list()
+            panel.populate_box(dict=page_info.model_list_box)
+            panel.initialize_combox()
+        panel.set_page_info(page_info=page_info)
+        self.opened_pages[page_info.type] = [page_info.window_name, panel]
+        return panel
+    def replace_page(self, index, page_info, type):
+        """
+            replace an existing page
+        """
+        self.DeletePage(index)
+        del self.opened_pages[type]
+        return self.add_page(page_info=page_info)
+    def add_fit_page(self, data, reset=False):
         """
             Add a fitting page on the notebook contained by fitpanel
             @param data: data to fit
             @return panel : page just added for further used. is used by fitting module
+        """
+        if data is not None:
+            if data.is_data:
+                name = data.name
+        """
+        if data is None:
+            return None
+        page_info = self.get_page_info(data=data)
+        type = page_info.type
+        npages = len(self.opened_pages.keys())
+        #check if only and empty page is opened
+        if len(self.opened_pages.keys()) > 0:
+            first_page_type = self.opened_pages.keys()[0]
+            if npages == 1 and first_page_type in ['empty']:
+                #replace the first empty page
+                name, panel = self.opened_pages[first_page_type]
+                index = self.GetPageIndex(panel)
+                panel = self.change_page_content(data=data, index=index)
+                del self.opened_pages[first_page_type]
+                return panel
+        if type in self.opened_pages.keys():
+            #this type of page is already created but it is a theory
+            # meaning the same page is just to fit different data
+            if not type.lower() in ['data']:
+                #delete the previous theory page and add a new one
+                name, panel = self.opened_pages[type]
+                self.manager.reset_plot_panel(panel.get_data())
+                #delete the existing page and replace it
+                index = self.GetPageIndex(panel)
+                panel = self.replace_page(index=index, page_info=page_info, type=type)
+                return panel
             else:
+                if data.__class__.__name__=="Data2D":
+                    name = 'Model 2D Fit'
+                else:
+                    name = 'Model 1D Fit'
+            myinfo = PageInfo( data=data, name=name )
+            myinfo.model_list_box = self.model_list_box.get_list()
+            myinfo.event_owner = self.event_owner
+            myinfo.manager = self.manager
+            myinfo.window_name = name
+            myinfo.window_caption = name
+        else :
+            name = "Fit Page"
+            myinfo = PageInfo( data=data, name=name )
+        if not name in self.list_fitpage_name:
+            # the first data loading
+            if not self.check_first_data and self.default_page is not None:
+                page_number = self.GetPageIndex(self.default_page)
+                self.SetPageText(page_number , name)
+                self.default_page.set_data(data)
+                self.default_page.set_page_info(page_info=myinfo)
+                self.default_page.initialize_combox()
+                if  data is not None:
+                    self.check_first_data = True
+                panel = self.default_page
+            else:
+                #if not name in self.fit_page_name :
+                from fitpage import FitPage
+                panel = FitPage(parent=self, page_info=myinfo)
+                self.AddPage(page=panel, caption=name, select=True)
+                if name == 'Model 1D Fit':
+                    self.fit_page1D_number= self.GetPageIndex(panel)
+                if name =='Model 2D Fit':
+                    self.fit_page2D_number= self.GetPageIndex(panel)
+                self.list_fitpage_name.append(name)
+                if data is not None:
+                    if reset:
+                        if name in self.fit_page_name.keys():
+                            memento= self.fit_page_name[name][0]
+                            panel.reset_page(memento)
+                        else:
+                            self.fit_page_name[name]=ListOfState()
+                    #self.fit_page_name[name].appendItem(panel.createMemento())
+            #GetPage(self, page_idx)
+            return panel
+        elif name =='Model 1D Fit':
+            if self.fit_page1D_number!=None:
+                panel =self.GetPage(self.fit_page1D_number)
+                #self.fit_page_name[name]=[]
+                self.fit_page_name[name]= ListOfState()
+                #self.fit_page_name[name].insert(0,panel.createMemento())
+                #self.fit_page_name[name].append(panel.createMemento())
+                return panel
+            return None
+        elif name =='Model 2D Fit':
+            if self.fit_page2D_number!=None:
+                panel =self.GetPage(self.fit_page2D_number)
+                self.fit_page_name[name]=ListOfState()
+                #self.fit_page_name[name].append(panel.createMemento())
+                return panel
+            return None
+        return None
+    def add_model_page(self,model,page_title="Model", qmin=0.0001, qmax=0.13,
+                        npts=50, topmenu=False, reset=False):
+        """
+            Add a model page only one  to display any model selected from the menu or the page combo box.
+            when this page is closed than the user will be able to open a new one
+            @param model: the model for which paramters will be changed
+            @param page_title: the name of the page
+            @param page_info: contains info about the state of the page
+            @param qmin: mimimum Q
+            @param qmax: maximum Q
+            @param npts: number of Q points
+        """
+        if topmenu==True:
+            ##first time to open model page
+            if self.count==0 :
+                #if not page_title in self.list_fitpage_name :
+                self._help_add_model_page(model=model, page_title=page_title,
+                                qmin=qmin, qmax=qmax, npts=npts, reset=reset)
+                self.count +=1
+            else:
+                self.model_page.select_model(model)
+                self.fit_page_name[page_title]=ListOfState()
+                #self.fit_page_name[page_title].insert(0,self.model_page.createMemento())
+    def _close_fitpage(self,data):
+        """
+            close a fit page when its data is completely remove from the graph
+        """
+        name = data.name
+        for index in range(self.GetPageCount()):
+            if self.GetPageText(index)== name:
+                selected_page = self.GetPage(index)
+                if index ==self.fit_page1D_number:
+                    self.fit_page1D_number=None
+                if index ==self.fit_page2D_number:
+                    self.fit_page2D_number=None
+                if selected_page in self.manager.page_finder:
+                    del self.manager.page_finder[selected_page]
+                ##remove the check box link to the model name of this page (selected_page)
+                try:
+                    self.sim_page.draw_page()
+                except:
+                    ## that page is already deleted no need to remove check box on
+                    ##non existing page
+                    pass
+                #Delete the name of the page into the list of open page
+                if selected_page.window_name in self.list_fitpage_name:
+                    self.list_fitpage_name.remove(selected_page.window_name)
+                self.DeletePage(index)
+                break
+                for name, panel in self.opened_pages.values():
+                    #Don't return any panel is the exact same page is created
+                    if name == page_info.window_name:
+                        return None
+                    else:
+                        panel = self.add_page(page_info=page_info)
+                        return panel
+        else:
+            #a new type of page is created
+            panel = self.add_page(page_info=page_info)
+            return panel
     def  _onGetstate(self, event):
         """
 …
             page.reset_page(state)
     def _onRedo(self, event ):
+    def _onRedo(self, event):
         """
             return the next state available
 …
                 state = self.fit_page_name[page.window_name].getNextItem()
             page.reset_page(state)
+    def _close_helper(self, selected_page):
+        """
+            Delete the given page from the notebook
+        """
+        #remove hint page
+        if selected_page == self.hint_page:
+            return
+        ## removing sim_page
+        if selected_page == self.sim_page :
+            self.manager.sim_page=None
+            return
+        ## closing other pages
+        state = selected_page.createMemento()
+        page_name = selected_page.window_name
+        page_finder = self.manager.get_page_finder()
+        fitproblem = None
+        ## removing fit page
+        if selected_page in page_finder:
+            #Delete the name of the page into the list of open page
+            for type, list in self.opened_pages.iteritems():
+                #Don't return any panel is the exact same page is created
+                name = str(list[0])
+                if selected_page.window_name == name:
+                    if type.lower() in ['theory1d', 'theory2d']:
+                        self.manager.remove_plot(selected_page, theory=True)
+                    else:
+                        self.manager.remove_plot(selected_page, theory=False)
+                    break
+            del page_finder[selected_page]
+        ##remove the check box link to the model name of this page (selected_page)
+        try:
+            self.sim_page.draw_page()
+        except:
+            ## that page is already deleted no need to remove check box on
+            ##non existing page
+            pass
+    def _help_add_model_page(self,model,page_title="Model", qmin=0.0001,
+                             qmax=0.13, npts=50,reset= False):
+        """
+            #TODO: fill in description
+            @param qmin: mimimum Q
+            @param qmax: maximum Q
+            @param npts: number of Q points
+        """
+        ## creating object that contaning info about model
+        myinfo = PageInfo(model= model ,name= page_title)
+        myinfo.model_list_box = self.model_list_box.get_list()
+        myinfo.event_owner = self.event_owner
+        myinfo.manager = self.manager
+        myinfo.window_name = page_title
+        myinfo.window_caption = page_title
+        from modelpage import ModelPage
+        panel = ModelPage(self,myinfo)
+        self.AddPage(page=panel, caption=page_title, select=True)
+        self.model_page_number=self.GetSelection()
+        self.model_page=self.GetPage(self.GetSelection())
+        #Delete the name of the page into the list of open page
+        for type, list in self.opened_pages.iteritems():
+            #Don't return any panel is the exact same page is created
+            name = str(list[0])
+            if selected_page.window_name == name:
+                del self.opened_pages[type]
+                break
-        ##resetting page
-        if reset:
-            if page_title in self.fit_page_name.keys():
-                memento= self.fit_page_name[page_title][0]
-                panel.reset_page(memento)
-        else:
-            self.fit_page_name[page_title]=ListOfState()
-            #self.fit_page_name[page_title]=[]
-            #self.fit_page_name[page_title].insert(0,panel.createMemento())

sansview/perspectives/fitting/fitproblem.py

-                      r7c845cb
+                      r2f189dc
         ## the current model
         self.model = None
+        self.model_index = None
         ## if 1 this fit problem will be selected to fit , if 0
         ## it will not be selected for fit
 …
         return self.model
+    def set_index(self, index):
+        """
+            set index of the model name
+        """
+        self.model_index = index
+    def get_index(self):
+        """
+            get index of the model name
+        """
+        return self.model_index
     def add_plotted_data(self,data):
         """

sansview/perspectives/fitting/fitting.py

-                      r837a043
+                      r2f189dc
         else:
             time.sleep(0.4)
+    def remove_plot(self, page, theory=False):
+        """
+            remove model plot when a fit page is closed
+        """
+        fitproblem = self.page_finder[page]
+        data = fitproblem.get_fit_data()
+        model = fitproblem.get_model()
+        if model is not None:
+            name = model.name
+            new_plot = Theory1D(x=[], y=[], dy=None)
+            new_plot.name = name
+            new_plot.xaxis(data._xaxis, data._xunit)
+            new_plot.yaxis(data._yaxis, data._yunit)
+            new_plot.group_id = data.group_id
+            new_plot.id = data.id + name
+            wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot, title=data.name))
+        if theory:
+            new_plot_data = Data1D(x=[], y=[], dx=None, dy=None)
+            new_plot_data.name = data.name
+            new_plot_data.xaxis(data._xaxis, data._xunit)
+            new_plot_data.yaxis(data._yaxis, data._yunit)
+            new_plot_data.group_id = data.group_id
+            new_plot_data.id = data.id
+            wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot_data,
+                                                    title=data.name))
     def _onEVT_SLICER_PANEL(self, event):
         """
 …
             from the plot
         """
         self.fit_panel._close_fitpage(event.data)
+        self.fit_panel.close_page_with_data(event.data)
     def _add_page_onmenu(self, name,fitproblem=None):
 …
         for plottable in self.panel.graph.plottables:
             if plottable.name == self.panel.graph.selected_plottable:
-                #if not hasattr(plottable, "is_data"):
                 if  plottable.__class__.__name__=="Theory1D":
                     dy=numpy.zeros(len(plottable.y))
 …
                         dy= copy.deepcopy(plottable.dy)
                     item= self.copy_data(plottable, dy)
+                    item = self.copy_data(plottable, dy)
                     item.group_id += "data1D"
                     item.id +="data1D"
                     item.is_data= False
+                    item.is_data = False
                     title = item.name
+                    wx.PostEvent(self.parent, NewPlotEvent(plot=item, title=str(title)))
+                    title = 'Data created from Theory'
+                    wx.PostEvent(self.parent, NewPlotEvent(plot=item,
+                                                            title=str(title),
+                                                           reset=True))
                 else:
                     item= self.copy_data(plottable, plottable.dy)
 …
                         wx.PostEvent(self.parent, StatusEvent(status="Page was already Created"))
                 except:
+                    wx.PostEvent(self.parent, StatusEvent(status="Creating Fit page: %s"\
+                    %sys.exc_value))
+                    raise
+                    #wx.PostEvent(self.parent, StatusEvent(status="Creating Fit page: %s"\
+                    #%sys.exc_value))
                     return

Note: See TracChangeset for help on using the changeset viewer.

Download in other formats: