Ignore:
Timestamp:
Sep 16, 2008 4:34:55 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:
fadea71
Parents:
3b19ac9
Message:

some bugs fixed

File:
1 edited

Legend:

Unmodified
Added
Removed

  • park_integration/AbstractFitEngine.py

    r388309d rca6d914  
    99    """ 
    1010    def __init__(self, name, model): 
    11          self._model, self._name = model,name 
    12          self.set(model.getParam(name)) 
     11        """ 
     12            @param name: the name of the model parameter 
     13            @param model: the sans model to wrap as a park model 
     14        """ 
     15        self._model, self._name = model,name 
     16        #set the value for the parameter of the given name 
     17        self.set(model.getParam(name)) 
    1318          
    14     def _getvalue(self): return self._model.getParam(self.name) 
    15      
    16     def _setvalue(self,value):  
     19    def _getvalue(self): 
     20        """ 
     21            override the _getvalue of park parameter 
     22            @return value the parameter associates with self.name 
     23        """ 
     24        return self._model.getParam(self.name) 
     25     
     26    def _setvalue(self,value): 
     27        """ 
     28            override the _setvalue pf park parameter 
     29            @param value: the value to set on a given parameter 
     30        """ 
    1731        self._model.setParam(self.name, value) 
    1832         
    … …  
    2034     
    2135    def _getrange(self): 
     36        """ 
     37            Override _getrange of park parameter 
     38            return the range of parameter 
     39        """ 
    2240        lo,hi = self._model.details[self.name][1:] 
    2341        if lo is None: lo = -numpy.inf 
    … …  
    2644     
    2745    def _setrange(self,r): 
     46        """ 
     47            override _setrange of park parameter 
     48            @param r: the value of the range to set 
     49        """ 
    2850        self._model.details[self.name][1:] = r 
    2951    range = property(_getrange,_setrange) 
    … …  
    3557    """ 
    3658    def __init__(self, sans_model, **kw): 
     59        """ 
     60            @param sans_model: the sans model to wrap using park interface 
     61        """ 
    3762        self.model = sans_model 
    38         self.name=sans_model.name 
    39         #print "ParkFitting:sans model",self.model 
     63        self.name = sans_model.name 
     64        #list of parameters names 
    4065        self.sansp = sans_model.getParamList() 
    41         #print "ParkFitting: sans model parameter list",sansp 
     66        #list of park parameter 
    4267        self.parkp = [SansParameter(p,sans_model) for p in self.sansp] 
    43         #print "ParkFitting: park model parameter ",self.parkp 
     68        #list of parameterset  
    4469        self.parameterset = park.ParameterSet(sans_model.name,pars=self.parkp) 
    4570        self.pars=[] 
    46        
    47     #def __call__(self, x, pars=[]): 
    48     #    return self.eval(x)    
     71   
     72   
    4973    def getParams(self,fitparams): 
     74        """ 
     75            return a list of value of paramter to fit 
     76            @param fitparams: list of paramaters name to fit 
     77        """ 
    5078        list=[] 
    5179        self.pars=[] 
    … …  
    5583                 if element.name ==str(item): 
    5684                     list.append(element.value) 
    57         #print "abstractfitengine: getparams",list 
    5885        return list 
    5986     
     87     
    6088    def setParams(self, params): 
     89        """ 
     90            Set value for parameters to fit 
     91            @param params: list of value for parameters to fit  
     92        """ 
    6193        list=[] 
    6294        for item in self.parkp: 
    … …  
    6597        for i in range(len(params)): 
    6698            self.parkp[i].value = params[i] 
    67             print "abstractfitengine: set-params",list[i],params[i] 
    68              
    6999            self.model.setParam(list[i],params[i]) 
    70100   
     101   
    71102    def eval(self,x): 
    72         
     103        """ 
     104            override eval method of park model.  
     105            @param x: the x value used to compute a function 
     106        """ 
    73107        return self.model.runXY(x) 
    74108    
    75     #def set(self, **kw): 
    76         #""" 
    77             #Set the initial value for a set of parameters. 
    78             #E.g., model.set(width=3,center=5) 
    79         #""" 
    80         #print "Abstractfitting : set called" 
    81         # This is a convenience funciton for the user. 
    82         #  
    83         #for k,v in kw.items():  
    84         #    self.parameterset[k].set(v) 
    85109    
    86110class Data(object): 
    87111    """ Wrapper class  for SANS data """ 
    88112    def __init__(self,x=None,y=None,dy=None,dx=None,sans_data=None): 
    89          
     113        """ 
     114            Data can be initital with a data (sans plottable) 
     115            or with vectors. 
     116        """ 
    90117        if  sans_data !=None: 
    91118            self.x= sans_data.x 
    … …  
    105132        self.qmax=None 
    106133        
     134        
    107135    def setFitRange(self,mini=None,maxi=None): 
    108136        """ to set the fit range""" 
    109137        self.qmin=mini 
    110138        self.qmax=maxi 
     139         
     140         
    111141    def getFitRange(self): 
    112          return self.qmin, self.qmax 
     142        """ 
     143            @return the range of data.x to fit 
     144        """ 
     145        return self.qmin, self.qmax 
     146      
     147      
    113148    def residuals(self, fn): 
    114149        """ @param fn: function that return model value 
    … …  
    117152        x,y,dy = [numpy.asarray(v) for v in (self.x,self.y,self.dy)] 
    118153        if self.qmin==None and self.qmax==None:  
    119             fx =[fn(v) for v in x] 
     154            fx =numpy.asarray([fn(v) for v in x]) 
    120155            return (y - fx)/dy 
    121156        else: 
    122157            idx = (x>=self.qmin) & (x <= self.qmax) 
    123             fx = [fn(item)for item in x[idx ]] 
     158            fx = numpy.asarray([fn(item)for item in x[idx ]]) 
    124159            return (y[idx] - fx)/dy[idx] 
    125160           
    … …  
    134169     
    135170class sansAssembly: 
     171    """ 
     172         Sans Assembly class a class wrapper to be call in optimizer.leastsq method 
     173    """ 
    136174    def __init__(self,Model=None , Data=None): 
    137        self.model = Model 
    138        self.data  = Data 
    139        self.res=[] 
     175        """ 
     176            @param Model: the model wrapper fro sans -model 
     177            @param Data: the data wrapper for sans data 
     178        """ 
     179        self.model = Model 
     180        self.data  = Data 
     181        self.res=[] 
    140182    def chisq(self, params): 
    141183        """ 
    … …  
    149191        return sum 
    150192    def __call__(self,params): 
     193        """ 
     194            Compute residuals 
     195            @param params: value of parameters to fit 
     196        """ 
    151197        self.model.setParams(params) 
    152198        self.res= self.data.residuals(self.model.eval) 
    … …  
    155201class FitEngine: 
    156202    def __init__(self): 
     203        """ 
     204            Base class for scipy and park fit engine 
     205        """ 
     206        #List of parameter names to fit 
    157207        self.paramList=[] 
     208        #Dictionnary of fitArrange element (fit problems) 
     209        self.fitArrangeDict={} 
     210         
    158211    def _concatenateData(self, listdata=[]): 
    159212        """   
    160213            _concatenateData method concatenates each fields of all data contains ins listdata. 
    161214            @param listdata: list of data  
    162              
    163             @return Data: 
    164                  
     215            @return Data: Data is wrapper class for sans plottable. it is created with all parameters 
     216             of data concatenanted 
    165217            @raise: if listdata is empty  will return None 
    166218            @raise: if data in listdata don't contain dy field ,will create an error 
    … …  
    195247                    else: 
    196248                        raise RuntimeError, "Fit._concatenateData: y-errors missing" 
    197             #return xtemp, ytemp,dytemp 
    198249            data= Data(x=xtemp,y=ytemp,dy=dytemp) 
    199250            data.setFitRange(self.mini, self.maxi) 
    200251            return data 
    201     def set_model(self,model,name,Uid,pars=[]): 
     252         
     253         
     254    def set_model(self,model,Uid,pars=[]): 
     255        """ 
     256            set a model on a given uid in the fit engine. 
     257            @param model: the model to fit 
     258            @param Uid :is the key of the fitArrange dictionnary where model is saved as a value 
     259            @param pars: the list of parameters to fit  
     260            @note : pars must contains only name of existing model's paramaters 
     261        """ 
    202262        if len(pars) >0: 
    203             self.paramList = [] 
    204263            if model==None: 
    205264                raise ValueError, "AbstractFitEngine: Specify parameters to fit" 
    206265            else: 
    207                 model.model.name = name 
    208                 model.name = name 
    209                 self.paramList=pars 
     266                for item in pars: 
     267                    if item in model.model.getParamList(): 
     268                        self.paramList.append(item) 
     269                    else: 
     270                        raise ValueError,"wrong paramter %s used to set model %s. Choose\ 
     271                            parameter name within %s"%(item, model.model.name,str(model.model.getParamList())) 
     272                        return 
    210273            #A fitArrange is already created but contains dList only at Uid 
    211             if self.fitArrangeList.has_key(Uid): 
    212                 self.fitArrangeList[Uid].set_model(model) 
     274            if self.fitArrangeDict.has_key(Uid): 
     275                self.fitArrangeDict[Uid].set_model(model) 
    213276            else: 
    214277            #no fitArrange object has been create with this Uid 
    215278                fitproblem = FitArrange() 
    216279                fitproblem.set_model(model) 
    217                 self.fitArrangeList[Uid] = fitproblem 
     280                self.fitArrangeDict[Uid] = fitproblem 
    218281        else: 
    219282            raise ValueError, "park_integration:missing parameters" 
    … …  
    225288            @param data: data added 
    226289            @param Uid: unique key corresponding to a fitArrange object with data 
    227             """ 
     290        """ 
    228291        if qmin !=None and qmax !=None: 
    229292            data.setFitRange(mini=qmin,maxi=qmax) 
    230293        #A fitArrange is already created but contains model only at Uid 
    231         if self.fitArrangeList.has_key(Uid): 
    232             self.fitArrangeList[Uid].add_data(data) 
     294        if self.fitArrangeDict.has_key(Uid): 
     295            self.fitArrangeDict[Uid].add_data(data) 
    233296        else: 
    234297        #no fitArrange object has been create with this Uid 
    235298            fitproblem= FitArrange() 
    236299            fitproblem.add_data(data) 
    237             self.fitArrangeList[Uid]=fitproblem     
     300            self.fitArrangeDict[Uid]=fitproblem     
    238301    
    239302    def get_model(self,Uid): 
    … …  
    243306            with this Uid 
    244307        """ 
    245         if self.fitArrangeList.has_key(Uid): 
    246             return self.fitArrangeList[Uid].get_model() 
     308        if self.fitArrangeDict.has_key(Uid): 
     309            return self.fitArrangeDict[Uid].get_model() 
    247310        else: 
    248311            return None 
    … …  
    250313    def remove_Fit_Problem(self,Uid): 
    251314        """remove   fitarrange in Uid""" 
    252         if self.fitArrangeList.has_key(Uid): 
    253             del self.fitArrangeList[Uid] 
     315        if self.fitArrangeDict.has_key(Uid): 
     316            del self.fitArrangeDict[Uid] 
    254317 
    255318     
Note: See TracChangeset for help on using the changeset viewer.