Changeset 2e0053e in sasview for sansmodels/src/sans/models


Ignore:
Timestamp:
Apr 18, 2012 2:10:29 PM (13 years ago)
Author:
Mathieu Doucet <doucetm@…>
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:
364658d
Parents:
2dda7ae1
Message:

Fixing code style problems

File:
1 edited

Legend:

Unmodified
Added
Removed

  • sansmodels/src/sans/models/SphericalSLDModel.py

    rcd075e8 r2e0053e  
    1     
     1""" 
     2    Spherical SLD model 
     3""" 
    24from sans.models.BaseComponent import BaseComponent 
    35from sans.models.SphereSLDModel import SphereSLDModel 
    46from copy import deepcopy 
    57from math import floor 
    6 #from scipy.special import erf 
    78func_list = {'Erf(|nu|*z)':0, 'RPower(z^|nu|)':1, 'LPower(z^|nu|)':2, \ 
    89                     'RExp(-|nu|*z)':3, 'LExp(-|nu|*z)':4} 
    910max_nshells = 10 
     11 
    1012class SphericalSLDModel(BaseComponent): 
    1113    """ 
    … …  
    1416    """ 
    1517    def __init__(self, multfactor=1): 
     18        """ 
     19            :param multfactor: number of layers in the model,  
     20            assumes 0<= n_shells <=10. 
     21        """ 
    1622        BaseComponent.__init__(self) 
    17         """ 
    18         :param multfactor: number of layers in the model,  
    19         assumes 0<= n_shells <=10. 
    20         """ 
    2123 
    2224        ## Setting  model name model description 
    23         self.description="" 
     25        self.description = "" 
    2426        model = SphereSLDModel() 
    2527        self.model = model 
    2628        self.name = "SphericalSLDModel" 
    27         self.description=model.description 
     29        self.description = model.description 
    2830        self.n_shells = multfactor 
    2931        ## Define parameters 
    … …  
    5355        # [int(maximum no. of functionality),"str(Titl), 
    5456        # [str(name of function0),...], [str(x-asix name of sld),...]] 
    55         self.multiplicity_info = [max_nshells,"No. of Shells:",[],['Radius']] 
     57        self.multiplicity_info = [max_nshells, "No. of Shells:", [], ['Radius']] 
    5658         
    5759     
    … …  
    8082            nshell = -1 
    8183            if name.split('_')[0] == 'thick': 
    82                 while nshell<1: 
     84                while nshell < 1: 
    8385                    nshell += 1 
    8486                    if name.split('_')[1] == 'inter%s' % str(nshell): 
    85                         self.dispersion[name]= value 
     87                        self.dispersion[name] = value 
    8688                    else:  
    8789                        continue 
    8890            else: 
    89                 self.dispersion[name]= value 
     91                self.dispersion[name] = value 
    9092 
    9193    def _set_params(self): 
    … …  
    101103            last_name = name.split('_')[pos] 
    102104            if first_name == 'npts': 
    103                 self.params[name]=value 
     105                self.params[name] = value 
    104106                continue 
    105107            elif first_name == 'func': 
    106                 n= -1 
    107                 while n<self.n_shells: 
     108                n = -1 
     109                while n < self.n_shells: 
    108110                    n += 1 
    109111                    if last_name == 'inter%s' % str(n):  
    110                         self.params[name]=value 
     112                        self.params[name] = value 
    111113                        continue 
    112114            elif last_name[0:5] == 'inter': 
    113                 n= -1 
    114                 while n<self.n_shells: 
     115                n = -1 
     116                while n < self.n_shells: 
    115117                    n += 1 
    116118                    if last_name == 'inter%s' % str(n): 
    117                         self.params[name]= value 
     119                        self.params[name] = value 
    118120                        continue 
    119121            elif last_name[0:4] == 'flat': 
    120                 while n<self.n_shells: 
     122                while n < self.n_shells: 
    121123                    n += 1 
    122124                    if last_name == 'flat%s' % str(n): 
    123                         self.params[name]= value 
     125                        self.params[name] = value 
    124126                        continue 
    125127            elif name == 'n_shells': 
    126128                continue 
    127129            else: 
    128                 self.params[name]= value 
     130                self.params[name] = value 
    129131   
    130132        self.model.params['n_shells'] = self.n_shells     
    … …  
    138140        this model details  
    139141        """ 
    140         for name ,detail in self.model.details.iteritems(): 
     142        for name, detail in self.model.details.iteritems(): 
    141143            if name in self.params.iterkeys(): 
    142                 self.details[name]= detail 
     144                self.details[name] = detail 
    143145             
    144146     
    … …  
    150152        for key in self.model.params.iterkeys(): 
    151153            if key not in self.params.keys(): 
    152                 if  key.split('_')[0] == 'thick': 
     154                if key.split('_')[0] == 'thick': 
    153155                    self.model.setParam(key, 0) 
    154156                    continue 
    155                 if  key.split('_')[0] == 'func':  
    156                         self.model.setParam(key, 0) 
    157                         continue 
     157                if key.split('_')[0] == 'func':  
     158                    self.model.setParam(key, 0) 
     159                    continue 
    158160 
    159161                for nshell in range(self.n_shells,max_nshells): 
    … …  
    163165                                value = self.model.params['sld_solv'] 
    164166                            self.model.setParam(key, value) 
    165                         except: pass 
     167                        except: 
     168                            raise RuntimeError, "SphericalSLD model problem" 
    166169     
    167170    def _get_func_list(self): 
    … …  
    169172        Get the list of functions in each layer (shell)  
    170173        """ 
    171         #func_list = {} 
    172174        return func_list 
    173175         
    … …  
    184186        beta = [] 
    185187        z0 = 0 
    186         sub_range = floor(n_sub/2.0) 
    187188        # two sld points for core 
    188189        z.append(0) 
    … …  
    192193        z0 += self.params['rad_core0'] 
    193194        # for layers from the core 
    194         for n in range(1,self.n_shells+2): 
     195        for n in range(1, self.n_shells+2): 
    195196            i = n 
     197            dz = self.params['thick_inter%s'% str(i-1)]/n_sub 
    196198            # j=0 for interface, j=1 for flat layer  
    197             for j in range(0,2): 
     199            for j in range(0, 2): 
    198200                # interation for sub-layers 
    199                 for n_s in range(0,n_sub+1): 
    200                     if j==1: 
    201                         if i==self.n_shells+1: 
     201                for n_s in range(0, n_sub+1): 
     202                    if j == 1: 
     203                        if i == self.n_shells+1: 
    202204                            break 
    203205                        # shift half sub thickness for the first point 
    … …  
    205207                        z.append(z0) 
    206208                        #z0 -= dz/2.0 
    207                         z0 += self.params['thick_flat%s'% str(i)] 
     209                        z0 += self.params['thick_flat%s' % str(i)] 
    208210                         
    209                         sld_i = self.params['sld_flat%s'% str(i)] 
    210                         beta.append(self.params['sld_flat%s'% str(i)]) 
     211                        sld_i = self.params['sld_flat%s' % str(i)] 
     212                        beta.append(self.params['sld_flat%s' % str(i)]) 
    211213                        dz = 0 
    212214                    else: 
    213                         dz = self.params['thick_inter%s'% str(i-1)]/n_sub 
    214                         nu = self.params['nu_inter%s'% str(i-1)] 
     215                        nu = self.params['nu_inter%s' % str(i-1)] 
    215216                        # decide which sld is which, sld_r or sld_l 
    216217                        if i == 1: 
    217218                            sld_l = self.params['sld_core0'] 
    218219                        else: 
    219                             sld_l = self.params['sld_flat%s'% str(i-1)] 
     220                            sld_l = self.params['sld_flat%s' % str(i-1)] 
    220221                        if i == self.n_shells+1: 
    221222                            sld_r = self.params['sld_solv'] 
    222223                        else: 
    223                             sld_r = self.params['sld_flat%s'% str(i)] 
     224                            sld_r = self.params['sld_flat%s' % str(i)] 
    224225                        # get function type 
    225                         func_idx = self.params['func_inter%s'% str(i-1)] 
     226                        func_idx = self.params['func_inter%s' % str(i-1)] 
    226227                        # calculate the sld 
    227228                        sld_i = self._get_sld(func_idx, n_sub, n_s, nu, 
    … …  
    231232                    beta.append(sld_i) 
    232233                    z0 += dz 
    233                     if j==1: break 
     234                    if j == 1: 
     235                        break 
    234236        # put sld of solvent 
    235237        z.append(z0) 
    … …  
    256258        sld_cal = SLDCalFunc() 
    257259        # set params 
    258         sld_cal.setParam('fun_type',func_idx) 
    259         sld_cal.setParam('npts_inter',n_sub) 
    260         sld_cal.setParam('shell_num',n_s) 
    261         sld_cal.setParam('nu_inter',nu) 
    262         sld_cal.setParam('sld_left',sld_l) 
    263         sld_cal.setParam('sld_right',sld_r) 
     260        sld_cal.setParam('fun_type', func_idx) 
     261        sld_cal.setParam('npts_inter', n_sub) 
     262        sld_cal.setParam('shell_num', n_s) 
     263        sld_cal.setParam('nu_inter', nu) 
     264        sld_cal.setParam('sld_left', sld_l) 
     265        sld_cal.setParam('sld_right', sld_r) 
    264266        # return sld value 
    265267        return sld_cal.run() 
    … …  
    273275        """ 
    274276        # set param to new model 
    275         self._setParamHelper( name, value) 
     277        self._setParamHelper(name, value) 
    276278         
    277279        ## setParam to model  
    278         if name=='sld_solv': 
     280        if name == 'sld_solv': 
    279281            # the sld_*** model.params not in params must set to  
    280282            # value of sld_solv 
    281283            for key in self.model.params.iterkeys(): 
    282                 if key not in self.params.keys()and key.split('_')[0] == 'sld': 
    283                         self.model.setParam(key, value) 
     284                if key not in self.params.keys() and key.split('_')[0] == 'sld': 
     285                    self.model.setParam(key, value) 
    284286             
    285         self.model.setParam( name, value) 
     287        self.model.setParam(name, value) 
    286288 
    287289    def _setParamHelper(self, name, value): 
    … …  
    290292        """ 
    291293        toks = name.split('.') 
    292         if len(toks)==2: 
     294        if len(toks) == 2: 
    293295            for item in self.dispersion.keys(): 
    294                 if item.lower()==toks[0].lower(): 
     296                if item.lower() == toks[0].lower(): 
    295297                    for par in self.dispersion[item]: 
    296298                        if par.lower() == toks[1].lower(): 
    … …  
    299301        # Look for standard parameter 
    300302        for item in self.params.keys(): 
    301             if item.lower()==name.lower(): 
     303            if item.lower() == name.lower(): 
    302304                self.params[item] = value 
    303305                return 
    … …  
    315317 
    316318        self.fixed.sort() 
    317         pass          
    318319 
    319320    def run(self, x = 0.0): 
    … …  
    341342    ## Now (May27,10) directly uses the model eval function  
    342343    ## instead of the for-loop in Base Component. 
    343     def evalDistribution(self, x = []): 
     344    def evalDistribution(self, x): 
    344345        """  
    345346        Evaluate the model in cartesian coordinates 
    … …  
    350351        # set effective radius and scaling factor before run 
    351352        return self.model.evalDistribution(x) 
     353     
    352354    def calculate_ER(self): 
    353355        """ 
    354356        """ 
    355357        return self.model.calculate_ER() 
     358     
    356359    def set_dispersion(self, parameter, dispersion): 
    357360        """ 
    … …  
    361364        :dispersion: dispersion object of type DispersionModel 
    362365        """ 
    363         value= None 
    364         try: 
    365             if parameter in self.model.dispersion.keys(): 
    366                 value= self.model.set_dispersion(parameter, dispersion) 
    367             self._set_dispersion() 
    368             return value 
    369         except: 
    370             raise  
     366        value = None 
     367        if parameter in self.model.dispersion.keys(): 
     368            value = self.model.set_dispersion(parameter, dispersion) 
     369        self._set_dispersion() 
     370        return value 
Note: See TracChangeset for help on using the changeset viewer.