Changeset 3b19ac9 in sasview for sansview


Ignore:
Timestamp:
Sep 16, 2008 4:33:54 PM (16 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:
ca6d914
Parents:
14d05ba
Message:

working on simultaneous fit and scipy/park fit added on menubar

Location:
sansview/perspectives/fitting
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • sansview/perspectives/fitting/fitproblem.py

    r1b07935d r3b19ac9  
    1919        self.theory_name=None 
    2020        self.model_list=[] 
     21        self.schedule='False' 
    2122         
    2223    def set_model(self,model,name): 
    … …  
    7677        self.model_list[0]=model 
    7778         
    78          
     79    def schedule_tofit(self, schedule='False'): 
     80        """ 
     81             set schedule to true to decide if this fit  must be performed 
     82        """ 
     83        self.schedule=schedule 
     84    def get_scheduled(self): 
     85        """ return true or false if a problem as being schedule for fitting""" 
     86        return self.schedule 
     87     
     88     

  • sansview/perspectives/fitting/fitting.py

    r4fc6dbf r3b19ac9  
    33import string, numpy, pylab, math 
    44 
     5from copy import deepcopy  
    56from sans.guitools.plottables import Data1D, Theory1D 
    67from sans.guitools.PlotPanel import PlotPanel 
    78from sans.guicomm.events import NewPlotEvent, StatusEvent   
    8 from copy import deepcopy  
    9 from sans.fit.AbstractFitEngine import Model 
    10 from sans.fit.AbstractFitEngine import Data 
     9from sans.fit.AbstractFitEngine import Model,Data 
    1110from fitproblem import FitProblem 
    1211from fitpanel import FitPanel 
    … …  
    1413import models 
    1514import fitpage 
     15 
    1616class PlottableData(Data,Data1D): 
    17     """ class plottable data""" 
     17    """ class plottable data: class allowing to plot Data type on panel""" 
    1818    def __init__(self,data,data1d): 
    1919        self.x = data1d.x 
    2020        self.y = data1d.y 
    21         self.dx= data1d.dx 
    22         self.dy= data1d.dy 
     21        self.dx = data1d.dx 
     22        self.dy = data1d.dy 
    2323        
    24         self.group_id= data1d.group_id 
     24        self.group_id = data1d.group_id 
    2525        x_name, x_units = data1d.get_xaxis()  
    2626        y_name, y_units = data1d.get_yaxis()  
    2727        self.xaxis( x_name, x_units) 
    2828        self.yaxis( y_name, y_units ) 
    29         self.qmin=data.qmin 
    30         self.qmax=data.qmax 
     29        self.qmin = data.qmin 
     30        self.qmax = data.qmax 
     31 
    3132class Plugin: 
    3233    """ 
    3334    """ 
    34      
    3535    def __init__(self): 
    3636        ## Plug-in name 
    … …  
    4949        self.standalone=True 
    5050        ## Fit engine 
    51         self._fit_engine = 'park' 
     51        self._fit_engine = 'scipy' 
    5252        # Log startup 
    5353        logging.info("Fitting plug-in started")    
    … …  
    6565        self.menu1.Append(id1, '&Show fit panel') 
    6666        wx.EVT_MENU(owner, id1, self.on_perspective) 
     67        id3 = wx.NewId() 
     68        self.menu1.Append(id3,'&scipy \ park','toggle engine to park or scipy') 
     69        wx.EVT_MENU(owner, id3, self._onset_engine) 
    6770         
    6871        #menu for model 
    … …  
    7477        self.fit_panel.set_model_list(self.menu_mng.get_model_list()) 
    7578        owner.Bind(fitpage.EVT_MODEL_BOX,self._on_model_panel) 
    76         #owner.Bind(modelpage.EVT_MODEL_DRAW,self.draw_model) 
    77        
     79        #create  menubar items 
    7880        return [(id, self.menu1, "Fitting"),(id2, menu2, "Model")] 
    7981     
    … …  
    113115        self.perspective.append(self.fit_panel.window_name) 
    114116        # take care of saving  data, model and page associated with each other 
    115         self.page_finder={} 
    116         self.index_model=0 
     117        self.page_finder = {} 
     118        #index number to create random model name 
     119        self.index_model = 0 
     120        #create the fitting panel 
    117121        return [self.fit_panel] 
    118122    
    … …  
    150154        for item in self.panel.graph.plottables: 
    151155            if item.name == self.panel.graph.selected_plottable: 
     156                #find a name for the page created for notebook 
    152157                try: 
    153158                    name = item.group_id # item in Data1D 
    … …  
    156161                try: 
    157162                    page = self.fit_panel.add_fit_page(name) 
     163                    # add data associated to the page created 
    158164                    page.set_data_name(item) 
     165                    #create a fitproblem storing all link to data,model,page creation 
    159166                    self.page_finder[page]= FitProblem() 
    160                     #creating Data type 
    161                     data1= Data(sans_data=item) 
    162                     datas=PlottableData(data=data1,data1d=item) 
    163                     self.page_finder[page].add_data(datas) 
     167                    data_for_park= Data(sans_data=item) 
     168                    datap=PlottableData(data=data_for_park,data1d=item) 
     169                    self.page_finder[page].add_data(datap) 
    164170                except: 
    165171                    raise  
    … …  
    173179     
    174180     
    175     def set_page_finder(self,modelname,param,values): 
     181    def set_page_finder(self,modelname,names,values): 
    176182        """ 
    177183             Used by simfitpage.py to reset a parameter given the string constrainst. 
    178184             @param modelname: the name ot the model for with the parameter has to reset 
    179185             @param value: can be a string in this case. 
     186             @param names: the paramter name 
    180187             @note: expecting park used for fit. 
    181188        """   
    … …  
    186193                model=list[0] 
    187194                if model.name== modelname: 
    188                     value.set_model_param(param,values) 
     195                    value.set_model_param(names,values) 
     196                     
    189197                    break 
    190198 
    … …  
    193201    def split_string(self,item):  
    194202        """ 
    195             recieve a word containing "" 
    196         """ 
    197         #print "fitting: split :went here"  
     203            receive a word containing dot and split it. used to split parameterset 
     204            name into model name and parameter name example: 
     205            paramaterset (item) = M1.A 
     206            @return model_name =M1 , parameter name =A 
     207        """ 
    198208        if string.find(item,".")!=-1: 
    199209            param_names= re.split("\.",item) 
    … …  
    205215    def _single_fit_completed(self,result,pars,current_pg,qmin,qmax): 
    206216        """ 
     217            Display fit result on one page of the notebook. 
     218            @param result: result of fit  
     219            @param pars: list of names of parameters fitted 
     220            @param current_pg: the page where information will be displayed 
     221            @param qmin: the minimum value of x to replot the model  
     222            @param qmax: the maximum value of x to replot model 
    207223           
    208224        """ 
    … …  
    214230                    model= list[0] 
    215231                    break 
    216             #print "fitting : result",result,result.pvec,result.cov,result.fitness 
    217232            i = 0 
    218233            for name in pars: 
    … …  
    221236                else: 
    222237                    model.setParam(name,result.pvec[i]) 
    223                     #print "fitting: i name out[i]", i,name,float(result.pvec[i]) 
    224238                    i += 1 
    225             new_cov=[] 
    226             if result.cov !=None: 
    227                  for j in range(len(result.cov)): 
    228                      new_cov.append(result.cov[j][j])   
    229             else: 
    230                 new_cov=None 
    231             current_pg.onsetValues(result.fitness, result.pvec,new_cov) 
     239            current_pg.onsetValues(result.fitness, result.pvec,result.stderr) 
    232240            self.plot_helper(currpage=current_pg,qmin=qmin,qmax=qmax) 
    233241        except: 
    234             raise 
    235242            wx.PostEvent(self.parent, StatusEvent(status="Fitting error: %s" % sys.exc_value)) 
    236243             
    … …  
    245252        try: 
    246253            for page, value in self.page_finder.iteritems(): 
    247                 data = value.get_data() 
    248                 list = value.get_model() 
    249                 model= list[0] 
    250                 
    251                 small_out = [] 
    252                 small_cov = [] 
    253                 i = 0 
    254                 for p in result.parameters: 
    255                     print "fitting: fit in park fitting", p.name, p.value,p.stderr 
    256                     model_name,param_name = self.split_string(p.name)   
    257                     print "fitting: simultfit",model.name,model_name,param_name ,p.name,param_name,p.value 
    258                     if model.name == model_name: 
    259                         print "fitting: hello",p.name,param_name,p.value 
    260                         small_out.append(p.value ) 
    261                         small_cov.append(p.stderr) 
    262                         model.setParam(param_name,p.value)    
    263                 #print "fitting: out of each page",page,small_out,small_cov,data.group_id 
    264                 page.onsetValues(result.fitness, small_out,small_cov) 
    265                 self.plot_helper(currpage= page,qmin= qmin,qmax= qmax)  
     254                print "fitting : simultaneous scheduled ",value.get_scheduled() 
     255                if value.get_scheduled()=='True': 
     256                    data = value.get_data() 
     257                    list = value.get_model() 
     258                    model= list[0] 
     259                    
     260                    small_out = [] 
     261                    small_cov = [] 
     262                    i = 0 
     263                    #Separate result in to data corresponding to each page 
     264                    for p in result.parameters: 
     265                        model_name,param_name = self.split_string(p.name)   
     266                        if model.name == model_name: 
     267                            small_out.append(p.value ) 
     268                            small_cov.append(p.stderr) 
     269                            model.setParam(param_name,p.value)   
     270                    # Display result on each page  
     271                    page.onsetValues(result.fitness, small_out,small_cov) 
     272                    #Replot model 
     273                    self.plot_helper(currpage= page,qmin= qmin,qmax= qmax)  
    266274        except: 
    267275             wx.PostEvent(self.parent, StatusEvent(status="Fitting error: %s" % sys.exc_value)) 
    … …  
    279287        from sans.fit.Fitting import Fit 
    280288        self.fitter= Fit(self._fit_engine) 
    281         #Setting an id to store model and data 
     289        #Setting an id to store model and data in fit engine 
    282290        if id==None: 
    283291            id=0 
    284         self.id=id 
     292        self.id = id 
     293        #Get information (model , data) related to the page on  
     294        #with the fit will be perform 
    285295        current_pg=self.fit_panel.get_current_page()  
    286296        for page, value in self.page_finder.iteritems(): 
    287297            if page ==current_pg : 
    288                 #print "fitting: self.page_finder",self.page_finder 
    289298                data = value.get_data() 
    290299                list=value.get_model() 
    291300                model=list[0] 
    292301                 
    293                 #Create dictionary of parameters for fitting used 
     302                #Create list of parameters for fitting used 
    294303                pars=[] 
    295304                templist=[] 
    … …  
    300309                    wx.PostEvent(self.parent, StatusEvent(status="Fitting error: %s" % sys.exc_value)) 
    301310                    return 
    302                 #for element in templist: 
    303                 #    print "fitting: templist",str(element[0].GetLabelText()) 
    304                 #print "fitting: model list",model.getParamList() 
     311               
    305312                for element in templist: 
    306313                    try: 
    307314                       pars.append(str(element[0].GetLabelText())) 
    308315                    except: 
    309                         raise 
    310316                        wx.PostEvent(self.parent, StatusEvent(status="Fitting error: %s" % sys.exc_value)) 
    311317                        return 
    312                 #print "fitting: pars",pars 
     318                # make sure to keep an alphabetic order  
     319                #of parameter names in the list 
    313320                pars.sort() 
    314                 print "fitting: model ",model.__class__.__name__ 
    315                 self.fitter.set_model(Model(model),model.name, self.id, pars)  
    316                 self.fitter.set_data(data,self.id,qmin,qmax) 
    317                 #Do the fit SCIPY 
    318                 try: 
     321                #Do the single fit 
     322                try: 
     323                    self.fitter.set_model(Model(model), self.id, pars)  
     324                    self.fitter.set_data(data,self.id,qmin,qmax) 
     325                 
    319326                    result=self.fitter.fit() 
    320327                    self._single_fit_completed(result,pars,current_pg,qmin,qmax) 
    … …  
    333340             
    334341        """ 
    335         #print "fitting: probabily breaking on fit call" 
    336342        #set an engine to perform fit 
    337343        from sans.fit.Fitting import Fit 
    338344        self.fitter= Fit(self._fit_engine) 
     345         
    339346        #Setting an id to store model and data 
    340347        if id==None: 
    341348             id = 0 
    342349        self.id = id 
     350         
    343351        for page, value in self.page_finder.iteritems(): 
    344352            try: 
    345                 #print "fitting: self.page_finder",value 
    346                 data = value.get_data() 
    347                 #print "fitting: data",data 
    348                 list = value.get_model() 
    349                 model= list[0] 
    350                 if data != None : 
     353                print "fitting : simultaneous scheduled ",value.get_scheduled(),value.schedule 
     354                if value.get_scheduled()=='True': 
     355                    print "fitting: self.page_finder",value.get_scheduled() 
     356                    data = value.get_data() 
     357                    #print "fitting: data",data 
     358                    list = value.get_model() 
     359                    model= list[0] 
    351360                    #Create dictionary of parameters for fitting used 
    352361                    pars = [] 
    353362                    templist = [] 
    354                     try: 
    355                         templist = page.get_param_list() 
    356                     except: 
    357                         wx.PostEvent(self.parent, StatusEvent(status="Fitting error: %s" % sys.exc_value)) 
    358                         return 
    359                      
     363                    templist = page.get_param_list() 
    360364                    for element in templist: 
    361365                        try: 
    … …  
    365369                            wx.PostEvent(self.parent, StatusEvent(status="Fitting error: %s" % sys.exc_value)) 
    366370                            return 
     371                    self.fitter.set_model(Model(model), self.id, pars)  
     372                    self.fitter.set_data(data,self.id,qmin,qmax) 
    367373                 
    368                     print "fitting: pars",pars,model.name 
    369                     #print "fitter",self.fitter 
    370                     #print "fitting: model name",model.name 
    371                     self.fitter.set_model(Model(model),model.name, self.id, pars)  
    372                     self.fitter.set_data(data,self.id,qmin,qmax) 
    373                 else: 
    374                     raise ValueError," Fitting: cannot set model with empty parameter" 
    375                 self.id += 1  
     374                    self.id += 1  
    376375            except: 
    377                     raise 
    378                     wx.PostEvent(self.parent, StatusEvent(status="Fitting error: %s" % sys.exc_value)) 
    379                     return  
    380         #Do the fit SCIPY 
     376                wx.PostEvent(self.parent, StatusEvent(status="Fitting error: %s" % sys.exc_value)) 
     377                return  
     378            #Do the simultaneous fit 
    381379        try: 
    382380            result=self.fitter.fit() 
    383381            self._simul_fit_completed(result,qmin,qmax) 
    384382        except: 
    385             raise 
    386383            wx.PostEvent(self.parent, StatusEvent(status="Simultaneous Fitting error: %s" % sys.exc_value)) 
    387384            return 
    388     
     385         
     386         
     387    def _onset_engine(self,event): 
     388        """ set engine to scipy""" 
     389        if self._fit_engine== 'park': 
     390            self._on_change_engine('scipy') 
     391        else: 
     392            self._on_change_engine('park') 
     393        wx.PostEvent(self.parent, StatusEvent(status="Engine set to: %s" % self._fit_engine)) 
     394     
     395   
     396     
    389397    def _on_change_engine(self, engine='park'): 
    390398        """ 
    … …  
    439447            @param currpage: page in a dictionary referring to some data 
    440448        """ 
    441         #print "fitting: plot helper" 
    442449        if self.fit_panel.get_page_count() >1: 
    443450            for page in self.page_finder.iterkeys(): 
    … …  
    492499                try: 
    493500                    from sans.guicomm.events import NewPlotEvent 
    494                     #print"fitting: theory",theory 
    495501                    wx.PostEvent(self.parent, NewPlotEvent(plot=theory, title="Analytical model")) 
    496502                except: 
    … …  
    503509            Plot a theory from a model selected from the menu 
    504510        """ 
    505         print "_on_model_menu done" 
    506         #name = evt.model.__class__.__name__ 
    507511        name="Model View" 
    508512        model=evt.modelinfo.model() 
    … …  
    512516         
    513517    def draw_model(self,model): 
     518        """ 
     519             draw model with default data value 
     520        """ 
    514521        x = pylab.arange(0.001, 0.1, 0.001) 
    515522        xlen = len(x) 
    … …  
    523530            
    524531            new_plot = Theory1D(x, y) 
    525             #new_plot.name = evt.model.__class__.__name__ 
    526532            new_plot.name ="Fitness" 
    527533            new_plot.xaxis("\\rm{Q}", 'A^{-1}') 

  • sansview/perspectives/fitting/models.py

    r49b7efa r3b19ac9  
    4040                try: 
    4141                    (file, path, info) = imp.find_module(name, path) 
    42                     print "models:module ",file 
    4342                    module = imp.load_module( name, file, item, info ) 
    44                     print "models:module ",module 
    4543                    if hasattr(module, "Model"): 
    4644                        try: 
    … …  
    125123        id = wx.NewId() 
    126124        if len(self.indep_model_list) == 0: 
    127             print "models: self.indep_model",self.indep_model 
    128125            for item in self.indep_model: 
    129126                if item not in self.indep_model_list.values(): 
    … …  
    139136                    id = wx.NewId()          
    140137        modelmenu.AppendMenu(wx.NewId(), "Shape-independent...", indep_submenu, "List of shape-independent models") 
     138         
     139         
     140         
    141141        model_info="additional models" 
    142142        id = wx.NewId() 
    … …  
    156156                    id = wx.NewId() 
    157157        modelmenu.AppendMenu(wx.NewId(),"Added models...", added_models, "List of additional models") 
    158          
    159          
    160158        return 0 
    161159     

  • sansview/perspectives/fitting/simfitpage.py

    r1b07935d r3b19ac9  
    9191            for item in self.model_list: 
    9292                item[0].SetValue(True) 
     93                item[1].schedule_tofit('True') 
    9394                self.model_toFit.append(item) 
    9495        else: 
    9596            for item in self.model_list: 
    9697                item[0].SetValue(False)  
     98                item[1].schedule_tofit('False') 
    9799            self.model_toFit=[] 
    98100        
    … …  
    163165        for item in self.model_list: 
    164166            if item[0].GetValue()==True: 
     167                item[1].schedule_tofit('True') 
    165168                self.model_toFit.append(item) 
    166169            else: 
    167170                if item in self.model_toFit: 
    168171                    self.model_toFit.remove(item) 
     172                    item[1].schedule_tofit('False') 
    169173                    self.cb1.SetValue(False) 
    170174        if len(self.model_list)==len(self.model_toFit): 
Note: See TracChangeset for help on using the changeset viewer.