Changeset ca6d914 in sasview


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

Location:
park_integration
Files:
3 added
4 deleted
7 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     

  • park_integration/Fitting.py

    r48882d1 rca6d914  
    4646        else: 
    4747            raise ValueError, "enter the keyword scipy or park" 
     48         
    4849    def returnEngine(self): 
    4950        """ @return self._engine"""  
    … …  
    5354        """Perform the fit """ 
    5455        return self._engine.fit(qmin,qmax) 
    55     def set_model(self,model,name,Uid,pars=[]): 
    56          self._engine.set_model(model,name,Uid,pars) 
     56     
     57    def set_model(self,model,Uid,pars=[]): 
     58         self._engine.set_model(model,Uid,pars) 
    5759    
    5860    def set_data(self,data,Uid,qmin=None, qmax=None): 
    5961        self._engine.set_data(data,Uid,qmin,qmax) 
     62         
    6063    def get_model(self,Uid): 
    6164        """ return list of data""" 
    … …  
    6568        """remove   fitarrange in Uid""" 
    6669        self._engine.remove_Fit_Problem(Uid) 
     70         
     71         

  • park_integration/ParkFitting.py

    r388309d rca6d914  
    4545            with Uid as keys 
    4646        """ 
    47         self.fitArrangeList={} 
     47        self.fitArrangeDict={} 
    4848        self.paramList=[] 
    4949         
    50     def createProblem(self): 
     50    def createAssembly(self): 
    5151        """ 
    5252        Extract sansmodel and sansdata from self.FitArrangelist ={Uid:FitArrange} 
    … …  
    5454        create an assembly self.problem=  park.Assembly([(parkmodel,parkdata)]) 
    5555        """ 
    56         print "ParkFitting: In createproblem" 
    5756        mylist=[] 
    5857        listmodel=[] 
    5958        i=0 
    60         for k,value in self.fitArrangeList.iteritems(): 
    61             #sansmodel=value.get_model() 
    62             #wrap sans model 
    63             #parkmodel = Model(sansmodel) 
     59        for k,value in self.fitArrangeDict.iteritems(): 
    6460            parkmodel = value.get_model() 
    65             #print "ParkFitting: createproblem: just create a model",parkmodel.parameterset 
    6661            for p in parkmodel.parameterset: 
    67                 #self.param_list.append(p._getname()) 
    68                 #if p.isfixed(): 
    69                 #print 'parameters',p.name 
    70                 #print "parkfitting: self.paramList",self.paramList 
    7162                if p.isfixed() and p._getname()in self.paramList: 
    72                 #if p.isfixed(): 
    7363                    p.set([-numpy.inf,numpy.inf]) 
    7464            i+=1     
    … …  
    7666            parkdata=self._concatenateData(Ldata) 
    7767             
    78             couple=(parkmodel,parkdata) 
    79             #print "Parkfitting: fitness",couple    
    80             mylist.append(couple) 
    81         #print "mylist",mylist 
     68            fitness=(parkmodel,parkdata) 
     69            mylist.append(fitness) 
     70     
    8271        self.problem =  park.Assembly(mylist) 
    8372         
    … …  
    9988            @return result.cov: Covariance matrix 
    10089        """ 
    101         #from numpy.linalg.linalg.LinAlgError import LinAlgError 
    102         #print "Parkfitting: fit method probably breaking just right before \ 
    103         #call fit" 
    104         self.createProblem() 
     90         
     91        self.createAssembly() 
    10592        pars=self.problem.fit_parameters() 
    10693        self.problem.eval() 
    107         #print "M0.B",self.problem[1].parameterset['B'].value,self.problem[0].parameterset['B'].value 
    108  
    10994        localfit = FitSimplex() 
    11095        localfit.ftol = 1e-8 
    111         #localfit.ftol = 1e-6 
    11296        fitter = FitMC(localfit=localfit) 
    113         print "ParkFitting: result1",pars 
    114         print "Parkfitting: in fit function fitness resid",self.problem[0].residuals() 
    115          
    11697        list=self.problem[0]._parameterset() 
    117         print "Parkfitting: in fit function fitness paramset",list 
    118         for item in list: 
    119             print "Parkfitting: in fit function fitness",item.name, item.value,item.path,item.range 
    12098        result = fit.fit(self.problem, 
    12199                     fitter=fitter, 
    122100                     handler= fitresult.ConsoleUpdate(improvement_delta=0.1)) 
    123         #result = fit.fit(self.problem) 
    124         print "ParkFitting: result",result.fitness,result.pvec,result.cov 
     101        
    125102        if result !=None: 
    126             #for p in result.parameters: 
    127             #    print "fit in park fitting", p.name, p.value,p.stderr 
    128             #return result.fitness,result.pvec,result.cov,result 
    129103            return result 
    130104        else: 

  • park_integration/ScipyFitting.py

    r48882d1 rca6d914  
    3535        Use a sans model 
    3636         
    37         Add data with a dictionnary of FitArrangeList where Uid is a key and data 
     37        Add data with a dictionnary of FitArrangeDict where Uid is a key and data 
    3838        is saved in FitArrange object. 
    3939        engine.set_data(data,Uid) 
    … …  
    4545        engine.set_param( model,"M1", {'A':2,'B':4}) 
    4646         
    47         Add model with a dictionnary of FitArrangeList{} where Uid is a key and model 
     47        Add model with a dictionnary of FitArrangeDict{} where Uid is a key and model 
    4848        is save in FitArrange object. 
    4949        engine.set_model(model,Uid) 
    … …  
    5454    def __init__(self): 
    5555        """ 
    56             Creates a dictionary (self.fitArrangeList={})of FitArrange elements 
     56            Creates a dictionary (self.fitArrangeDict={})of FitArrange elements 
    5757            with Uid as keys 
    5858        """ 
    59         self.fitArrangeList={} 
     59        self.fitArrangeDict={} 
    6060        self.paramList=[] 
    6161    def fit(self,qmin=None, qmax=None): 
    6262         # Protect against simultanous fitting attempts 
    63         if len(self.fitArrangeList)>1:  
     63        if len(self.fitArrangeDict)>1:  
    6464            raise RuntimeError, "Scipy can't fit more than a single fit problem at a time." 
    6565         
    6666        # fitproblem contains first fitArrange object(one model and a list of data) 
    67         fitproblem=self.fitArrangeList.values()[0] 
     67        fitproblem=self.fitArrangeDict.values()[0] 
    6868        listdata=[] 
    6969        model = fitproblem.get_model() 
    … …  
    7777            qmax= max(data.x)  
    7878        functor= sansAssembly(model,data) 
    79         print "scipyfitting:param list",model.getParams(self.paramList) 
    80         print "scipyfitting:functor",functor(model.getParams(self.paramList)) 
    81      
     79        
    8280        out, cov_x, info, mesg, success = optimize.leastsq(functor,model.getParams(self.paramList), full_output=1, warning=True) 
    8381        chisqr = functor.chisq(out) 
     82        if cov_x is not None and numpy.isfinite(cov_x).all(): 
     83            stderr = numpy.sqrt(numpy.diag(cov_x)) 
    8484         
    85         print "scipyfitting: info",mesg 
    86         print"scipyfitting : success",success 
    87         print "scipyfitting: out", out 
    88         print "scipyfitting: cov_x", cov_x 
    89         print "scipyfitting: chisqr", chisqr 
    90          
    91         if not (numpy.isnan(out).any()): 
     85        if not (numpy.isnan(out).any()) or ( cov_x !=None) : 
    9286                result = fitresult() 
    9387                result.fitness = chisqr 
    94                 result.cov  = cov_x 
    95                  
     88                result.stderr  = stderr 
    9689                result.pvec = out 
    9790                result.success =success 
    … …  
    9992                return result 
    10093        else:   
    101             raise ValueError, "SVD did not converge" 
     94            raise ValueError, "SVD did not converge"+str(success) 
    10295         
    10396        

  • park_integration/docs/use-cases.txt

    r103a0b0 rca6d914  
    23231.1.3.1.        The user does not choose a data set before starting the fit. 
    24241.1.3.2.        The user does not choose a model before starting the fit. 
     251.1.3.3.        the user does not specify the list of parameter to fit  
     261.1.3.4.        the user enters a list of parameters that do not belong to the model 
    2527 
    2628 
    … …  
    5557 
    56582.1.2.1.        The client does not enter initial parameters 
     592.1.2.2.        the user enters a list of parameters not belonging to the model 
    5760 
    5861 

  • park_integration/test/cyl_testdata.txt

    rcfe97ea rca6d914  
    110.007778 1.78E+14 13335629  
    2  
    320.023333 5.32E+13 7293888  
    430.031111 3.40E+13 5833464  
    … …  
    12110.093333 1.47E+11 383624.8  
    13120.101111 1.19E+11 344493.8  
    14  
    15130.124444 2.58E+11 507633.7  
    16140.132222 2.44E+11 493743.9  
    … …  
    22200.178889 4.41E+10 209959  
    23210.186667 4.02E+10 200480.7  
    24  
    25220.202222 5.33E+10 230891.5  
    26230.21 4.99E+10 223441.9  
    … …  
    37340.295556 1.05E+10 102300  
    38350.303333 7.95E+09 89146.17  
    39  
    40360.334444 7.92E+09 89019.55  
    41370.342222 9.75E+09 98739.25  

  • park_integration/test/testdata_line.txt

    r6b126e8 rca6d914  
    1 #y=A*x+B 
    2 #A=2.5 
    3 #B=4 
     1#y=A+x*B 
     2#B=2.5 
     3#A=4 
    440  2.83954  0.6 
    550.204082  3.44938  0.676531 
Note: See TracChangeset for help on using the changeset viewer.