-                      rac7be54
+                      re0c16ce
         ## parameters with orientation: can be removed since there is no orientational params
         self._set_orientation_params()
     def _clone(self, obj):
         """
 …
         return obj
     def _set_dispersion(self):
         """
         model dispersions
         Polydispersion should not be applied to s_model
         """
         ##set dispersion from model
+        """
+        ##set dispersion from model
         for name , value in self.model.dispersion.iteritems():
             nshell = 0
 …
                     if name.split('_')[-1] == 'shell%s' % str(nshell):
                         self.dispersion[name] = value
                     else:
+                    else:
                         continue
             else:
                 self.dispersion[name] = value
     def _set_orientation_params(self):
         """
         model orientation and magnetic parameters, same params for this model
         """
+        """
         ##set dispersion from model
         for param in self.model.orientation_params:
 …
                     self.orientation_params.append(param)
                     self.magnetic_params.append(param)
                     continue
+                    continue
     def _set_params(self):
         """
         Concatenate the parameters of the model to create
         this model parameters
+        this model parameters
         """
         # rearrange the parameters for the given # of shells
 …
             else:
                 self.params[name]= value
         # set constrained values for the original model params
         self._set_xtra_model_param()
+        self._set_xtra_model_param()
     def _set_details(self):
         """
         Concatenate details of the original model to create
         this model details
+        this model details
         """
         for name ,detail in self.model.details.iteritems():
             if name in self.params.iterkeys():
                 self.details[name]= detail
     def _set_xtra_model_param(self):
         """
 …
                                 self.model.setParam(key, 0.0)
                         except: pass
     def getProfile(self):
         """
         Get SLD profile
+        : return: (r, beta) where r is a list of radius of the transition points
             beta is a list of the corresponding SLD values
         : Note: This works only for func_shell num = 2.
+        Get SLD profile
+        **Note:** This works only for func_shell num = 2.
+        :return: (r, beta) where r is a list of radius of the transition points\
+         and beta is a list of the corresponding SLD values.
         """
         r = []
 …
         r.append(self.params['rad_core0'])
         beta.append(self.params['sld_core0'])
         # for shells
         for n in range(1, self.n_shells+1):
             # Left side of each shells
             r0 = r[len(r)-1]
+            r0 = r[len(r)-1]
             r.append(r0)
             exec "beta.append(self.params['sld_shell%s'% str(n)])"
 …
             r.append(r0)
             exec "beta.append(self.params['sld_shell%s'% str(n)])"
         # for solvent
         r0 = r[len(r)-1]
 …
         r.append(r_solv)
         beta.append(self.params['sld_solv'])
         return r, beta
     def setParam(self, name, value):
         """
+        """
         Set the value of a model parameter
         : param name: name of the parameter
         : param value: value of the parameter
+        :param name: name of the parameter
+        :param value: value of the parameter
         """
         # set param to new model
         self._setParamHelper( name, value)
         ## setParam to model
+        ## setParam to model
         if name == 'sld_solv':
             # the sld_*** model.params not in params must set to value of sld_solv
 …
                 self.params[item] = value
                 return
         #raise ValueError, "Model does not contain parameter %s" % name
     def _set_fixed_params(self):
         """
 …
         """
         for item in self.model.fixed:
             if item.split('.')[0] in self.params.keys():
+            if item.split('.')[0] in self.params.keys():
                 self.fixed.append(item)
         self.fixed.sort()
     def run(self, x = 0.0):
         """
+        """
         Evaluate the model
         : param x: input q-value (float or [float, float] as [r, theta])
         : return: (DAB value)
+        :param x: input q-value (float or [float, float] as [r, theta])
+        :return: (DAB value)
         """
         # set effective radius and scaling factor before run
 …
     def runXY(self, x = 0.0):
         """
+        """
         Evaluate the model
         : param x: input q-value (float or [float, float] as [qx, qy])
         : return: DAB value
+        :param x: input q-value (float or [float, float] as [qx, qy])
+        :return: DAB value
         """
         # set effective radius and scaling factor before run
         return self.model.runXY(x)
     ## Now (May27,10) directly uses the model eval function
     ## instead of the for-loop in Base Component.
     def evalDistribution(self, x = []):
         """
+        """
         Evaluate the model in cartesian coordinates
         : param x: input q[], or [qx[], qy[]]
         : return: scattering function P(q[])
+        :param x: input q[], or [qx[], qy[]]
+        :return: scattering function P(q[])
         """
         # set effective radius and scaling factor before run
         return self.model.evalDistribution(x)
     def calculate_ER(self):
         """
+        """
         Calculate the effective radius for P(q)*S(q)
         :return: the value of the effective radius
+        """
+        """
         return self.model.calculate_ER()
     def calculate_VR(self):
         """
+        """
         Calculate the volf ratio for P(q)*S(q)
         :return: the value of the volf ratio
+        """
+        """
         return self.model.calculate_VR()
     def set_dispersion(self, parameter, dispersion):
         """
         Set the dispersion object for a model parameter
         : param parameter: name of the parameter [string]
         :dispersion: dispersion object of type DispersionModel
+        :param parameter: name of the parameter [string]
+        :param dispersion: dispersion object of type DispersionModel
         """
         value = None
 …
             return value
         except:
             raise
+            raise

Note: See TracChangeset for help on using the changeset viewer.

SasView

Changeset e0c16ce in sasview

Legend:

src/sas/models/CoreMultiShellModel.py

Download in other formats: