Changeset 4dd63eb in sasview


Ignore:
Timestamp:
Jul 10, 2008 6:05:09 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:
49b3ddd
Parents:
83ca047
Message:

change on set_model

Location:
park_integration
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • park_integration/Fitting.py

    r93f0a586 r4dd63eb  
    5050        return self._engine 
    5151     
    52     def fit(self,pars, qmin=None, qmax=None): 
     52    def fit(self, qmin=None, qmax=None): 
    5353        """Perform the fit """ 
    54        
    55     def set_model(self,model,Uid): 
     54        return self._engine.fit(qmin,qmax) 
     55    def set_model(self,model,name,Uid,pars={}): 
    5656        """ Set model """ 
    57         
     57        self._engine.set_model(model,name,Uid, pars) 
    5858    def set_data(self,data,Uid): 
    5959        """ Receive plottable and create a list of data to fit""" 
    60              
     60        self._engine.set_data(data,Uid) 
    6161    def get_model(self,Uid): 
    6262        """ return list of data""" 
    63      
    64     def set_param(self,model,name, pars): 
    65         """ Recieve a dictionary of parameter and save it """ 
    66         self._engine.set_param(model, name, pars) 
     63        self._engine.get_model(Uid) 
    6764    
    68     def remove_data(self,Uid,data=None): 
    69         """ remove one or all data""" 
    70                   
    71     def remove_model(self,Uid): 
    72         """ remove model """ 
     65    def remove_Fit_Problem(self,Uid): 
     66        """remove   fitarrange in Uid""" 
     67        self._engine.remove_Fit_Problem(Uid) 
    7368  

  • park_integration/ParkFitting.py

    r792db7d5 r4dd63eb  
    185185        self.fitArrangeList={} 
    186186        
    187     def createProblem(self,pars={}): 
     187    def createProblem(self): 
    188188        """ 
    189189        Extract sansmodel and sansdata from self.FitArrangelist ={Uid:FitArrange} 
    … …  
    211211         
    212212     
    213     def fit(self,pars=None, qmin=None, qmax=None): 
     213    def fit(self, qmin=None, qmax=None): 
    214214        """ 
    215215            Performs fit with park.fit module.It can  perform fit with one model 
    … …  
    229229 
    230230        
    231         self.createProblem(pars) 
     231        self.createProblem() 
    232232        pars=self.problem.fit_parameters() 
    233233        self.problem.eval() 
    … …  
    240240                         fitter=fitter, 
    241241                         handler= fitresult.ConsoleUpdate(improvement_delta=0.1)) 
    242          
     242        print "result",result 
    243243        return result.fitness,result.pvec,result.cov 
    244244     
    245     def set_model(self,model,Uid): 
    246         """  
     245    def set_model(self,model,name,Uid,pars={}): 
     246        """  
     247       
     248            Receive a dictionary of parameter and save it Parameter list 
     249            For scipy.fit use. 
    247250            Set model in a FitArrange object and add that object in a dictionary 
    248251            with key Uid. 
    249             @param model: the model added 
     252            @param model: model on with parameter values are set 
     253            @param name: model name 
    250254            @param Uid: unique key corresponding to a fitArrange object with model 
    251         """ 
     255            @param pars: dictionary of paramaters name and value 
     256            pars={parameter's name: parameter's value} 
     257             
     258        """ 
     259        self.parameters=[] 
     260        if model==None: 
     261            raise ValueError, "Cannot set parameters for empty model" 
     262        else: 
     263            model.name=name 
     264            for key, value in pars.iteritems(): 
     265                param = Parameter(model, key, value) 
     266                self.parameters.append(param) 
     267         
    252268        #A fitArrange is already created but contains dList only at Uid 
    253269        if self.fitArrangeList.has_key(Uid): 
    … …  
    258274            fitproblem.set_model(model) 
    259275            self.fitArrangeList[Uid]=fitproblem 
     276         
    260277         
    261278    def set_data(self,data,Uid): 
    … …  
    286303            return None 
    287304     
    288     def set_param(self,model,name, pars): 
    289         """  
    290             Recieve a dictionary of parameter and save it  
    291             @param model: model on with parameter values are set 
    292             @param name: model name 
    293             @param pars: dictionary of paramaters name and value 
    294             pars={parameter's name: parameter's value} 
    295             @return list of Parameter instance 
    296         """ 
    297         parameters=[] 
    298         if model==None: 
    299             raise ValueError, "Cannot set parameters for empty model" 
    300         else: 
    301             model.name=name 
    302             for key, value in pars.iteritems(): 
    303                 param = Parameter(model, key, value) 
    304                 parameters.append(param) 
    305         return parameters 
    306      
    307     def remove_data(self,Uid,data=None): 
    308         """ remove one or all data.if data ==None will remove the whole 
    309             list of data at Uid; else will remove only data in that list. 
    310             @param Uid: unique id containing FitArrange object with data 
    311             @param data:data to be removed 
    312         """ 
    313         if data==None: 
    314         # remove all element in data list 
    315             if self.fitArrangeList.has_key(Uid): 
    316                 self.fitArrangeList[Uid].remove_datalist() 
    317         else: 
    318         #remove only data in dList 
    319             if self.fitArrangeList.has_key(Uid): 
    320                 self.fitArrangeList[Uid].remove_data(data) 
    321                  
    322     def remove_model(self,Uid): 
    323         """  
    324             remove model in FitArrange object with Uid. 
    325             @param Uid: Unique id corresponding to the FitArrange object  
    326             where model must be removed. 
    327         """ 
    328         if self.fitArrangeList.has_key(Uid): 
    329             self.fitArrangeList[Uid].remove_model() 
    330305    def remove_Fit_Problem(self,Uid): 
    331306        """remove   fitarrange in Uid""" 
    332307        if self.fitArrangeList.has_key(Uid): 
    333308            del self.fitArrangeList[Uid] 
     309             
    334310    def _concatenateData(self, listdata=[]): 
    335311        """   

  • park_integration/ScipyFitting.py

    r792db7d5 r4dd63eb  
    8888        self.fitArrangeList={} 
    8989         
    90     def fit(self,pars, qmin=None, qmax=None): 
     90    def fit(self,qmin=None, qmax=None): 
    9191        """ 
    9292            Performs fit with scipy optimizer.It can only perform fit with one model 
    … …  
    107107        listdata = fitproblem.get_data() 
    108108         
    109         #Create list of Parameter instances and save parameters values in model 
    110         parameters = self.set_param(model,model.name,pars) 
    111109        
    112110        # Concatenate dList set (contains one or more data)before fitting 
    … …  
    119117        if qmax==None: 
    120118            qmax= max(xtemp)  
    121              
     119         
    122120        #perform the fit  
    123         chisqr, out, cov = fitHelper(model,parameters, xtemp,ytemp, dytemp ,qmin,qmax) 
     121        chisqr, out, cov = fitHelper(model,self.parameters, xtemp,ytemp, dytemp ,qmin,qmax) 
     122         
    124123        return chisqr, out, cov 
    125124     
    … …  
    158157            return xtemp, ytemp,dytemp 
    159158         
    160     def set_model(self,model,Uid): 
    161         """  
     159    def set_model(self,model,name,Uid,pars={}): 
     160        """  
     161       
     162            Receive a dictionary of parameter and save it Parameter list 
     163            For scipy.fit use. 
    162164            Set model in a FitArrange object and add that object in a dictionary 
    163165            with key Uid. 
    164             @param model: the model added 
     166            @param model: model on with parameter values are set 
     167            @param name: model name 
    165168            @param Uid: unique key corresponding to a fitArrange object with model 
    166         """ 
     169            @param pars: dictionary of paramaters name and value 
     170            pars={parameter's name: parameter's value} 
     171             
     172        """ 
     173        self.parameters=[] 
     174        if model==None: 
     175            raise ValueError, "Cannot set parameters for empty model" 
     176        else: 
     177            model.name=name 
     178            for key, value in pars.iteritems(): 
     179                param = Parameter(model, key, value) 
     180                self.parameters.append(param) 
     181         
    167182        #A fitArrange is already created but contains dList only at Uid 
    168183        if self.fitArrangeList.has_key(Uid): 
    … …  
    201216            return None 
    202217     
    203     def set_param(self,model,name, pars): 
    204         """  
    205             Recieve a dictionary of parameter and save it  
    206             @param model: model on with parameter values are set 
    207             @param name: model name 
    208             @param pars: dictionary of paramaters name and value 
    209             pars={parameter's name: parameter's value} 
    210             @return list of Parameter instance 
    211         """ 
    212         parameters=[] 
    213         if model==None: 
    214             raise ValueError, "Cannot set parameters for empty model" 
    215         else: 
    216             model.name=name 
    217             for key, value in pars.iteritems(): 
    218                 param = Parameter(model, key, value) 
    219                 parameters.append(param) 
    220         return parameters 
    221      
    222     def remove_data(self,Uid,data=None): 
    223         """ remove one or all data.if data ==None will remove the whole 
    224             list of data at Uid; else will remove only data in that list. 
    225             @param Uid: unique id containing FitArrange object with data 
    226             @param data:data to be removed 
    227         """ 
    228         if data==None: 
    229         # remove all element in data list 
    230             if self.fitArrangeList.has_key(Uid): 
    231                 self.fitArrangeList[Uid].remove_datalist() 
    232         else: 
    233         #remove only data in dList 
    234             if self.fitArrangeList.has_key(Uid): 
    235                 self.fitArrangeList[Uid].remove_data(data) 
    236                  
    237     def remove_model(self,Uid): 
    238         """  
    239             remove model in FitArrange object with Uid. 
    240             @param Uid: Unique id corresponding to the FitArrange object  
    241             where model must be removed. 
    242         """ 
     218     
     219     
     220    def remove_Fit_Problem(self,Uid): 
     221        """remove   fitarrange in Uid""" 
    243222        if self.fitArrangeList.has_key(Uid): 
    244             self.fitArrangeList[Uid].remove_model() 
     223            del self.fitArrangeList[Uid] 
    245224                 
    246225 

  • park_integration/test/constrainttestpark.py

    r792db7d5 r4dd63eb  
    2727        #Importing the Fit module 
    2828        from sans.fit.Fitting import Fit 
    29         fitter= Fit() 
     29        fitter= Fit('park') 
    3030        # Receives the type of model for the fitting 
    3131        from sans.guitools.LineModel import LineModel 
    3232        model1  = LineModel() 
    3333        model2  = LineModel() 
    34         #set engine for scipy  
    35         fitter.fit_engine('park') 
    36         engine = fitter.returnEngine() 
     34         
    3735        #Do the fit 
    38         engine.set_param( model1,"M1", {'A':2,'B':3}) 
    39         engine.set_model(model1,1) 
    40         engine.set_data(data1,1) 
    41         #print "m1 param b", M1.B 
    42         engine.set_param( model2,"M2", {'A':'M1.A','B':'M1.B'}) 
    43         engine.set_model(model2,2) 
    4436         
    45         engine.set_data(data2,2) 
     37        fitter.set_model(model1,"M1",1, {'A':1,'B':2}) 
     38        fitter.set_data(data1,1) 
     39        
     40        fitter.set_model(model2,"M2",2, {'A':'M1.A','B':'M1.B'}) 
     41        fitter.set_data(data2,2) 
    4642     
    4743         
    48         chisqr2, out2, cov2= engine.fit({'A':2,'B':1},None,None) 
     44        chisqr2, out2, cov2= fitter.fit() 
    4945        print "chisqr2",chisqr2 
    5046        print "out2", out2 

  • park_integration/test/testfitting.py

    r792db7d5 r4dd63eb  
    55from sans.guitools.plottables import Theory1D 
    66from sans.guitools.plottables import Data1D 
    7 from sans.fit.ScipyFitting import Parameter 
     7 
    88import math 
    99class testFitModule(unittest.TestCase): 
    … …  
    6464        #Importing the Fit module 
    6565        from sans.fit.Fitting import Fit 
    66         fitter= Fit() 
    67         fitter.fit_engine('scipy') 
    68         engine = fitter.returnEngine() 
     66        fitter= Fit('scipy') 
     67         
    6968        # Receives the type of model for the fitting 
    7069        from sans.guitools.LineModel import LineModel 
    … …  
    7372         
    7473        #Do the fit SCIPY 
    75         engine.set_data(data1,1) 
    76         #engine.set_param( model1,"M1", {'A':2,'B':4}) 
    77         engine.set_model(model1,1) 
     74        fitter.set_data(data1,1) 
     75        fitter.set_model(model1,"M1",1,{'A':2,'B':1}) 
    7876         
    79         chisqr1, out1, cov1=engine.fit({'A':2,'B':1},None,None) 
     77        chisqr1, out1, cov1=fitter.fit() 
    8078        """ testing SCIPy results""" 
    8179        self.assert_(math.fabs(out1[1]-2.5)/math.sqrt(cov1[1][1]) < 2) 
    … …  
    8381        self.assert_(chisqr1/len(data1.x) < 2) 
    8482        # PARK 
    85         fitter= Fit() 
    86         fitter.fit_engine('park') 
    87         engine = fitter.returnEngine() 
     83        fitter= Fit('park') 
    8884         
    8985        #Do the fit 
    90         engine.set_data(data1,1) 
    91         engine.set_param( model2,"M1", {'A':2,'B':1}) 
    92         engine.set_model(model2,1) 
     86        fitter.set_data(data1,1) 
     87        fitter.set_model(model2,"M1",1,{'A':2,'B':1}) 
    9388        
    94         chisqr2, out2, cov2=engine.fit({'A':2,'B':1},None,None) 
     89        chisqr2, out2, cov2=fitter.fit(None,None) 
    9590         
    9691        self.assert_(math.fabs(out2[1]-2.5)/math.sqrt(cov2[1][1]) < 2) 

  • park_integration/test/testpark.py

    r792db7d5 r4dd63eb  
    3333        #Importing the Fit module 
    3434        from sans.fit.Fitting import Fit 
    35         fitter= Fit() 
     35        fitter= Fit('park') 
    3636        # Receives the type of model for the fitting 
    3737        from sans.guitools.LineModel import LineModel 
    3838        model1  = LineModel() 
    3939        model2  = LineModel() 
    40         #set engine for scipy  
    41         fitter.fit_engine('park') 
    42         engine = fitter.returnEngine() 
     40         
    4341        #Do the fit 
    44         engine.set_param( model1,"M1", {'A':2.5,'B':4}) 
    45         engine.set_model(model1,1) 
    46         engine.set_data(data1,1) 
     42        fitter.set_model(model1,"M1",1, {'A':2.5,'B':4}) 
     43        fitter.set_data(data1,1) 
    4744         
    48         engine.set_param( model2,"M2", {'A':2,'B':4}) 
    49         engine.set_model(model2,2) 
    50         engine.set_data(data2,2) 
     45        fitter.set_model(model2,"M2",2, {'A':2,'B':3}) 
     46        fitter.set_data(data2,2) 
    5147         
    52         chisqr1, out1, cov1= engine.fit({'A':2,'B':1},None,None) 
     48        chisqr1, out1, cov1= fitter.fit() 
    5349         
    5450        self.assert_(math.fabs(out1[1]-2.5)/math.sqrt(cov1[1][1]) < 2) 
    … …  
    6359         
    6460         
    65         engine.set_data(data3,1) 
    66         chisqr2, out2, cov2= engine.fit({'A':2,'B':1},None,None) 
     61        fitter.set_data(data3,1) 
     62        chisqr2, out2, cov2= fitter.fit(None,None) 
    6763        self.assert_(math.fabs(out2[1]-2.5)/math.sqrt(cov2[1][1]) < 2) 
    6864        print math.fabs(out2[0]-4.0)/math.sqrt(cov2[0][0]) 
    … …  
    7571        #self.assert_(chisqr2/len(data2.x) < 2) 
    7672         
     73        fitter.remove_Fit_Problem(2) 
    7774         
    78          
    79         engine.remove_Fit_Problem(2) 
    80         chisqr3, out3, cov3= engine.fit({'A':2,'B':1},None,None) 
     75        chisqr3, out3, cov3= fitter.fit() 
    8176        #print "park",chisqr3, out3, cov3 
    8277        self.assert_(math.fabs(out1[1]-2.5)/math.sqrt(cov1[1][1]) < 2) 
Note: See TracChangeset for help on using the changeset viewer.