Index: doc/guide/plugin.rst
===================================================================
--- doc/guide/plugin.rst	(revision c94ab04e18bfbb17455ae74d31a271d9cdb0f3b4)
+++ doc/guide/plugin.rst	(revision db1d9d5f306f6645d007300bc421fb71d3669eda)
@@ -303,5 +303,5 @@
 **Note: The order of the parameters in the definition will be the order of the
 parameters in the user interface and the order of the parameters in Fq(), Iq(),
-Iqac(), Iqabc(), form_volume() and shell_volume().
+Iqac(), Iqabc(), radius_effective(), form_volume() and shell_volume().
 And** *scale* **and** *background* **parameters are implicit to all models,
 so they do not need to be included in the parameter table.**
@@ -387,5 +387,7 @@
 can take arbitrary values, even for integer parameters, so your model should
 round the incoming parameter value to the nearest integer inside your model
-you should round to the nearest integer.  In C code, you can do this using::
+you should round to the nearest integer.  In C code, you can do this using:
+
+.. code-block:: c
 
     static double
@@ -499,16 +501,19 @@
 Models should define *form_volume(par1, par2, ...)* where the parameter
 list includes the *volume* parameters in order.  This is used for a weighted
-volume normalization so that scattering is on an absolute scale.  If
-*form_volume* is not defined, then the default *form_volume = 1.0* will be
-used.
+volume normalization so that scattering is on an absolute scale.  For
+solid shapes, the *I(q)* function should use *form_volume* squared
+as its scale factor.  If *form_volume* is not defined, then the default
+*form_volume = 1.0* will be used.
 
 Hollow shapes, where the volume fraction of particle corresponds to the
 material in the shell rather than the volume enclosed by the shape, must
 also define a *shell_volume(par1, par2, ...)* function.  The parameters
-are the same as for *form_volume*.  The *I(q)* calculation should use
-*shell_volume* squared as its scale factor for the volume normalization.
-The structure factor calculation needs *form_volume* in order to properly
-scale the volume fraction parameter, so both functions are required for
-hollow shapes.
+are the same as for *form_volume*.  Here the *I(q)* function should use
+*shell_volume* squared instead of *form_volume* squared so that the scale
+parameter corresponds to the volume fraction of material in the sample.
+The structure factor calculation needs the volume fraction of the filled
+shapes for its calculation, so the volume fraction parameter in the model
+is automatically scaled by *form_volume/shell_volume* prior to calling the
+structure factor.
 
 **Note: Pure python models do not yet support direct computation of the**
@@ -525,5 +530,7 @@
     """
 
-This expands into the equivalent C code::
+This expands into the equivalent C code:
+
+.. code-block:: c
 
     double Iq(double q, double par1, double par2, ...);
@@ -536,5 +543,5 @@
 includes only the volume parameters.
 
-*form_volume* defines the volume of the shell for hollow shapes. As in
+*shell_volume* defines the volume of the shell for hollow shapes. As in
 python models, it includes only the volume parameters.
 
@@ -568,5 +575,7 @@
 Rather than returning NAN from Iq, you must define the *INVALID(v)*.  The
 *v* parameter lets you access all the parameters in the model using
-*v.par1*, *v.par2*, etc. For example::
+*v.par1*, *v.par2*, etc. For example:
+
+.. code-block:: c
 
     #define INVALID(v) (v.bell_radius < v.radius)
@@ -583,5 +592,7 @@
 
 Instead of defining the *Iq* function, models can define *Fq* as
-something like::
+something like:
+
+.. code-block:: c
 
     double Fq(double q, double *F1, double *F2, double par1, double par2, ...);
@@ -615,5 +626,5 @@
 laboratory frame and beam travelling along $-z$.
 
-The oriented C model (oriented pure Python models are not supported) 
+The oriented C model (oriented pure Python models are not supported)
 is called using *Iqabc(qa, qb, qc, par1, par2, ...)* where
 *par1*, etc. are the parameters to the model.  If the shape is rotationally
@@ -644,5 +655,7 @@
 
 Using the $z, w$ values for Gauss-Legendre integration in "lib/gauss76.c", the
-numerical integration is then::
+numerical integration is then:
+
+.. code-block:: c
 
     double outer_sum = 0.0;
@@ -987,5 +1000,7 @@
   memory, and wrong answers computed. The conclusion from a very long and
   strange debugging session was that any arrays that you declare in your
-  model should be a multiple of four. For example::
+  model should be a multiple of four. For example:
+
+  .. code-block:: c
 
       double Iq(q, p1, p2, ...)
@@ -1019,41 +1034,75 @@
 structure factor is the *hardsphere* interaction, which
 uses the effective radius of the form factor as an input to the structure
-factor model.  The effective radius is the average radius of the
-form averaged over all the polydispersity values.
-
-::
-
-    def ER(radius, thickness):
-        """Effective radius of a core-shell sphere."""
-        return radius + thickness
-
-Now consider the *core_shell_sphere*, which has a simple effective radius
-equal to the radius of the core plus the thickness of the shell, as
-shown above. Given polydispersity over *(r1, r2, ..., rm)* in radius and
-*(t1, t2, ..., tn)* in thickness, *ER* is called with a mesh
-grid covering all possible combinations of radius and thickness.
-That is, *radius* is *(r1, r2, ..., rm, r1, r2, ..., rm, ...)*
-and *thickness* is *(t1, t1, ... t1, t2, t2, ..., t2, ...)*.
-The *ER* function returns one effective radius for each combination.
-The effective radius calculator weights each of these according to
-the polydispersity distributions and calls the structure factor
-with the average *ER*.
-
-::
-
-    def VR(radius, thickness):
-        """Sphere and shell volumes for a core-shell sphere."""
-        whole = 4.0/3.0 * pi * (radius + thickness)**3
-        core = 4.0/3.0 * pi * radius**3
-        return whole, whole - core
-
-Core-shell type models have an additional volume ratio which scales
-the structure factor.  The *VR* function returns the volume of
-the whole sphere and the volume of the shell. Like *ER*, there is
-one return value for each point in the mesh grid.
-
-*NOTE: we may be removing or modifying this feature soon. As of the
-time of writing, core-shell sphere returns (1., 1.) for VR, giving a volume
-ratio of 1.0.*
+factor model.  The effective radius is the weighted average over all
+values of the shape in polydisperse systems.
+
+There can be many notions of effective radius, depending on the shape.  For
+a sphere it is clearly just the radius, but for an ellipsoid of revolution
+we provide average curvature, equivalent sphere radius, minimum radius and
+maximum radius.  These options are listed as *radius_effective_modes* in
+the python model defintion, and must be computed by the *radius_effective*
+function which takes the *radius_effective_mode* parameter as an integer,
+along with the various model parameters.  Unlike normal C/Python arrays,
+the first mode is 1, the second is 2, etc.  Mode 0 indicates that the
+effective radius from the shape is to be ignored in favour of the the
+effective radius parameter in the structure factor model.
+
+
+Consider the core-shell sphere, which defines the following effective radius
+modes in the python model::
+
+    radius_effective_modes = [
+        "outer radius",
+        "core radius",
+    ]
+
+and the following function in the C-file for the model:
+
+.. code-block:: c
+
+    static double
+    radius_effective(int mode, double radius, double thickness)
+    {
+        switch (mode) {
+            case 0: return radius + thickness;
+            case 1: return radius;
+            default: return 0.;
+        }
+    }
+
+    static double
+    form_volume(double radius, double thickness)
+    {
+        return M_4PI_3 * cube(radius + thickness);
+    }
+
+Given polydispersity over *(r1, r2, ..., rm)* in radius and *(t1, t2, ..., tn)*
+in thickness, *radius_effective* is called over a mesh grid covering all
+possible combinations of radius and thickness, with a single *(ri, tj)* pair
+in each call. The weights each of these results according to the
+polydispersity distributions and calls the structure factor with the average
+effective radius.  Similarly, for *form_volume*.
+
+Hollow models have an additional volume ratio which is needed to scale the
+structure factor.  The structure factor uses the volume fraction of the filled
+particles as part of its density estimate, but the scale factor for the
+scattering intensity (as non-solvent volume fraction / volume) is determined
+by the shell volume only.  Therefore the *shell_volume* function is
+needed to compute the form:shell volume ratio, which then scales the
+*volfraction* parameter prior to calling the structure factor calculator.
+In the case of a hollow sphere, this would be:
+
+.. code-block:: c
+
+    static double
+    shell_volume(double radius, double thickness)
+    {
+        double whole = M_4PI_3 * cube(radius + thickness);
+        double core = M_4PI_3 * cube(radius);
+        return whole - core;
+    }
+
+If *shell_volume* is not present, then *form_volume* and *shell_volume* are
+assumed to be equal, and the shape is considered solid.
 
 Unit Tests
@@ -1115,5 +1164,5 @@
 ...................
 
-**NB: For now, this more detailed testing is only possible if you have a 
+**NB: For now, this more detailed testing is only possible if you have a
 SasView build environment available!**
 
@@ -1253,2 +1302,3 @@
 | 2016-10-25 Steve King
 | 2017-05-07 Paul Kienzle - Moved from sasview to sasmodels docs
+| 2019-03-28 Paul Kienzle - Update docs for radius_effective and shell_volume
Index: doc/guide/resolution.rst
===================================================================
--- doc/guide/resolution.rst	(revision 8d2df05cc8c770af51d340dda4bdf2fe60d8a371)
+++ doc/guide/resolution.rst	(revision db1d9d5f306f6645d007300bc421fb71d3669eda)
@@ -1,5 +1,5 @@
 .. resolution.rst
 
-.. This is a port of the original SasView html help file sm_help to ReSTructured 
+.. This is a port of the original SasView html help file sm_help to ReSTructured
 .. text by S King, ISIS, during SasView CodeCamp-III in Feb 2015.
 
@@ -17,5 +17,5 @@
 resolution contribution into a model calculation/simulation (which by definition
 will be exact) to make it more representative of what has been measured
-experimentally - a process called *smearing*. The Sasmodels component of SasView 
+experimentally - a process called *smearing*. The Sasmodels component of SasView
 does the latter.
 
@@ -32,16 +32,16 @@
 
 .. note::
-    Problems may be encountered if the data set loaded by SasView is a 
-    concatenation of SANS data from several detector distances where, of 
-    course, the worst Q resolution is next to the beam stop at each detector 
-    distance. (This will also be noticeable in the residuals plot where 
-    there will be poor overlap). SasView sensibly orders all the input 
-    data points by increasing Q for nicer-looking plots, however, the dQ 
-    data can then vary considerably from point to point. If 'Use dQ data' 
-    smearing is selected then spikes may appear in the model fits, whereas 
+    Problems may be encountered if the data set loaded by SasView is a
+    concatenation of SANS data from several detector distances where, of
+    course, the worst Q resolution is next to the beam stop at each detector
+    distance. (This will also be noticeable in the residuals plot where
+    there will be poor overlap). SasView sensibly orders all the input
+    data points by increasing Q for nicer-looking plots, however, the dQ
+    data can then vary considerably from point to point. If 'Use dQ data'
+    smearing is selected then spikes may appear in the model fits, whereas
     if 'None' or 'Custom Pinhole Smear' are selected the fits look normal.
-    
-    In such instances, possible solutions are to simply remove the data 
-    with poor Q resolution from the shorter detector distances, or to fit 
+
+    In such instances, possible solutions are to simply remove the data
+    with poor Q resolution from the shorter detector distances, or to fit
     the data from different detector distances simultaneously.
 
Index: explore/beta/sasfit_compare.py
===================================================================
--- explore/beta/sasfit_compare.py	(revision 119073a61da4bc8256d0f33c999a38f346f9dfc6)
+++ explore/beta/sasfit_compare.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -408,5 +408,5 @@
         #radius_effective=12.59921049894873,
         )
-    target = sasmodels_theory(q, model, effective_radius_mode=0, structure_factor_mode=1, **pars)
+    target = sasmodels_theory(q, model, radius_effective_mode=0, structure_factor_mode=1, **pars)
     actual = ellipsoid_pe(q, norm='sasview', **pars)
     title = " ".join(("sasmodels", model, pd_type))
Index: explore/beta/sasfit_compare_new.py
===================================================================
--- explore/beta/sasfit_compare_new.py	(revision b6422c70e7f1518835a0b3c12f01bccb859a6999)
+++ explore/beta/sasfit_compare_new.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -360,5 +360,5 @@
 #polydispersity for hollow_cylinder
 def hollow_cylinder_pe(q,radius=20, thickness=10, length=80, sld=4, sld_solvent=1, volfraction=0.15,
-        radius_pd=0.1, thickness_pd=0.2, length_pd=0.05, radius_pd_type="gaussian", length_pd_type="gaussian", 
+        radius_pd=0.1, thickness_pd=0.2, length_pd=0.05, radius_pd_type="gaussian", length_pd_type="gaussian",
         thickness_pd_type="gaussian", radius_effective=None, background=0, scale=1,
                  norm='sasview'):
@@ -595,5 +595,5 @@
 #       this one is only used locally for "actual"
         )
-    target = sasmodels_theory(q, model, effective_radius_mode=0, structure_factor_mode=1, **pars)
+    target = sasmodels_theory(q, model, radius_effective_mode=0, structure_factor_mode=1, **pars)
     actual = sphere_r(q, norm='sasview', **pars)
     title = " ".join(("sasmodels", model, pd_type))
@@ -612,8 +612,8 @@
         background=0,
         radius_pd=0.01, thickness_pd=0.01, radius_pd_type=pd_type, thickness_pd_type=pd_type,
-        radius_effective=30. ) 
+        radius_effective=30. )
         # equivalent average sphere radius for local "actual" to match what sasview uses, use None to compute average outer radius here,
 
-    target = sasmodels_theory(q, model, effective_radius_mode=0, structure_factor_mode=1, **pars)
+    target = sasmodels_theory(q, model, radius_effective_mode=0, structure_factor_mode=1, **pars)
     actual = vesicle_pe(q, norm='sasview', **pars)
     title = " ".join(("sasmodels", model, pd_type))
@@ -633,7 +633,7 @@
         background=0,
         radius_pd=0.1, thickness_pd=0.0, length_pd=0.0, radius_pd_type=pd_type, thickness_pd_type=pd_type, length_pd_type=pd_type,
-        radius_effective=40.687)  
+        radius_effective=40.687)
         # equivalent average sphere radius for local "actual" to match what sasview uses
-    target = sasmodels_theory(q, model, effective_radius_mode=0, structure_factor_mode=1, **pars)
+    target = sasmodels_theory(q, model, radius_effective_mode=0, structure_factor_mode=1, **pars)
     actual = hollow_cylinder_pe(q, norm='sasview', **pars)
 # RKH monodisp was OK,    actual = hollow_cylinder_theta(q,radius=20, thickness=10, length=80, sld=4, sld_solvent=1 )
@@ -656,5 +656,5 @@
 # if change radius_effective to some other value, the S(Q) from sasview does not agree
         )
-    target = sasmodels_theory(q, model, effective_radius_mode=0, structure_factor_mode=1, **pars)
+    target = sasmodels_theory(q, model, radius_effective_mode=0, structure_factor_mode=1, **pars)
     actual = ellipsoid_pe(q, norm='sasview', **pars)
 # RKH test       actual = ellipsoid_theta(q, radius_polar=20, radius_equatorial=400, sld=4, sld_solvent=1, volfraction=0.15, radius_effective=270.)
Index: sasmodels/conversion_table.py
===================================================================
--- sasmodels/conversion_table.py	(revision fa8e6dcf3e461c78e01fc9879eb87ba90aa8db08)
+++ sasmodels/conversion_table.py	(revision ef476e6b7ffc21ee7a467a47ef19a30527778450)
@@ -854,5 +854,5 @@
             "TwoPowerLawModel",
         ],
-        "unified_power_rg": [
+        "unified_power_Rg": [
             "UnifiedPowerRg",
             dict(((field_new+str(index), field_old+str(index))
Index: sasmodels/convert.py
===================================================================
--- sasmodels/convert.py	(revision fa8e6dcf3e461c78e01fc9879eb87ba90aa8db08)
+++ sasmodels/convert.py	(revision ef476e6b7ffc21ee7a467a47ef19a30527778450)
@@ -606,5 +606,5 @@
             if pars['volfraction_a'] > 0.5:
                 pars['volfraction_a'] = 1.0 - pars['volfraction_a']
-        elif name == 'unified_power_rg':
+        elif name == 'unified_power_Rg':
             pars['level'] = int(pars['level'])
 
Index: sasmodels/core.py
===================================================================
--- sasmodels/core.py	(revision b297ba9e837aada12de87cd46ea7a01bfe549da7)
+++ sasmodels/core.py	(revision 9562dd291d339c408b3d9b5e9ec9b50ac5ea3449)
@@ -376,11 +376,11 @@
     # type: () -> None
     """Check that model load works"""
+    from .product import RADIUS_ID, VOLFRAC_ID, STRUCTURE_MODE_ID, RADIUS_MODE_ID
     #Test the the model produces the parameters that we would expect
     model = load_model("cylinder@hardsphere*sphere")
     actual = [p.name for p in model.info.parameters.kernel_parameters]
-    target = ("sld sld_solvent radius length theta phi"
-              " radius_effective volfraction "
-              " structure_factor_mode radius_effective_mode"
-              " A_sld A_sld_solvent A_radius").split()
+    target = ["sld", "sld_solvent", "radius", "length", "theta", "phi",
+              RADIUS_ID, VOLFRAC_ID, STRUCTURE_MODE_ID, RADIUS_MODE_ID,
+              "A_sld", "A_sld_solvent", "A_radius"]
     assert target == actual, "%s != %s"%(target, actual)
 
Index: sasmodels/direct_model.py
===================================================================
--- sasmodels/direct_model.py	(revision b297ba9e837aada12de87cd46ea7a01bfe549da7)
+++ sasmodels/direct_model.py	(revision e220acc6e66a35148031748a9408b1ffc4530a38)
@@ -59,7 +59,7 @@
     """
     mesh = get_mesh(calculator.info, pars, dim=calculator.dim, mono=mono)
-    #print("pars", list(zip(*mesh))[0])
+    #print("in call_kernel: pars:", list(zip(*mesh))[0])
     call_details, values, is_magnetic = make_kernel_args(calculator, mesh)
-    #print("values:", values)
+    #print("in call_kernel: values:", values)
     return calculator(call_details, values, cutoff, is_magnetic)
 
@@ -72,11 +72,12 @@
 
     Use parameter *radius_effective_mode* to select the effective radius
-    calculation.
+    calculation to use amongst the *radius_effective_modes* list given in the
+    model.
     """
     R_eff_type = int(pars.pop(RADIUS_MODE_ID, 1.0))
     mesh = get_mesh(calculator.info, pars, dim=calculator.dim, mono=mono)
-    #print("pars", list(zip(*mesh))[0])
+    #print("in call_Fq: pars", list(zip(*mesh))[0])
     call_details, values, is_magnetic = make_kernel_args(calculator, mesh)
-    #print("values:", values)
+    #print("in call_Fq: values:", values)
     return calculator.Fq(call_details, values, cutoff, is_magnetic, R_eff_type)
 
@@ -118,5 +119,5 @@
         active = lambda name: True
 
-    #print("pars",[p.id for p in parameters.call_parameters])
+    #print("in get_mesh: pars:",[p.id for p in parameters.call_parameters])
     mesh = [_get_par_weights(p, values, active(p.name))
             for p in parameters.call_parameters]
Index: sasmodels/generate.py
===================================================================
--- sasmodels/generate.py	(revision b297ba9e837aada12de87cd46ea7a01bfe549da7)
+++ sasmodels/generate.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -27,5 +27,5 @@
     which are hollow.
 
-    *effective_radius(mode, p1, p2, ...)* returns the effective radius of
+    *radius_effective(mode, p1, p2, ...)* returns the effective radius of
     the form with particular dimensions.  Mode determines the type of
     effective radius returned, with mode=1 for equivalent volume.
@@ -820,5 +820,5 @@
                               for p in partable.kernel_parameters))
     # Define the function calls
-    call_effective_radius = "#define CALL_EFFECTIVE_RADIUS(_mode, _v) 0.0"
+    call_radius_effective = "#define CALL_RADIUS_EFFECTIVE(_mode, _v) 0.0"
     if partable.form_volume_parameters:
         refs = _call_pars("_v.", partable.form_volume_parameters)
@@ -833,8 +833,8 @@
                 "do { _form = _shell = form_volume(%s); } "
                 "while (0)") % (",".join(refs))
-        if model_info.effective_radius_type:
-            call_effective_radius = (
-                "#define CALL_EFFECTIVE_RADIUS(_mode, _v) "
-                "effective_radius(_mode, %s)") % (",".join(refs))
+        if model_info.radius_effective_modes:
+            call_radius_effective = (
+                "#define CALL_RADIUS_EFFECTIVE(_mode, _v) "
+                "radius_effective(_mode, %s)") % (",".join(refs))
     else:
         # Model doesn't have volume.  We could make the kernel run a little
@@ -845,5 +845,5 @@
             "do { _form = _shell = 1.0; } while (0)")
     source.append(call_volume)
-    source.append(call_effective_radius)
+    source.append(call_radius_effective)
     model_refs = _call_pars("_v.", partable.iq_parameters)
 
Index: sasmodels/kernel.py
===================================================================
--- sasmodels/kernel.py	(revision b297ba9e837aada12de87cd46ea7a01bfe549da7)
+++ sasmodels/kernel.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -78,5 +78,5 @@
         """
         _, F2, _, shell_volume, _ = self.Fq(call_details, values, cutoff,
-                                            magnetic, effective_radius_type=0)
+                                            magnetic, radius_effective_mode=0)
         combined_scale = values[0]/shell_volume
         background = values[1]
@@ -85,5 +85,5 @@
 
     def Fq(self, call_details, values, cutoff, magnetic,
-           effective_radius_type=0):
+           radius_effective_mode=0):
         # type: (CallDetails, np.ndarray, np.ndarray, float, bool, int) -> np.ndarray
         r"""
@@ -143,5 +143,5 @@
         volume fraction of the particles.  The model can have several
         different ways to compute effective radius, with the
-        *effective_radius_type* parameter used to select amongst them.  The
+        *radius_effective_mode* parameter used to select amongst them.  The
         volume fraction of particles should be determined from the total
         volume fraction of the form, not just the shell volume fraction.
@@ -153,5 +153,5 @@
         """
         self._call_kernel(call_details, values, cutoff, magnetic,
-                          effective_radius_type)
+                          radius_effective_mode)
         #print("returned",self.q_input.q, self.result)
         nout = 2 if self.info.have_Fq and self.dim == '1d' else 1
@@ -165,5 +165,5 @@
         form_volume = self.result[nout*self.q_input.nq + 1]/total_weight
         shell_volume = self.result[nout*self.q_input.nq + 2]/total_weight
-        effective_radius = self.result[nout*self.q_input.nq + 3]/total_weight
+        radius_effective = self.result[nout*self.q_input.nq + 3]/total_weight
         if shell_volume == 0.:
             shell_volume = 1.
@@ -171,5 +171,5 @@
               if nout == 2 else None)
         F2 = self.result[0:nout*self.q_input.nq:nout]/total_weight
-        return F1, F2, effective_radius, shell_volume, form_volume/shell_volume
+        return F1, F2, radius_effective, shell_volume, form_volume/shell_volume
 
     def release(self):
@@ -181,5 +181,5 @@
 
     def _call_kernel(self, call_details, values, cutoff, magnetic,
-                     effective_radius_type):
+                     radius_effective_mode):
         # type: (CallDetails, np.ndarray, np.ndarray, float, bool, int) -> np.ndarray
         """
Index: sasmodels/kernel_iq.c
===================================================================
--- sasmodels/kernel_iq.c	(revision 8973e0dd01924c3850d3624b5b4a433a0e2893c8)
+++ sasmodels/kernel_iq.c	(revision 8973e0dd01924c3850d3624b5b4a433a0e2893c8)
@@ -27,5 +27,5 @@
 //      parameters in the parameter table.
 //  CALL_VOLUME(form, shell, table) : assign form and shell values
-//  CALL_EFFECTIVE_RADIUS(type, table) : call the R_eff function
+//  CALL_RADIUS_EFFECTIVE(mode, table) : call the R_eff function
 //  CALL_IQ(q, table) : call the Iq function for 1D calcs.
 //  CALL_IQ_A(q, table) : call the Iq function with |q| for 2D data.
@@ -304,5 +304,5 @@
     pglobal double *result,       // nq+1 return values, again with padding
     const double cutoff,          // cutoff in the dispersity weight product
-    int32_t effective_radius_type // which effective radius to compute
+    int32_t radius_effective_mode // which effective radius to compute
     )
 {
@@ -722,6 +722,6 @@
       weighted_form += weight * form;
       weighted_shell += weight * shell;
-      if (effective_radius_type != 0) {
-        weighted_radius += weight * CALL_EFFECTIVE_RADIUS(effective_radius_type, local_values.table);
+      if (radius_effective_mode != 0) {
+        weighted_radius += weight * CALL_RADIUS_EFFECTIVE(radius_effective_mode, local_values.table);
       }
       BUILD_ROTATION();
Index: sasmodels/kernelcl.py
===================================================================
--- sasmodels/kernelcl.py	(revision 069743ad3277819b232d3b3bc5a2e94eb110f106)
+++ sasmodels/kernelcl.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -577,5 +577,5 @@
 
     def _call_kernel(self, call_details, values, cutoff, magnetic,
-                     effective_radius_type):
+                     radius_effective_mode):
         # type: (CallDetails, np.ndarray, float, bool, int) -> np.ndarray
         env = environment()
@@ -601,5 +601,5 @@
             self._result_b,   # Result storage.
             self._as_dtype(cutoff),  # Probability cutoff.
-            np.uint32(effective_radius_type),  # R_eff mode.
+            np.uint32(radius_effective_mode),  # R_eff mode.
         ]
 
Index: sasmodels/kernelcuda.py
===================================================================
--- sasmodels/kernelcuda.py	(revision b297ba9e837aada12de87cd46ea7a01bfe549da7)
+++ sasmodels/kernelcuda.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -473,5 +473,5 @@
 
     def _call_kernel(self, call_details, values, cutoff, magnetic,
-                     effective_radius_type):
+                     radius_effective_mode):
         # type: (CallDetails, np.ndarray, float, bool, int) -> np.ndarray
 
@@ -492,5 +492,5 @@
             self._result_b,   # Result storage.
             self._as_dtype(cutoff),  # Probability cutoff.
-            np.uint32(effective_radius_type),  # R_eff mode.
+            np.uint32(radius_effective_mode),  # R_eff mode.
         ]
         grid = partition(self.q_input.nq)
Index: sasmodels/kerneldll.py
===================================================================
--- sasmodels/kerneldll.py	(revision b297ba9e837aada12de87cd46ea7a01bfe549da7)
+++ sasmodels/kerneldll.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -403,5 +403,5 @@
 
     def _call_kernel(self, call_details, values, cutoff, magnetic,
-                     effective_radius_type):
+                     radius_effective_mode):
         # type: (CallDetails, np.ndarray, float, bool, int) -> np.ndarray
 
@@ -417,5 +417,5 @@
             self.result.ctypes.data,   # Result storage.
             self._as_dtype(cutoff),  # Probability cutoff.
-            effective_radius_type,  # R_eff mode.
+            radius_effective_mode,  # R_eff mode.
         ]
 
Index: sasmodels/kernelpy.py
===================================================================
--- sasmodels/kernelpy.py	(revision b297ba9e837aada12de87cd46ea7a01bfe549da7)
+++ sasmodels/kernelpy.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -172,5 +172,5 @@
         volume = model_info.form_volume
         shell = model_info.shell_volume
-        radius = model_info.effective_radius
+        radius = model_info.radius_effective
         self._volume = ((lambda: (shell(*volume_args), volume(*volume_args))) if shell and volume
                         else (lambda: [volume(*volume_args)]*2) if volume
@@ -180,5 +180,5 @@
                         else (lambda mode: 1.0))
 
-    def _call_kernel(self, call_details, values, cutoff, magnetic, effective_radius_type):
+    def _call_kernel(self, call_details, values, cutoff, magnetic, radius_effective_mode):
         # type: (CallDetails, np.ndarray, np.ndarray, float, bool) -> np.ndarray
         if magnetic:
@@ -186,6 +186,6 @@
         #print("Calling python kernel")
         #call_details.show(values)
-        radius = ((lambda: 0.0) if effective_radius_type == 0
-                  else (lambda: self._radius(effective_radius_type)))
+        radius = ((lambda: 0.0) if radius_effective_mode == 0
+                  else (lambda: self._radius(radius_effective_mode)))
         self.result = _loops(
             self._parameter_vector, self._form, self._volume, radius,
Index: sasmodels/model_test.py
===================================================================
--- sasmodels/model_test.py	(revision b297ba9e837aada12de87cd46ea7a01bfe549da7)
+++ sasmodels/model_test.py	(revision 8795b6f853cd54be29051109ba0e616e1b31b673)
@@ -240,4 +240,5 @@
                     s_name = pars.pop('@S')
                     ps_test = [pars] + list(test[1:])
+                    #print("PS TEST PARAMS!!!",ps_test)
                     # build the P@S model
                     s_info = load_model_info(s_name)
@@ -246,4 +247,7 @@
                                            platform=self.platform)
                     # run the tests
+                    #self.info = ps_model.info
+                    #print("SELF.INFO PARAMS!!!",[p.id for p in self.info.parameters.call_parameters])
+                    #print("PS MODEL PARAMETERS:",[p.id for p in ps_model.info.parameters.call_parameters])
                     results.append(self.run_one(ps_model, ps_test))
 
@@ -303,6 +307,7 @@
             """Run a single test case."""
             user_pars, x, y = test[:3]
-            pars = expand_pars(self.info.parameters, user_pars)
-            invalid = invalid_pars(self.info.parameters, pars)
+            #print("PS MODEL PARAMETERS:",[p.id for p in model.info.parameters.call_parameters])
+            pars = expand_pars(model.info.parameters, user_pars)
+            invalid = invalid_pars(model.info.parameters, pars)
             if invalid:
                 raise ValueError("Unknown parameters in test: " + ", ".join(invalid))
@@ -328,30 +333,18 @@
             else:
                 y1 = y
-                y2 = test[3] if not isinstance(test[3], list) else [test[3]]
-                F1, F2, R_eff, volume, volume_ratio = call_Fq(kernel, pars)
-                if F1 is not None:  # F1 is none for models with Iq instead of Fq
-                    self._check_vectors(x, y1, F1, 'F')
-                self._check_vectors(x, y2, F2, 'F^2')
+                y2 = test[3] if isinstance(test[3], list) else [test[3]]
+                F, Fsq, R_eff, volume, volume_ratio = call_Fq(kernel, pars)
+                if F is not None:  # F is none for models with Iq instead of Fq
+                    self._check_vectors(x, y1, F, 'F')
+                self._check_vectors(x, y2, Fsq, 'F^2')
                 self._check_scalar(test[4], R_eff, 'R_eff')
                 self._check_scalar(test[5], volume, 'volume')
                 self._check_scalar(test[6], volume_ratio, 'form:shell ratio')
-                return F2
+                return Fsq
 
         def _check_scalar(self, target, actual, name):
-            if target is None:
-                # smoke test --- make sure it runs and produces a value
-                self.assertTrue(not np.isnan(actual),
-                                'invalid %s: %s' % (name, actual))
-            elif np.isnan(target):
-                # make sure nans match
-                self.assertTrue(np.isnan(actual),
-                                '%s: expected:%s; actual:%s'
-                                % (name, target, actual))
-            else:
-                # is_near does not work for infinite values, so also test
-                # for exact values.
-                self.assertTrue(target == actual or is_near(target, actual, 5),
-                                '%s: expected:%s; actual:%s'
-                                % (name, target, actual))
+            self.assertTrue(is_near(target, actual, 5),
+                            '%s: expected:%s; actual:%s'
+                            % (name, target, actual))
 
         def _check_vectors(self, x, target, actual, name='I'):
@@ -363,19 +356,7 @@
                              '%s(...) returned wrong length'%name)
             for xi, yi, actual_yi in zip(x, target, actual):
-                if yi is None:
-                    # smoke test --- make sure it runs and produces a value
-                    self.assertTrue(not np.isnan(actual_yi),
-                                    'invalid %s(%s): %s' % (name, xi, actual_yi))
-                elif np.isnan(yi):
-                    # make sure nans match
-                    self.assertTrue(np.isnan(actual_yi),
-                                    '%s(%s): expected:%s; actual:%s'
-                                    % (name, xi, yi, actual_yi))
-                else:
-                    # is_near does not work for infinite values, so also test
-                    # for exact values.
-                    self.assertTrue(yi == actual_yi or is_near(yi, actual_yi, 5),
-                                    '%s(%s); expected:%s; actual:%s'
-                                    % (name, xi, yi, actual_yi))
+                self.assertTrue(is_near(yi, actual_yi, 5),
+                                '%s(%s): expected:%s; actual:%s'
+                                % (name, xi, target, actual))
 
     return ModelTestCase
@@ -389,5 +370,8 @@
     invalid = []
     for par in sorted(pars.keys()):
-        # special handling of R_eff mode, which is not a usual parameter
+        # Ignore the R_eff mode parameter when checking for valid parameters.
+        # It is an allowed parameter for a model even though it does not exist
+        # in the parameter table.  The call_Fq() function pops it from the
+        # parameter list and sends it directly to kernel.Fq().
         if par == product.RADIUS_MODE_ID:
             continue
@@ -405,8 +389,29 @@
     """
     Returns true if *actual* is within *digits* significant digits of *target*.
-    """
-    import math
-    shift = 10**math.ceil(math.log10(abs(target)))
-    return abs(target-actual)/shift < 1.5*10**-digits
+
+    *taget* zero and inf should match *actual* zero and inf.  If you want to
+    accept eps for zero, choose a value such as 1e-10, which must match up to
+    +/- 1e-15 when *digits* is the default value of 5.
+
+    If *target* is None, then just make sure that *actual* is not NaN.
+
+    If *target* is NaN, make sure *actual* is NaN.
+    """
+    if target is None:
+        # target is None => actual cannot be NaN
+        return not np.isnan(actual)
+    elif target == 0.:
+        # target is 0. => actual must be 0.
+        # Note: if small values are allowed, then use maybe test zero against eps instead?
+        return actual == 0.
+    elif np.isfinite(target):
+        shift = np.ceil(np.log10(abs(target)))
+        return abs(target-actual) < 1.5*10**(shift-digits)
+    elif target == actual:
+        # target is inf => actual must be inf of same sign
+        return True
+    else:
+        # target is NaN => actual must be NaN
+        return np.isnan(target) == np.isnan(actual)
 
 # CRUFT: old interface; should be deprecated and removed
Index: sasmodels/modelinfo.py
===================================================================
--- sasmodels/modelinfo.py	(revision b297ba9e837aada12de87cd46ea7a01bfe549da7)
+++ sasmodels/modelinfo.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -265,5 +265,5 @@
     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
+    to shell_volume (for hollow shapes), and to radius_effective (for
     structure factor interactions) respectively.
 
@@ -841,5 +841,5 @@
     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.radius_effective_modes = getattr(kernel_module, 'radius_effective_modes', None)
     info.have_Fq = getattr(kernel_module, 'have_Fq', False)
     info.profile_axes = getattr(kernel_module, 'profile_axes', ['x', 'y'])
@@ -848,5 +848,5 @@
     info.source = getattr(kernel_module, 'source', [])
     info.c_code = getattr(kernel_module, 'c_code', None)
-    info.effective_radius = getattr(kernel_module, 'effective_radius', None)
+    info.radius_effective = getattr(kernel_module, 'radius_effective', None)
     # TODO: check the structure of the tests
     info.tests = getattr(kernel_module, 'tests', [])
@@ -961,5 +961,5 @@
     #: 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]
+    radius_effective_modes = 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
@@ -989,5 +989,5 @@
     #: monodisperse approximation for non-dilute solutions, P@S.  The first
     #: argument is the integer effective radius mode, with default 0.
-    effective_radius = None  # type: Union[None, Callable[[int, np.ndarray], float]]
+    radius_effective = None  # type: Union[None, Callable[[int, 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
Index: sasmodels/models/_spherepy.py
===================================================================
--- sasmodels/models/_spherepy.py	(revision 0507e09b26f5789862db8a175d64657cf4f3b829)
+++ sasmodels/models/_spherepy.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -48,6 +48,6 @@
 ----------------------------
 
-* **Author: P Kienzle** 
-* **Last Modified by:** 
+* **Author: P Kienzle**
+* **Last Modified by:**
 * **Last Reviewed by:** S King and P Parker **Date:** 2013/09/09 and 2014/01/06
 * **Source added by :** Steve King **Date:** March 25, 2019
@@ -83,7 +83,7 @@
     return 1.333333333333333 * pi * radius ** 3
 
-def effective_radius(mode, radius):
+def radius_effective(mode, radius):
     """Calculate R_eff for sphere"""
-    return radius
+    return radius if mode else 0.
 
 def Iq(q, sld, sld_solvent, radius):
Index: sasmodels/models/barbell.c
===================================================================
--- sasmodels/models/barbell.c	(revision 99658f6e997e12486269a52113af19f5089e0ef0)
+++ sasmodels/models/barbell.c	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -85,5 +85,5 @@
 
 static double
-effective_radius(int mode, double radius_bell, double radius, double length)
+radius_effective(int mode, double radius_bell, double radius, double length)
 {
     switch (mode) {
Index: sasmodels/models/barbell.py
===================================================================
--- sasmodels/models/barbell.py	(revision 0507e09b26f5789862db8a175d64657cf4f3b829)
+++ sasmodels/models/barbell.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -126,5 +126,5 @@
 source = ["lib/polevl.c", "lib/sas_J1.c", "lib/gauss76.c", "barbell.c"]
 have_Fq = True
-effective_radius_type = [
+radius_effective_modes = [
     "equivalent cylinder excluded volume", "equivalent volume sphere",
     "radius", "half length", "half total length",
Index: sasmodels/models/capped_cylinder.c
===================================================================
--- sasmodels/models/capped_cylinder.c	(revision 99658f6e997e12486269a52113af19f5089e0ef0)
+++ sasmodels/models/capped_cylinder.c	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -107,5 +107,5 @@
 
 static double
-effective_radius(int mode, double radius, double radius_cap, double length)
+radius_effective(int mode, double radius, double radius_cap, double length)
 {
     switch (mode) {
Index: sasmodels/models/capped_cylinder.py
===================================================================
--- sasmodels/models/capped_cylinder.py	(revision 0507e09b26f5789862db8a175d64657cf4f3b829)
+++ sasmodels/models/capped_cylinder.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -146,5 +146,5 @@
 source = ["lib/polevl.c", "lib/sas_J1.c", "lib/gauss76.c", "capped_cylinder.c"]
 have_Fq = True
-effective_radius_type = [
+radius_effective_modes = [
     "equivalent cylinder excluded volume", "equivalent volume sphere",
     "radius", "half length", "half total length",
Index: sasmodels/models/core_multi_shell.c
===================================================================
--- sasmodels/models/core_multi_shell.c	(revision d42dd4a6467163ad6ef165b733218fc2181ec1de)
+++ sasmodels/models/core_multi_shell.c	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -26,5 +26,5 @@
 
 static double
-effective_radius(int mode, double core_radius, double fp_n, double thickness[])
+radius_effective(int mode, double core_radius, double fp_n, double thickness[])
 {
   switch (mode) {
Index: sasmodels/models/core_multi_shell.py
===================================================================
--- sasmodels/models/core_multi_shell.py	(revision 0507e09b26f5789862db8a175d64657cf4f3b829)
+++ sasmodels/models/core_multi_shell.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -108,5 +108,5 @@
 source = ["lib/sas_3j1x_x.c", "core_multi_shell.c"]
 have_Fq = True
-effective_radius_type = ["outer radius", "core radius"]
+radius_effective_modes = ["outer radius", "core radius"]
 
 def random():
Index: sasmodels/models/core_shell_bicelle.c
===================================================================
--- sasmodels/models/core_shell_bicelle.c	(revision 99658f6e997e12486269a52113af19f5089e0ef0)
+++ sasmodels/models/core_shell_bicelle.c	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -60,5 +60,5 @@
 
 static double
-effective_radius(int mode, double radius, double thick_rim, double thick_face, double length)
+radius_effective(int mode, double radius, double thick_rim, double thick_face, double length)
 {
     switch (mode) {
Index: sasmodels/models/core_shell_bicelle.py
===================================================================
--- sasmodels/models/core_shell_bicelle.py	(revision 0507e09b26f5789862db8a175d64657cf4f3b829)
+++ sasmodels/models/core_shell_bicelle.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -165,5 +165,5 @@
           "core_shell_bicelle.c"]
 have_Fq = True
-effective_radius_type = [
+radius_effective_modes = [
     "excluded volume", "equivalent volume sphere", "outer rim radius",
     "half outer thickness", "half diagonal",
Index: sasmodels/models/core_shell_bicelle_elliptical.c
===================================================================
--- sasmodels/models/core_shell_bicelle_elliptical.c	(revision 99658f6e997e12486269a52113af19f5089e0ef0)
+++ sasmodels/models/core_shell_bicelle_elliptical.c	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -35,5 +35,5 @@
 
 static double
-effective_radius(int mode, double r_minor, double x_core, double thick_rim, double thick_face, double length)
+radius_effective(int mode, double r_minor, double x_core, double thick_rim, double thick_face, double length)
 {
     switch (mode) {
Index: sasmodels/models/core_shell_bicelle_elliptical.py
===================================================================
--- sasmodels/models/core_shell_bicelle_elliptical.py	(revision 0507e09b26f5789862db8a175d64657cf4f3b829)
+++ sasmodels/models/core_shell_bicelle_elliptical.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -155,5 +155,5 @@
           "core_shell_bicelle_elliptical.c"]
 have_Fq = True
-effective_radius_type = [
+radius_effective_modes = [
     "equivalent cylinder excluded volume", "equivalent volume sphere",
     "outer rim average radius", "outer rim min radius",
Index: sasmodels/models/core_shell_bicelle_elliptical_belt_rough.c
===================================================================
--- sasmodels/models/core_shell_bicelle_elliptical_belt_rough.c	(revision 99658f6e997e12486269a52113af19f5089e0ef0)
+++ sasmodels/models/core_shell_bicelle_elliptical_belt_rough.c	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -36,5 +36,5 @@
 
 static double
-effective_radius(int mode, double r_minor, double x_core, double thick_rim, double thick_face, double length)
+radius_effective(int mode, double r_minor, double x_core, double thick_rim, double thick_face, double length)
 {
     switch (mode) {
Index: sasmodels/models/core_shell_bicelle_elliptical_belt_rough.py
===================================================================
--- sasmodels/models/core_shell_bicelle_elliptical_belt_rough.py	(revision 0507e09b26f5789862db8a175d64657cf4f3b829)
+++ sasmodels/models/core_shell_bicelle_elliptical_belt_rough.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -168,5 +168,5 @@
           "core_shell_bicelle_elliptical_belt_rough.c"]
 have_Fq = True
-effective_radius_type = [
+radius_effective_modes = [
     "equivalent cylinder excluded volume", "equivalent volume sphere",
     "outer rim average radius", "outer rim min radius",
Index: sasmodels/models/core_shell_cylinder.c
===================================================================
--- sasmodels/models/core_shell_cylinder.c	(revision 99658f6e997e12486269a52113af19f5089e0ef0)
+++ sasmodels/models/core_shell_cylinder.c	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -37,5 +37,5 @@
 
 static double
-effective_radius(int mode, double radius, double thickness, double length)
+radius_effective(int mode, double radius, double thickness, double length)
 {
     switch (mode) {
Index: sasmodels/models/core_shell_cylinder.py
===================================================================
--- sasmodels/models/core_shell_cylinder.py	(revision 81d0b9bccff7ed3da6e4dd6a1f3cebae2e86f542)
+++ sasmodels/models/core_shell_cylinder.py	(revision db1d9d5f306f6645d007300bc421fb71d3669eda)
@@ -141,5 +141,5 @@
 source = ["lib/polevl.c", "lib/sas_J1.c", "lib/gauss76.c", "core_shell_cylinder.c"]
 have_Fq = True
-effective_radius_type = [
+radius_effective_modes = [
     "excluded volume", "equivalent volume sphere", "outer radius", "half outer length",
     "half min outer dimension", "half max outer dimension", "half outer diagonal",
Index: sasmodels/models/core_shell_ellipsoid.c
===================================================================
--- sasmodels/models/core_shell_ellipsoid.c	(revision 99658f6e997e12486269a52113af19f5089e0ef0)
+++ sasmodels/models/core_shell_ellipsoid.c	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -68,5 +68,5 @@
 
 static double
-effective_radius(int mode, double radius_equat_core, double x_core, double thick_shell, double x_polar_shell)
+radius_effective(int mode, double radius_equat_core, double x_core, double thick_shell, double x_polar_shell)
 {
     const double radius_equat_tot = radius_equat_core + thick_shell;
Index: sasmodels/models/core_shell_ellipsoid.py
===================================================================
--- sasmodels/models/core_shell_ellipsoid.py	(revision e5a8f33dff2ddeac9fa0154daadf4f8eaed568e2)
+++ sasmodels/models/core_shell_ellipsoid.py	(revision db1d9d5f306f6645d007300bc421fb71d3669eda)
@@ -3,8 +3,8 @@
 ----------
 
-Parameters for this model are the core axial ratio $X_{core}$ and a shell 
-thickness $t_{shell}$, which are more often what we would like to determine 
-and make the model better behaved, particularly when polydispersity is 
-applied, than the four independent radii used in the original parameterization 
+Parameters for this model are the core axial ratio $X_{core}$ and a shell
+thickness $t_{shell}$, which are more often what we would like to determine
+and make the model better behaved, particularly when polydispersity is
+applied, than the four independent radii used in the original parameterization
 of this model.
 
@@ -19,5 +19,5 @@
 $X_{core}$ = 1 is a spherical core.
 
-For a fixed shell thickness $X_{polar shell}$ = 1, to scale $t_{shell}$ 
+For a fixed shell thickness $X_{polar shell}$ = 1, to scale $t_{shell}$
 pro-rata with the radius set or constrain $X_{polar shell}$ = $X_{core}$.
 
@@ -47,5 +47,4 @@
 
 .. In following equation SK changed radius\_equat\_core to R_e
-  
 .. math::
     :nowrap:
@@ -76,6 +75,6 @@
 $V = (4/3)\pi R_pR_e^2$ is the volume of the ellipsoid , $R_p$ is the
 polar radius along the rotational axis of the ellipsoid, $R_e$ is the
-equatorial radius perpendicular to the rotational axis of the ellipsoid, 
-$t_{shell}$ is the thickness of the shell at the equator, 
+equatorial radius perpendicular to the rotational axis of the ellipsoid,
+$t_{shell}$ is the thickness of the shell at the equator,
 and $\Delta \rho$ (the contrast) is the scattering length density difference,
 either $(\rho_{core} - \rho_{shell})$ or $(\rho_{shell} - \rho_{solvent})$.
@@ -161,5 +160,5 @@
 source = ["lib/sas_3j1x_x.c", "lib/gauss76.c", "core_shell_ellipsoid.c"]
 have_Fq = True
-effective_radius_type = [
+radius_effective_modes = [
     "average outer curvature", "equivalent volume sphere",
     "min outer radius", "max outer radius",
Index: sasmodels/models/core_shell_parallelepiped.c
===================================================================
--- sasmodels/models/core_shell_parallelepiped.c	(revision 99658f6e997e12486269a52113af19f5089e0ef0)
+++ sasmodels/models/core_shell_parallelepiped.c	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -75,5 +75,5 @@
 
 static double
-effective_radius(int mode, double length_a, double length_b, double length_c,
+radius_effective(int mode, double length_a, double length_b, double length_c,
                  double thick_rim_a, double thick_rim_b, double thick_rim_c)
 {
Index: sasmodels/models/core_shell_parallelepiped.py
===================================================================
--- sasmodels/models/core_shell_parallelepiped.py	(revision 0507e09b26f5789862db8a175d64657cf4f3b829)
+++ sasmodels/models/core_shell_parallelepiped.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -236,5 +236,5 @@
 source = ["lib/gauss76.c", "core_shell_parallelepiped.c"]
 have_Fq = True
-effective_radius_type = [
+radius_effective_modes = [
     "equivalent cylinder excluded volume",
     "equivalent volume sphere",
Index: sasmodels/models/core_shell_sphere.c
===================================================================
--- sasmodels/models/core_shell_sphere.c	(revision d42dd4a6467163ad6ef165b733218fc2181ec1de)
+++ sasmodels/models/core_shell_sphere.c	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -6,5 +6,5 @@
 
 static double
-effective_radius(int mode, double radius, double thickness)
+radius_effective(int mode, double radius, double thickness)
 {
     switch (mode) {
Index: sasmodels/models/core_shell_sphere.py
===================================================================
--- sasmodels/models/core_shell_sphere.py	(revision 0507e09b26f5789862db8a175d64657cf4f3b829)
+++ sasmodels/models/core_shell_sphere.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -60,7 +60,7 @@
 ----------------------------
 
-* **Author:** 
-* **Last Modified by:** 
-* **Last Reviewed by:** 
+* **Author:**
+* **Last Modified by:**
+* **Last Reviewed by:**
 * **Source added by :** Steve King **Date:** March 25, 2019
 """
@@ -92,5 +92,5 @@
 source = ["lib/sas_3j1x_x.c", "lib/core_shell.c", "core_shell_sphere.c"]
 have_Fq = True
-effective_radius_type = ["outer radius", "core radius"]
+radius_effective_modes = ["outer radius", "core radius"]
 
 demo = dict(scale=1, background=0, radius=60, thickness=10,
Index: sasmodels/models/cylinder.c
===================================================================
--- sasmodels/models/cylinder.c	(revision 99658f6e997e12486269a52113af19f5089e0ef0)
+++ sasmodels/models/cylinder.c	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -32,5 +32,5 @@
 
 static double
-effective_radius(int mode, double radius, double length)
+radius_effective(int mode, double radius, double length)
 {
     switch (mode) {
Index: sasmodels/models/cylinder.py
===================================================================
--- sasmodels/models/cylinder.py	(revision 0507e09b26f5789862db8a175d64657cf4f3b829)
+++ sasmodels/models/cylinder.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -110,7 +110,7 @@
 ----------------------------
 
-* **Author:** 
-* **Last Modified by:** 
-* **Last Reviewed by:** 
+* **Author:**
+* **Last Modified by:**
+* **Last Reviewed by:**
 * **Source added by :** Steve King **Date:** March 25, 2019
 """
@@ -155,5 +155,5 @@
 source = ["lib/polevl.c", "lib/sas_J1.c", "lib/gauss76.c", "cylinder.c"]
 have_Fq = True
-effective_radius_type = [
+radius_effective_modes = [
     "excluded volume", "equivalent volume sphere", "radius",
     "half length", "half min dimension", "half max dimension", "half diagonal",
@@ -184,26 +184,28 @@
             phi_pd=10, phi_pd_n=5)
 
-# pylint: disable=bad-whitespace, line-too-long
+# Test 1-D and 2-D models
 qx, qy = 0.2 * np.cos(2.5), 0.2 * np.sin(2.5)
-# After redefinition of angles, find new tests values.  Was 10 10 in old coords
+theta, phi = 80.1534480601659, 10.1510817110481  # (10, 10) in sasview 3.x
 tests = [
     [{}, 0.2, 0.042761386790780453],
     [{}, [0.2], [0.042761386790780453]],
-    #  new coords
-    [{'theta':80.1534480601659, 'phi':10.1510817110481}, (qx, qy), 0.03514647218513852],
-    [{'theta':80.1534480601659, 'phi':10.1510817110481}, [(qx, qy)], [0.03514647218513852]],
-    # old coords
-    #[{'theta':10.0, 'phi':10.0}, (qx, qy), 0.03514647218513852],
-    #[{'theta':10.0, 'phi':10.0}, [(qx, qy)], [0.03514647218513852]],
+    [{'theta': theta, 'phi': phi}, (qx, qy), 0.03514647218513852],
+    [{'theta': theta, 'phi': phi}, [(qx, qy)], [0.03514647218513852]],
 ]
-del qx, qy  # not necessary to delete, but cleaner
-
-# Default radius and length
-def calc_volume(radius, length):
-    """Return form volume for cylinder."""
-    return pi*radius**2*length
-def calc_r_effs(radius, length):
-    """Return effective radii for modes 0-7 of cylinder."""
-    return [
+del qx, qy, theta, phi  # not necessary to delete, but cleaner
+
+def _extend_with_reff_tests(radius, length):
+    """Test R_eff and form volume calculations"""
+    # V and Vr are the same for each R_eff mode
+    V = pi*radius**2*length  # shell volume = form volume for solid objects
+    Vr = 1.0  # form:shell volume ratio
+    # Use test value for I(0.2) from above to check Fsq value.  Need to
+    # remove scale and background before testing.
+    q = 0.2
+    scale, background = V, 0.001
+    Fsq = (0.042761386790780453 - background)*scale
+    F = None  # Need target value for <F>
+    # Various values for R_eff, depending on mode
+    r_effs = [
         0.,
         0.5*(0.75*radius*(2.0*radius*length
@@ -216,18 +218,18 @@
         np.sqrt(4*radius**2 + length**2)/2.,
     ]
-r_effs = calc_r_effs(parameters[2][2], parameters[3][2])
-cyl_vol = calc_volume(parameters[2][2], parameters[3][2])
-tests.extend([
-    ({'radius_effective_mode': 0}, 0.1, None, None, r_effs[0], cyl_vol, 1.0),
-    ({'radius_effective_mode': 1}, 0.1, None, None, r_effs[1], None, None),
-    ({'radius_effective_mode': 2}, 0.1, None, None, r_effs[2], None, None),
-    ({'radius_effective_mode': 3}, 0.1, None, None, r_effs[3], None, None),
-    ({'radius_effective_mode': 4}, 0.1, None, None, r_effs[4], None, None),
-    ({'radius_effective_mode': 5}, 0.1, None, None, r_effs[5], None, None),
-    ({'radius_effective_mode': 6}, 0.1, None, None, r_effs[6], None, None),
-    ({'radius_effective_mode': 7}, 0.1, None, None, r_effs[7], None, None),
-])
-del r_effs, cyl_vol
-# pylint: enable=bad-whitespace, line-too-long
+    tests.extend([
+        ({'radius_effective_mode': 0}, q, F, Fsq, r_effs[0], V, Vr),
+        ({'radius_effective_mode': 1}, q, F, Fsq, r_effs[1], V, Vr),
+        ({'radius_effective_mode': 2}, q, F, Fsq, r_effs[2], V, Vr),
+        ({'radius_effective_mode': 3}, q, F, Fsq, r_effs[3], V, Vr),
+        ({'radius_effective_mode': 4}, q, F, Fsq, r_effs[4], V, Vr),
+        ({'radius_effective_mode': 5}, q, F, Fsq, r_effs[5], V, Vr),
+        ({'radius_effective_mode': 6}, q, F, Fsq, r_effs[6], V, Vr),
+        ({'radius_effective_mode': 7}, q, F, Fsq, r_effs[7], V, Vr),
+    ])
+
+# Test Reff and volume with default model parameters
+_extend_with_reff_tests(parameters[2][2], parameters[3][2])
+del _extend_with_reff_tests
 
 # ADDED by:  RKH  ON: 18Mar2016 renamed sld's etc
Index: sasmodels/models/ellipsoid.c
===================================================================
--- sasmodels/models/ellipsoid.c	(revision 99658f6e997e12486269a52113af19f5089e0ef0)
+++ sasmodels/models/ellipsoid.c	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -32,5 +32,5 @@
 
 static double
-effective_radius(int mode, double radius_polar, double radius_equatorial)
+radius_effective(int mode, double radius_polar, double radius_equatorial)
 {
     switch (mode) {
Index: sasmodels/models/ellipsoid.py
===================================================================
--- sasmodels/models/ellipsoid.py	(revision 0507e09b26f5789862db8a175d64657cf4f3b829)
+++ sasmodels/models/ellipsoid.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -167,5 +167,5 @@
 source = ["lib/sas_3j1x_x.c", "lib/gauss76.c", "ellipsoid.c"]
 have_Fq = True
-effective_radius_type = [
+radius_effective_modes = [
     "average curvature", "equivalent volume sphere", "min radius", "max radius",
     ]
Index: sasmodels/models/elliptical_cylinder.c
===================================================================
--- sasmodels/models/elliptical_cylinder.c	(revision 99658f6e997e12486269a52113af19f5089e0ef0)
+++ sasmodels/models/elliptical_cylinder.c	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -41,5 +41,5 @@
 
 static double
-effective_radius(int mode, double radius_minor, double r_ratio, double length)
+radius_effective(int mode, double radius_minor, double r_ratio, double length)
 {
     switch (mode) {
Index: sasmodels/models/elliptical_cylinder.py
===================================================================
--- sasmodels/models/elliptical_cylinder.py	(revision 0507e09b26f5789862db8a175d64657cf4f3b829)
+++ sasmodels/models/elliptical_cylinder.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -131,5 +131,5 @@
 source = ["lib/polevl.c", "lib/sas_J1.c", "lib/gauss76.c", "elliptical_cylinder.c"]
 have_Fq = True
-effective_radius_type = [
+radius_effective_modes = [
     "equivalent cylinder excluded volume",
     "equivalent volume sphere", "average radius", "min radius", "max radius",
Index: sasmodels/models/flexible_cylinder.py
===================================================================
--- sasmodels/models/flexible_cylinder.py	(revision 40c982540fc3adc5018a73c39d308307a19d52c3)
+++ sasmodels/models/flexible_cylinder.py	(revision db1d9d5f306f6645d007300bc421fb71d3669eda)
@@ -33,5 +33,5 @@
 and solvent respectively.
 
-Our model uses the form factor calculations in reference [1] as implemented in a 
+Our model uses the form factor calculations in reference [1] as implemented in a
 c-library provided by the NIST Center for Neutron Research (Kline, 2006). This states:
 
@@ -41,5 +41,5 @@
     pseudocontinuous limit.
     See equations (13,26-27) in the original reference for the details.
-    
+
 .. note::
 
@@ -61,5 +61,27 @@
 
 
-**This is a model with complex behaviour depending on the ratio of** $L/b$ **and the 
+**This is a model with complex behaviour depending on the ratio of** $L/b$ **and the
+reader is strongly encouraged to read reference [1] before use.**
+
+.. note::
+
+    There are several typos in the original reference that have been corrected
+    by WRC [2]. Details of the corrections are in the reference below. Most notably
+
+    - Equation (13): the term $(1 - w(QR))$ should swap position with $w(QR)$
+
+    - Equations (23) and (24) are incorrect; WRC has entered these into
+      Mathematica and solved analytically. The results were then converted to
+      code.
+
+    - Equation (27) should be $q0 = max(a3/(Rg^2)^{1/2},3)$ instead of
+      $max(a3*b(Rg^2)^{1/2},3)$
+
+    - The scattering function is negative for a range of parameter values and
+      q-values that are experimentally accessible. A correction function has been
+      added to give the proper behavior.
+
+
+**This is a model with complex behaviour depending on the ratio of** $L/b$ **and the
 reader is strongly encouraged to read reference [1] before use.**
 
@@ -85,6 +107,6 @@
 ----------------------------
 
-* **Author:** 
-* **Last Modified by:** 
+* **Author:**
+* **Last Modified by:**
 * **Last Reviewed by:** Steve King **Date:** March 26, 2019
 * **Source added by :** Steve King **Date:** March 25, 2019
Index: sasmodels/models/flexible_cylinder_elliptical.py
===================================================================
--- sasmodels/models/flexible_cylinder_elliptical.py	(revision 40c982540fc3adc5018a73c39d308307a19d52c3)
+++ sasmodels/models/flexible_cylinder_elliptical.py	(revision db1d9d5f306f6645d007300bc421fb71d3669eda)
@@ -26,6 +26,6 @@
 -----------
 
-The function is calculated in a similar way to that for the 
-:ref:`flexible-cylinder` model in reference [1] below using the author's 
+The function is calculated in a similar way to that for the
+:ref:`flexible-cylinder` model in reference [1] below using the author's
 "Method 3 With Excluded Volume".
 
@@ -71,5 +71,5 @@
 these parameters must be held fixed during model fitting.
 
-**This is a model with complex behaviour depending on the ratio of** $L/b$ **and the 
+**This is a model with complex behaviour depending on the ratio of** $L/b$ **and the
 reader is strongly encouraged to read reference [1] before use.**
 
@@ -95,5 +95,5 @@
 ----------------------------
 
-* **Author:** 
+* **Author:**
 * **Last Modified by:** Richard Heenan **Date:** December, 2016
 * **Last Reviewed by:** Steve King **Date:** March 26, 2019
Index: sasmodels/models/fuzzy_sphere.c
===================================================================
--- sasmodels/models/fuzzy_sphere.c	(revision d42dd4a6467163ad6ef165b733218fc2181ec1de)
+++ sasmodels/models/fuzzy_sphere.c	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -5,5 +5,5 @@
 
 static double
-effective_radius(int mode, double radius, double fuzziness)
+radius_effective(int mode, double radius, double fuzziness)
 {
     switch (mode) {
Index: sasmodels/models/fuzzy_sphere.py
===================================================================
--- sasmodels/models/fuzzy_sphere.py	(revision 0507e09b26f5789862db8a175d64657cf4f3b829)
+++ sasmodels/models/fuzzy_sphere.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -63,7 +63,7 @@
 ----------------------------
 
-* **Author:** 
-* **Last Modified by:** 
-* **Last Reviewed by:** 
+* **Author:**
+* **Last Modified by:**
+* **Last Reviewed by:**
 * **Source added by :** Steve King **Date:** March 25, 2019
 """
@@ -98,5 +98,5 @@
 source = ["lib/sas_3j1x_x.c", "fuzzy_sphere.c"]
 have_Fq = True
-effective_radius_type = ["radius", "radius + fuzziness"]
+radius_effective_modes = ["radius", "radius + fuzziness"]
 
 def random():
Index: sasmodels/models/hardsphere.py
===================================================================
--- sasmodels/models/hardsphere.py	(revision 5f3c53407f846f392cb5b6037b030e309de351eb)
+++ sasmodels/models/hardsphere.py	(revision db1d9d5f306f6645d007300bc421fb71d3669eda)
@@ -3,17 +3,17 @@
 Calculates the interparticle structure factor for monodisperse
 spherical particles interacting through hard sphere (excluded volume)
-interactions. This $S(q)$ may also be a reasonable approximation for 
-other particle shapes that freely rotate (but see the note below), 
+interactions. This $S(q)$ may also be a reasonable approximation for
+other particle shapes that freely rotate (but see the note below),
 and for moderately polydisperse systems.
 
 .. note::
 
-   This routine is intended for uncharged particles! For charged 
+   This routine is intended for uncharged particles! For charged
    particles try using the :ref:`hayter-msa` $S(q)$ instead.
-   
+
 .. note::
 
-   Earlier versions of SasView did not incorporate the so-called 
-   $\beta(q)$ ("beta") correction [1] for polydispersity and non-sphericity. 
+   Earlier versions of SasView did not incorporate the so-called
+   $\beta(q)$ ("beta") correction [1] for polydispersity and non-sphericity.
    This is only available in SasView versions 4.2.2 and higher.
 
@@ -25,8 +25,8 @@
 
 For numerical stability the computation uses a Taylor series expansion
-at very small $qR$, but there may be a very minor glitch at the 
+at very small $qR$, but there may be a very minor glitch at the
 transition point in some circumstances.
 
-This S(q) uses the Percus-Yevick closure relationship [2] where the 
+This S(q) uses the Percus-Yevick closure relationship [2] where the
 interparticle potential $U(r)$ is
 
@@ -62,7 +62,7 @@
 ----------------------------
 
-* **Author:** 
-* **Last Modified by:** 
-* **Last Reviewed by:** 
+* **Author:**
+* **Last Modified by:**
+* **Last Reviewed by:**
 * **Source added by :** Steve King **Date:** March 25, 2019
 """
Index: sasmodels/models/hayter_msa.py
===================================================================
--- sasmodels/models/hayter_msa.py	(revision 99478655778bcd4624a7d9e4983e9f86b6f44615)
+++ sasmodels/models/hayter_msa.py	(revision db1d9d5f306f6645d007300bc421fb71d3669eda)
@@ -1,32 +1,32 @@
 # Note: model title and parameter table are inserted automatically
 r"""
-Calculates the interparticle structure factor for a system of charged, 
-spheroidal, objects in a dielectric medium [1,2]. When combined with an 
-appropriate form factor $P(q)$, this allows for inclusion of the 
-interparticle interference effects due to screened Coulombic 
+Calculates the interparticle structure factor for a system of charged,
+spheroidal, objects in a dielectric medium [1,2]. When combined with an
+appropriate form factor $P(q)$, this allows for inclusion of the
+interparticle interference effects due to screened Coulombic
 repulsion between the charged particles.
 
 .. note::
 
-   This routine only works for charged particles! If the charge is set 
-   to zero the routine may self-destruct! For uncharged particles use 
+   This routine only works for charged particles! If the charge is set
+   to zero the routine may self-destruct! For uncharged particles use
    the :ref:`hardsphere` $S(q)$ instead. The upper limit for the charge
    is limited to 200e to avoid numerical instabilities.
-   
+
 .. note::
 
-   Earlier versions of SasView did not incorporate the so-called 
-   $\beta(q)$ ("beta") correction [3] for polydispersity and non-sphericity. 
+   Earlier versions of SasView did not incorporate the so-called
+   $\beta(q)$ ("beta") correction [3] for polydispersity and non-sphericity.
    This is only available in SasView versions 4.2.2 and higher.
 
 The salt concentration is used to compute the ionic strength of the solution
-which in turn is used to compute the Debye screening length. There is no 
-provision for entering the ionic strength directly. **At present the 
-counterions are assumed to be monovalent**, though it should be possible 
-to simulate the effect of multivalent counterions by increasing the salt 
+which in turn is used to compute the Debye screening length. There is no
+provision for entering the ionic strength directly. **At present the
+counterions are assumed to be monovalent**, though it should be possible
+to simulate the effect of multivalent counterions by increasing the salt
 concentration.
 
-Over the range 0 - 100 C the dielectric constant $\kappa$ of water may be 
-approximated with a maximum deviation of 0.01 units by the empirical 
+Over the range 0 - 100 C the dielectric constant $\kappa$ of water may be
+approximated with a maximum deviation of 0.01 units by the empirical
 formula [4]
 
@@ -34,5 +34,5 @@
 
     \kappa = 87.740 - 0.40008 T + 9.398x10^{-4} T^2 - 1.410x10^{-6} T^3
-    
+
 where $T$ is the temperature in celsius.
 
@@ -73,6 +73,6 @@
 ----------------------------
 
-* **Author:** 
-* **Last Modified by:** 
+* **Author:**
+* **Last Modified by:**
 * **Last Reviewed by:** Steve King **Date:** March 28, 2019
 * **Source added by :** Steve King **Date:** March 25, 2019
@@ -101,6 +101,6 @@
     [Hayter-Penfold RMSA charged sphere interparticle S(Q) structure factor]
         Interparticle structure factor S(Q) for charged hard spheres.
-    This routine only works for charged particles! For uncharged particles 
-    use the hardsphere S(q) instead. The "beta(q)" correction is available 
+    This routine only works for charged particles! For uncharged particles
+    use the hardsphere S(q) instead. The "beta(q)" correction is available
     in versions 4.2.2 and higher.
 """
@@ -110,8 +110,8 @@
 #             [ "name", "units", default, [lower, upper], "type", "description" ],
 #
-# NOTE: SMK, 28Mar19 The upper limit for charge is set to 200 to avoid instabilities noted by PK in 
-#       Ticket #1152. Also see the thread in Ticket 859. The docs above also note that charge=0 will 
+# NOTE: SMK, 28Mar19 The upper limit for charge is set to 200 to avoid instabilities noted by PK in
+#       Ticket #1152. Also see the thread in Ticket 859. The docs above also note that charge=0 will
 #       cause problems, yet the default parameters allowed it! After discussions with PK I have
-#       changed it to (an arbitarily) small but non-zero value.  But I haven't changed the low limit 
+#       changed it to (an arbitarily) small but non-zero value.  But I haven't changed the low limit
 #       in function random() below.
 #
Index: sasmodels/models/hollow_cylinder.c
===================================================================
--- sasmodels/models/hollow_cylinder.c	(revision 99658f6e997e12486269a52113af19f5089e0ef0)
+++ sasmodels/models/hollow_cylinder.c	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -34,5 +34,5 @@
 
 static double
-effective_radius(int mode, double radius, double thickness, double length)
+radius_effective(int mode, double radius, double thickness, double length)
 {
     switch (mode) {
Index: sasmodels/models/hollow_cylinder.py
===================================================================
--- sasmodels/models/hollow_cylinder.py	(revision 0507e09b26f5789862db8a175d64657cf4f3b829)
+++ sasmodels/models/hollow_cylinder.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -110,5 +110,5 @@
 source = ["lib/polevl.c", "lib/sas_J1.c", "lib/gauss76.c", "hollow_cylinder.c"]
 have_Fq = True
-effective_radius_type = [
+radius_effective_modes = [
     "excluded volume", "equivalent outer volume sphere",
     "outer radius", "half length",
Index: sasmodels/models/hollow_rectangular_prism.c
===================================================================
--- sasmodels/models/hollow_rectangular_prism.c	(revision 99658f6e997e12486269a52113af19f5089e0ef0)
+++ sasmodels/models/hollow_rectangular_prism.c	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -30,5 +30,5 @@
 
 static double
-effective_radius(int mode, double length_a, double b2a_ratio, double c2a_ratio, double thickness)
+radius_effective(int mode, double length_a, double b2a_ratio, double c2a_ratio, double thickness)
 // NOTE length_a is external dimension!
 {
Index: sasmodels/models/hollow_rectangular_prism.py
===================================================================
--- sasmodels/models/hollow_rectangular_prism.py	(revision 0507e09b26f5789862db8a175d64657cf4f3b829)
+++ sasmodels/models/hollow_rectangular_prism.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -157,5 +157,5 @@
 source = ["lib/gauss76.c", "hollow_rectangular_prism.c"]
 have_Fq = True
-effective_radius_type = [
+radius_effective_modes = [
     "equivalent cylinder excluded volume", "equivalent outer volume sphere",
     "half length_a", "half length_b", "half length_c",
Index: sasmodels/models/hollow_rectangular_prism_thin_walls.c
===================================================================
--- sasmodels/models/hollow_rectangular_prism_thin_walls.c	(revision 99658f6e997e12486269a52113af19f5089e0ef0)
+++ sasmodels/models/hollow_rectangular_prism_thin_walls.c	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -26,5 +26,5 @@
 
 static double
-effective_radius(int mode, double length_a, double b2a_ratio, double c2a_ratio)
+radius_effective(int mode, double length_a, double b2a_ratio, double c2a_ratio)
 {
     switch (mode) {
Index: sasmodels/models/hollow_rectangular_prism_thin_walls.py
===================================================================
--- sasmodels/models/hollow_rectangular_prism_thin_walls.py	(revision 0507e09b26f5789862db8a175d64657cf4f3b829)
+++ sasmodels/models/hollow_rectangular_prism_thin_walls.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -117,5 +117,5 @@
 source = ["lib/gauss76.c", "hollow_rectangular_prism_thin_walls.c"]
 have_Fq = True
-effective_radius_type = [
+radius_effective_modes = [
     "equivalent cylinder excluded volume", "equivalent outer volume sphere",
     "half length_a", "half length_b", "half length_c",
Index: sasmodels/models/mono_gauss_coil.c
===================================================================
--- sasmodels/models/mono_gauss_coil.c	(revision 153f8f65310518796a9b07f12a9e7cfa49ee4111)
+++ sasmodels/models/mono_gauss_coil.c	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -6,5 +6,5 @@
 
 static double
-effective_radius(int mode, double rg)
+radius_effective(int mode, double rg)
 {
     switch (mode) {
Index: sasmodels/models/mono_gauss_coil.py
===================================================================
--- sasmodels/models/mono_gauss_coil.py	(revision 0507e09b26f5789862db8a175d64657cf4f3b829)
+++ sasmodels/models/mono_gauss_coil.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -59,7 +59,7 @@
 ----------------------------
 
-* **Author:** 
-* **Last Modified by:** 
-* **Last Reviewed by:** 
+* **Author:**
+* **Last Modified by:**
+* **Last Reviewed by:**
 * **Source added by :** Steve King **Date:** March 25, 2019"""
 
@@ -86,5 +86,5 @@
 source = ["mono_gauss_coil.c"]
 have_Fq = False
-effective_radius_type = ["R_g", "2R_g", "3R_g", "sqrt(5/3)*R_g"]
+radius_effective_modes = ["R_g", "2R_g", "3R_g", "sqrt(5/3)*R_g"]
 
 
Index: sasmodels/models/multilayer_vesicle.c
===================================================================
--- sasmodels/models/multilayer_vesicle.c	(revision ee60aa768b29c58e20b19e94578ec3a94a0889d7)
+++ sasmodels/models/multilayer_vesicle.c	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -48,5 +48,5 @@
 
 static double
-effective_radius(int mode, double radius, double thick_shell, double thick_solvent, double fp_n_shells)
+radius_effective(int mode, double radius, double thick_shell, double thick_solvent, double fp_n_shells)
 {
     // case 1: outer radius
Index: sasmodels/models/multilayer_vesicle.py
===================================================================
--- sasmodels/models/multilayer_vesicle.py	(revision 6607260ee7aa5dd8ac172c86cdec32f354c2726d)
+++ sasmodels/models/multilayer_vesicle.py	(revision db1d9d5f306f6645d007300bc421fb71d3669eda)
@@ -154,5 +154,5 @@
 source = ["lib/sas_3j1x_x.c", "multilayer_vesicle.c"]
 have_Fq = True
-effective_radius_type = ["outer radius"]
+radius_effective_modes = ["outer radius"]
 
 def random():
Index: sasmodels/models/onion.c
===================================================================
--- sasmodels/models/onion.c	(revision ee60aa768b29c58e20b19e94578ec3a94a0889d7)
+++ sasmodels/models/onion.c	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -47,5 +47,5 @@
 
 static double
-effective_radius(int mode, double radius_core, double n_shells, double thickness[])
+radius_effective(int mode, double radius_core, double n_shells, double thickness[])
 {
   // case 1: outer radius
Index: sasmodels/models/onion.py
===================================================================
--- sasmodels/models/onion.py	(revision 62dc8895694e8dcacf8cb65a82b543b1efa56f42)
+++ sasmodels/models/onion.py	(revision db1d9d5f306f6645d007300bc421fb71d3669eda)
@@ -8,5 +8,5 @@
 .. note::
 
-    *radius* represents the core radius $r_0$ and *thickness[k]* represents 
+    *radius* represents the core radius $r_0$ and *thickness[k]* represents
     the thickness of the shell, $r_{k+1} - r_k$.
 
@@ -60,5 +60,5 @@
 and the volume is $V(r) = \frac{4\pi}{3}r^3$.
 
-The volume of the particle is determined by the radius of the outer 
+The volume of the particle is determined by the radius of the outer
 shell, so $V_\text{particle} = V(r_N)$.
 
@@ -104,8 +104,8 @@
     B&=\frac{\rho_\text{out} - \rho_\text{in}}{e^A-1}
          & C &= \frac{\rho_\text{in}e^A - \rho_\text{out}}{e^A-1} \\
-         
+
     \alpha_\text{in} &= A\frac{r_{\text{shell}-1}}{\Delta t_\text{shell}}
          & \alpha_\text{out} &= A\frac{r_\text{shell}}{\Delta t_\text{shell}} \\
-         
+
     \beta_\text{in} &= qr_{\text{shell}-1}
         & \beta_\text{out} &= qr_\text{shell} \\
@@ -123,5 +123,5 @@
 **Linear SLD profile** ($A \sim 0$):
 
-For small $A$, say, $A = -0.0001$, the function converges to that of of a linear 
+For small $A$, say, $A = -0.0001$, the function converges to that of of a linear
 SLD profile with
 
@@ -159,5 +159,5 @@
 **Constant SLD** ($A = 0$):
 
-When $A = 0$ the exponential function has no dependence on the radius (meaning 
+When $A = 0$ the exponential function has no dependence on the radius (meaning
 $\rho_\text{out}$ is ignored in this case) and becomes flat. We set the constant
 to $\rho_\text{in}$ for convenience, and thus the form factor contributed by
@@ -197,6 +197,6 @@
 ----------------------------
 
-* **Author:** 
-* **Last Modified by:** 
+* **Author:**
+* **Last Modified by:**
 * **Last Reviewed by:** Steve King **Date:** March 28, 2019
 * **Source added by :** Steve King **Date:** March 25, 2019
@@ -347,5 +347,5 @@
 single = False
 have_Fq = True
-effective_radius_type = ["outer radius"]
+radius_effective_modes = ["outer radius"]
 
 profile_axes = ['Radius (A)', 'SLD (1e-6/A^2)']
Index: sasmodels/models/parallelepiped.c
===================================================================
--- sasmodels/models/parallelepiped.c	(revision 99658f6e997e12486269a52113af19f5089e0ef0)
+++ sasmodels/models/parallelepiped.c	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -37,5 +37,5 @@
 
 static double
-effective_radius(int mode, double length_a, double length_b, double length_c)
+radius_effective(int mode, double length_a, double length_b, double length_c)
 {
     switch (mode) {
Index: sasmodels/models/parallelepiped.py
===================================================================
--- sasmodels/models/parallelepiped.py	(revision 0507e09b26f5789862db8a175d64657cf4f3b829)
+++ sasmodels/models/parallelepiped.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -240,5 +240,5 @@
 source = ["lib/gauss76.c", "parallelepiped.c"]
 have_Fq = True
-effective_radius_type = [
+radius_effective_modes = [
     "equivalent cylinder excluded volume", "equivalent volume sphere",
     "half length_a", "half length_b", "half length_c",
Index: sasmodels/models/pearl_necklace.c
===================================================================
--- sasmodels/models/pearl_necklace.c	(revision 44531368cbd90b0933fb61551a48e8edc051e6f9)
+++ sasmodels/models/pearl_necklace.c	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -86,5 +86,5 @@
 
 static double
-effective_radius(int mode, double radius, double edge_sep, double thick_string, double fp_num_pearls)
+radius_effective(int mode, double radius, double edge_sep, double thick_string, double fp_num_pearls)
 {
     switch (mode) {
Index: sasmodels/models/pearl_necklace.py
===================================================================
--- sasmodels/models/pearl_necklace.py	(revision c0136c722916ad8f651124ed56a25d1fb9118d2a)
+++ sasmodels/models/pearl_necklace.py	(revision db1d9d5f306f6645d007300bc421fb71d3669eda)
@@ -111,5 +111,5 @@
 source = ["lib/sas_Si.c", "lib/sas_3j1x_x.c", "pearl_necklace.c"]
 single = False  # use double precision unless told otherwise
-effective_radius_type = ["equivalent volume sphere"]
+radius_effective_modes = ["equivalent volume sphere"]
 
 def random():
Index: sasmodels/models/poly_gauss_coil.py
===================================================================
--- sasmodels/models/poly_gauss_coil.py	(revision 0507e09b26f5789862db8a175d64657cf4f3b829)
+++ sasmodels/models/poly_gauss_coil.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -58,7 +58,7 @@
 ----------------------------
 
-* **Author:** 
-* **Last Modified by:** 
-* **Last Reviewed by:** 
+* **Author:**
+* **Last Modified by:**
+* **Last Reviewed by:**
 * **Source added by :** Steve King **Date:** March 25, 2019
 """
Index: sasmodels/models/pringle.c
===================================================================
--- sasmodels/models/pringle.c	(revision 99658f6e997e12486269a52113af19f5089e0ef0)
+++ sasmodels/models/pringle.c	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -111,5 +111,5 @@
 
 static double
-effective_radius(int mode, double radius, double thickness, double alpha, double beta)
+radius_effective(int mode, double radius, double thickness, double alpha, double beta)
 {
     switch (mode) {
Index: sasmodels/models/pringle.py
===================================================================
--- sasmodels/models/pringle.py	(revision 0507e09b26f5789862db8a175d64657cf4f3b829)
+++ sasmodels/models/pringle.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -85,5 +85,5 @@
 source = ["lib/polevl.c", "lib/sas_J0.c", "lib/sas_J1.c",
           "lib/sas_JN.c", "lib/gauss76.c", "pringle.c"]
-effective_radius_type = [
+radius_effective_modes = [
     "equivalent cylinder excluded volume",
     "equivalent volume sphere",
Index: sasmodels/models/raspberry.c
===================================================================
--- sasmodels/models/raspberry.c	(revision d42dd4a6467163ad6ef165b733218fc2181ec1de)
+++ sasmodels/models/raspberry.c	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -15,5 +15,5 @@
 
 static double
-effective_radius(int mode, double radius_lg, double radius_sm, double penetration)
+radius_effective(int mode, double radius_lg, double radius_sm, double penetration)
 {
     switch (mode) {
Index: sasmodels/models/raspberry.py
===================================================================
--- sasmodels/models/raspberry.py	(revision 0507e09b26f5789862db8a175d64657cf4f3b829)
+++ sasmodels/models/raspberry.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -161,5 +161,5 @@
 
 source = ["lib/sas_3j1x_x.c", "raspberry.c"]
-effective_radius_type = ["radius_large", "radius_outer"]
+radius_effective_modes = ["radius_large", "radius_outer"]
 
 def random():
Index: sasmodels/models/rectangular_prism.c
===================================================================
--- sasmodels/models/rectangular_prism.c	(revision 99658f6e997e12486269a52113af19f5089e0ef0)
+++ sasmodels/models/rectangular_prism.c	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -14,5 +14,5 @@
 
 static double
-effective_radius(int mode, double length_a, double b2a_ratio, double c2a_ratio)
+radius_effective(int mode, double length_a, double b2a_ratio, double c2a_ratio)
 {
     switch (mode) {
Index: sasmodels/models/rectangular_prism.py
===================================================================
--- sasmodels/models/rectangular_prism.py	(revision 0507e09b26f5789862db8a175d64657cf4f3b829)
+++ sasmodels/models/rectangular_prism.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -110,7 +110,7 @@
 ----------------------------
 
-* **Author:** 
-* **Last Modified by:** 
-* **Last Reviewed by:** 
+* **Author:**
+* **Last Modified by:**
+* **Last Reviewed by:**
 * **Source added by :** Steve King **Date:** March 25, 2019
 """
@@ -151,5 +151,5 @@
 source = ["lib/gauss76.c", "rectangular_prism.c"]
 have_Fq = True
-effective_radius_type = [
+radius_effective_modes = [
     "equivalent cylinder excluded volume", "equivalent volume sphere",
     "half length_a", "half length_b", "half length_c",
Index: sasmodels/models/rpa.py
===================================================================
--- sasmodels/models/rpa.py	(revision 055ec4fc3a36fe5d3ff655931eb83565f03cf269)
+++ sasmodels/models/rpa.py	(revision db1d9d5f306f6645d007300bc421fb71d3669eda)
@@ -34,5 +34,5 @@
 that $R_g^2 = n b^2/6$ where $b$ is the statistical segment length and $n$ is
 the number of statistical segment lengths. A nice tutorial on how these are
-constructed and implemented can be found in chapters 28, 31 and 34, and Part H, 
+constructed and implemented can be found in chapters 28, 31 and 34, and Part H,
 of Hammouda's 'SANS Toolbox' [3].
 
Index: sasmodels/models/sphere.c
===================================================================
--- sasmodels/models/sphere.c	(revision ee60aa768b29c58e20b19e94578ec3a94a0889d7)
+++ sasmodels/models/sphere.c	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -5,5 +5,5 @@
 
 static double
-effective_radius(int mode, double radius)
+radius_effective(int mode, double radius)
 {
     // case 1: radius
Index: sasmodels/models/sphere.py
===================================================================
--- sasmodels/models/sphere.py	(revision 0507e09b26f5789862db8a175d64657cf4f3b829)
+++ sasmodels/models/sphere.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -49,6 +49,6 @@
 ----------------------------
 
-* **Author:** 
-* **Last Modified by:** 
+* **Author:**
+* **Last Modified by:**
 * **Last Reviewed by:** S King and P Parker **Date:** 2013/09/09 and 2014/01/06
 * **Source added by :** Steve King **Date:** March 25, 2019
@@ -81,5 +81,5 @@
 source = ["lib/sas_3j1x_x.c", "sphere.c"]
 have_Fq = True
-effective_radius_type = ["radius"]
+radius_effective_modes = ["radius"]
 
 def random():
@@ -92,10 +92,44 @@
 
 tests = [
-    [{}, 0.2, 0.726362],
-    [{"scale": 1., "background": 0., "sld": 6., "sld_solvent": 1.,
-      "radius": 120., "radius_pd": 0.2, "radius_pd_n":45},
-     0.2, 0.228843],
-    [{"radius": 120., "radius_pd": 0.2, "radius_pd_n":45},
-     0.1, None, None, 120., None, 1.0],
-    [{"@S": "hardsphere"}, 0.1, None],
+     [{}, 0.2, 0.726362], # each test starts with default parameter values inside { }, unless modified. Then Q and expected value of I(Q)
+     [{"scale": 1., "background": 0., "sld": 6., "sld_solvent": 1.,
+       "radius": 120., "radius_pd": 0.2, "radius_pd_n":45},
+      0.2, 0.2288431],
+    [{"radius": 120., "radius_pd": 0.02, "radius_pd_n":45},
+      0.2, 792.0646662454202, 1166737.0473152, 120.0, 7246723.820358589, 1.0], # the longer list here checks  F1, F2, R_eff, volume, volume_ratio = call_Fq(kernel, pars)
+   #  But note P(Q) = F2/volume
+   #  F and F^2 are "unscaled", with for  n <F F*>S(q) or for beta approx I(q) = n [<F F*> + <F><F*> (S(q) - 1)]
+   #  for n the number density and <.> the orientation average, and F = integral rho(r) exp(i q . r) dr.
+   #  The number density is volume fraction divided by particle volume.
+   #  Effectively, this leaves F = V drho form, where form is the usual 3 j1(qr)/(qr) or whatever depending on the shape.
+   # [{"@S": "hardsphere"},
+   #    0.01, 55.881884232102124], # this is current value, not verified elsewhere yet
+   # [{"radius": 120., "radius_pd": 0.2, "radius_pd_n":45},
+   #   0.2, 1.233304061, [1850806.119736], 120.0, 8087664.1226, 1.0], # the longer list here checks  F1, F2, R_eff, volume, volume_ratio = call_Fq(kernel, pars)
+   # [{"@S": "hardsphere"},
+   #     0.2, 0.14730859242492958], #  this is current value, not verified elsewhere yet
+    # [{"@S": "hardsphere"},
+    #    0.1, 0.7940350343811906], #  this is current value, not verified elsewhere yet
+    [{"@S": "hardsphere",
+     "radius": 120., "radius_pd": 0.2, "radius_pd_n":45,
+     "volfraction":0.2,
+     "radius_effective":45.0,     # uses this (check)
+     "structure_factor_mode": 1,  # 0 = normal decoupling approximation, 1 = beta(Q) approx
+     "radius_effective_mode": 0   # equivalent sphere, there is only one valid mode for sphere. says -this used r_eff =0 or default 50?
+     }, 0.01, 1316.2990966463444 ],
+    [{"@S": "hardsphere",
+     "radius": 120., "radius_pd": 0.2, "radius_pd_n":45,
+     "volfraction":0.2,
+     "radius_effective":50.0,        # hard sphere structure factor
+     "structure_factor_mode": 1,  # 0 = normal decoupling approximation, 1 = beta(Q) approx
+     "radius_effective_mode": 0   # this used r_eff =0 or default 50?
+     }, 0.01, 1324.7375636587356 ],
+    [{"@S": "hardsphere",
+     "radius": 120., "radius_pd": 0.2, "radius_pd_n":45,
+     "volfraction":0.2,
+     "radius_effective":50.0,        # hard sphere structure factor
+     "structure_factor_mode": 1,  # 0 = normal decoupling approximation, 1 = beta(Q) approx
+     "radius_effective_mode": 1   # this used 120 ???
+     }, 0.01, 1579.2858949296565 ]
 ]
+# putting None for expected result will pass the test if there are no errors from the routine, but without any check on the value of the result
Index: sasmodels/models/spherical_sld.c
===================================================================
--- sasmodels/models/spherical_sld.c	(revision ee60aa768b29c58e20b19e94578ec3a94a0889d7)
+++ sasmodels/models/spherical_sld.c	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -19,5 +19,5 @@
 
 static double
-effective_radius(int mode, double fp_n_shells, double thickness[], double interface[])
+radius_effective(int mode, double fp_n_shells, double thickness[], double interface[])
 {
     // case 1: outer radius
Index: sasmodels/models/spherical_sld.py
===================================================================
--- sasmodels/models/spherical_sld.py	(revision 0507e09b26f5789862db8a175d64657cf4f3b829)
+++ sasmodels/models/spherical_sld.py	(revision 627b68ba23ef354dd8256c6325ff76a9c070c252)
@@ -18,4 +18,8 @@
 sub-shell is described by a line function, with *n_steps* sub-shells per
 interface. The form factor is normalized by the total volume of the sphere.
+
+.. note::
+
+   *n_shells* must be an integer. *n_steps* must be an ODD integer.
 
 Interface shapes are as follows:
@@ -73,5 +77,4 @@
     3 \rho_\text{solvent} V(r_N)
     \Big[ \frac{\sin(qr_N) - qr_N \cos(qr_N)} {qr_N^3} \Big]
-
 
 Here we assumed that the SLDs of the core and solvent are constant in $r$.
@@ -156,5 +159,4 @@
     \end{align*}
 
-
 We assume $\rho_{\text{inter}_j} (r)$ is approximately linear
 within the sub-shell $j$.
@@ -179,5 +181,4 @@
     when $P(Q) * S(Q)$ is applied.
 
-
 References
 ----------
@@ -194,9 +195,9 @@
 
 Authorship and Verification
-----------------------------
+---------------------------
 
 * **Author:** Jae-Hie Cho **Date:** Nov 1, 2010
 * **Last Modified by:** Paul Kienzle **Date:** Dec 20, 2016
-* **Last Reviewed by:** Paul Butler **Date:** September 8, 2018
+* **Last Reviewed by:** Steve King **Date:** March 29, 2019
 * **Source added by :** Steve King **Date:** March 25, 2019
 """
@@ -207,5 +208,5 @@
 
 name = "spherical_sld"
-title = "Sperical SLD intensity calculation"
+title = "Spherical SLD intensity calculation"
 description = """
             I(q) =
@@ -219,5 +220,5 @@
 # pylint: disable=bad-whitespace, line-too-long
 #            ["name", "units", default, [lower, upper], "type", "description"],
-parameters = [["n_shells",             "",           1,      [1, 10],        "volume", "number of shells"],
+parameters = [["n_shells",             "",           1,      [1, 10],        "volume", "number of shells (must be integer)"],
               ["sld_solvent",          "1e-6/Ang^2", 1.0,    [-inf, inf],    "sld", "solvent sld"],
               ["sld[n_shells]",        "1e-6/Ang^2", 4.06,   [-inf, inf],    "sld", "sld of the shell"],
@@ -232,5 +233,5 @@
 single = False  # TODO: fix low q behaviour
 have_Fq = True
-effective_radius_type = ["outer radius"]
+radius_effective_modes = ["outer radius"]
 
 profile_axes = ['Radius (A)', 'SLD (1e-6/A^2)']
Index: sasmodels/models/squarewell.py
===================================================================
--- sasmodels/models/squarewell.py	(revision 5f3c53407f846f392cb5b6037b030e309de351eb)
+++ sasmodels/models/squarewell.py	(revision db1d9d5f306f6645d007300bc421fb71d3669eda)
@@ -1,15 +1,15 @@
 # Note: model title and parameter table are inserted automatically
 r"""
-Calculates the interparticle structure factor for a hard sphere fluid 
-with a narrow, attractive, square well potential. **The Mean Spherical 
-Approximation (MSA) closure relationship is used, but it is not the most 
-appropriate closure for an attractive interparticle potential.** However, 
-the solution has been compared to Monte Carlo simulations for a square 
-well fluid and these show the MSA calculation to be limited to well 
+Calculates the interparticle structure factor for a hard sphere fluid
+with a narrow, attractive, square well potential. **The Mean Spherical
+Approximation (MSA) closure relationship is used, but it is not the most
+appropriate closure for an attractive interparticle potential.** However,
+the solution has been compared to Monte Carlo simulations for a square
+well fluid and these show the MSA calculation to be limited to well
 depths $\epsilon < 1.5$ kT and volume fractions $\phi < 0.08$.
 
 Positive well depths correspond to an attractive potential well. Negative
 well depths correspond to a potential "shoulder", which may or may not be
-physically reasonable. The :ref:`stickyhardsphere` model may be a better 
+physically reasonable. The :ref:`stickyhardsphere` model may be a better
 choice in some circumstances.
 
@@ -18,6 +18,6 @@
 .. note::
 
-   Earlier versions of SasView did not incorporate the so-called 
-   $\beta(q)$ ("beta") correction [2] for polydispersity and non-sphericity. 
+   Earlier versions of SasView did not incorporate the so-called
+   $\beta(q)$ ("beta") correction [2] for polydispersity and non-sphericity.
    This is only available in SasView versions 4.2.2 and higher.
 
@@ -62,6 +62,6 @@
 ----------------------------
 
-* **Author:** 
-* **Last Modified by:** 
+* **Author:**
+* **Last Modified by:**
 * **Last Reviewed by:** Steve King **Date:** March 27, 2019
 * **Source added by :** Steve King **Date:** March 25, 2019
@@ -75,8 +75,8 @@
 description = """\
     [Square well structure factor, with MSA closure]
-        Interparticle structure factor S(Q) for a hard sphere fluid 
+        Interparticle structure factor S(Q) for a hard sphere fluid
     with a narrow attractive well. Fits are prone to deliver non-
-    physical parameters; use with care and read the references in 
-    the model documentation.The "beta(q)" correction is available 
+    physical parameters; use with care and read the references in
+    the model documentation.The "beta(q)" correction is available
     in versions 4.2.2 and higher.
 """
Index: sasmodels/models/stickyhardsphere.py
===================================================================
--- sasmodels/models/stickyhardsphere.py	(revision 5f3c53407f846f392cb5b6037b030e309de351eb)
+++ sasmodels/models/stickyhardsphere.py	(revision db1d9d5f306f6645d007300bc421fb71d3669eda)
@@ -1,17 +1,17 @@
 # Note: model title and parameter table are inserted automatically
 r"""
-Calculates the interparticle structure factor for a hard sphere fluid 
-with a narrow, attractive, potential well. Unlike the :ref:`squarewell` 
-model, here a perturbative solution of the Percus-Yevick closure 
-relationship is used. The strength of the attractive well is described 
+Calculates the interparticle structure factor for a hard sphere fluid
+with a narrow, attractive, potential well. Unlike the :ref:`squarewell`
+model, here a perturbative solution of the Percus-Yevick closure
+relationship is used. The strength of the attractive well is described
 in terms of "stickiness" as defined below.
 
 The perturbation parameter (perturb), $\tau$, should be fixed between 0.01
-and 0.1 and the "stickiness", $\epsilon$, allowed to vary to adjust the 
-interaction strength. The "stickiness" is defined in the equation below and is 
-a function of both the perturbation parameter and the interaction strength. 
-$\epsilon$ and $\tau$ are defined in terms of the hard sphere diameter $(\sigma = 2 R)$, 
-the width of the square well, $\Delta$ (having the same units as $R$\ ), 
-and the depth of the well, $U_o$, in units of $kT$. From the definition, it 
+and 0.1 and the "stickiness", $\epsilon$, allowed to vary to adjust the
+interaction strength. The "stickiness" is defined in the equation below and is
+a function of both the perturbation parameter and the interaction strength.
+$\epsilon$ and $\tau$ are defined in terms of the hard sphere diameter $(\sigma = 2 R)$,
+the width of the square well, $\Delta$ (having the same units as $R$\ ),
+and the depth of the well, $U_o$, in units of $kT$. From the definition, it
 is clear that smaller $\epsilon$ means a stronger attraction.
 
@@ -37,6 +37,6 @@
 
 The true particle volume fraction, $\phi$, is not equal to $h$ which appears
-in most of reference [1]. The two are related in equation (24). Reference 
-[1] also describes the relationship between this perturbative solution and 
+in most of reference [1]. The two are related in equation (24). Reference
+[1] also describes the relationship between this perturbative solution and
 the original sticky hard sphere (or "adhesive sphere") model of Baxter [2].
 
@@ -47,15 +47,15 @@
    reported to the command window and $S(q)$ is set to -1 (so it will
    disappear on a log-log plot!).
-   
-   Use tight bounds to keep the parameters to values that you know are 
-   physical (test them), and keep nudging them until the optimization 
+
+   Use tight bounds to keep the parameters to values that you know are
+   physical (test them), and keep nudging them until the optimization
    does not hit the constraints.
 
 .. note::
 
-   Earlier versions of SasView did not incorporate the so-called 
-   $\beta(q)$ ("beta") correction [3] for polydispersity and non-sphericity. 
+   Earlier versions of SasView did not incorporate the so-called
+   $\beta(q)$ ("beta") correction [3] for polydispersity and non-sphericity.
    This is only available in SasView versions 4.2.2 and higher.
-   
+
 In SasView the effective radius may be calculated from the parameters
 used in the form factor $P(q)$ that this $S(q)$ is combined with.
@@ -86,6 +86,6 @@
 ----------------------------
 
-* **Author:** 
-* **Last Modified by:** 
+* **Author:**
+* **Last Modified by:**
 * **Last Reviewed by:** Steve King **Date:** March 27, 2019
 * **Source added by :** Steve King **Date:** March 25, 2019
@@ -101,8 +101,8 @@
 description = """\
     [Sticky hard sphere structure factor, with Percus-Yevick closure]
-        Interparticle structure factor S(Q) for a hard sphere fluid 
+        Interparticle structure factor S(Q) for a hard sphere fluid
     with a narrow attractive well. Fits are prone to deliver non-
-    physical parameters; use with care and read the references in 
-    the model documentation.The "beta(q)" correction is available 
+    physical parameters; use with care and read the references in
+    the model documentation.The "beta(q)" correction is available
     in versions 4.2.2 and higher.
 """
Index: sasmodels/models/triaxial_ellipsoid.c
===================================================================
--- sasmodels/models/triaxial_ellipsoid.c	(revision 99658f6e997e12486269a52113af19f5089e0ef0)
+++ sasmodels/models/triaxial_ellipsoid.c	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -76,5 +76,5 @@
 
 static double
-effective_radius(int mode, double radius_equat_minor, double radius_equat_major, double radius_polar)
+radius_effective(int mode, double radius_equat_minor, double radius_equat_major, double radius_polar)
 {
     switch (mode) {
Index: sasmodels/models/triaxial_ellipsoid.py
===================================================================
--- sasmodels/models/triaxial_ellipsoid.py	(revision 0507e09b26f5789862db8a175d64657cf4f3b829)
+++ sasmodels/models/triaxial_ellipsoid.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -164,5 +164,5 @@
 source = ["lib/sas_3j1x_x.c", "lib/gauss76.c", "triaxial_ellipsoid.c"]
 have_Fq = True
-effective_radius_type = [
+radius_effective_modes = [
     "equivalent biaxial ellipsoid average curvature",
     "equivalent volume sphere", "min radius", "max radius",
Index: sasmodels/models/unified_power_Rg.py
===================================================================
--- sasmodels/models/unified_power_Rg.py	(revision ef476e6b7ffc21ee7a467a47ef19a30527778450)
+++ sasmodels/models/unified_power_Rg.py	(revision ef476e6b7ffc21ee7a467a47ef19a30527778450)
@@ -0,0 +1,159 @@
+r"""
+Definition
+----------
+
+This model employs the empirical multiple level unified Exponential/Power-law
+fit method developed by Beaucage. Four functions are included so that 1, 2, 3,
+or 4 levels can be used. In addition a 0 level has been added which simply
+calculates
+
+.. math::
+
+    I(q) = \text{scale} / q + \text{background}
+
+The Beaucage method is able to reasonably approximate the scattering from
+many different types of particles, including fractal clusters, random coils
+(Debye equation), ellipsoidal particles, etc.
+
+The model works best for mass fractal systems characterized by Porod exponents
+between 5/3 and 3. It should not be used for surface fractal systems. Hammouda
+(2010) has pointed out a deficiency in the way this model handles the
+transitioning between the Guinier and Porod regimes and which can create
+artefacts that appear as kinks in the fitted model function.
+
+Also see the :ref:`guinier-porod` model.
+
+The empirical fit function is:
+
+.. math::
+
+    I(q) = \text{background}
+    + \sum_{i=1}^N \Bigl[
+        G_i \exp\Bigl(-\frac{q^2R_{gi}^2}{3}\Bigr)
+       + B_i \exp\Bigl(-\frac{q^2R_{g(i+1)}^2}{3}\Bigr)
+             \Bigl(\frac{1}{q_i^*}\Bigr)^{P_i} \Bigr]
+
+where
+
+.. math::
+
+    q_i^* = q \left[\operatorname{erf}
+            \left(\frac{q R_{gi}}{\sqrt{6}}\right)
+        \right]^{-3}
+
+
+For each level, the four parameters $G_i$, $R_{gi}$, $B_i$ and $P_i$ must
+be chosen.  Beaucage has an additional factor $k$ in the definition of
+$q_i^*$ which is ignored here.
+
+For example, to approximate the scattering from random coils (Debye equation),
+set $R_{gi}$ as the Guinier radius, $P_i = 2$, and $B_i = 2 G_i / R_{gi}$
+
+See the references for further information on choosing the parameters.
+
+For 2D data: The 2D scattering intensity is calculated in the same way as 1D,
+where the $q$ vector is defined as
+
+.. math::
+
+    q = \sqrt{q_x^2 + q_y^2}
+
+
+References
+----------
+
+.. [#] G Beaucage, *J. Appl. Cryst.*, 28 (1995) 717-728
+.. [#] G Beaucage, *J. Appl. Cryst.*, 29 (1996) 134-146
+.. [#] B Hammouda, *Analysis of the Beaucage model, J. Appl. Cryst.*, (2010), 43, 1474-1478
+
+Source
+------
+
+`unified_power_Rg.py <https://github.com/SasView/sasmodels/blob/master/sasmodels/models/unified_power_Rg.py>`_
+
+Authorship and Verification
+----------------------------
+
+* **Author:** 
+* **Last Modified by:** 
+* **Last Reviewed by:** 
+* **Source added by :** Steve King **Date:** March 25, 2019
+"""
+
+from __future__ import division
+
+import numpy as np
+from numpy import inf, exp, sqrt, errstate
+from scipy.special import erf, gamma
+
+category = "shape-independent"
+name = "unified_power_Rg"
+title = "Unified Power Rg"
+description = """
+        The Beaucage model employs the empirical multiple level unified
+        Exponential/Power-law fit method developed by G. Beaucage. Four functions
+        are included so that 1, 2, 3, or 4 levels can be used.
+        """
+
+# pylint: disable=bad-whitespace, line-too-long
+parameters = [
+    ["level",     "",     1,      [1, 6], "", "Level number"],
+    ["rg[level]", "Ang",  15.8,   [0, inf], "", "Radius of gyration"],
+    ["power[level]", "",  4,      [-inf, inf], "", "Power"],
+    ["B[level]",  "1/cm", 4.5e-6, [-inf, inf], "", ""],
+    ["G[level]",  "1/cm", 400,    [0, inf], "", ""],
+    ]
+# pylint: enable=bad-whitespace, line-too-long
+
+def Iq(q, level, rg, power, B, G):
+    """Return I(q) for unified power Rg model."""
+    level = int(level + 0.5)
+    if level == 0:
+        with errstate(divide='ignore'):
+            return 1./q
+
+    with errstate(divide='ignore', invalid='ignore'):
+        result = np.zeros(q.shape, 'd')
+        for i in range(level):
+            exp_now = exp(-(q*rg[i])**2/3.)
+            pow_now = (erf(q*rg[i]/sqrt(6.))**3/q)**power[i]
+            if i < level-1:
+                exp_next = exp(-(q*rg[i+1])**2/3.)
+            else:
+                exp_next = 1
+            result += G[i]*exp_now + B[i]*exp_next*pow_now
+
+    result[q == 0] = np.sum(G[:level])
+    return result
+
+Iq.vectorized = True
+
+def random():
+    """Return a random parameter set for the model."""
+    level = np.minimum(np.random.poisson(0.5) + 1, 6)
+    n = level
+    power = np.random.uniform(1.6, 3, n)
+    rg = 10**np.random.uniform(1, 5, n)
+    G = np.random.uniform(0.1, 10, n)**2 * 10**np.random.uniform(0.3, 3, n)
+    B = G * power / rg**power * gamma(power/2)
+    scale = 10**np.random.uniform(1, 4)
+    pars = dict(
+        #background=0,
+        scale=scale,
+        level=level,
+    )
+    pars.update(("power%d"%(k+1), v) for k, v in enumerate(power))
+    pars.update(("rg%d"%(k+1), v) for k, v in enumerate(rg))
+    pars.update(("B%d"%(k+1), v) for k, v in enumerate(B))
+    pars.update(("G%d"%(k+1), v) for k, v in enumerate(G))
+    return pars
+
+demo = dict(
+    level=2,
+    rg=[15.8, 21],
+    power=[4, 2],
+    B=[4.5e-6, 0.0006],
+    G=[400, 3],
+    scale=1.,
+    background=0.,
+)
Index: smodels/models/unified_power_rg.py
===================================================================
--- sasmodels/models/unified_power_rg.py	(revision 7a5f8afcd94f7cc6f98efab423657560350f9f99)
+++ 	(revision )
@@ -1,159 +1,0 @@
-r"""
-Definition
-----------
-
-This model employs the empirical multiple level unified Exponential/Power-law
-fit method developed by Beaucage. Four functions are included so that 1, 2, 3,
-or 4 levels can be used. In addition a 0 level has been added which simply
-calculates
-
-.. math::
-
-    I(q) = \text{scale} / q + \text{background}
-
-The Beaucage method is able to reasonably approximate the scattering from
-many different types of particles, including fractal clusters, random coils
-(Debye equation), ellipsoidal particles, etc.
-
-The model works best for mass fractal systems characterized by Porod exponents
-between 5/3 and 3. It should not be used for surface fractal systems. Hammouda
-(2010) has pointed out a deficiency in the way this model handles the
-transitioning between the Guinier and Porod regimes and which can create
-artefacts that appear as kinks in the fitted model function.
-
-Also see the :ref:`guinier-porod` model.
-
-The empirical fit function is:
-
-.. math::
-
-    I(q) = \text{background}
-    + \sum_{i=1}^N \Bigl[
-        G_i \exp\Bigl(-\frac{q^2R_{gi}^2}{3}\Bigr)
-       + B_i \exp\Bigl(-\frac{q^2R_{g(i+1)}^2}{3}\Bigr)
-             \Bigl(\frac{1}{q_i^*}\Bigr)^{P_i} \Bigr]
-
-where
-
-.. math::
-
-    q_i^* = q \left[\operatorname{erf}
-            \left(\frac{q R_{gi}}{\sqrt{6}}\right)
-        \right]^{-3}
-
-
-For each level, the four parameters $G_i$, $R_{gi}$, $B_i$ and $P_i$ must
-be chosen.  Beaucage has an additional factor $k$ in the definition of
-$q_i^*$ which is ignored here.
-
-For example, to approximate the scattering from random coils (Debye equation),
-set $R_{gi}$ as the Guinier radius, $P_i = 2$, and $B_i = 2 G_i / R_{gi}$
-
-See the references for further information on choosing the parameters.
-
-For 2D data: The 2D scattering intensity is calculated in the same way as 1D,
-where the $q$ vector is defined as
-
-.. math::
-
-    q = \sqrt{q_x^2 + q_y^2}
-
-
-References
-----------
-
-.. [#] G Beaucage, *J. Appl. Cryst.*, 28 (1995) 717-728
-.. [#] G Beaucage, *J. Appl. Cryst.*, 29 (1996) 134-146
-.. [#] B Hammouda, *Analysis of the Beaucage model, J. Appl. Cryst.*, (2010), 43, 1474-1478
-
-Source
-------
-
-`unified_power_rg.py <https://github.com/SasView/sasmodels/blob/master/sasmodels/models/unified_power_rg.py>`_
-
-Authorship and Verification
-----------------------------
-
-* **Author:** 
-* **Last Modified by:** 
-* **Last Reviewed by:** 
-* **Source added by :** Steve King **Date:** March 25, 2019
-"""
-
-from __future__ import division
-
-import numpy as np
-from numpy import inf, exp, sqrt, errstate
-from scipy.special import erf, gamma
-
-category = "shape-independent"
-name = "unified_power_rg"
-title = "Unified Power Rg"
-description = """
-        The Beaucage model employs the empirical multiple level unified
-        Exponential/Power-law fit method developed by G. Beaucage. Four functions
-        are included so that 1, 2, 3, or 4 levels can be used.
-        """
-
-# pylint: disable=bad-whitespace, line-too-long
-parameters = [
-    ["level",     "",     1,      [1, 6], "", "Level number"],
-    ["rg[level]", "Ang",  15.8,   [0, inf], "", "Radius of gyration"],
-    ["power[level]", "",  4,      [-inf, inf], "", "Power"],
-    ["B[level]",  "1/cm", 4.5e-6, [-inf, inf], "", ""],
-    ["G[level]",  "1/cm", 400,    [0, inf], "", ""],
-    ]
-# pylint: enable=bad-whitespace, line-too-long
-
-def Iq(q, level, rg, power, B, G):
-    """Return I(q) for unified power Rg model."""
-    level = int(level + 0.5)
-    if level == 0:
-        with errstate(divide='ignore'):
-            return 1./q
-
-    with errstate(divide='ignore', invalid='ignore'):
-        result = np.zeros(q.shape, 'd')
-        for i in range(level):
-            exp_now = exp(-(q*rg[i])**2/3.)
-            pow_now = (erf(q*rg[i]/sqrt(6.))**3/q)**power[i]
-            if i < level-1:
-                exp_next = exp(-(q*rg[i+1])**2/3.)
-            else:
-                exp_next = 1
-            result += G[i]*exp_now + B[i]*exp_next*pow_now
-
-    result[q == 0] = np.sum(G[:level])
-    return result
-
-Iq.vectorized = True
-
-def random():
-    """Return a random parameter set for the model."""
-    level = np.minimum(np.random.poisson(0.5) + 1, 6)
-    n = level
-    power = np.random.uniform(1.6, 3, n)
-    rg = 10**np.random.uniform(1, 5, n)
-    G = np.random.uniform(0.1, 10, n)**2 * 10**np.random.uniform(0.3, 3, n)
-    B = G * power / rg**power * gamma(power/2)
-    scale = 10**np.random.uniform(1, 4)
-    pars = dict(
-        #background=0,
-        scale=scale,
-        level=level,
-    )
-    pars.update(("power%d"%(k+1), v) for k, v in enumerate(power))
-    pars.update(("rg%d"%(k+1), v) for k, v in enumerate(rg))
-    pars.update(("B%d"%(k+1), v) for k, v in enumerate(B))
-    pars.update(("G%d"%(k+1), v) for k, v in enumerate(G))
-    return pars
-
-demo = dict(
-    level=2,
-    rg=[15.8, 21],
-    power=[4, 2],
-    B=[4.5e-6, 0.0006],
-    G=[400, 3],
-    scale=1.,
-    background=0.,
-)
Index: sasmodels/models/vesicle.c
===================================================================
--- sasmodels/models/vesicle.c	(revision 12f4c19f620b0845847bb04e53189f2c43808bac)
+++ sasmodels/models/vesicle.c	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -13,5 +13,5 @@
 
 static double
-effective_radius(int mode, double radius, double thickness)
+radius_effective(int mode, double radius, double thickness)
 {
     // case 1: outer radius
Index: sasmodels/models/vesicle.py
===================================================================
--- sasmodels/models/vesicle.py	(revision 0507e09b26f5789862db8a175d64657cf4f3b829)
+++ sasmodels/models/vesicle.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -107,5 +107,5 @@
 source = ["lib/sas_3j1x_x.c", "vesicle.c"]
 have_Fq = True
-effective_radius_type = ["outer radius"]
+radius_effective_modes = ["outer radius"]
 
 def random():
Index: sasmodels/product.py
===================================================================
--- sasmodels/product.py	(revision b297ba9e837aada12de87cd46ea7a01bfe549da7)
+++ sasmodels/product.py	(revision 8795b6f853cd54be29051109ba0e616e1b31b673)
@@ -31,10 +31,10 @@
 # pylint: enable=unused-import
 
-# TODO: make estimates available to constraints
+# TODO: make shape averages available to constraints
 #ESTIMATED_PARAMETERS = [
-#    ["est_radius_effective", "A", 0.0, [0, np.inf], "", "Estimated effective radius"],
-#    ["est_volume_ratio", "", 1.0, [0, np.inf], "", "Estimated volume ratio"],
+#    ["mean_radius_effective", "A", 0.0, [0, np.inf], "", "mean effective radius"],
+#    ["mean_volume", "A", 0.0, [0, np.inf], "", "mean volume"],
+#    ["mean_volume_ratio", "", 1.0, [0, np.inf], "", "mean form: mean shell volume ratio"],
 #]
-
 STRUCTURE_MODE_ID = "structure_factor_mode"
 RADIUS_MODE_ID = "radius_effective_mode"
@@ -44,5 +44,5 @@
     # type: (ModelInfo) -> List[Parameter]
     """
-    Create parameters for structure_factor_mode and radius_effective_mode.
+    Create parameters for structure factor and effective radius modes.
     """
     pars = []
@@ -56,10 +56,10 @@
             "Structure factor calculation")
         pars.append(par)
-    if p_info.effective_radius_type is not None:
+    if p_info.radius_effective_modes is not None:
         par = parse_parameter(
             RADIUS_MODE_ID,
             "",
             1,
-            [["unconstrained"] + p_info.effective_radius_type],
+            [["unconstrained"] + p_info.radius_effective_modes],
             "",
             "Effective radius calculation")
@@ -177,5 +177,5 @@
         S,                # type: np.ndarray
         scale,            # type: float
-        effective_radius, # type: float
+        radius_effective, # type: float
         beta_mode,        # type: bool
     ):
@@ -193,5 +193,5 @@
             ("beta(Q)", F1**2 / F2),
             ("S_eff(Q)", 1 + (F1**2 / F2)*(S-1)),
-            ("effective_radius", effective_radius),
+            ("effective_radius", radius_effective),
             # ("I(Q)", scale*(F2 + (F1**2)*(S-1)) + bg),
         ))
@@ -200,5 +200,5 @@
             ("P(Q)", scale*F2),
             ("S(Q)", S),
-            ("effective_radius", effective_radius),
+            ("effective_radius", radius_effective),
         ))
     return parts
@@ -281,6 +281,8 @@
         # R_eff type parameter is the second parameter after P and S parameters
         # unless the model doesn't support beta mode, in which case it is first
-        have_radius_type = p_info.effective_radius_type is not None
+        have_radius_type = p_info.radius_effective_modes is not None
+        #print(p_npars,s_npars)
         radius_type_offset = 2+p_npars+s_npars + (1 if have_beta_mode else 0)
+        #print(values[radius_type_offset])
         radius_type = int(values[radius_type_offset]) if have_radius_type else 0
 
@@ -331,5 +333,5 @@
         # Call the form factor kernel to compute <F> and <F^2>.
         # If the model doesn't support Fq the returned <F> will be None.
-        F1, F2, effective_radius, shell_volume, volume_ratio = self.p_kernel.Fq(
+        F1, F2, radius_effective, shell_volume, volume_ratio = self.p_kernel.Fq(
             p_details, p_values, cutoff, magnetic, radius_type)
 
@@ -341,8 +343,8 @@
         # implementation details in kernel_iq.c.
         #print("R_eff=%d:%g, volfrac=%g, volume ratio=%g"
-        #      % (radius_type, effective_radius, volfrac, volume_ratio))
+        #      % (radius_type, radius_effective, volfrac, volume_ratio))
         if radius_type > 0:
             # set the value to the model R_eff and set the weight to 1
-            s_values[2] = s_values[2+s_npars+s_offset[0]] = effective_radius
+            s_values[2] = s_values[2+s_npars+s_offset[0]] = radius_effective
             s_values[2+s_npars+s_offset[0]+nweights] = 1.0
         s_values[3] = s_values[2+s_npars+s_offset[1]] = volfrac*volume_ratio
@@ -370,5 +372,5 @@
         # the results directly rather than through a lazy evaluator.
         self.results = lambda: _intermediates(
-            F1, F2, S, combined_scale, effective_radius, beta_mode)
+            F1, F2, S, combined_scale, radius_effective, beta_mode)
 
         return final_result
Index: sasmodels/sasview_model.py
===================================================================
--- sasmodels/sasview_model.py	(revision b297ba9e837aada12de87cd46ea7a01bfe549da7)
+++ sasmodels/sasview_model.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -299,5 +299,5 @@
     attrs['category'] = model_info.category
     attrs['is_structure_factor'] = model_info.structure_factor
-    attrs['is_form_factor'] = model_info.effective_radius_type is not None
+    attrs['is_form_factor'] = model_info.radius_effective_modes is not None
     attrs['is_multiplicity_model'] = variants[0] > 1
     attrs['multiplicity_info'] = variants
@@ -763,5 +763,5 @@
         #    if er_mode > 0:
         #        res = calculator.Fq(call_details, values, cutoff=self.cutoff,
-        #                            magnetic=False, effective_radius_type=mode)
+        #                            magnetic=False, radius_effective_mode=mode)
         #        R_eff, form_shell_ratio = res[2], res[4]
         #        return R_eff, form_shell_ratio
