Index: sasmodels/product.py
===================================================================
--- sasmodels/product.py	(revision b39bf3b280713aebf2f5492c8799baf517ae6248)
+++ sasmodels/product.py	(revision a34b8119b864fa10b972c2a11f92a9c5e13207f1)
@@ -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"],
 #]
-# NOTE there are radius_effective_mode, effective_radius_type, but only structure_factor_mode
 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_type and radius_effective_type.
+    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,5 +281,5 @@
         # 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)
@@ -333,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)
 
@@ -343,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
@@ -372,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
