Changeset 7fdb332 in sasview for sansmodels


Ignore:
Timestamp:
Jul 26, 2012 11:47:53 AM (12 years ago)
Author:
Jae Cho <jhjcho@…>
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:
48c547b
Parents:
f1e0c1eb
Message:

pylint cleanups

Location:
sansmodels/src/sans/models
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • sansmodels/src/sans/models/BaseComponent.py

    r4ce74b44 r7fdb332  
    3232        # string containing information about the model such as the equation 
    3333        #of the given model, exception or possible use 
    34         self.description='' 
     34        self.description = '' 
    3535        #list of parameter that can be fitted 
    3636        self.fixed = [] 
     
    6666        #return self.params[str(par_name)].is_fittable() 
    6767    
    68     def run(self, x): return NotImplemented 
    69     def runXY(self, x): return NotImplemented   
    70     def calculate_ER(self): return NotImplemented   
    71     def calculate_VR(self): return NotImplemented  
     68    def run(self, x):  
     69        """ 
     70        run 1d 
     71        """ 
     72        return NotImplemented 
     73     
     74    def runXY(self, x):  
     75        """ 
     76        run 2d 
     77        """ 
     78        return NotImplemented   
     79     
     80    def calculate_ER(self):  
     81        """ 
     82        Calculate effective radius 
     83        """ 
     84        return NotImplemented   
     85     
     86    def calculate_VR(self):  
     87        """ 
     88        Calculate volume fraction ratio 
     89        """ 
     90        return NotImplemented  
     91     
    7292    def evalDistribution(self, qdist): 
    7393        """ 
     
    112132                qdist[0].__class__.__name__ != 'ndarray' or \ 
    113133                qdist[1].__class__.__name__ != 'ndarray': 
    114                     raise RuntimeError, "evalDistribution expects a list of 2 ndarrays" 
     134                msg = "evalDistribution expects a list of 2 ndarrays" 
     135                raise RuntimeError, msg 
    115136                 
    116137            # Extract qx and qy for code clarity 
     
    121142            q = numpy.sqrt(qx**2+qy**2) 
    122143            # vectorize the model function runXY 
    123             v_model = numpy.vectorize(self.runXY,otypes=[float]) 
     144            v_model = numpy.vectorize(self.runXY, otypes=[float]) 
    124145            # calculate the scattering 
    125146            iq_array = v_model(q) 
     
    128149                 
    129150        elif qdist.__class__.__name__ == 'ndarray': 
    130                 # We have a simple 1D distribution of q-values 
    131                 v_model = numpy.vectorize(self.runXY,otypes=[float]) 
    132                 iq_array = v_model(qdist) 
    133  
    134                 return iq_array 
     151            # We have a simple 1D distribution of q-values 
     152            v_model = numpy.vectorize(self.runXY, otypes=[float]) 
     153            iq_array = v_model(qdist) 
     154            return iq_array 
    135155             
    136156        else: 
     
    246266     
    247267    # Old-style methods that are no longer used 
    248     def setParamWithToken(self, name, value, token, member): return NotImplemented 
    249     def getParamWithToken(self, name, token, member): return NotImplemented 
    250     def getParamListWithToken(self, token, member): return NotImplemented 
    251     def __add__(self, other): raise ValueError, "Model operation are no longer supported" 
    252     def __sub__(self, other): raise ValueError, "Model operation are no longer supported" 
    253     def __mul__(self, other): raise ValueError, "Model operation are no longer supported" 
    254     def __div__(self, other): raise ValueError, "Model operation are no longer supported" 
    255          
     268    def setParamWithToken(self, name, value, token, member):  
     269        """ 
     270        set Param With Token 
     271        """ 
     272        return NotImplemented 
     273    def getParamWithToken(self, name, token, member):  
     274        """ 
     275        get Param With Token 
     276        """ 
     277        return NotImplemented 
     278     
     279    def getParamListWithToken(self, token, member):  
     280        """ 
     281        get Param List With Token 
     282        """ 
     283        return NotImplemented 
     284    def __add__(self, other):  
     285        """ 
     286        add 
     287        """ 
     288        raise ValueError, "Model operation are no longer supported" 
     289    def __sub__(self, other):  
     290        """ 
     291        sub 
     292        """ 
     293        raise ValueError, "Model operation are no longer supported" 
     294    def __mul__(self, other):  
     295        """ 
     296        mul 
     297        """ 
     298        raise ValueError, "Model operation are no longer supported" 
     299    def __div__(self, other):  
     300        """ 
     301        div 
     302        """ 
     303        raise ValueError, "Model operation are no longer supported" 
     304         
  • sansmodels/src/sans/models/MultiplicationModel.py

    ra8a55f2 r7fdb332  
    11 
    22from sans.models.BaseComponent import BaseComponent 
    3 import numpy, math 
     3#import numpy, math 
    44import copy 
    5 from sans.models.pluginmodel import Model1DPlugin 
     5#from sans.models.pluginmodel import Model1DPlugin 
    66class MultiplicationModel(BaseComponent): 
    77    """ 
     
    1717        BaseComponent.__init__(self) 
    1818        """ 
    19             @param p_model: form factor, P(Q) 
    20             @param s_model: structure factor, S(Q) 
     19        :param p_model: form factor, P(Q) 
     20        :param s_model: structure factor, S(Q) 
    2121        """ 
    2222 
    2323        ## Setting  model name model description 
    24         self.description="" 
     24        self.description = "" 
    2525        self.name = p_model.name +" * "+ s_model.name 
    26         self.description= self.name+"\n" 
     26        self.description= self.name + "\n" 
    2727        self.fill_description(p_model, s_model) 
    2828 
     
    3434         
    3535        ##models  
    36         self.p_model= p_model 
    37         self.s_model= s_model         
     36        self.p_model = p_model 
     37        self.s_model = s_model         
    3838        
    3939        ## dispersion 
     
    100100        ##set dispersion only from p_model  
    101101        for name , value in self.p_model.dispersion.iteritems(): 
    102             self.dispersion[name]= value  
     102            self.dispersion[name] = value  
    103103                                       
    104104    def getProfile(self): 
     
    111111        """ 
    112112        try: 
    113             x,y = self.p_model.getProfile() 
     113            x, y = self.p_model.getProfile() 
    114114        except: 
    115115            x = None 
     
    126126        for name , value in self.p_model.params.iteritems(): 
    127127            if not name in self.params.keys() and name != 'scale': 
    128                 self.params[name]= value 
     128                self.params[name] = value 
    129129             
    130130        for name , value in self.s_model.params.iteritems(): 
    131131            #Remove the effect_radius from the (P*S) model parameters. 
    132132            if not name in self.params.keys() and name != 'effect_radius': 
    133                 self.params[name]= value 
     133                self.params[name] = value 
    134134                 
    135135        # Set "scale and effec_radius to P and S model as initializing 
     
    143143            this model details  
    144144        """ 
    145         for name ,detail in self.p_model.details.iteritems(): 
     145        for name, detail in self.p_model.details.iteritems(): 
    146146            if name != 'scale': 
    147                 self.details[name]= detail 
     147                self.details[name] = detail 
    148148             
    149149        for name , detail in self.s_model.details.iteritems(): 
    150150            if not name in self.details.keys() or name != 'effect_radius': 
    151                 self.details[name]= detail 
     151                self.details[name] = detail 
    152152     
    153153    def _set_scale_factor(self): 
     
    159159            factor = self.p_model.calculate_VR() 
    160160            if factor == None or factor == NotImplemented or factor == 0.0: 
    161                 val= value 
     161                val = value 
    162162            else: 
    163163                val = value / factor 
     
    174174        #Reset the effective_radius of s_model just before the run 
    175175        if effective_radius != None and effective_radius != NotImplemented: 
    176             self.s_model.setParam('effect_radius',effective_radius) 
     176            self.s_model.setParam('effect_radius', effective_radius) 
    177177                 
    178178    def setParam(self, name, value): 
    179179        """  
    180             Set the value of a model parameter 
    181          
    182             @param name: name of the parameter 
    183             @param value: value of the parameter 
     180        Set the value of a model parameter 
     181         
     182        :param name: name of the parameter 
     183        :param value: value of the parameter 
    184184        """ 
    185185        # set param to P*S model 
     
    237237                 
    238238    def run(self, x = 0.0): 
    239         """ Evaluate the model 
    240             @param x: input q-value (float or [float, float] as [r, theta]) 
    241             @return: (scattering function value) 
     239        """  
     240        Evaluate the model 
     241        :param x: input q-value (float or [float, float] as [r, theta]) 
     242        :return: (scattering function value) 
    242243        """ 
    243244        # set effective radius and scaling factor before run 
    244245        self._set_effect_radius() 
    245246        self._set_scale_factor() 
    246         return self.params['scale_factor']*self.p_model.run(x)*self.s_model.run(x) 
     247        return self.params['scale_factor'] * self.p_model.run(x) * \ 
     248                            self.s_model.run(x) 
    247249 
    248250    def runXY(self, x = 0.0): 
     
    254256        self._set_effect_radius() 
    255257        self._set_scale_factor() 
    256         return self.params['scale_factor']*self.p_model.runXY(x)* self.s_model.runXY(x) 
     258        out = self.params['scale_factor'] * self.p_model.runXY(x) * \ 
     259                        self.s_model.runXY(x) 
     260        return out 
    257261     
    258262    ## Now (May27,10) directly uses the model eval function  
    259263    ## instead of the for-loop in Base Component. 
    260264    def evalDistribution(self, x = []): 
    261         """ Evaluate the model in cartesian coordinates 
    262             @param x: input q[], or [qx[], qy[]] 
    263             @return: scattering function P(q[]) 
     265        """  
     266        Evaluate the model in cartesian coordinates 
     267        :param x: input q[], or [qx[], qy[]] 
     268        :return: scattering function P(q[]) 
    264269        """ 
    265270        # set effective radius and scaling factor before run 
    266271        self._set_effect_radius() 
    267272        self._set_scale_factor() 
    268         return self.params['scale_factor']*self.p_model.evalDistribution(x)* self.s_model.evalDistribution(x) 
     273        out = self.params['scale_factor'] * self.p_model.evalDistribution(x) * \ 
     274                        self.s_model.evalDistribution(x) 
     275        return out 
    269276 
    270277    def set_dispersion(self, parameter, dispersion): 
    271278        """ 
    272             Set the dispersion object for a model parameter 
    273             @param parameter: name of the parameter [string] 
    274             @dispersion: dispersion object of type DispersionModel 
    275         """ 
    276         value= None 
     279        Set the dispersion object for a model parameter 
     280        :param parameter: name of the parameter [string] 
     281        :dispersion: dispersion object of type DispersionModel 
     282        """ 
     283        value = None 
    277284        try: 
    278285            if parameter in self.p_model.dispersion.keys(): 
    279                 value= self.p_model.set_dispersion(parameter, dispersion) 
     286                value = self.p_model.set_dispersion(parameter, dispersion) 
    280287            self._set_dispersion() 
    281288            return value 
     
    288295        """ 
    289296        description = "" 
    290         description += "Note:1) The effect_radius (effective radius) of %s \n"% (s_model.name) 
    291         description +="             is automatically calculated from size parameters (radius...).\n" 
    292         description += "         2) For non-spherical shape, this approximation is valid \n" 
    293         description += "            only for limited systems. Thus, use it at your own risk.\n" 
    294         description +="See %s description and %s description \n"%( p_model.name, s_model.name ) 
     297        description += "Note:1) The effect_radius (effective radius) of %s \n"%\ 
     298                                                                (s_model.name) 
     299        description += "             is automatically calculated " 
     300        description += "from size parameters (radius...).\n" 
     301        description += "         2) For non-spherical shape, " 
     302        description += "this approximation is valid \n" 
     303        description += "            only for limited systems. " 
     304        description += "Thus, use it at your own risk.\n" 
     305        description += "See %s description and %s description \n"% \ 
     306                                                ( p_model.name, s_model.name ) 
    295307        description += "        for details of individual models." 
    296308        self.description += description 
  • sansmodels/src/sans/models/UnifiedPowerRgModel.py

    reace08e r7fdb332  
    1     
    21from sans.models.BaseComponent import BaseComponent 
    32from math import exp, sqrt 
     
    1312        BaseComponent.__init__(self) 
    1413        """ 
    15         :param multfactor: number of levels in the model, assumes 0<= level# <=5. 
     14        :param multfactor: number of levels in the model,  
     15            assumes 0<= level# <=5. 
    1616        """ 
    1717 
    1818        ## Setting  model name model description 
    1919        self.name = "UnifiedPowerRg" 
    20         self.description="""Multiple Levels of Unified Exponential/Power-law Method. 
     20        self.description = """ 
     21        Multiple Levels of Unified Exponential/Power-law Method. 
    2122        Up to Level 6 is provided. 
    2223        Note; the additional Level 0 is an inverse linear function,  
     
    5354         
    5455        ## functional multiplicity of the model 
    55         self.multiplicity_info = [max_level_n,"Level No.:",[],[]] 
    56      
    57     def _unifiedpowerrg(self,x): 
     56        self.multiplicity_info = [max_level_n, "Level No.:", [], []] 
     57     
     58    def _unifiedpowerrg(self, x): 
    5859        """ 
    5960        Scattering function 
     
    7374            return answer 
    7475        # rearrange the parameters for the given label no. 
    75         for ind in range(1,l_num+1): 
     76        for ind in range(1, l_num+1): 
    7677            # get exp term 
    77             exp_now = exp(-power(x*self.params['Rg%s'% ind],2)/3.0) 
     78            exp_now = exp(-power(x*self.params['Rg%s'% ind], 2)/3.0) 
    7879            # get erf term 
    7980            erf_now = erf(x*self.params['Rg%s'% ind]/sqrt(6.0)) 
    8081            # get power term 
    81             pow_now = power((erf_now*erf_now*erf_now/x),self.params['power%s'% ind]) 
     82            pow_now = power((erf_now*erf_now*erf_now/x),  
     83                            self.params['power%s'% ind]) 
    8284            # get next exp term only if it exists 
    8385            try: 
    84                 exp_next = exp(-power(x*self.params['Rg%s'% (ind+1)],2)/3.0) 
     86                exp_next = exp(-power(x*self.params['Rg%s'% (ind+1)], 2)/3.0) 
    8587            except: 
    8688                exp_next = 1.0 
    8789            # get to the calculation 
    88             answer += self.params['G%s'% ind]*exp_now + self.params['B%s'% ind]* \ 
    89                             exp_next * pow_now 
     90            answer += self.params['G%s'% ind]*exp_now + \ 
     91                            self.params['B%s'% ind] * exp_next * pow_now 
    9092        # take care of the singular point 
    9193        if x == 0.0: 
    9294            answer = 0.0 
    93             for ind in range(1,l_num+1): 
     95            for ind in range(1, l_num+1): 
    9496                answer += self.params['G%s'% ind] 
    9597        # get scaled 
     
    117119        l_num = self.level_num 
    118120        # rearrange the parameters for the given label no. 
    119         for ind in range(0,l_num+1): 
     121        for ind in range(0, l_num+1): 
    120122            if ind == 0: 
    121123                continue 
     
    128130            # Set reasonably define default values that consistent  
    129131            # w/NIST for label #1 
    130             self.params['G%s'% ind] = 0.3*mult*pow(10, \ 
     132            self.params['G%s'% ind] = 0.3 * mult * pow(10, \ 
    131133                            (l_num+1 - float('%s'% ind))) 
    132             self.params['Rg%s'% ind] = 21.0/mult*pow(10, \ 
     134            self.params['Rg%s'% ind] = 21.0 / mult * pow(10, \ 
    133135                              (l_num - float('%s'% ind))) 
    134             self.params['B%s'% ind] = 6e-03/mult*pow(10, \ 
     136            self.params['B%s'% ind] = 6e-03/mult * pow(10, \ 
    135137                           -(l_num+1 - float('%s'% ind))) 
    136138            self.params['power%s'% ind] = 2.0 * mul_pow 
     
    146148        self.details['scale'] = ['', None, None] 
    147149        # rearrange the parameters for the given label no. 
    148         for ind in range(0,self.level_num+1): 
     150        for ind in range(0, self.level_num+1): 
    149151            if ind == 0: 
    150152                continue 
     
    215217            return self._unifiedpowerrg(x) 
    216218        elif x.__class__.__name__ == 'tuple': 
    217             raise ValueError, "Tuples are not allowed as input to BaseComponent models" 
     219            msg = "Tuples are not allowed as input to BaseComponent models" 
     220            raise ValueError, msg 
    218221        else: 
    219222            return self._unifiedpowerrg(x) 
     
    233236            return self._unifiedpowerrg(x) 
    234237        elif x.__class__.__name__ == 'tuple': 
    235             raise ValueError, "Tuples are not allowed as input to BaseComponent models" 
     238            msg = "Tuples are not allowed as input to BaseComponent models" 
     239            raise ValueError, msg 
    236240        else: 
    237241            return self._unifiedpowerrg(x) 
Note: See TracChangeset for help on using the changeset viewer.