Changeset 89f3b66 in sasview for park_integration


Ignore:
Timestamp:
Oct 19, 2010 9:02:08 PM (14 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:
4ddb7a4
Parents:
74b1770
Message:

working pylint

Location:
park_integration
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • park_integration/AbstractFitEngine.py

    r189be4e r89f3b66  
    11 
    2  
    3 import logging, sys 
    4 import park,numpy,math, copy 
     2import  copy 
     3import logging 
     4import sys 
     5import numpy 
     6import math 
     7import park 
    58from DataLoader.data_info import Data1D 
    69from DataLoader.data_info import Data2D 
    … …  
    1821         
    1922        """ 
    20         self._model, self._name = model,name 
     23        self._model, self._name = model, name 
    2124        #set the value for the parameter of the given name 
    2225        self.set(model.getParam(name)) 
    … …  
    3134        return self._model.getParam(self.name) 
    3235     
    33     def _setvalue(self,value): 
     36    def _setvalue(self, value): 
    3437        """ 
    3538        override the _setvalue pf park parameter 
    … …  
    4851        """ 
    4952        #if not  self.name in self._model.getDispParamList(): 
    50         lo,hi = self._model.details[self.name][1:3] 
     53        lo, hi = self._model.details[self.name][1:3] 
    5154        if lo is None: lo = -numpy.inf 
    5255        if hi is None: hi = numpy.inf 
    … …  
    5861            raise ValueError,"wrong fit range for parameters" 
    5962         
    60         return lo,hi 
    61      
    62     def _setrange(self,r): 
     63        return lo, hi 
     64     
     65    def _setrange(self, r): 
    6366        """ 
    6467        override _setrange of park parameter 
    … …  
    6871        """ 
    6972        self._model.details[self.name][1:3] = r 
    70     range = property(_getrange,_setrange) 
     73    range = property(_getrange, _setrange) 
    7174     
    7275class Model(park.Model): 
    … …  
    8790        self.parkp = [SansParameter(p,sans_model) for p in self.sansp] 
    8891        #list of parameterset  
    89         self.parameterset = park.ParameterSet(sans_model.name,pars=self.parkp) 
    90         self.pars=[] 
     92        self.parameterset = park.ParameterSet(sans_model.name, pars=self.parkp) 
     93        self.pars = [] 
    9194   
    92     def getParams(self,fitparams): 
     95    def getParams(self, fitparams): 
    9396        """ 
    9497        return a list of value of paramter to fit 
    … …  
    97100         
    98101        """ 
    99         list=[] 
    100         self.pars=[] 
    101         self.pars=fitparams 
     102        list = [] 
     103        self.pars = [] 
     104        self.pars = fitparams 
    102105        for item in fitparams: 
    103106            for element in self.parkp: 
    104                  if element.name ==str(item): 
     107                 if element.name == str(item): 
    105108                     list.append(element.value) 
    106109        return list 
    107110     
    108     def setParams(self,paramlist, params): 
     111    def setParams(self, paramlist, params): 
    109112        """ 
    110113        Set value for parameters to fit 
    … …  
    116119            for i in range(len(self.parkp)): 
    117120                for j in range(len(paramlist)): 
    118                     if self.parkp[i].name==paramlist[j]: 
     121                    if self.parkp[i].name == paramlist[j]: 
    119122                        self.parkp[i].value = params[j] 
    120                         self.model.setParam(self.parkp[i].name,params[j]) 
     123                        self.model.setParam(self.parkp[i].name, params[j]) 
    121124        except: 
    122125            raise 
    123126   
    124     def eval(self,x): 
     127    def eval(self, x): 
    125128        """ 
    126129        override eval method of park model.  
    … …  
    141144    a way to get residuals from data. 
    142145    """ 
    143     def __init__(self,x, y,dx= None, dy=None, smearer=None): 
    144         Data1D.__init__(self, x=numpy.array(x), y=numpy.array(y), dx=dx, dy=dy) 
     146    def __init__(self, x, y, dx=None, dy=None, smearer=None): 
    145147        """ 
    146148        :param smearer: is an object of class QSmearer or SlitSmearer 
    … …  
    162164             
    163165        """ 
     166        Data1D.__init__(self, x=x, y=y, dx=dx, dy=dy) 
     167         
    164168        self.smearer = smearer 
    165169         
    166170        # Check error bar; if no error bar found, set it constant(=1) 
    167171        # TODO: Should provide an option for users to set it like percent, constant, or dy data 
    168         if dy ==None or dy==[] or dy.all()==0: 
    169             self.dy= numpy.ones(len(y))   
     172        if dy == None or dy == [] or dy.all() == 0: 
     173            self.dy = numpy.ones(len(y))   
    170174        else: 
    171             self.dy= numpy.asarray(dy).copy() 
     175            self.dy = numpy.asarray(dy).copy() 
    172176 
    173177        ## Min Q-value 
    174178        #Skip the Q=0 point, especially when y(q=0)=None at x[0]. 
    175         if min (self.x) ==0.0 and self.x[0]==0 and not numpy.isfinite(self.y[0]): 
     179        if min (self.x) == 0.0 and self.x[0] == 0 and\ 
     180                     not numpy.isfinite(self.y[0]): 
    176181            self.qmin = min(self.x[self.x!=0]) 
    177182        else:                               
    178             self.qmin= min (self.x) 
     183            self.qmin = min(self.x) 
    179184        ## Max Q-value 
    180         self.qmax = max (self.x) 
     185        self.qmax = max(self.x) 
    181186         
    182187        # Range used for input to smearing 
    … …  
    184189        self._qmax_unsmeared = self.qmax 
    185190        # Identify the bin range for the unsmeared and smeared spaces 
    186         self.idx = (self.x>=self.qmin) & (self.x <= self.qmax) 
    187         self.idx_unsmeared = (self.x>=self._qmin_unsmeared) & (self.x <= self._qmax_unsmeared) 
     191        self.idx = (self.x >= self.qmin) & (self.x <= self.qmax) 
     192        self.idx_unsmeared = (self.x >= self._qmin_unsmeared) \ 
     193                            & (self.x <= self._qmax_unsmeared) 
    188194   
    189         
    190         
    191     def setFitRange(self,qmin=None,qmax=None): 
     195    def setFitRange(self, qmin=None, qmax=None): 
    192196        """ to set the fit range""" 
    193197        # Skip Q=0 point, (especially for y(q=0)=None at x[0]). 
    194198        # ToDo: Find better way to do it. 
    195         if qmin==0.0 and not numpy.isfinite(self.y[qmin]): 
    196             self.qmin = min(self.x[self.x!=0]) 
    197         elif qmin!=None:                        
     199        if qmin == 0.0 and not numpy.isfinite(self.y[qmin]): 
     200            self.qmin = min(self.x[self.x != 0]) 
     201        elif qmin != None:                        
    198202            self.qmin = qmin             
    199  
    200         if qmax !=None: 
     203        if qmax != None: 
    201204            self.qmax = qmax 
    202              
    203205        # Determine the range needed in unsmeared-Q to cover 
    204206        # the smeared Q range 
    … …  
    207209         
    208210        self._first_unsmeared_bin = 0 
    209         self._last_unsmeared_bin  = len(self.x)-1 
     211        self._last_unsmeared_bin  = len(self.x) - 1 
    210212         
    211213        if self.smearer!=None: 
    212             self._first_unsmeared_bin, self._last_unsmeared_bin = self.smearer.get_bin_range(self.qmin, self.qmax) 
     214            self._first_unsmeared_bin, self._last_unsmeared_bin = \ 
     215                    self.smearer.get_bin_range(self.qmin, self.qmax) 
    213216            self._qmin_unsmeared = self.x[self._first_unsmeared_bin] 
    214217            self._qmax_unsmeared = self.x[self._last_unsmeared_bin] 
    215218             
    216219        # Identify the bin range for the unsmeared and smeared spaces 
    217         self.idx = (self.x>=self.qmin) & (self.x <= self.qmax) 
    218         self.idx = self.idx & (self.dy!=0)   ## zero error can not participate for fitting 
    219         self.idx_unsmeared = (self.x>=self._qmin_unsmeared) & (self.x <= self._qmax_unsmeared) 
     220        self.idx = (self.x >= self.qmin) & (self.x <= self.qmax) 
     221        ## zero error can not participate for fitting 
     222        self.idx = self.idx & (self.dy != 0)   
     223        self.idx_unsmeared = (self.x >= self._qmin_unsmeared) \ 
     224                            & (self.x <= self._qmax_unsmeared) 
    220225   
    221          
    222226    def getFitRange(self): 
    223227        """ 
    … …  
    239243        """ 
    240244        # Compute theory data f(x) 
    241         fx= numpy.zeros(len(self.x)) 
     245        fx = numpy.zeros(len(self.x)) 
    242246        fx[self.idx_unsmeared] = fn(self.x[self.idx_unsmeared]) 
    243247        
    244248        ## Smear theory data 
    245249        if self.smearer is not None: 
    246             fx = self.smearer(fx, self._first_unsmeared_bin, self._last_unsmeared_bin) 
    247  
     250            fx = self.smearer(fx, self._first_unsmeared_bin,  
     251                              self._last_unsmeared_bin) 
    248252        ## Sanity check 
    249         if numpy.size(self.dy)!= numpy.size(fx): 
    250             raise RuntimeError, "FitData1D: invalid error array %d <> %d" % (numpy.shape(self.dy), 
    251                                                                               numpy.size(fx)) 
    252                                                                                
    253         return (self.y[self.idx]-fx[self.idx])/self.dy[self.idx] 
     253        if numpy.size(self.dy) != numpy.size(fx): 
     254            msg = "FitData1D: invalid error array " 
     255            msg += "%d <> %d" % (numpy.shape(self.dy), numpy.size(fx))                                                       
     256            raise RuntimeError, msg   
     257        return (self.y[self.idx] - fx[self.idx]) / self.dy[self.idx] 
    254258      
    255259    def residuals_deriv(self, model, pars=[]): 
    … …  
    262266        return [] 
    263267     
    264      
    265268class FitData2D(Data2D): 
    266269    """ Wrapper class  for SANS data """ 
    267     def __init__(self,sans_data2d ,data=None, err_data=None): 
    268         Data2D.__init__(self, data= data, err_data= err_data) 
     270    def __init__(self, sans_data2d, data=None, err_data=None): 
     271        Data2D.__init__(self, data=data, err_data= err_data) 
    269272        """ 
    270273        Data can be initital with a data (sans plottable) 
    271274        or with vectors. 
    272275        """ 
    273         self.res_err_image=[] 
    274         self.index_model=[] 
    275         self.qmin= None 
    276         self.qmax= None 
     276        self.res_err_image = [] 
     277        self.index_model = [] 
     278        self.qmin = None 
     279        self.qmax = None 
    277280        self.smearer = None 
    278         self.set_data(sans_data2d ) 
    279  
    280          
    281     def set_data(self, sans_data2d, qmin=None, qmax=None ): 
     281        self.set_data(sans_data2d) 
     282 
     283         
     284    def set_data(self, sans_data2d, qmin=None, qmax=None): 
    282285        """ 
    283286        Determine the correct qx_data and qy_data within range to fit 
    284287        """ 
    285         self.data     = sans_data2d.data 
     288        self.data = sans_data2d.data 
    286289        self.err_data = sans_data2d.err_data 
    287290        self.qx_data = sans_data2d.qx_data 
    288291        self.qy_data = sans_data2d.qy_data 
    289         self.mask       = sans_data2d.mask 
     292        self.mask = sans_data2d.mask 
    290293 
    291294        x_max = max(math.fabs(sans_data2d.xmin), math.fabs(sans_data2d.xmax)) 
    … …  
    296299            self.qmin = 1e-16 
    297300        if qmax == None: 
    298             self.qmax = math.sqrt(x_max*x_max +y_max*y_max) 
     301            self.qmax = math.sqrt(x_max * x_max + y_max * y_max) 
    299302        ## new error image for fitting purpose 
    300         if self.err_data== None or self.err_data ==[]: 
    301             self.res_err_data= numpy.ones(len(self.data)) 
     303        if self.err_data == None or self.err_data == []: 
     304            self.res_err_data = numpy.ones(len(self.data)) 
    302305        else: 
    303306            self.res_err_data = copy.deepcopy(self.err_data) 
    304307        #self.res_err_data[self.res_err_data==0]=1 
    305308         
    306         self.radius= numpy.sqrt(self.qx_data**2 + self.qy_data**2) 
     309        self.radius = numpy.sqrt(self.qx_data**2 + self.qy_data**2) 
    307310         
    308311        # Note: mask = True: for MASK while mask = False for NOT to mask 
    309         self.index_model = ((self.qmin <= self.radius)&(self.radius<= self.qmax)) 
     312        self.index_model = ((self.qmin <= self.radius)&\ 
     313                            (self.radius <= self.qmax)) 
    310314        self.index_model = (self.index_model) & (self.mask) 
    311315        self.index_model = (self.index_model) & (numpy.isfinite(self.data)) 
    … …  
    321325        self.smearer.get_data() 
    322326 
    323     def setFitRange(self,qmin=None,qmax=None): 
     327    def setFitRange(self, qmin=None, qmax=None): 
    324328        """ to set the fit range""" 
    325         if qmin==0.0: 
     329        if qmin == 0.0: 
    326330            self.qmin = 1e-16 
    327         elif qmin!=None:                        
     331        elif qmin != None:                        
    328332            self.qmin = qmin             
    329         if qmax!=None: 
    330             self.qmax= qmax         
    331         self.radius= numpy.sqrt(self.qx_data**2 + self.qy_data**2) 
    332         self.index_model = ((self.qmin <= self.radius)&(self.radius<= self.qmax)) 
     333        if qmax != None: 
     334            self.qmax = qmax         
     335        self.radius = numpy.sqrt(self.qx_data**2 + self.qy_data**2) 
     336        self.index_model = ((self.qmin <= self.radius)&\ 
     337                            (self.radius <= self.qmax)) 
    333338        self.index_model = (self.index_model) &(self.mask) 
    334339        self.index_model = (self.index_model) & (numpy.isfinite(self.data)) 
    … …  
    352357            gn = fn.get_value()   
    353358        else: 
    354             gn = fn([self.qx_data[self.index_model],self.qy_data[self.index_model]]) 
     359            gn = fn([self.qx_data[self.index_model], 
     360                     self.qy_data[self.index_model]]) 
    355361        # use only the data point within ROI range 
    356         res=(self.data[self.index_model] - gn)/self.res_err_data[self.index_model] 
     362        res = (self.data[self.index_model] - gn)/\ 
     363                    self.res_err_data[self.index_model] 
    357364        return res 
    358365         
    … …  
    418425        #import thread 
    419426        self.model.setParams(self.paramlist,params) 
    420         self.res= self.data.residuals(self.model.eval) 
     427        self.res = self.data.residuals(self.model.eval) 
    421428        if self.fitresult is not None and  self.handler is not None: 
    422429            self.fitresult.set_model(model=self.model) 
    … …  
    450457        :param listdata: list of data  
    451458         
    452         :return Data: Data is wrapper class for sans plottable. it is created with all parameters 
    453            of data concatenanted 
     459        :return Data: Data is wrapper class for sans plottable. 
     460         it is created with all parameters of data concatenanted 
    454461             
    455462        :raise: if listdata is empty  will return None 
    456         :raise: if data in listdata don't contain dy field ,will create an error 
    457             during fitting 
     463        :raise: if data in listdata don't contain dy field , 
     464        will create an error during fitting 
    458465             
    459466        """ 
    … …  
    467474        #return listdata[0] 
    468475         
    469         if listdata==[]: 
     476        if listdata == []: 
    470477            raise ValueError, " data list missing" 
    471478        else: 
    472             xtemp=[] 
    473             ytemp=[] 
    474             dytemp=[] 
    475             self.mini=None 
    476             self.maxi=None 
     479            xtemp = [] 
     480            ytemp = [] 
     481            dytemp = [] 
     482            self.mini = None 
     483            self.maxi = None 
    477484                
    478485            for item in listdata: 
    479                 data=item.data 
    480                 mini,maxi=data.getFitRange() 
    481                 if self.mini==None and self.maxi==None: 
    482                     self.mini=mini 
    483                     self.maxi=maxi 
     486                data = item.data 
     487                mini, maxi = data.getFitRange() 
     488                if self.mini == None and self.maxi == None: 
     489                    self.mini = mini 
     490                    self.maxi = maxi 
    484491                else: 
    485492                    if mini < self.mini: 
    486                         self.mini=mini 
     493                        self.mini = mini 
    487494                    if self.maxi < maxi: 
    488                         self.maxi=maxi 
    489                          
    490                      
     495                        self.maxi = maxi 
    491496                for i in range(len(data.x)): 
    492497                    xtemp.append(data.x[i]) 
    493498                    ytemp.append(data.y[i]) 
    494                     if data.dy is not None and len(data.dy)==len(data.y):    
     499                    if data.dy is not None and len(data.dy) == len(data.y):    
    495500                        dytemp.append(data.dy[i]) 
    496501                    else: 
    497                         raise RuntimeError, "Fit._concatenateData: y-errors missing" 
    498             data= Data(x=xtemp,y=ytemp,dy=dytemp) 
     502                        msg = "Fit._concatenateData: y-errors missing" 
     503                        raise RuntimeError, msg 
     504            data = Data(x=xtemp, y=ytemp, dy=dytemp) 
    499505            data.setFitRange(self.mini, self.maxi) 
    500506            return data 
    … …  
    525531            raise ValueError, "AbstractFitEngine: Need to set model to fit" 
    526532         
    527         new_model= model 
     533        new_model = model 
    528534        if not issubclass(model.__class__, Model): 
    529             new_model= Model(model) 
    530          
    531         if len(constraints)>0: 
     535            new_model = Model(model) 
     536         
     537        if len(constraints) > 0: 
    532538            for constraint in constraints: 
    533539                name, value = constraint 
    534540                try: 
    535                     new_model.parameterset[ str(name)].set( str(value) ) 
     541                    new_model.parameterset[str(name)].set(str(value)) 
    536542                except: 
    537                     msg= "Fit Engine: Error occurs when setting the constraint" 
     543                    msg = "Fit Engine: Error occurs when setting the constraint" 
    538544                    msg += " %s for parameter %s "%(value, name) 
    539545                    raise ValueError, msg 
    540546                 
    541         if len(pars) >0: 
    542             temp=[] 
     547        if len(pars) > 0: 
     548            temp = [] 
    543549            for item in pars: 
    544550                if item in new_model.model.getParamList(): 
    … …  
    547553                else: 
    548554                     
    549                     msg = "wrong parameter %s used"%str(item) 
    550                     msg += "to set model %s. Choose"%str(new_model.model.name) 
    551                     msg += "parameter name within %s"%str(new_model.model.getParamList()) 
    552                     raise ValueError,msg 
     555                    msg = "wrong parameter %s used" % str(item) 
     556                    msg += "to set model %s. Choose" % str(new_model.model.name) 
     557                    msg += "parameter name within %s" % \ 
     558                                str(new_model.model.getParamList()) 
     559                    raise ValueError, msg 
    553560               
    554561            #A fitArrange is already created but contains dList only at Uid 
    555562            if self.fitArrangeDict.has_key(Uid): 
    556563                self.fitArrangeDict[Uid].set_model(new_model) 
    557                 self.fitArrangeDict[Uid].pars= pars 
     564                self.fitArrangeDict[Uid].pars = pars 
    558565            else: 
    559566            #no fitArrange object has been create with this Uid 
    560567                fitproblem = FitArrange() 
    561568                fitproblem.set_model(new_model) 
    562                 fitproblem.pars= pars 
     569                fitproblem.pars = pars 
    563570                self.fitArrangeDict[Uid] = fitproblem 
    564571                 
    … …  
    566573            raise ValueError, "park_integration:missing parameters" 
    567574     
    568     def set_data(self,data,Uid,smearer=None,qmin=None,qmax=None): 
     575    def set_data(self, data, Uid, smearer=None, qmin=None, qmax=None): 
    569576        """  
    570577        Receives plottable, creates a list of data to fit,set data 
    … …  
    576583         
    577584        """ 
    578         if data.__class__.__name__=='Data2D': 
    579             fitdata=FitData2D(sans_data2d=data, data=data.data, err_data= data.err_data) 
     585        if data.__class__.__name__ == 'Data2D': 
     586            fitdata = FitData2D(sans_data2d=data, data=data.data, 
     587                                 err_data=data.err_data) 
    580588        else: 
    581             fitdata=FitData1D(x=data.x, y=data.y , dx= data.dx,dy=data.dy,smearer=smearer) 
     589            fitdata = FitData1D(x=data.x, y=data.y , 
     590                                 dx=data.dx, dy=data.dy, smearer=smearer) 
    582591        
    583         fitdata.setFitRange(qmin=qmin,qmax=qmax) 
     592        fitdata.setFitRange(qmin=qmin, qmax=qmax) 
    584593        #A fitArrange is already created but contains model only at Uid 
    585594        if self.fitArrangeDict.has_key(Uid): 
    … …  
    587596        else: 
    588597        #no fitArrange object has been create with this Uid 
    589             fitproblem= FitArrange() 
     598            fitproblem = FitArrange() 
    590599            fitproblem.add_data(fitdata) 
    591             self.fitArrangeDict[Uid]=fitproblem     
     600            self.fitArrangeDict[Uid] = fitproblem     
    592601    
    593     def get_model(self,Uid): 
     602    def get_model(self, Uid): 
    594603        """  
    595604         
    … …  
    605614            return None 
    606615     
    607     def remove_Fit_Problem(self,Uid): 
     616    def remove_Fit_Problem(self, Uid): 
    608617        """remove   fitarrange in Uid""" 
    609618        if self.fitArrangeDict.has_key(Uid): 
    610619            del self.fitArrangeDict[Uid] 
    611620             
    612     def select_problem_for_fit(self,Uid,value): 
     621    def select_problem_for_fit(self, Uid, value): 
    613622        """ 
    614623        select a couple of model and data at the Uid position in dictionary 
    … …  
    620629        """ 
    621630        if self.fitArrangeDict.has_key(Uid): 
    622              self.fitArrangeDict[Uid].set_to_fit( value) 
     631             self.fitArrangeDict[Uid].set_to_fit(value) 
    623632              
    624     def get_problem_to_fit(self,Uid): 
     633    def get_problem_to_fit(self, Uid): 
    625634        """ 
    626635        return the self.selected value of the fit problem of Uid 
    … …  
    644653        """ 
    645654        self.model = None 
    646         self.dList =[] 
    647         self.pars=[] 
     655        self.dList = [] 
     656        self.pars = [] 
    648657        #self.selected  is zero when this fit problem is not schedule to fit  
    649658        #self.selected is 1 when schedule to fit  
    650659        self.selected = 0 
    651660         
    652     def set_model(self,model): 
     661    def set_model(self, model): 
    653662        """  
    654663        set_model save a copy of the model 
    … …  
    659668        self.model = model 
    660669         
    661     def add_data(self,data): 
     670    def add_data(self, data): 
    662671        """  
    663672        add_data fill a self.dList with data to fit 
    … …  
    686695        return self.dList[0]  
    687696       
    688     def remove_data(self,data): 
     697    def remove_data(self, data): 
    689698        """ 
    690699        Remove one element from the list 
    … …  
    703712         
    704713        """ 
    705         self.selected= value 
     714        self.selected = value 
    706715         
    707716    def get_to_fit(self): 

  • park_integration/Fitting.py

    raa36f96 r89f3b66  
    55""" 
    66 
    7 from scipy import optimize 
     7#from scipy import optimize 
    88from ScipyFitting import ScipyFit 
    99from ParkFitting import ParkFit 
    … …  
    3333        self.set_engine(engine) 
    3434           
    35     def set_engine(self,word): 
     35    def set_engine(self, word): 
    3636        """ 
    3737        Select the type of Fit  
    … …  
    4343              
    4444        """ 
    45         if word=="scipy": 
    46             self._engine=ScipyFit() 
    47         elif word=="park": 
     45        if word == "scipy": 
     46            self._engine = ScipyFit() 
     47        elif word == "park": 
    4848            self._engine=ParkFit() 
    4949        else: 
    … …  
    5353        """Perform the fit """ 
    5454        try: 
    55             return self._engine.fit(q,handler, curr_thread= curr_thread) 
     55            return self._engine.fit(q,handler, curr_thread=curr_thread) 
    5656        except: 
    5757            raise 
    5858     
    59     def set_model(self,model,Uid,pars=[],constraints=[]): 
     59    def set_model(self, model, Uid, pars=[], constraints=[]): 
    6060        """ 
    6161        store a model model to fit at the position Uid of the fit engine 
    6262        """ 
    63         self._engine.set_model(model,Uid,pars,constraints) 
     63        self._engine.set_model(model, Uid, pars, constraints) 
    6464    
    65     
    66     def set_data(self,data,Uid,smearer=None,qmin=None, qmax=None): 
     65    def set_data(self, data, Uid, smearer=None, qmin=None, qmax=None): 
    6766        """ 
    6867        Store data to fit at the psotion Uid of the fit engine 
    … …  
    7473         
    7574        """ 
    76         self._engine.set_data(data,Uid,smearer,qmin, qmax) 
     75        self._engine.set_data(data, Uid, smearer, qmin, qmax) 
    7776         
    78          
    79     def get_model(self,Uid): 
     77    def get_model(self, Uid): 
    8078        """ return list of data""" 
    8179        self._engine.get_model(Uid) 
    8280 
    8381 
    84     def remove_Fit_Problem(self,Uid): 
     82    def remove_Fit_Problem(self, Uid): 
    8583        """remove fitarrange in Uid""" 
    8684        self._engine.remove_Fit_Problem(Uid) 
    8785         
    88          
    89     def select_problem_for_fit(self,Uid,value): 
     86    def select_problem_for_fit(self, Uid, value): 
    9087        """ 
    9188        select a couple of model and data at the Uid position in dictionary 
    … …  
    9592             can only have the value one or zero 
    9693        """ 
    97         self._engine.select_problem_for_fit(Uid,value) 
     94        self._engine.select_problem_for_fit(Uid, value) 
    9895         
    99          
    100     def get_problem_to_fit(self,Uid): 
     96    def get_problem_to_fit(self, Uid): 
    10197        """ 
    10298        return the self.selected value of the fit problem of Uid 

  • park_integration/Loader.py

    raa36f96 r89f3b66  
    11# class Loader  to load any king of file 
    2 import wx 
    3 import string,numpy 
     2#import wx 
     3#import string 
     4import numpy 
    45class Load: 
    56    """ 
    … …  
    78    """ 
    89     
    9     def _init_(self,x=None,y=None,dx=None,dy=None): 
     10    def _init_(self, x=None, y=None, dx=None, dy=None): 
    1011        # variable to store loaded values 
    1112        self.x = x 
    … …  
    1516        self.filename = None 
    1617         
    17     def set_filename(self,path=None): 
     18    def set_filename(self, path=None): 
    1819        """ 
    1920        Store path into a variable.If the user doesn't give a path as a parameter a pop-up 
    … …  
    2526        self.filename = path 
    2627        
    27  
    2828    def get_filename(self): 
    2929        """ return the file's path""" 
    … …  
    3333        """ Store the values loaded from file in local variables""" 
    3434        if not self.filename == None: 
    35             input_f =  open(self.filename,'r') 
     35            input_f =  open(self.filename, 'r') 
    3636            buff = input_f.read() 
    3737            lines = buff.split('\n') 
    38             self.x=[] 
    39             self.y=[] 
     38            self.x = [] 
     39            self.y = [] 
    4040            self.dx = []  
    41             self.dy=[] 
     41            self.dy = [] 
    4242            for line in lines: 
    4343                try: 
    … …  
    6464    def get_values(self): 
    6565        """ Return x, y, dx, dy""" 
    66         return self.x,self.y,self.dx,self.dy 
     66        return self.x, self.y, self.dx, self.dy 
    6767     
    68     def load_data(self,data): 
     68    def load_data(self, data): 
    6969        """ Return plottable""" 
    7070        #load data 
    … …  
    7272        data.y = self.y 
    7373        data.dx = self.dx 
    74         data.dy =self.dy 
     74        data.dy = self.dy 
    7575        #Load its View class 
    7676        #plottable.reset_view() 
    … …  
    7878     
    7979if __name__ == "__main__":  
    80     load= Load() 
     80    load = Load() 
    8181    load.set_filename("testdata_line.txt") 
    8282    print load.get_filename()  

  • park_integration/ParkFitting.py

    raa36f96 r89f3b66  
    77simple fit with park optimizer. 
    88""" 
    9 import time 
    10 import numpy 
     9#import time 
     10#import numpy 
    1111import park 
    12 from park import fit,fitresult 
     12from park import fit, fitresult 
    1313from park import assembly 
    1414from park.fitmc import FitSimplex, FitMC 
    … …  
    5252        with Uid as keys 
    5353        """ 
    54         self.fitArrangeDict={} 
    55         self.paramList=[] 
     54        self.fitArrangeDict = {} 
     55        self.paramList = [] 
    5656         
    5757    def createAssembly(self): 
    … …  
    6161        create an assembly self.problem=  park.Assembly([(parkmodel,parkdata)]) 
    6262        """ 
    63         mylist=[] 
    64         listmodel=[] 
    65         i=0 
    66         fitproblems=[] 
    67         for id ,fproblem in self.fitArrangeDict.iteritems(): 
    68             if fproblem.get_to_fit()==1: 
     63        mylist = [] 
     64        listmodel = [] 
     65        i = 0 
     66        fitproblems = [] 
     67        for id,fproblem in self.fitArrangeDict.iteritems(): 
     68            if fproblem.get_to_fit() == 1: 
    6969                fitproblems.append(fproblem) 
    70                  
    71         if len(fitproblems)==0 :  
     70        if len(fitproblems) == 0:  
    7271            raise RuntimeError, "No Assembly scheduled for Park fitting." 
    7372            return 
    … …  
    7675            for p in parkmodel.parameterset: 
    7776                ## does not allow status change for constraint parameters 
    78                 if p.status!= 'computed': 
     77                if p.status != 'computed': 
    7978                    if p._getname()in item.pars: 
    8079                        ## make parameters selected for fit will be between boundaries 
    81                         p.set( p.range ) 
    82                                  
     80                        p.set(p.range)          
    8381                    else: 
    84                         p.status= 'fixed' 
    85               
    86             i+=1 
    87             Ldata=item.get_data() 
     82                        p.status = 'fixed' 
     83            i += 1 
     84            Ldata = item.get_data() 
    8885            #parkdata=self._concatenateData(Ldata) 
    89             parkdata=Ldata 
    90             fitness=(parkmodel,parkdata) 
     86            parkdata = Ldata 
     87            fitness = (parkmodel, parkdata) 
    9188            mylist.append(fitness) 
     89        self.problem = park.Assembly(mylist) 
    9290         
    93         self.problem =  park.Assembly(mylist) 
    94          
    95     def fit(self,q=None,handler=None, curr_thread= None): 
     91    def fit(self, q=None, handler=None, curr_thread=None): 
    9692        """ 
    9793        Performs fit with park.fit module.It can  perform fit with one model 
    … …  
    112108        """ 
    113109        self.createAssembly() 
    114      
    115110        localfit = FitSimplex() 
    116111        localfit.ftol = 1e-8 
    … …  
    119114        fitter = FitMC(localfit=localfit, start_points=1) 
    120115        if handler == None: 
    121             handler= fitresult.ConsoleUpdate(improvement_delta=0.1) 
    122        
    123              
     116            handler = fitresult.ConsoleUpdate(improvement_delta=0.1) 
    124117        result = fit.fit(self.problem, 
    125118                         fitter=fitter, 
    126                          handler= handler) 
     119                         handler=handler) 
    127120        self.problem.all_results(result) 
    128         if result !=None: 
    129             if q !=None: 
     121        if result != None: 
     122            if q != None: 
    130123                q.put(result) 
    131124                return q 

  • park_integration/ScipyFitting.py

    raa36f96 r89f3b66  
    1010from scipy import optimize 
    1111 
    12 from AbstractFitEngine import FitEngine, SansAssembly,FitAbort 
     12from AbstractFitEngine import FitEngine, SansAssembly, FitAbort 
    1313 
    1414class fitresult(object): 
    … …  
    1717    """ 
    1818    def __init__(self, model=None, paramList=None): 
    19         self.calls     = None 
    20         self.fitness   = None 
    21         self.chisqr    = None 
    22         self.pvec      = None 
    23         self.cov       = None 
    24         self.info      = None 
    25         self.mesg      = None 
    26         self.success   = None 
    27         self.stderr    = None 
     19        self.calls = None 
     20        self.fitness = None 
     21        self.chisqr = None 
     22        self.pvec = None 
     23        self.cov = None 
     24        self.info = None 
     25        self.mesg = None 
     26        self.success = None 
     27        self.stderr = None 
    2828        self.parameters = None 
    2929        self.model = model 
    … …  
    4848 
    4949        result_param = zip(xrange(n), self.model.parameterset) 
    50         L = ["P%-3d  %s......|.....%s"%(p[0], p[1], p[1].value) for p in result_param if p[1].name in self.paramList ] 
    51         L.append("=== goodness of fit: %s"%(str(self.fitness))) 
     50        L = ["P%-3d  %s......|.....%s"%(p[0], p[1], p[1].value)\ 
     51              for p in result_param if p[1].name in self.paramList] 
     52        L.append("=== goodness of fit: %s" % (str(self.fitness))) 
    5253        return "\n".join(L) 
    5354     
    … …  
    8990        with Uid as keys 
    9091        """ 
    91         self.fitArrangeDict={} 
    92         self.paramList=[] 
     92        self.fitArrangeDict = {} 
     93        self.paramList = [] 
    9394    #def fit(self, *args, **kw): 
    9495    #    return profile(self._fit, *args, **kw) 
    … …  
    9798        """ 
    9899        """ 
    99         fitproblem=[] 
    100         for id ,fproblem in self.fitArrangeDict.iteritems(): 
    101             if fproblem.get_to_fit()==1: 
     100        fitproblem = [] 
     101        for id, fproblem in self.fitArrangeDict.iteritems(): 
     102            if fproblem.get_to_fit() == 1: 
    102103                fitproblem.append(fproblem) 
    103         if len(fitproblem)>1 :  
     104        if len(fitproblem) > 1 :  
    104105            msg = "Scipy can't fit more than a single fit problem at a time." 
    105106            raise RuntimeError, msg 
    106107            return 
    107         elif len(fitproblem)==0 :  
     108        elif len(fitproblem) == 0 :  
    108109            raise RuntimeError, "No Assembly scheduled for Scipy fitting." 
    109110            return 
    110111     
    111         listdata=[] 
     112        listdata = [] 
    112113        model = fitproblem[0].get_model() 
    113114        listdata = fitproblem[0].get_data() 
    114115        # Concatenate dList set (contains one or more data)before fitting 
    115116        data = listdata 
    116         self.curr_thread= curr_thread 
     117        self.curr_thread = curr_thread 
    117118        result = fitresult(model=model, paramList=self.paramList) 
    118119        if handler is not None: 
    … …  
    120121        #try: 
    121122        functor = SansAssembly(self.paramList, model, data, handler=handler, 
    122                                 fitresult=result,curr_thread= self.curr_thread) 
     123                         fitresult=result, curr_thread= self.curr_thread) 
    123124        
    124125        
    … …  
    146147                return result 
    147148        else:   
    148             raise ValueError, "SVD did not converge"+str(success) 
     149            raise ValueError, "SVD did not converge" + str(success) 
    149150     
    150151 

  • park_integration/temp_code_exchange.py

    raa36f96 r89f3b66  
    88# This code belongs in AbstractFitEngine 
    99class FitData1D: 
    10     def setFitRange(self,qmin=None,qmax=None): 
     10    def setFitRange(self, qmin=None, qmax=None): 
    1111        """  
    1212        Change the fit range. 
    … …  
    1818        # Skip Q=0 point, (especially for y(q=0)=None at x[0]). 
    1919        #ToDo: Fix this. 
    20         if qmin==0.0 and not numpy.isfinite(self.data.y[qmin]): 
     20        if qmin == 0.0 and not numpy.isfinite(self.data.y[qmin]): 
    2121            self.qmin = min(self.data.x[self.data.x!=0]) 
    22         elif qmin!=None:                        
     22        elif qmin != None:                        
    2323            self.qmin = qmin             
    2424 
    25         if qmax !=None: 
     25        if qmax != None: 
    2626            self.qmax = qmax 
    2727             
    … …  
    4040            # Take 3 sigmas as the offset between smeared and unsmeared space. 
    4141            try: 
    42                 offset = 3.0*max(self.smearer.width) 
     42                offset = 3.0 * max(self.smearer.width) 
    4343                self._qmin_unsmeared = max([min(self.data.x), self.qmin-offset]) 
    4444                self._qmax_unsmeared = min([max(self.data.x), self.qmax+offset]) 
    … …  
    6464         
    6565        """ 
    66         x,y = [numpy.asarray(v) for v in (self.x,self.y)] 
    67         if self.dy ==None or self.dy==[]: 
    68             dy= numpy.zeros(len(y))   
     66        x, y = [numpy.asarray(v) for v in (self.x, self.y)] 
     67        if self.dy == None or self.dy == []: 
     68            dy = numpy.zeros(len(y))   
    6969        else: 
    70             dy= numpy.asarray(dy) 
    71       
    72         dy[dy==0]=1 
    73         idx_unsmeared = (x>=self._qmin_unsmeared) & (x <= self._qmax_unsmeared) 
    74    
     70            dy = numpy.asarray(dy) 
     71        dy[dy == 0] = 1 
     72        idx_unsmeared = (x >= self._qmin_unsmeared) \ 
     73                        & (x <= self._qmax_unsmeared) 
    7574        # Compute theory data f(x) 
    76         idx=[] 
    77         tempy=[] 
    78         tempfx=[] 
    79         tempdy=[] 
    80      
     75        idx = [] 
     76        tempy = [] 
     77        tempfx = [] 
     78        tempdy = [] 
    8179        _first_bin = None 
    8280        for i_x in range(len(x)): 
    8381            try: 
    84                 if idx_unsmeared[i_x]==True: 
     82                if idx_unsmeared[i_x] == True: 
    8583                    if _first_bin is None: 
    8684                        _first_bin = i_x 
    8785                     
    88                     value= fn(x[i_x]) 
    89                     idx.append(x[i_x]>=self.qmin and x[i_x]<=self.qmax) 
     86                    value = fn(x[i_x]) 
     87                    idx.append(x[i_x] >= self.qmin and \ 
     88                                x[i_x] <= self.qmax) 
    9089                    tempfx.append( value) 
    9190                    tempy.append(y[i_x]) 
    … …  
    101100        
    102101        newy = numpy.asarray(tempy) 
    103         newfx= numpy.asarray(tempfx) 
    104         newdy= numpy.asarray(tempdy) 
     102        newfx = numpy.asarray(tempfx) 
     103        newdy = numpy.asarray(tempdy) 
    105104        
    106105        ## Sanity check 
    107         if numpy.size(newdy)!= numpy.size(newfx): 
    108             raise RuntimeError, "FitData1D: invalid error array %d <> %d" % (numpy.size(newdy), numpy.size(newfx)) 
    109  
    110         return (newy[idx]-newfx[idx])/newdy[idx] 
    111       
     106        if numpy.size(newdy) != numpy.size(newfx): 
     107            msg = "FitData1D: invalid error " 
     108            msg += "array %d <> %d" % (numpy.size(newdy), numpy.size(newfx)) 
     109            raise RuntimeError, msg 
     110        return (newy[idx] - newfx[idx]) / newdy[idx] 
    112111      
    113112    def residuals_alt(self, fn): 
    … …  
    137136        # Make sure the arrays are numpy arrays, which are 
    138137        # expected by the fitter. 
    139         x,y = [numpy.asarray(v) for v in (self.x,self.y)] 
    140         if self.dy ==None or self.dy==[]: 
    141             dy= numpy.zeros(len(y))   
     138        x, y = [numpy.asarray(v) for v in (self.x, self.y)] 
     139        if self.dy == None or self.dy == []: 
     140            dy = numpy.zeros(len(y))   
    142141        else: 
    143             dy= numpy.asarray(dy) 
    144       
    145         dy[dy==0]=1 
    146         idx = (x>=self.qmin) & (x <= self.qmax) 
    147         idx_unsmeared = (x>=self._qmin_unsmeared) & (x <= self._qmax_unsmeared) 
    148    
     142            dy = numpy.asarray(dy) 
     143        dy[dy ==0 ] = 1 
     144        idx = (x >= self.qmin) & (x <= self.qmax) 
     145        idx_unsmeared = (x >= self._qmin_unsmeared) \ 
     146                            & (x <= self._qmax_unsmeared) 
    149147        # Compute theory data f(x) 
    150         fx= numpy.zeros(len(x)) 
    151      
     148        fx = numpy.zeros(len(x)) 
    152149        # First and last bins of the array, corresponding to 
    153150        # the Q range to be smeared 
    … …  
    156153        for i_x in range(len(x)): 
    157154            try: 
    158                 if idx_unsmeared[i_x]==True: 
     155                if idx_unsmeared[i_x] == True: 
    159156                    if _first_bin is None: 
    160157                        _first_bin = i_x 
    161158                    else: 
    162159                        _last_bin  = i_x 
    163                      
    164160                    value = fn(x[i_x]) 
    165161                    fx[i_x] = value 
    … …  
    168164                ## Should properly log the error 
    169165                pass 
    170                   
    171166        # Smear theory data 
    172167        if self.smearer is not None: 
    173168            fx = self.smearer(fx, _first_bin, _last_bin) 
    174         
    175169        # Sanity check 
    176         if numpy.size(dy)!= numpy.size(fx): 
    177             raise RuntimeError, "FitData1D: invalid error array %d <> %d" % (numpy.size(dy), numpy.size(fx)) 
    178  
     170        if numpy.size(dy) != numpy.size(fx): 
     171            msg = "FitData1D: invalid error array" 
     172            msg += " %d <> %d" % (numpy.size(dy), numpy.size(fx)) 
     173 
     174            raise RuntimeError, msg 
    179175        # Return the residuals for the smeared (observed) Q range 
    180         return (y[idx]-fx[idx])/dy[idx] 
     176        return (y[idx] - fx[idx]) / dy[idx] 
    181177      
    182178# The following code belongs in DataLoader.qsmearing 
    … …  
    202198        """ 
    203199        # Sanity check 
    204         if len(iq)+first_bin > self.nbins: 
    205             raise RuntimeError, "Invalid I(q) vector: inconsistent array length %s > %s" % (str(len(iq)+first_bin), str(self.nbins)) 
     200        if len(iq) + first_bin > self.nbins: 
     201            msg = "Invalid I(q) vector: inconsistent array length " 
     202            msg += " %s > %s" % (str(len(iq) + first_bin), str(self.nbins)) 
     203            raise RuntimeError, msg 
    206204         
    207205        if self._weights == None: 
    … …  
    210208        iq_smeared = numpy.zeros(len(iq)) 
    211209        # Loop over q-values 
    212         idwb=[] 
     210        idwb = [] 
    213211         
    214212        for q_i in range(len(iq)): 
    … …  
    216214            counts = 0.0   
    217215            for i in range(len(iq)): 
    218                 if iq[i]==0 or self._weights[q_i+first_bin][i+first_bin]==0: 
     216                if iq[i] == 0 or \ 
     217                    self._weights[q_i+first_bin][i+first_bin] == 0: 
    219218                    continue 
    220219                else: 
    221220                    sum += iq[i] * self._weights[q_i+first_bin][i+first_bin]  
    222221                    counts += self._weights[q_i+first_bin][i+first_bin] 
    223              
    224222            if counts == 0: 
    225223                iq_smeared[q_i] = 0 
    226224            else: 
    227225                iq_smeared[q_i] = sum/counts  
    228         return iq_smeared               
     226        return iq_smeared    
     227     
     228            
Note: See TracChangeset for help on using the changeset viewer.