Changes in sasmodels/modelinfo.py [39a06c9:4f4d3e3] in sasmodels

File:

• sasmodels/modelinfo.py (modified) (15 diffs)

sasmodels/modelinfo.py

@@ -164 +164 @@
     parameter.length = length
     parameter.length_control = control
+
     return parameter
 
@@ -264 +265 @@
     will have a magnitude and a direction, which may be different from
     other sld parameters. The volume parameters are used for calls
-    to form_volume within the kernel (required for volume normalization),
-    to shell_volume (for hollow shapes), and to effective_radius (for
-    structure factor interactions) respectively.
+    to form_volume within the kernel (required for volume normalization)
+    and for calls to ER and VR for effective radius and volume ratio
+    respectively.
 
     *description* is a short description of the parameter.  This will
@@ -290 +291 @@
     example, might be used to set the value of a shape parameter.
 
-    These values are set by :func:`make_parameter_table` and
+    Control parameters are used for variant models such as :ref:`rpa` which
+    have different cases with different parameters, as well as models
+    like :ref:`spherical_sld` with its user defined number of shells.
+    The control parameter should appear in the parameter table along with the
+    parameters it is is controlling.  For variant models, use *[CASES]* in
+    place of the parameter limits Within the parameter definition table,
+    with case names such as::
+
+         CASES = ["diblock copolymer", "triblock copolymer", ...]
+
+    This should give *limits=[[case1, case2, ...]]*, but the model loader
+    translates it to *limits=[0, len(CASES)-1]*, and adds *choices=CASES* to
+    the :class:`Parameter` definition. Note that models can use a list of
+    cases as a parameter without it being a control parameter.  Either way,
+    the parameter is sent to the model evaluator as *float(choice_num)*,
+    where choices are numbered from 0. :meth:`ModelInfo.get_hidden_parameters`
+    will determine which parameers to display.
+
+    The class contructor should not be called directly, but instead the
+    parameter table is built using :func:`make_parameter_table` and
     :func:`parse_parameter` therein.
     """
@@ -423 +443 @@
         self.kernel_parameters = parameters
         self._set_vector_lengths()
+
         self.npars = sum(p.length for p in self.kernel_parameters)
         self.nmagnetic = sum(p.length for p in self.kernel_parameters
@@ -429 +450 @@
         if self.nmagnetic:
             self.nvalues += 3 + 3*self.nmagnetic
+
         self.call_parameters = self._get_call_parameters()
         self.defaults = self._get_defaults()
@@ -719 +741 @@
 
 #: Set of variables defined in the model that might contain C code
-C_SYMBOLS = ['Imagnetic', 'Iq', 'Iqxy', 'Iqac', 'Iqabc', 'form_volume', 'shell_volume', 'c_code']
+C_SYMBOLS = ['Imagnetic', 'Iq', 'Iqxy', 'Iqac', 'Iqabc', 'form_volume', 'c_code']
 
 def _find_source_lines(model_info, kernel_module):
@@ -768 +790 @@
         # Custom sum/multi models
         return kernel_module.model_info
-
     info = ModelInfo()
     #print("make parameter table", kernel_module.parameters)
@@ -790 +811 @@
     info.category = getattr(kernel_module, 'category', None)
     info.structure_factor = getattr(kernel_module, 'structure_factor', False)
-    # TODO: find Fq by inspection
-    info.effective_radius_type = getattr(kernel_module, 'effective_radius_type', None)
-    info.have_Fq = getattr(kernel_module, 'have_Fq', False)
     info.profile_axes = getattr(kernel_module, 'profile_axes', ['x', 'y'])
     # Note: custom.load_custom_kernel_module assumes the C sources are defined
@@ -798 +816 @@
     info.source = getattr(kernel_module, 'source', [])
     info.c_code = getattr(kernel_module, 'c_code', None)
-    info.effective_radius = getattr(kernel_module, 'effective_radius', None)
     # TODO: check the structure of the tests
     info.tests = getattr(kernel_module, 'tests', [])
+    info.ER = getattr(kernel_module, 'ER', None) # type: ignore
+    info.VR = getattr(kernel_module, 'VR', None) # type: ignore
     info.form_volume = getattr(kernel_module, 'form_volume', None) # type: ignore
-    info.shell_volume = getattr(kernel_module, 'shell_volume', None) # type: ignore
     info.Iq = getattr(kernel_module, 'Iq', None) # type: ignore
     info.Iqxy = getattr(kernel_module, 'Iqxy', None) # type: ignore
@@ -814 +832 @@
     info.single = getattr(kernel_module, 'single', not callable(info.Iq))
     info.random = getattr(kernel_module, 'random', None)
-
-    # multiplicity info
-    control_pars = [p.id for p in parameters.kernel_parameters if p.is_control]
-    default_control = control_pars[0] if control_pars else None
-    info.control = getattr(kernel_module, 'control', default_control)
     info.hidden = getattr(kernel_module, 'hidden', None) # type: ignore
+
+    # Set control flag for explicitly set parameters, e.g., in the RPA model.
+    control = getattr(kernel_module, 'control', None)
+    if control is not None:
+        parameters[control].is_control = True
 
     if callable(info.Iq) and parameters.has_2d:
@@ -826 +844 @@
     info.lineno = {}
     _find_source_lines(info, kernel_module)
+
     return info
 
@@ -872 +891 @@
     #: *sphere*hardsphere* or *cylinder+sphere*.
     composition = None      # type: Optional[Tuple[str, List[ModelInfo]]]
-    #: Name of the control parameter for a variant model such as :ref:`rpa`.
-    #: The *control* parameter should appear in the parameter table, with
-    #: limits defined as *[CASES]*, for case names such as
-    #: *CASES = ["diblock copolymer", "triblock copolymer", ...]*.
-    #: This should give *limits=[[case1, case2, ...]]*, but the
-    #: model loader translates this to *limits=[0, len(CASES)-1]*, and adds
-    #: *choices=CASES* to the :class:`Parameter` definition. Note that
-    #: models can use a list of cases as a parameter without it being a
-    #: control parameter.  Either way, the parameter is sent to the model
-    #: evaluator as *float(choice_num)*, where choices are numbered from 0.
-    #: See also :attr:`hidden`.
-    control = None          # type: str
     #: Different variants require different parameters.  In order to show
     #: just the parameters needed for the variant selected by :attr:`control`,
@@ -918 +925 @@
     #: provided in the file.
     structure_factor = None # type: bool
-    #: True if the model defines an Fq function with signature
-    #: void Fq(double q, double *F1, double *F2, ...)
-    have_Fq = False
-    #: List of options for computing the effective radius of the shape,
-    #: or None if the model is not usable as a form factor model.
-    effective_radius_type = None   # type: List[str]
     #: List of C source files used to define the model.  The source files
     #: should define the *Iq* function, and possibly *Iqac* or *Iqabc* if the
     #: model defines orientation parameters. Files containing the most basic
     #: functions must appear first in the list, followed by the files that
-    #: use those functions.
+    #: use those functions.  Form factors are indicated by providing
+    #: an :attr:`ER` function.
     source = None           # type: List[str]
-    #: inline source code, added after all elements of source
-    c_code = None           # type: Optional[str]
+    #: The set of tests that must pass.  The format of the tests is described
+    #: in :mod:`model_test`.
+    tests = None            # type: List[TestCondition]
+    #: Returns the effective radius of the model given its volume parameters.
+    #: The presence of *ER* indicates that the model is a form factor model
+    #: that may be used together with a structure factor to form an implicit
+    #: multiplication model.
+    #:
+    #: The parameters to the *ER* function must be marked with type *volume*.
+    #: in the parameter table.  They will appear in the same order as they
+    #: do in the table.  The values passed to *ER* will be vectors, with one
+    #: value for each polydispersity condition.  For example, if the model
+    #: is polydisperse over both length and radius, then both length and
+    #: radius will have the same number of values in the vector, with one
+    #: value for each *length X radius*.  If only *radius* is polydisperse,
+    #: then the value for *length* will be repeated once for each value of
+    #: *radius*.  The *ER* function should return one effective radius for
+    #: each parameter set.  Multiplicity parameters will be received as
+    #: arrays, with one row per polydispersity condition.
+    ER = None               # type: Optional[Callable[[np.ndarray], np.ndarray]]
+    #: Returns the occupied volume and the total volume for each parameter set.
+    #: See :attr:`ER` for details on the parameters.
+    VR = None               # type: Optional[Callable[[np.ndarray], Tuple[np.ndarray, np.ndarray]]]
+    #: Arbitrary C code containing supporting functions, etc., to be inserted
+    #: after everything in source.  This can include Iq and Iqxy functions with
+    #: the full function signature, including all parameters.
+    c_code = None
     #: Returns the form volume for python-based models.  Form volume is needed
     #: for volume normalization in the polydispersity integral.  If no
@@ -939 +966 @@
     #: C code, either defined as a string, or in the sources.
     form_volume = None      # type: Union[None, str, Callable[[np.ndarray], float]]
-    #: Returns the shell volume for python-based models.  Form volume and
-    #: shell volume are needed for volume normalization in the polydispersity
-    #: integral and structure interactions for hollow shapes.  If no
-    #: parameters are *volume* parameters, then shell volume is not needed.
-    #: For C-based models, (with :attr:`sources` defined, or with :attr:`Iq`
-    #: defined using a string containing C code), shell_volume must also be
-    #: C code, either defined as a string, or in the sources.
-    shell_volume = None      # type: Union[None, str, Callable[[np.ndarray], float]]
     #: Returns *I(q, a, b, ...)* for parameters *a*, *b*, etc. defined
     #: by the parameter table.  *Iq* can be defined as a python function, or
@@ -981 +1000 @@
     #: Line numbers for symbols defining C code
     lineno = None           # type: Dict[str, int]
-    #: The set of tests that must pass.  The format of the tests is described
-    #: in :mod:`model_test`.
-    tests = None            # type: List[TestCondition]
 
     def __init__(self):