Changeset c4d6900 in sasview for park_integration


Ignore:
Timestamp:
Oct 27, 2010 2:07:46 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:
b0ab6cb
Parents:
7406040
Message:

working on pylint

Location:
park_integration
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • park_integration/AbstractFitEngine.py

    rb2f25dc5 rc4d6900  
    11 
    22import  copy 
    3 import logging 
    4 import sys 
     3#import logging 
     4#import sys 
    55import numpy 
    66import math 
    … …  
    2323         
    2424        """ 
     25        park.Parameter.__init__(self, name) 
    2526        self._model, self._name = model, name 
    2627        #set the value for the parameter of the given name 
    … …  
    4546        self._model.setParam(self.name, value) 
    4647         
    47     value = property(_getvalue,_setvalue) 
     48    value = property(_getvalue, _setvalue) 
    4849     
    4950    def _getrange(self): 
    … …  
    9596        self.sansp = sans_model.getParamList() 
    9697        #list of park parameter 
    97         self.parkp = [SansParameter(p,sans_model) for p in self.sansp] 
     98        self.parkp = [SansParameter(p, sans_model) for p in self.sansp] 
    9899        #list of parameterset  
    99100        self.parameterset = park.ParameterSet(sans_model.name, pars=self.parkp) 
    100101        self.pars = [] 
    101102   
    102     def getParams(self, fitparams): 
     103    def get_params(self, fitparams): 
    103104        """ 
    104105        return a list of value of paramter to fit 
    … …  
    107108         
    108109        """ 
    109         list = [] 
     110        list_params = [] 
    110111        self.pars = [] 
    111112        self.pars = fitparams 
    112113        for item in fitparams: 
    113114            for element in self.parkp: 
    114                  if element.name == str(item): 
    115                      list.append(element.value) 
    116         return list 
    117      
    118     def setParams(self, paramlist, params): 
     115                if element.name == str(item): 
     116                    list_params.append(element.value) 
     117        return list_params 
     118     
     119    def set_params(self, paramlist, params): 
    119120        """ 
    120121        Set value for parameters to fit 
    … …  
    143144        except: 
    144145            raise 
     146         
     147    def eval_derivs(self, x, pars=[]): 
     148        """ 
     149        Evaluate the model and derivatives wrt pars at x. 
     150 
     151        pars is a list of the names of the parameters for which derivatives 
     152        are desired. 
     153 
     154        This method needs to be specialized in the model to evaluate the 
     155        model function.  Alternatively, the model can implement is own 
     156        version of residuals which calculates the residuals directly 
     157        instead of calling eval. 
     158        """ 
     159        return [] 
     160 
    145161 
    146162     
    … …  
    174190         
    175191        self.smearer = smearer 
    176          
     192        self._first_unsmeared_bin = None 
     193        self._last_unsmeared_bin = None 
    177194        # Check error bar; if no error bar found, set it constant(=1) 
    178         # TODO: Should provide an option for users to set it like percent, constant, or dy data 
     195        # TODO: Should provide an option for users to set it like percent, 
     196        # constant, or dy data 
    179197        if dy == None or dy == [] or dy.all() == 0: 
    180198            self.dy = numpy.ones(len(y))   
    … …  
    200218                            & (self.x <= self._qmax_unsmeared) 
    201219   
    202     def setFitRange(self, qmin=None, qmax=None): 
     220    def set_fit_range(self, qmin=None, qmax=None): 
    203221        """ to set the fit range""" 
    204222        # Skip Q=0 point, (especially for y(q=0)=None at x[0]). 
    … …  
    218236        self._last_unsmeared_bin  = len(self.x) - 1 
    219237         
    220         if self.smearer!=None: 
     238        if self.smearer != None: 
    221239            self._first_unsmeared_bin, self._last_unsmeared_bin = \ 
    222240                    self.smearer.get_bin_range(self.qmin, self.qmax) 
    … …  
    231249                            & (self.x <= self._qmax_unsmeared) 
    232250   
    233     def getFitRange(self): 
     251    def get_fit_range(self): 
    234252        """ 
    235253        return the range of data.x to fit 
    … …  
    276294    """ Wrapper class  for SANS data """ 
    277295    def __init__(self, sans_data2d, data=None, err_data=None): 
    278         Data2D.__init__(self, data=data, err_data= err_data) 
     296        Data2D.__init__(self, data=data, err_data=err_data) 
    279297        """ 
    280298        Data can be initital with a data (sans plottable) 
    … …  
    286304        self.qmax = None 
    287305        self.smearer = None 
     306        self.radius = 0 
     307        self.res_err_data = [] 
    288308        self.set_data(sans_data2d) 
    289309 
    290          
    291310    def set_data(self, sans_data2d, qmin=None, qmax=None): 
    292311        """ 
    … …  
    322341        self.index_model = (self.index_model) & (numpy.isfinite(self.data)) 
    323342         
    324     def set_smearer(self,smearer):   
     343    def set_smearer(self, smearer):   
    325344        """ 
    326345        Set smearer 
    … …  
    332351        self.smearer.get_data() 
    333352 
    334     def setFitRange(self, qmin=None, qmax=None): 
     353    def set_fit_range(self, qmin=None, qmax=None): 
    335354        """ to set the fit range""" 
    336355        if qmin == 0.0: 
    … …  
    345364        self.index_model = (self.index_model) &(self.mask) 
    346365        self.index_model = (self.index_model) & (numpy.isfinite(self.data)) 
    347         self.index_model = (self.index_model) & (self.res_err_data!=0) 
    348          
    349     def getFitRange(self): 
     366        self.index_model = (self.index_model) & (self.res_err_data != 0) 
     367         
     368    def get_fit_range(self): 
    350369        """ 
    351370        return the range of data.x to fit 
    … …  
    407426        self.func_name = "Functor" 
    408427         
    409     def chisq(self, params): 
     428    #def chisq(self, params): 
     429    def chisq(self): 
    410430        """ 
    411431        Calculates chi^2 
    … …  
    418438        sum = 0 
    419439        for item in self.res: 
    420             sum += item*item 
    421         if len(self.res)==0: 
     440            sum += item * item 
     441        if len(self.res) == 0: 
    422442            return None 
    423         return sum/ len(self.res) 
    424      
    425     def __call__(self,params): 
     443        return sum / len(self.res) 
     444     
     445    def __call__(self, params): 
    426446        """ 
    427447        Compute residuals 
    … …  
    431451        """ 
    432452        #import thread 
    433         self.model.setParams(self.paramlist,params) 
     453        self.model.set_params(self.paramlist,params) 
    434454        self.res = self.data.residuals(self.model.eval) 
    435455        if self.fitresult is not None and  self.handler is not None: 
    436456            self.fitresult.set_model(model=self.model) 
    437             fitness = self.chisq(params=params) 
     457            #fitness = self.chisq(params=params) 
     458            fitness = self.chisq() 
    438459            self.fitresult.set_fitness(fitness=fitness) 
    439460            self.handler.set_result(result=self.fitresult) 
    … …  
    456477        #Dictionnary of fitArrange element (fit problems) 
    457478        self.fit_arrange_dict = {} 
    458          
    459     def _concatenateData(self, listdata=[]): 
    460         """   
    461         _concatenateData method concatenates each fields of all data  
    462         contains ins listdata. 
    463          
    464         :param listdata: list of data  
    465          
    466         :return Data: Data is wrapper class for sans plottable. 
    467          it is created with all parameters of data concatenanted 
    468              
    469         :raise: if listdata is empty  will return None 
    470         :raise: if data in listdata don't contain dy field , 
    471         will create an error during fitting 
    472              
    473         """ 
    474         #TODO: we have to refactor the way we handle data. 
    475         # We should move away from plottables and move towards the Data1D objects 
    476         # defined in DataLoader. Data1D allows data manipulations, which should be 
    477         # used to concatenate.  
    478         # In the meantime we should switch off the concatenation. 
    479         #if len(listdata)>1: 
    480         #    raise RuntimeError, "FitEngine._concatenateData: Multiple data files is not currently supported" 
    481         #return listdata[0] 
    482          
    483         if listdata == []: 
    484             raise ValueError, " data list missing" 
    485         else: 
    486             xtemp = [] 
    487             ytemp = [] 
    488             dytemp = [] 
    489             self.mini = None 
    490             self.maxi = None 
    491                 
    492             for item in listdata: 
    493                 data = item.data 
    494                 mini, maxi = data.getFitRange() 
    495                 if self.mini == None and self.maxi == None: 
    496                     self.mini = mini 
    497                     self.maxi = maxi 
    498                 else: 
    499                     if mini < self.mini: 
    500                         self.mini = mini 
    501                     if self.maxi < maxi: 
    502                         self.maxi = maxi 
    503                 for i in range(len(data.x)): 
    504                     xtemp.append(data.x[i]) 
    505                     ytemp.append(data.y[i]) 
    506                     if data.dy is not None and len(data.dy) == len(data.y):    
    507                         dytemp.append(data.dy[i]) 
    508                     else: 
    509                         msg = "Fit._concatenateData: y-errors missing" 
    510                         raise RuntimeError, msg 
    511             data = Data(x=xtemp, y=ytemp, dy=dytemp) 
    512             data.setFitRange(self.mini, self.maxi) 
    513             return data 
    514          
    515          
    516     def set_model(self, model, Uid, pars=[], constraints=[]): 
    517         """ 
    518         set a model on a given uid in the fit engine. 
     479   
     480    def set_model(self, model, id, pars=[], constraints=[]): 
     481        """ 
     482        set a model on a given  in the fit engine. 
    519483         
    520484        :param model: sans.models type  
    521         :param Uid: is the key of the fitArrange dictionary where model is  
     485        :param : is the key of the fitArrange dictionary where model is  
    522486                saved as a value 
    523487        :param pars: the list of parameters to fit  
    … …  
    549513                except: 
    550514                    msg = "Fit Engine: Error occurs when setting the constraint" 
    551                     msg += " %s for parameter %s "%(value, name) 
     515                    msg += " %s for parameter %s " % (value, name) 
    552516                    raise ValueError, msg 
    553517                 
    … …  
    566530                    raise ValueError, msg 
    567531               
    568             #A fitArrange is already created but contains dList only at Uid 
    569             if self.fit_arrange_dict.has_key(Uid): 
    570                 self.fit_arrange_dict[Uid].set_model(new_model) 
    571                 self.fit_arrange_dict[Uid].pars = pars 
     532            #A fitArrange is already created but contains data_list only at id 
     533            if self.fit_arrange_dict.has_key(id): 
     534                self.fit_arrange_dict[id].set_model(new_model) 
     535                self.fit_arrange_dict[id].pars = pars 
    572536            else: 
    573             #no fitArrange object has been create with this Uid 
     537            #no fitArrange object has been create with this id 
    574538                fitproblem = FitArrange() 
    575539                fitproblem.set_model(new_model) 
    576540                fitproblem.pars = pars 
    577                 self.fit_arrange_dict[Uid] = fitproblem 
     541                self.fit_arrange_dict[id] = fitproblem 
    578542                 
    579543        else: 
    580544            raise ValueError, "park_integration:missing parameters" 
    581545     
    582     def set_data(self, data, Uid, smearer=None, qmin=None, qmax=None): 
     546    def set_data(self, data, id, smearer=None, qmin=None, qmax=None): 
    583547        """  
    584548        Receives plottable, creates a list of data to fit,set data 
    585549        in a FitArrange object and adds that object in a dictionary  
    586         with key Uid. 
     550        with key id. 
    587551         
    588552        :param data: data added 
    589         :param Uid: unique key corresponding to a fitArrange object with data 
     553        :param id: unique key corresponding to a fitArrange object with data 
    590554         
    591555        """ 
    … …  
    597561                                 dx=data.dx, dy=data.dy, smearer=smearer) 
    598562        
    599         fitdata.setFitRange(qmin=qmin, qmax=qmax) 
    600         #A fitArrange is already created but contains model only at Uid 
    601         if self.fit_arrange_dict.has_key(Uid): 
    602             self.fit_arrange_dict[Uid].add_data(fitdata) 
     563        fitdata.set_fit_range(qmin=qmin, qmax=qmax) 
     564        #A fitArrange is already created but contains model only at id 
     565        if self.fit_arrange_dict.has_key(id): 
     566            self.fit_arrange_dict[id].add_data(fitdata) 
    603567        else: 
    604         #no fitArrange object has been create with this Uid 
     568        #no fitArrange object has been create with this id 
    605569            fitproblem = FitArrange() 
    606570            fitproblem.add_data(fitdata) 
    607             self.fit_arrange_dict[Uid] = fitproblem     
     571            self.fit_arrange_dict[id] = fitproblem     
    608572    
    609     def get_model(self, Uid): 
    610         """  
    611          
    612         :param Uid: Uid is key in the dictionary containing the model to return 
    613          
    614         :return:  a model at this uid or None if no FitArrange element was created 
    615             with this Uid 
    616              
    617         """ 
    618         if self.fit_arrange_dict.has_key(Uid): 
    619             return self.fit_arrange_dict[Uid].get_model() 
     573    def get_model(self, id): 
     574        """  
     575         
     576        :param id: id is key in the dictionary containing the model to return 
     577         
     578        :return:  a model at this id or None if no FitArrange element was  
     579            created with this id 
     580             
     581        """ 
     582        if self.fit_arrange_dict.has_key(id): 
     583            return self.fit_arrange_dict[id].get_model() 
    620584        else: 
    621585            return None 
    622586     
    623     def remove_Fit_Problem(self, Uid): 
    624         """remove   fitarrange in Uid""" 
    625         if self.fit_arrange_dict.has_key(Uid): 
    626             del self.fit_arrange_dict[Uid] 
    627              
    628     def select_problem_for_fit(self, Uid, value): 
    629         """ 
    630         select a couple of model and data at the Uid position in dictionary 
     587    def remove_fit_problem(self, id): 
     588        """remove   fitarrange in id""" 
     589        if self.fit_arrange_dict.has_key(id): 
     590            del self.fit_arrange_dict[id] 
     591             
     592    def select_problem_for_fit(self, id, value): 
     593        """ 
     594        select a couple of model and data at the id position in dictionary 
    631595        and set in self.selected value to value 
    632596         
    … …  
    635599                 
    636600        """ 
    637         if self.fit_arrange_dict.has_key(Uid): 
    638              self.fit_arrange_dict[Uid].set_to_fit(value) 
     601        if self.fit_arrange_dict.has_key(id): 
     602            self.fit_arrange_dict[id].set_to_fit(value) 
    639603              
    640     def get_problem_to_fit(self, Uid): 
    641         """ 
    642         return the self.selected value of the fit problem of Uid 
    643          
    644         :param Uid: the Uid of the problem 
    645          
    646         """ 
    647         if self.fit_arrange_dict.has_key(Uid): 
    648              self.fit_arrange_dict[Uid].get_to_fit() 
     604    def get_problem_to_fit(self, id): 
     605        """ 
     606        return the self.selected value of the fit problem of id 
     607         
     608        :param id: the id of the problem 
     609         
     610        """ 
     611        if self.fit_arrange_dict.has_key(id): 
     612            self.fit_arrange_dict[id].get_to_fit() 
    649613     
    650614class FitArrange: 
    … …  
    660624        """ 
    661625        self.model = None 
    662         self.dList = [] 
     626        self.data_list = [] 
    663627        self.pars = [] 
    664628        #self.selected  is zero when this fit problem is not schedule to fit  
    … …  
    677641    def add_data(self, data): 
    678642        """  
    679         add_data fill a self.dList with data to fit 
     643        add_data fill a self.data_list with data to fit 
    680644         
    681645        :param data: Data to add in the list   
    682646         
    683647        """ 
    684         if not data in self.dList: 
    685             self.dList.append(data) 
     648        if not data in self.data_list: 
     649            self.data_list.append(data) 
    686650             
    687651    def get_model(self): 
    … …  
    696660        """  
    697661         
    698         :return: list of data dList 
    699          
    700         """ 
    701         #return self.dList  
    702         return self.dList[0]  
     662        :return: list of data data_list 
     663         
     664        """ 
     665        #return self.data_list  
     666        return self.data_list[0]  
    703667       
    704668    def remove_data(self, data): 
    … …  
    706670        Remove one element from the list 
    707671         
    708         :param data: Data to remove from dList 
    709          
    710         """ 
    711         if data in self.dList: 
    712             self.dList.remove(data) 
     672        :param data: Data to remove from data_list 
     673         
     674        """ 
     675        if data in self.data_list: 
     676            self.data_list.remove(data) 
    713677             
    714678    def set_to_fit (self, value=0): 

  • park_integration/Fitting.py

    r89f3b66 rc4d6900  
    66 
    77#from scipy import optimize 
    8 from ScipyFitting import ScipyFit 
    9 from ParkFitting import ParkFit 
     8from sans.fit.ScipyFitting import ScipyFit 
     9from sans.fit.ParkFitting import ParkFit 
    1010 
    1111 
    … …  
    1919        fitter.fit_engine('scipy') or fitter.fit_engine('park') 
    2020        engine = fitter.returnEngine() 
    21         engine.set_data(data,Uid) 
     21        engine.set_data(data,id) 
    2222        engine.set_param( model,model.name, pars) 
    23         engine.set_model(model,Uid) 
     23        engine.set_model(model,id) 
    2424         
    2525        chisqr1, out1, cov1=engine.fit(pars,qmin,qmax) 
    … …  
    4646            self._engine = ScipyFit() 
    4747        elif word == "park": 
    48             self._engine=ParkFit() 
     48            self._engine = ParkFit() 
    4949        else: 
    5050            raise ValueError, "enter the keyword scipy or park" 
    … …  
    5252    def fit(self, q=None, handler=None, curr_thread=None): 
    5353        """Perform the fit """ 
    54         try: 
    55             return self._engine.fit(q,handler, curr_thread=curr_thread) 
    56         except: 
    57             raise 
     54        #try: 
     55        return self._engine.fit(q, handler, curr_thread=curr_thread) 
     56        #except: 
     57        #    raise 
    5858     
    59     def set_model(self, model, Uid, pars=[], constraints=[]): 
     59    def set_model(self, model, id, pars=[], constraints=[]): 
    6060        """ 
    61         store a model model to fit at the position Uid of the fit engine 
     61        store a model model to fit at the position id of the fit engine 
    6262        """ 
    63         self._engine.set_model(model, Uid, pars, constraints) 
     63        self._engine.set_model(model, id, pars, constraints) 
    6464    
    65     def set_data(self, data, Uid, smearer=None, qmin=None, qmax=None): 
     65    def set_data(self, data, id, smearer=None, qmin=None, qmax=None): 
    6666        """ 
    67         Store data to fit at the psotion Uid of the fit engine 
     67        Store data to fit at the psotion id of the fit engine 
    6868         
    6969        :param data: data to fit 
    … …  
    7373         
    7474        """ 
    75         self._engine.set_data(data, Uid, smearer, qmin, qmax) 
     75        self._engine.set_data(data, id, smearer, qmin, qmax) 
    7676         
    77     def get_model(self, Uid): 
     77    def get_model(self, id): 
    7878        """ return list of data""" 
    79         self._engine.get_model(Uid) 
     79        self._engine.get_model(id) 
    8080 
    8181 
    82     def remove_Fit_Problem(self, Uid): 
    83         """remove fitarrange in Uid""" 
    84         self._engine.remove_Fit_Problem(Uid) 
     82    def remove_fit_problem(self, id): 
     83        """remove fitarrange in id""" 
     84        self._engine.remove_fit_problem(id) 
    8585         
    86     def select_problem_for_fit(self, Uid, value): 
     86    def select_problem_for_fit(self, id, value): 
    8787        """ 
    88         select a couple of model and data at the Uid position in dictionary 
     88        select a couple of model and data at the id position in dictionary 
    8989        and set in self.selected value to value 
    9090         
    … …  
    9292             can only have the value one or zero 
    9393        """ 
    94         self._engine.select_problem_for_fit(Uid, value) 
     94        self._engine.select_problem_for_fit(id, value) 
    9595         
    96     def get_problem_to_fit(self, Uid): 
     96    def get_problem_to_fit(self, id): 
    9797        """ 
    98         return the self.selected value of the fit problem of Uid 
     98        return the self.selected value of the fit problem of id 
    9999            
    100         :param Uid: the Uid of the problem 
     100        :param id: the id of the problem 
    101101         
    102102        """ 
    103         return self._engine.get_problem_to_fit(Uid) 
     103        return self._engine.get_problem_to_fit(id) 

  • park_integration/Loader.py

    r89f3b66 rc4d6900  
    33#import string 
    44import numpy 
     5 
    56class Load: 
    67    """ 
    … …  
    89    """ 
    910     
    10     def _init_(self, x=None, y=None, dx=None, dy=None): 
     11    def __init__(self, x=None, y=None, dx=None, dy=None): 
    1112        # variable to store loaded values 
    1213        self.x = x 
    … …  
    1819    def set_filename(self, path=None): 
    1920        """ 
    20         Store path into a variable.If the user doesn't give a path as a parameter a pop-up 
     21        Store path into a variable.If the user doesn't give  
     22        a path as a parameter a pop-up 
    2123        window appears to select the file. 
    2224         
    … …  
    5355                except: 
    5456                    print "READ ERROR", line 
    55              
    56              
    5757            # Sanity check 
    5858            if not len(self.x) == len(self.dx): 

  • park_integration/ScipyFitting.py

    rb2f25dc5 rc4d6900  
    1212from sans.fit.AbstractFitEngine import FitEngine 
    1313from sans.fit.AbstractFitEngine import SansAssembly 
    14 from sans.fit.AbstractFitEngine import FitAbort 
     14#from sans.fit.AbstractFitEngine import FitAbort 
    1515 
    1616class fitresult(object): 
    … …  
    1818    Storing fit result 
    1919    """ 
    20     def __init__(self, model=None, paramList=None): 
     20    def __init__(self, model=None, param_list=None): 
    2121        self.calls = None 
    2222        self.fitness = None 
    … …  
    3030        self.parameters = None 
    3131        self.model = model 
    32         self.param_list = paramList 
     32        self.param_list = param_list 
    3333      
    3434    def set_model(self, model): 
    … …  
    5050 
    5151        result_param = zip(xrange(n), self.model.parameterset) 
    52         L = ["P%-3d  %s......|.....%s"%(p[0], p[1], p[1].value)\ 
     52        msg = ["P%-3d  %s......|.....%s" % (p[0], p[1], p[1].value)\ 
    5353              for p in result_param if p[1].name in self.param_list] 
    54         L.append("=== goodness of fit: %s" % (str(self.fitness))) 
    55         return "\n".join(L) 
     54        msg.append("=== goodness of fit: %s" % (str(self.fitness))) 
     55        return "\n".join(msg) 
    5656     
    5757    def print_summary(self): 
    … …  
    9595        self.fit_arrange_dict = {} 
    9696        self.param_list = [] 
     97        self.curr_thread = None 
    9798    #def fit(self, *args, **kw): 
    9899    #    return profile(self._fit, *args, **kw) 
    … …  
    102103        """ 
    103104        fitproblem = [] 
    104         for id, fproblem in self.fit_arrange_dict.iteritems(): 
     105        for fproblem in self.fit_arrange_dict.itervalues(): 
    105106            if fproblem.get_to_fit() == 1: 
    106107                fitproblem.append(fproblem) 
    … …  
    119120        data = listdata 
    120121        self.curr_thread = curr_thread 
    121         result = fitresult(model=model, paramList=self.param_list) 
     122        result = fitresult(model=model, param_list=self.param_list) 
    122123        if handler is not None: 
    123124            handler.set_result(result=result) 
    … …  
    125126        functor = SansAssembly(self.param_list, model, data, handler=handler, 
    126127                         fitresult=result, curr_thread= self.curr_thread) 
    127         
    128         
    129         out, cov_x, info, mesg, success = optimize.leastsq(functor, 
    130                                                 model.getParams(self.param_list), 
    131                                                     full_output=1, warning=True) 
     128        out, cov_x, _, _, success = optimize.leastsq(functor, 
     129                                            model.get_params(self.param_list), 
     130                                                    full_output=1, 
     131                                                    warning=True) 
    132132         
    133         chisqr = functor.chisq(out) 
    134          
     133        #chisqr = functor.chisq(out) 
     134        chisqr = functor.chisq() 
    135135        if cov_x is not None and numpy.isfinite(cov_x).all(): 
    136136            stderr = numpy.sqrt(numpy.diag(cov_x)) 
    137137        else: 
    138138            stderr = None 
    139         if not (numpy.isnan(out).any()) or ( cov_x !=None) : 
    140                 result.fitness = chisqr 
    141                 result.stderr  = stderr 
    142                 result.pvec = out 
    143                 result.success = success 
    144                 #print result 
    145                 if q is not None: 
    146                     #print "went here" 
    147                     q.put(result) 
    148                     #print "get q scipy fit enfine",q.get() 
    149                     return q 
    150                 return result 
     139        if not (numpy.isnan(out).any()) or (cov_x != None): 
     140            result.fitness = chisqr 
     141            result.stderr  = stderr 
     142            result.pvec = out 
     143            result.success = success 
     144            #print result 
     145            if q is not None: 
     146                #print "went here" 
     147                q.put(result) 
     148                #print "get q scipy fit enfine",q.get() 
     149                return q 
     150            return result 
    151151        else:   
    152152            raise ValueError, "SVD did not converge" + str(success) 
    … …  
    154154 
    155155 
    156 def profile(fn, *args, **kw): 
    157     import cProfile, pstats, os 
    158     global call_result 
    159     def call(): 
    160         global call_result 
    161         call_result = fn(*args, **kw) 
    162     cProfile.runctx('call()', dict(call=call), {}, 'profile.out') 
    163     stats = pstats.Stats('profile.out') 
    164     #stats.sort_stats('time') 
    165     stats.sort_stats('calls') 
    166     stats.print_stats() 
    167     os.unlink('profile.out') 
    168     return call_result 
     156#def profile(fn, *args, **kw): 
     157#    import cProfile, pstats, os 
     158#    global call_result 
     159#   def call(): 
     160#        global call_result 
     161#        call_result = fn(*args, **kw) 
     162#    cProfile.runctx('call()', dict(call=call), {}, 'profile.out') 
     163#    stats = pstats.Stats('profile.out') 
     164#    stats.sort_stats('time') 
     165#    stats.sort_stats('calls') 
     166#    stats.print_stats() 
     167#    os.unlink('profile.out') 
     168#    return call_result 
    169169 
    170170       
Note: See TracChangeset for help on using the changeset viewer.