Changeset b2f25dc5 in sasview for park_integration


Ignore:
Timestamp:
Oct 20, 2010 4:53:49 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:
67e258c
Parents:
d2539aa
Message:

working on pylint

Location:
park_integration
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • park_integration/AbstractFitEngine.py

    r89f3b66 rb2f25dc5  
    99from DataLoader.data_info import Data2D 
    1010 
     11     
     12     
    1113class SansParameter(park.Parameter): 
    1214    """ 
    … …  
    6264         
    6365        return lo, hi 
     66     
     67    def get_name(self): 
     68        """ 
     69        """ 
     70        return self._getname() 
    6471     
    6572    def _setrange(self, r): 
    … …  
    446453        """ 
    447454        #List of parameter names to fit 
    448         self.paramList=[] 
     455        self.param_list = [] 
    449456        #Dictionnary of fitArrange element (fit problems) 
    450         self.fitArrangeDict={} 
     457        self.fit_arrange_dict = {} 
    451458         
    452459    def _concatenateData(self, listdata=[]): 
    … …  
    550557                if item in new_model.model.getParamList(): 
    551558                    temp.append(item) 
    552                     self.paramList.append(item) 
     559                    self.param_list.append(item) 
    553560                else: 
    554561                     
    … …  
    560567               
    561568            #A fitArrange is already created but contains dList only at Uid 
    562             if self.fitArrangeDict.has_key(Uid): 
    563                 self.fitArrangeDict[Uid].set_model(new_model) 
    564                 self.fitArrangeDict[Uid].pars = pars 
     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 
    565572            else: 
    566573            #no fitArrange object has been create with this Uid 
    … …  
    568575                fitproblem.set_model(new_model) 
    569576                fitproblem.pars = pars 
    570                 self.fitArrangeDict[Uid] = fitproblem 
     577                self.fit_arrange_dict[Uid] = fitproblem 
    571578                 
    572579        else: 
    … …  
    592599        fitdata.setFitRange(qmin=qmin, qmax=qmax) 
    593600        #A fitArrange is already created but contains model only at Uid 
    594         if self.fitArrangeDict.has_key(Uid): 
    595             self.fitArrangeDict[Uid].add_data(fitdata) 
     601        if self.fit_arrange_dict.has_key(Uid): 
     602            self.fit_arrange_dict[Uid].add_data(fitdata) 
    596603        else: 
    597604        #no fitArrange object has been create with this Uid 
    598605            fitproblem = FitArrange() 
    599606            fitproblem.add_data(fitdata) 
    600             self.fitArrangeDict[Uid] = fitproblem     
     607            self.fit_arrange_dict[Uid] = fitproblem     
    601608    
    602609    def get_model(self, Uid): 
    … …  
    609616             
    610617        """ 
    611         if self.fitArrangeDict.has_key(Uid): 
    612             return self.fitArrangeDict[Uid].get_model() 
     618        if self.fit_arrange_dict.has_key(Uid): 
     619            return self.fit_arrange_dict[Uid].get_model() 
    613620        else: 
    614621            return None 
    … …  
    616623    def remove_Fit_Problem(self, Uid): 
    617624        """remove   fitarrange in Uid""" 
    618         if self.fitArrangeDict.has_key(Uid): 
    619             del self.fitArrangeDict[Uid] 
     625        if self.fit_arrange_dict.has_key(Uid): 
     626            del self.fit_arrange_dict[Uid] 
    620627             
    621628    def select_problem_for_fit(self, Uid, value): 
    … …  
    628635                 
    629636        """ 
    630         if self.fitArrangeDict.has_key(Uid): 
    631              self.fitArrangeDict[Uid].set_to_fit(value) 
     637        if self.fit_arrange_dict.has_key(Uid): 
     638             self.fit_arrange_dict[Uid].set_to_fit(value) 
    632639              
    633640    def get_problem_to_fit(self, Uid): 
    … …  
    638645         
    639646        """ 
    640         if self.fitArrangeDict.has_key(Uid): 
    641              self.fitArrangeDict[Uid].get_to_fit() 
     647        if self.fit_arrange_dict.has_key(Uid): 
     648             self.fit_arrange_dict[Uid].get_to_fit() 
    642649     
    643650class FitArrange: 

  • park_integration/ParkFitting.py

    r89f3b66 rb2f25dc5  
    44""" 
    55ParkFitting module contains SansParameter,Model,Data 
    6 FitArrange, ParkFit,Parameter classes.All listed classes work together to perform a  
    7 simple fit with park optimizer. 
     6FitArrange, ParkFit,Parameter classes.All listed classes work together 
     7to perform a simple fit with park optimizer. 
    88""" 
    99#import time 
    1010#import numpy 
    11 import park 
    12 from park import fit, fitresult 
    13 from park import assembly 
    14 from park.fitmc import FitSimplex, FitMC 
     11#import park 
     12from park import fit 
     13from park import fitresult 
     14from park.assembly import Assembly 
     15from park.fitmc import FitSimplex  
     16from park.fitmc import FitMC 
    1517 
    1618#from Loader import Load 
    17 from AbstractFitEngine import FitEngine 
     19from sans.fit.AbstractFitEngine import FitEngine 
    1820 
    1921 
    … …  
    3638    engine.set_param( model,"M1", {'A':2,'B':4}) 
    3739     
    38     Add model with a dictionnary of FitArrangeList{} where Uid is a key and model 
     40    Add model with a dictionnary of FitArrangeList{} where Uid is a key 
     41    and model 
    3942    is save in FitArrange object. 
    4043    engine.set_model(model,Uid) 
    … …  
    5255        with Uid as keys 
    5356        """ 
    54         self.fitArrangeDict = {} 
    55         self.paramList = [] 
     57        FitEngine.__init__(self) 
     58        self.fit_arrange_dict = {} 
     59        self.param_list = [] 
    5660         
    57     def createAssembly(self): 
     61    def create_assembly(self): 
    5862        """ 
    59         Extract sansmodel and sansdata from self.FitArrangelist ={Uid:FitArrange} 
    60         Create parkmodel and park data ,form a list couple of parkmodel and parkdata 
     63        Extract sansmodel and sansdata from  
     64        self.FitArrangelist ={Uid:FitArrange} 
     65        Create parkmodel and park data ,form a list couple of parkmodel  
     66        and parkdata 
    6167        create an assembly self.problem=  park.Assembly([(parkmodel,parkdata)]) 
    6268        """ 
    6369        mylist = [] 
    64         listmodel = [] 
    65         i = 0 
     70        #listmodel = [] 
     71        #i = 0 
    6672        fitproblems = [] 
    67         for id,fproblem in self.fitArrangeDict.iteritems(): 
     73        for fproblem in self.fit_arrange_dict.itervalues(): 
    6874            if fproblem.get_to_fit() == 1: 
    6975                fitproblems.append(fproblem) 
    … …  
    7682                ## does not allow status change for constraint parameters 
    7783                if p.status != 'computed': 
    78                     if p._getname()in item.pars: 
    79                         ## make parameters selected for fit will be between boundaries 
     84                    if p.get_name()in item.pars: 
     85                        ## make parameters selected for  
     86                        #fit will be between boundaries 
    8087                        p.set(p.range)          
    8188                    else: 
    8289                        p.status = 'fixed' 
    83             i += 1 
    84             Ldata = item.get_data() 
     90            #i += 1 
     91            data_list = item.get_data() 
    8592            #parkdata=self._concatenateData(Ldata) 
    86             parkdata = Ldata 
     93            parkdata = data_list 
    8794            fitness = (parkmodel, parkdata) 
    8895            mylist.append(fitness) 
    89         self.problem = park.Assembly(mylist) 
     96        self.problem = Assembly(mylist) 
    9097         
    9198    def fit(self, q=None, handler=None, curr_thread=None): 
    … …  
    93100        Performs fit with park.fit module.It can  perform fit with one model 
    94101        and a set of data, more than two fit of  one model and sets of data or  
    95         fit with more than two model associated with their set of data and constraints 
     102        fit with more than two model associated with their set of data and  
     103        constraints 
    96104         
    97         :param pars: Dictionary of parameter names for the model and their values. 
     105        :param pars: Dictionary of parameter names for the model and their  
     106            values. 
    98107        :param qmin: The minimum value of data's range to be fit 
    99108        :param qmax: The maximum value of data's range to be fit 
    100109         
    101         :note: all parameter are ignored most of the time.Are just there to keep ScipyFit 
    102             and ParkFit interface the same. 
     110        :note: all parameter are ignored most of the time.Are just there  
     111            to keep ScipyFit and ParkFit interface the same. 
    103112             
    104113        :return: result.fitness Value of the goodness of fit metric 
    105         :return: result.pvec list of parameter with the best value found during fitting 
     114        :return: result.pvec list of parameter with the best value  
     115            found during fitting 
    106116        :return: result.cov Covariance matrix 
    107117         
    108118        """ 
    109         self.createAssembly() 
     119        self.create_assembly() 
    110120        localfit = FitSimplex() 
    111121        localfit.ftol = 1e-8 

  • park_integration/ScipyFitting.py

    r89f3b66 rb2f25dc5  
    1010from scipy import optimize 
    1111 
    12 from AbstractFitEngine import FitEngine, SansAssembly, FitAbort 
     12from sans.fit.AbstractFitEngine import FitEngine 
     13from sans.fit.AbstractFitEngine import SansAssembly 
     14from sans.fit.AbstractFitEngine import FitAbort 
    1315 
    1416class fitresult(object): 
    … …  
    2830        self.parameters = None 
    2931        self.model = model 
    30         self.paramList = paramList 
     32        self.param_list = paramList 
    3133      
    3234    def set_model(self, model): 
    … …  
    4345        """ 
    4446        """ 
    45         if self.pvec == None and self.model is None and self.paramList is None: 
     47        if self.pvec == None and self.model is None and self.param_list is None: 
    4648            return "No results" 
    4749        n = len(self.model.parameterset) 
    … …  
    4951        result_param = zip(xrange(n), self.model.parameterset) 
    5052        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] 
     53              for p in result_param if p[1].name in self.param_list] 
    5254        L.append("=== goodness of fit: %s" % (str(self.fitness))) 
    5355        return "\n".join(L) 
    … …  
    8789    def __init__(self): 
    8890        """ 
    89         Creates a dictionary (self.fitArrangeDict={})of FitArrange elements 
     91        Creates a dictionary (self.fit_arrange_dict={})of FitArrange elements 
    9092        with Uid as keys 
    9193        """ 
    92         self.fitArrangeDict = {} 
    93         self.paramList = [] 
     94        FitEngine.__init__(self) 
     95        self.fit_arrange_dict = {} 
     96        self.param_list = [] 
    9497    #def fit(self, *args, **kw): 
    9598    #    return profile(self._fit, *args, **kw) 
    … …  
    99102        """ 
    100103        fitproblem = [] 
    101         for id, fproblem in self.fitArrangeDict.iteritems(): 
     104        for id, fproblem in self.fit_arrange_dict.iteritems(): 
    102105            if fproblem.get_to_fit() == 1: 
    103106                fitproblem.append(fproblem) 
    … …  
    116119        data = listdata 
    117120        self.curr_thread = curr_thread 
    118         result = fitresult(model=model, paramList=self.paramList) 
     121        result = fitresult(model=model, paramList=self.param_list) 
    119122        if handler is not None: 
    120123            handler.set_result(result=result) 
    121124        #try: 
    122         functor = SansAssembly(self.paramList, model, data, handler=handler, 
     125        functor = SansAssembly(self.param_list, model, data, handler=handler, 
    123126                         fitresult=result, curr_thread= self.curr_thread) 
    124127        
    125128        
    126129        out, cov_x, info, mesg, success = optimize.leastsq(functor, 
    127                                                 model.getParams(self.paramList), 
     130                                                model.getParams(self.param_list), 
    128131                                                    full_output=1, warning=True) 
    129132         
Note: See TracChangeset for help on using the changeset viewer.