Index: sasmodels/models/barbell.c
===================================================================
--- sasmodels/models/barbell.c	(revision 2f5c6d4a9ea74b4cc7a58030e36695b0634eb349)
+++ sasmodels/models/barbell.c	(revision 22221346d45e39a667fe231ce7ca5ecfc79b0ac5)
@@ -1,19 +1,19 @@
-double form_volume(double bell_radius, double radius, double length);
+double form_volume(double radius_bell, double radius, double length);
 double Iq(double q, double sld, double solvent_sld,
-        double bell_radius, double radius, double length);
+        double radius_bell, double radius, double length);
 double Iqxy(double qx, double qy, double sld, double solvent_sld,
-        double bell_radius, double radius, double length,
+        double radius_bell, double radius, double length,
         double theta, double phi);
 
-#define INVALID(v) (v.bell_radius < v.radius)
+#define INVALID(v) (v.radius_bell < v.radius)
 
 //barbell kernel - same as dumbell
 static double
-_bell_kernel(double q, double h, double bell_radius,
+_bell_kernel(double q, double h, double radius_bell,
              double half_length, double sin_alpha, double cos_alpha)
 {
     // translate a point in [-1,1] to a point in [lower,upper]
     const double upper = 1.0;
-    const double lower = h/bell_radius;
+    const double lower = h/radius_bell;
     const double zm = 0.5*(upper-lower);
     const double zb = 0.5*(upper+lower);
@@ -26,7 +26,7 @@
     //    m = q R cos(alpha)
     //    b = q(L/2-h) cos(alpha)
-    const double m = q*bell_radius*cos_alpha; // cos argument slope
+    const double m = q*radius_bell*cos_alpha; // cos argument slope
     const double b = q*(half_length-h)*cos_alpha; // cos argument intercept
-    const double qrst = q*bell_radius*sin_alpha; // Q*R*sin(theta)
+    const double qrst = q*radius_bell*sin_alpha; // Q*R*sin(theta)
     double total = 0.0;
     for (int i = 0; i < 76; i++){
@@ -39,9 +39,9 @@
     // translate dx in [-1,1] to dx in [lower,upper]
     const double integral = total*zm;
-    const double bell_Fq = 2*M_PI*cube(bell_radius)*integral;
+    const double bell_Fq = 2*M_PI*cube(radius_bell)*integral;
     return bell_Fq;
 }
 
-double form_volume(double bell_radius,
+double form_volume(double radius_bell,
         double radius,
         double length)
@@ -49,7 +49,7 @@
 
     // bell radius should never be less than radius when this is called
-    const double hdist = sqrt(square(bell_radius) - square(radius));
-    const double p1 = 2.0/3.0*cube(bell_radius);
-    const double p2 = square(bell_radius)*hdist;
+    const double hdist = sqrt(square(radius_bell) - square(radius));
+    const double p1 = 2.0/3.0*cube(radius_bell);
+    const double p2 = square(radius_bell)*hdist;
     const double p3 = cube(hdist)/3.0;
 
@@ -58,7 +58,7 @@
 
 double Iq(double q, double sld, double solvent_sld,
-          double bell_radius, double radius, double length)
+          double radius_bell, double radius, double length)
 {
-    const double h = -sqrt(bell_radius*bell_radius - radius*radius);
+    const double h = -sqrt(radius_bell*radius_bell - radius*radius);
     const double half_length = 0.5*length;
 
@@ -72,5 +72,5 @@
         SINCOS(alpha, sin_alpha, cos_alpha);
 
-        const double bell_Fq = _bell_kernel(q, h, bell_radius, half_length, sin_alpha, cos_alpha);
+        const double bell_Fq = _bell_kernel(q, h, radius_bell, half_length, sin_alpha, cos_alpha);
         const double bj = sas_J1c(q*radius*sin_alpha);
         const double si = sinc(q*half_length*cos_alpha);
@@ -90,5 +90,5 @@
 double Iqxy(double qx, double qy,
         double sld, double solvent_sld,
-        double bell_radius, double radius, double length,
+        double radius_bell, double radius, double length,
         double theta, double phi)
 {
@@ -100,10 +100,10 @@
     const double alpha = acos(cos_val); // rod angle relative to q
 
-    const double h = -sqrt(square(bell_radius) - square(radius));
+    const double h = -sqrt(square(radius_bell) - square(radius));
     const double half_length = 0.5*length;
 
     double sin_alpha, cos_alpha; // slots to hold sincos function output
     SINCOS(alpha, sin_alpha, cos_alpha);
-    const double bell_Fq = _bell_kernel(q, h, bell_radius, half_length, sin_alpha, cos_alpha);
+    const double bell_Fq = _bell_kernel(q, h, radius_bell, half_length, sin_alpha, cos_alpha);
     const double bj = sas_J1c(q*radius*sin_alpha);
     const double si = sinc(q*half_length*cos_alpha);
Index: sasmodels/models/barbell.py
===================================================================
--- sasmodels/models/barbell.py	(revision 42356c8890c04b71169941b12a36fc0e07e2034b)
+++ sasmodels/models/barbell.py	(revision 22221346d45e39a667fe231ce7ca5ecfc79b0ac5)
@@ -13,5 +13,5 @@
 .. figure:: img/barbell_geometry.jpg
 
-    Barbell geometry, where $r$ is *radius*, $R$ is *bell_radius* and
+    Barbell geometry, where $r$ is *radius*, $R$ is *radius_bell* and
     $L$ is *length*. Since the end cap radius $R \geq r$ and by definition
     for this geometry $h < 0$, $h$ is then defined by $r$ and $R$ as
@@ -103,5 +103,5 @@
 parameters = [["sld",         "1e-6/Ang^2",   4, [-inf, inf], "sld",         "Barbell scattering length density"],
               ["sld_solvent", "1e-6/Ang^2",   1, [-inf, inf], "sld",         "Solvent scattering length density"],
-              ["bell_radius", "Ang",         40, [0, inf],    "volume",      "Spherical bell radius"],
+              ["radius_bell", "Ang",         40, [0, inf],    "volume",      "Spherical bell radius"],
               ["radius",      "Ang",         20, [0, inf],    "volume",      "Cylindrical bar radius"],
               ["length",      "Ang",        400, [0, inf],    "volume",      "Cylinder bar length"],
@@ -116,5 +116,5 @@
 demo = dict(scale=1, background=0,
             sld=6, sld_solvent=1,
-            bell_radius=40, radius=20, length=400,
+            radius_bell=40, radius=20, length=400,
             theta=60, phi=60,
             radius_pd=.2, radius_pd_n=5,
Index: sasmodels/models/capped_cylinder.c
===================================================================
--- sasmodels/models/capped_cylinder.c	(revision 2f5c6d4a9ea74b4cc7a58030e36695b0634eb349)
+++ sasmodels/models/capped_cylinder.c	(revision 22221346d45e39a667fe231ce7ca5ecfc79b0ac5)
@@ -1,9 +1,9 @@
-double form_volume(double radius, double cap_radius, double length);
+double form_volume(double radius, double radius_cap, double length);
 double Iq(double q, double sld, double solvent_sld,
-    double radius, double cap_radius, double length);
+    double radius, double radius_cap, double length);
 double Iqxy(double qx, double qy, double sld, double solvent_sld,
-    double radius, double cap_radius, double length, double theta, double phi);
+    double radius, double radius_cap, double length, double theta, double phi);
 
-#define INVALID(v) (v.cap_radius < v.radius)
+#define INVALID(v) (v.radius_cap < v.radius)
 
 // Integral over a convex lens kernel for t in [h/R,1].  See the docs for
@@ -12,14 +12,14 @@
 //   h is the length of the lens "inside" the cylinder.  This negative wrt the
 //       definition of h in the docs.
-//   cap_radius is the radius of the lens
+//   radius_cap is the radius of the lens
 //   length is the cylinder length, or the separation between the lens halves
 //   alpha is the angle of the cylinder wrt q.
 static double
-_cap_kernel(double q, double h, double cap_radius,
+_cap_kernel(double q, double h, double radius_cap,
                       double half_length, double sin_alpha, double cos_alpha)
 {
     // translate a point in [-1,1] to a point in [lower,upper]
     const double upper = 1.0;
-    const double lower = h/cap_radius; // integral lower bound
+    const double lower = h/radius_cap; // integral lower bound
     const double zm = 0.5*(upper-lower);
     const double zb = 0.5*(upper+lower);
@@ -32,7 +32,7 @@
     //    m = q R cos(alpha)
     //    b = q(L/2-h) cos(alpha)
-    const double m = q*cap_radius*cos_alpha; // cos argument slope
+    const double m = q*radius_cap*cos_alpha; // cos argument slope
     const double b = q*(half_length-h)*cos_alpha; // cos argument intercept
-    const double qrst = q*cap_radius*sin_alpha; // Q*R*sin(theta)
+    const double qrst = q*radius_cap*sin_alpha; // Q*R*sin(theta)
     double total = 0.0;
     for (int i=0; i<76 ;i++) {
@@ -45,9 +45,9 @@
     // translate dx in [-1,1] to dx in [lower,upper]
     const double integral = total*zm;
-    const double cap_Fq = 2*M_PI*cube(cap_radius)*integral;
+    const double cap_Fq = 2*M_PI*cube(radius_cap)*integral;
     return cap_Fq;
 }
 
-double form_volume(double radius, double cap_radius, double length)
+double form_volume(double radius, double radius_cap, double length)
 {
     // cap radius should never be less than radius when this is called
@@ -74,12 +74,12 @@
     //        = pi r^2 L + pi hc (r^2 + hc^2/3)
     //        = pi (r^2 (L+hc) + hc^3/3)
-    const double hc = cap_radius - sqrt(cap_radius*cap_radius - radius*radius);
+    const double hc = radius_cap - sqrt(radius_cap*radius_cap - radius*radius);
     return M_PI*(radius*radius*(length+hc) + hc*hc*hc/3.0);
 }
 
 double Iq(double q, double sld, double solvent_sld,
-          double radius, double cap_radius, double length)
+          double radius, double radius_cap, double length)
 {
-    const double h = sqrt(cap_radius*cap_radius - radius*radius);
+    const double h = sqrt(radius_cap*radius_cap - radius*radius);
     const double half_length = 0.5*length;
 
@@ -93,5 +93,5 @@
         SINCOS(alpha, sin_alpha, cos_alpha);
 
-        const double cap_Fq = _cap_kernel(q, h, cap_radius, half_length, sin_alpha, cos_alpha);
+        const double cap_Fq = _cap_kernel(q, h, radius_cap, half_length, sin_alpha, cos_alpha);
         const double bj = sas_J1c(q*radius*sin_alpha);
         const double si = sinc(q*half_length*cos_alpha);
@@ -111,5 +111,5 @@
 double Iqxy(double qx, double qy,
     double sld, double solvent_sld, double radius,
-    double cap_radius, double length,
+    double radius_cap, double length,
     double theta, double phi)
 {
@@ -121,10 +121,10 @@
     const double alpha = acos(cos_val); // rod angle relative to q
 
-    const double h = sqrt(cap_radius*cap_radius - radius*radius);
+    const double h = sqrt(radius_cap*radius_cap - radius*radius);
     const double half_length = 0.5*length;
 
     double sin_alpha, cos_alpha; // slots to hold sincos function output
     SINCOS(alpha, sin_alpha, cos_alpha);
-    const double cap_Fq = _cap_kernel(q, h, cap_radius, half_length, sin_alpha, cos_alpha);
+    const double cap_Fq = _cap_kernel(q, h, radius_cap, half_length, sin_alpha, cos_alpha);
     const double bj = sas_J1c(q*radius*sin_alpha);
     const double si = sinc(q*half_length*cos_alpha);
Index: sasmodels/models/capped_cylinder.py
===================================================================
--- sasmodels/models/capped_cylinder.py	(revision 42356c8890c04b71169941b12a36fc0e07e2034b)
+++ sasmodels/models/capped_cylinder.py	(revision 22221346d45e39a667fe231ce7ca5ecfc79b0ac5)
@@ -96,5 +96,5 @@
     Note: As the length of cylinder -->0,
     it becomes a Convex Lens.
-    It must be that radius <(=) cap_radius.
+    It must be that radius <(=) radius_cap.
     [Parameters];
     scale: volume fraction of spheres,
@@ -102,5 +102,5 @@
     radius: radius of the cylinder,
     length: length of the cylinder,
-    cap_radius: radius of the semi-spherical cap,
+    radius_cap: radius of the semi-spherical cap,
     sld: SLD of the capped cylinder,
     sld_solvent: SLD of the solvent.
@@ -122,5 +122,5 @@
               # in the capped cylinder, and zero for no bar in the barbell model.  In
               # both models, one would be a pill.
-              ["cap_radius", "Ang",     20, [0, inf],    "volume", "Cap radius"],
+              ["radius_cap", "Ang",     20, [0, inf],    "volume", "Cap radius"],
               ["length",     "Ang",    400, [0, inf],    "volume", "Cylinder length"],
               ["theta",      "degrees", 60, [-inf, inf], "orientation", "In plane angle"],
@@ -133,8 +133,8 @@
 demo = dict(scale=1, background=0,
             sld=6, sld_solvent=1,
-            radius=260, cap_radius=290, length=290,
+            radius=260, radius_cap=290, length=290,
             theta=30, phi=15,
             radius_pd=.2, radius_pd_n=1,
-            cap_radius_pd=.2, cap_radius_pd_n=1,
+            radius_cap_pd=.2, radius_cap_pd_n=1,
             length_pd=.2, length_pd_n=10,
             theta_pd=15, theta_pd_n=45,
Index: sasmodels/models/core_shell_bicelle.c
===================================================================
--- sasmodels/models/core_shell_bicelle.c	(revision 43b7eea5794b4eb3362114ebde67ff2fb1c38fdc)
+++ sasmodels/models/core_shell_bicelle.c	(revision 22221346d45e39a667fe231ce7ca5ecfc79b0ac5)
@@ -1,7 +1,7 @@
-double form_volume(double radius, double rim_thickness, double face_thickness, double length);
+double form_volume(double radius, double thick_rim, double thick_face, double length);
 double Iq(double q,
           double radius,
-          double rim_thickness,
-          double face_thickness,
+          double thick_rim,
+          double thick_face,
           double length,
           double core_sld,
@@ -13,6 +13,6 @@
 double Iqxy(double qx, double qy,
           double radius,
-          double rim_thickness,
-          double face_thickness,
+          double thick_rim,
+          double thick_face,
           double length,
           double core_sld,
@@ -24,7 +24,7 @@
 
 
-double form_volume(double radius, double rim_thickness, double face_thickness, double length)
+double form_volume(double radius, double thick_rim, double thick_face, double length)
 {
-    return M_PI*(radius+rim_thickness)*(radius+rim_thickness)*(length+2*face_thickness);
+    return M_PI*(radius+thick_rim)*(radius+thick_rim)*(length+2*thick_face);
 }
 
@@ -102,6 +102,6 @@
 bicelle_kernel_2d(double q, double q_x, double q_y,
           double radius,
-          double rim_thickness,
-          double face_thickness,
+          double thick_rim,
+          double thick_face,
           double length,
           double core_sld,
@@ -125,5 +125,5 @@
 
     // Get the kernel
-    double answer = bicelle_kernel(q, radius, rim_thickness, face_thickness,
+    double answer = bicelle_kernel(q, radius, thick_rim, thick_face,
                            length/2.0, core_sld, face_sld, rim_sld,
                            solvent_sld, alpha) / fabs(sin(alpha));
@@ -136,6 +136,6 @@
 double Iq(double q,
           double radius,
-          double rim_thickness,
-          double face_thickness,
+          double thick_rim,
+          double thick_face,
           double length,
           double core_sld,
@@ -144,5 +144,5 @@
           double solvent_sld)
 {
-    double intensity = bicelle_integration(q, radius, rim_thickness, face_thickness,
+    double intensity = bicelle_integration(q, radius, thick_rim, thick_face,
                        length, core_sld, face_sld, rim_sld, solvent_sld);
     return intensity*1.0e-4;
@@ -152,6 +152,6 @@
 double Iqxy(double qx, double qy,
           double radius,
-          double rim_thickness,
-          double face_thickness,
+          double thick_rim,
+          double thick_face,
           double length,
           double core_sld,
@@ -166,6 +166,6 @@
     double intensity = bicelle_kernel_2d(q, qx/q, qy/q,
                       radius,
-                      rim_thickness,
-                      face_thickness,
+                      thick_rim,
+                      thick_face,
                       length,
                       core_sld,
Index: sasmodels/models/core_shell_bicelle.py
===================================================================
--- sasmodels/models/core_shell_bicelle.py	(revision 40a87fa5096610e24c3ead10299f609e99f093f2)
+++ sasmodels/models/core_shell_bicelle.py	(revision 22221346d45e39a667fe231ce7ca5ecfc79b0ac5)
@@ -76,6 +76,6 @@
 parameters = [
     ["radius",         "Ang",       20, [0, inf],    "volume",      "Cylinder core radius"],
-    ["rim_thickness",  "Ang",       10, [0, inf],    "volume",      "Rim shell thickness"],
-    ["face_thickness", "Ang",       10, [0, inf],    "volume",      "Cylinder face thickness"],
+    ["thick_rim",  "Ang",       10, [0, inf],    "volume",      "Rim shell thickness"],
+    ["thick_face", "Ang",       10, [0, inf],    "volume",      "Cylinder face thickness"],
     ["length",         "Ang",      400, [0, inf],    "volume",      "Cylinder length"],
     ["sld_core",       "1e-6/Ang^2", 1, [-inf, inf], "sld",         "Cylinder core scattering length density"],
@@ -94,6 +94,6 @@
 demo = dict(scale=1, background=0,
             radius=20.0,
-            rim_thickness=10.0,
-            face_thickness=10.0,
+            thick_rim=10.0,
+            thick_face=10.0,
             length=400.0,
             sld_core=1.0,
@@ -108,6 +108,6 @@
     # Accuracy tests based on content in test/utest_other_models.py
     [{'radius': 20.0,
-      'rim_thickness': 10.0,
-      'face_thickness': 10.0,
+      'thick_rim': 10.0,
+      'thick_face': 10.0,
       'length': 400.0,
       'sld_core': 1.0,
@@ -119,6 +119,6 @@
 
     [{'radius': 20.0,
-      'rim_thickness': 10.0,
-      'face_thickness': 10.0,
+      'thick_rim': 10.0,
+      'thick_face': 10.0,
       'length': 400.0,
       'sld_core': 1.0,
@@ -133,6 +133,6 @@
     # Additional tests with larger range of parameters
     [{'radius': 3.0,
-      'rim_thickness': 100.0,
-      'face_thickness': 100.0,
+      'thick_rim': 100.0,
+      'thick_face': 100.0,
       'length': 1200.0,
       'sld_core': 5.0,
Index: sasmodels/models/core_shell_ellipsoid.c
===================================================================
--- sasmodels/models/core_shell_ellipsoid.c	(revision 29172aa52f4fdcefe534e792b14ec43221514fe1)
+++ sasmodels/models/core_shell_ellipsoid.c	(revision 22221346d45e39a667fe231ce7ca5ecfc79b0ac5)
@@ -1,11 +1,11 @@
-double form_volume(double equat_core,
-                   double polar_core,
-                   double equat_shell,
-                   double polar_shell);
+double form_volume(double radius_equat_core,
+                   double radius_polar_core,
+                   double radius_equat_shell,
+                   double radius_polar_shell);
 double Iq(double q,
-          double equat_core,
-          double polar_core,
-          double equat_shell,
-          double polar_shell,
+          double radius_equat_core,
+          double radius_polar_core,
+          double radius_equat_shell,
+          double radius_polar_shell,
           double sld_core,
           double sld_shell,
@@ -14,8 +14,8 @@
 
 double Iqxy(double qx, double qy,
-          double equat_core,
-          double polar_core,
-          double equat_shell,
-          double polar_shell,
+          double radius_equat_core,
+          double radius_polar_core,
+          double radius_equat_shell,
+          double radius_polar_shell,
           double sld_core,
           double sld_shell,
@@ -25,10 +25,10 @@
 
 
-double form_volume(double equat_core,
-                   double polar_core,
-                   double equat_shell,
-                   double polar_shell)
+double form_volume(double radius_equat_core,
+                   double radius_polar_core,
+                   double radius_equat_shell,
+                   double radius_polar_shell)
 {
-    double vol = 4.0*M_PI/3.0*equat_shell*equat_shell*polar_shell;
+    double vol = 4.0*M_PI/3.0*radius_equat_shell*radius_equat_shell*radius_polar_shell;
     return vol;
 }
@@ -36,8 +36,8 @@
 static double
 core_shell_ellipsoid_kernel(double q,
-          double equat_core,
-          double polar_core,
-          double equat_shell,
-          double polar_shell,
+          double radius_equat_core,
+          double radius_polar_core,
+          double radius_equat_shell,
+          double radius_polar_shell,
           double sld_core,
           double sld_shell,
@@ -57,8 +57,8 @@
         double zi = ( Gauss76Z[i]*(uplim-lolim) + uplim + lolim )/2.0;
         double yyy = Gauss76Wt[i] * gfn4(zi,
-                                  equat_core,
-                                  polar_core,
-                                  equat_shell,
-                                  polar_shell,
+                                  radius_equat_core,
+                                  radius_polar_core,
+                                  radius_equat_shell,
+                                  radius_polar_shell,
                                   delpc,
                                   delps,
@@ -77,8 +77,8 @@
 static double
 core_shell_ellipsoid_kernel_2d(double q, double q_x, double q_y,
-          double equat_core,
-          double polar_core,
-          double equat_shell,
-          double polar_shell,
+          double radius_equat_core,
+          double radius_polar_core,
+          double radius_equat_shell,
+          double radius_polar_shell,
           double sld_core,
           double sld_shell,
@@ -105,8 +105,8 @@
     // Call the IGOR library function to get the kernel: MUST use gfn4 not gf2 because of the def of params.
     double answer = gfn4(cos_val,
-                  equat_core,
-                  polar_core,
-                  equat_shell,
-                  polar_shell,
+                  radius_equat_core,
+                  radius_polar_core,
+                  radius_equat_shell,
+                  radius_polar_shell,
                   sldcs,
                   sldss,
@@ -120,8 +120,8 @@
 
 double Iq(double q,
-          double equat_core,
-          double polar_core,
-          double equat_shell,
-          double polar_shell,
+          double radius_equat_core,
+          double radius_polar_core,
+          double radius_equat_shell,
+          double radius_polar_shell,
           double sld_core,
           double sld_shell,
@@ -129,8 +129,8 @@
 {
     double intensity = core_shell_ellipsoid_kernel(q,
-           equat_core,
-           polar_core,
-           equat_shell,
-           polar_shell,
+           radius_equat_core,
+           radius_polar_core,
+           radius_equat_shell,
+           radius_polar_shell,
            sld_core,
            sld_shell,
@@ -142,8 +142,8 @@
 
 double Iqxy(double qx, double qy,
-          double equat_core,
-          double polar_core,
-          double equat_shell,
-          double polar_shell,
+          double radius_equat_core,
+          double radius_polar_core,
+          double radius_equat_shell,
+          double radius_polar_shell,
           double sld_core,
           double sld_shell,
@@ -155,8 +155,8 @@
     q = sqrt(qx*qx+qy*qy);
     double intensity = core_shell_ellipsoid_kernel_2d(q, qx/q, qy/q,
-                       equat_core,
-                       polar_core,
-                       equat_shell,
-                       polar_shell,
+                       radius_equat_core,
+                       radius_polar_core,
+                       radius_equat_shell,
+                       radius_polar_shell,
                        sld_core,
                        sld_shell,
Index: sasmodels/models/core_shell_ellipsoid.py
===================================================================
--- sasmodels/models/core_shell_ellipsoid.py	(revision 40a87fa5096610e24c3ead10299f609e99f093f2)
+++ sasmodels/models/core_shell_ellipsoid.py	(revision 22221346d45e39a667fe231ce7ca5ecfc79b0ac5)
@@ -52,5 +52,5 @@
 .. note::
     The 2nd virial coefficient of the solid ellipsoid is calculated based on
-    the *radius_a* (= *polar_shell)* and *radius_b (= equat_shell)* values,
+    the *radius_a* (= *radius_polar_shell)* and *radius_b (= radius_equat_shell)* values,
     and used as the effective radius for *S(Q)* when $P(Q) * S(Q)$ is applied.
 
@@ -82,8 +82,8 @@
     single particle scattering amplitude.
     [Parameters]:
-    equat_core = equatorial radius of core, Rminor_core,
-    polar_core = polar radius of core, Rmajor_core,
-    equat_shell = equatorial radius of shell, Rminor_outer,
-    polar_shell = polar radius of shell, Rmajor_outer,
+    radius_equat_core = equatorial radius of core, Rminor_core,
+    radius_polar_core = polar radius of core, Rmajor_core,
+    radius_equat_shell = equatorial radius of shell, Rminor_outer,
+    radius_polar_shell = polar radius of shell, Rmajor_outer,
     sld_core = scattering length density of core,
     sld_shell = scattering length density of shell,
@@ -102,8 +102,8 @@
 #   ["name", "units", default, [lower, upper], "type", "description"],
 parameters = [
-    ["equat_core",  "Ang",      200,   [0, inf],    "volume",      "Equatorial radius of core, r minor core"],
-    ["polar_core",  "Ang",       10,   [0, inf],    "volume",      "Polar radius of core, r major core"],
-    ["equat_shell", "Ang",      250,   [0, inf],    "volume",      "Equatorial radius of shell, r minor outer"],
-    ["polar_shell", "Ang",       30,   [0, inf],    "volume",      "Polar radius of shell, r major outer"],
+    ["radius_equat_core",  "Ang",      200,   [0, inf],    "volume",      "Equatorial radius of core, r minor core"],
+    ["radius_polar_core",  "Ang",       10,   [0, inf],    "volume",      "Polar radius of core, r major core"],
+    ["radius_equat_shell", "Ang",      250,   [0, inf],    "volume",      "Equatorial radius of shell, r minor outer"],
+    ["radius_polar_shell", "Ang",       30,   [0, inf],    "volume",      "Polar radius of shell, r major outer"],
     ["sld_core",    "1e-6/Ang^2", 2,   [-inf, inf], "sld",         "Core scattering length density"],
     ["sld_shell",   "1e-6/Ang^2", 1,   [-inf, inf], "sld",         "Shell scattering length density"],
@@ -116,17 +116,17 @@
 source = ["lib/sph_j1c.c", "lib/gfn.c", "lib/gauss76.c", "core_shell_ellipsoid.c"]
 
-def ER(equat_core, polar_core, equat_shell, polar_shell):
+def ER(radius_equat_core, radius_polar_core, radius_equat_shell, radius_polar_shell):
     """
         Returns the effective radius used in the S*P calculation
     """
     from .ellipsoid import ER as ellipsoid_ER
-    return ellipsoid_ER(polar_shell, equat_shell)
+    return ellipsoid_ER(radius_polar_shell, radius_equat_shell)
 
 
 demo = dict(scale=1, background=0.001,
-            equat_core=200.0,
-            polar_core=10.0,
-            equat_shell=250.0,
-            polar_shell=30.0,
+            radius_equat_core=200.0,
+            radius_polar_core=10.0,
+            radius_equat_shell=250.0,
+            radius_polar_shell=30.0,
             sld_core=2.0,
             sld_shell=1.0,
@@ -142,8 +142,8 @@
 tests = [
     # Accuracy tests based on content in test/utest_other_models.py
-    [{'equat_core': 200.0,
-      'polar_core': 20.0,
-      'equat_shell': 250.0,
-      'polar_shell': 30.0,
+    [{'radius_equat_core': 200.0,
+      'radius_polar_core': 20.0,
+      'radius_equat_shell': 250.0,
+      'radius_polar_shell': 30.0,
       'sld_core': 2.0,
       'sld_shell': 1.0,
@@ -156,8 +156,8 @@
     [{'background': 0.01}, 0.1, 8.86741],
 
-    [{'equat_core': 20.0,
-      'polar_core': 200.0,
-      'equat_shell': 54.0,
-      'polar_shell': 3.0,
+    [{'radius_equat_core': 20.0,
+      'radius_polar_core': 200.0,
+      'radius_equat_shell': 54.0,
+      'radius_polar_shell': 3.0,
       'sld_core': 20.0,
       'sld_shell': 10.0,
@@ -169,8 +169,8 @@
     [{'background': 0.001}, (0.4, 0.5), 0.00170471],
 
-    [{'equat_core': 20.0,
-      'polar_core': 200.0,
-      'equat_shell': 54.0,
-      'polar_shell': 3.0,
+    [{'radius_equat_core': 20.0,
+      'radius_polar_core': 200.0,
+      'radius_equat_shell': 54.0,
+      'radius_polar_shell': 3.0,
       'sld_core': 20.0,
       'sld_shell': 10.0,
Index: sasmodels/models/core_shell_ellipsoid_xt.c
===================================================================
--- sasmodels/models/core_shell_ellipsoid_xt.c	(revision e7678b2f993854334aca4c45e1c7022b2fdbb509)
+++ sasmodels/models/core_shell_ellipsoid_xt.c	(revision 22221346d45e39a667fe231ce7ca5ecfc79b0ac5)
@@ -1,10 +1,10 @@
-double form_volume(double equat_core,
+double form_volume(double radius_equat_core,
                    double polar_core,
                    double equat_shell,
                    double polar_shell);
 double Iq(double q,
-          double equat_core,
+          double radius_equat_core,
           double x_core,
-          double t_shell,
+          double thick_shell,
           double x_polar_shell,
           double core_sld,
@@ -14,7 +14,7 @@
 
 double Iqxy(double qx, double qy,
-          double equat_core,
+          double radius_equat_core,
           double x_core,
-          double t_shell,
+          double thick_shell,
           double x_polar_shell,
           double core_sld,
@@ -25,11 +25,11 @@
 
 
-double form_volume(double equat_core,
+double form_volume(double radius_equat_core,
                    double x_core,
-                   double t_shell,
+                   double thick_shell,
                    double x_polar_shell)
 {
-    const double equat_shell = equat_core + t_shell;
-    const double polar_shell = equat_core*x_core + t_shell*x_polar_shell;
+    const double equat_shell = radius_equat_core + thick_shell;
+    const double polar_shell = radius_equat_core*x_core + thick_shell*x_polar_shell;
     double vol = 4.0*M_PI/3.0*equat_shell*equat_shell*polar_shell;
     return vol;
@@ -38,7 +38,7 @@
 static double
 core_shell_ellipsoid_xt_kernel(double q,
-          double equat_core,
+          double radius_equat_core,
           double x_core,
-          double t_shell,
+          double thick_shell,
           double x_polar_shell,
           double core_sld,
@@ -55,12 +55,12 @@
 
 
-    const double polar_core = equat_core*x_core;
-    const double equat_shell = equat_core + t_shell;
-    const double polar_shell = equat_core*x_core + t_shell*x_polar_shell;
+    const double polar_core = radius_equat_core*x_core;
+    const double equat_shell = radius_equat_core + thick_shell;
+    const double polar_shell = radius_equat_core*x_core + thick_shell*x_polar_shell;
 
     for(int i=0;i<N_POINTS_76;i++) {
         double zi = ( Gauss76Z[i]*(uplim-lolim) + uplim + lolim )/2.0;
         double yyy = Gauss76Wt[i] * gfn4(zi,
-                                  equat_core,
+                                  radius_equat_core,
                                   polar_core,
                                   equat_shell,
@@ -81,7 +81,7 @@
 static double
 core_shell_ellipsoid_xt_kernel_2d(double q, double q_x, double q_y,
-          double equat_core,
+          double radius_equat_core,
           double x_core,
-          double t_shell,
+          double thick_shell,
           double x_polar_shell,
           double core_sld,
@@ -106,12 +106,12 @@
     const double cos_val = cyl_x*q_x + cyl_y*q_y;
 
-    const double polar_core = equat_core*x_core;
-    const double equat_shell = equat_core + t_shell;
-    const double polar_shell = equat_core*x_core + t_shell*x_polar_shell;
+    const double polar_core = radius_equat_core*x_core;
+    const double equat_shell = radius_equat_core + thick_shell;
+    const double polar_shell = radius_equat_core*x_core + thick_shell*x_polar_shell;
 
     // Call the IGOR library function to get the kernel:
     // MUST use gfn4 not gf2 because of the def of params.
     double answer = gfn4(cos_val,
-                  equat_core,
+                  radius_equat_core,
                   polar_core,
                   equat_shell,
@@ -128,7 +128,7 @@
 
 double Iq(double q,
-          double equat_core,
+          double radius_equat_core,
           double x_core,
-          double t_shell,
+          double thick_shell,
           double x_polar_shell,
           double core_sld,
@@ -137,7 +137,7 @@
 {
     double intensity = core_shell_ellipsoid_xt_kernel(q,
-           equat_core,
+           radius_equat_core,
            x_core,
-           t_shell,
+           thick_shell,
            x_polar_shell,
            core_sld,
@@ -150,7 +150,7 @@
 
 double Iqxy(double qx, double qy,
-          double equat_core,
+          double radius_equat_core,
           double x_core,
-          double t_shell,
+          double thick_shell,
           double x_polar_shell,
           double core_sld,
@@ -163,7 +163,7 @@
     q = sqrt(qx*qx+qy*qy);
     double intensity = core_shell_ellipsoid_xt_kernel_2d(q, qx/q, qy/q,
-                       equat_core,
+                       radius_equat_core,
                        x_core,
-                       t_shell,
+                       thick_shell,
                        x_polar_shell,
                        core_sld,
Index: sasmodels/models/core_shell_ellipsoid_xt.py
===================================================================
--- sasmodels/models/core_shell_ellipsoid_xt.py	(revision 40a87fa5096610e24c3ead10299f609e99f093f2)
+++ sasmodels/models/core_shell_ellipsoid_xt.py	(revision 22221346d45e39a667fe231ce7ca5ecfc79b0ac5)
@@ -14,20 +14,20 @@
 The geometric parameters of this model are
 
-*equat_core =* equatorial core radius *= R_minor_core*
+*radius_equat_core =* equatorial core radius *= R_minor_core*
 
-*X_core = polar_core / equat_core = Rmajor_core / Rminor_core*
+*X_core = polar_core / radius_equat_core = Rmajor_core / Rminor_core*
 
-*T_shell = equat_outer - equat_core = Rminor_outer - Rminor_core*
+*Thick_shell = equat_outer - radius_equat_core = Rminor_outer - Rminor_core*
 
-*XpolarShell = Tpolar_shell / T_shell = (Rmajor_outer - Rmajor_core)/
+*XpolarShell = Tpolar_shell / Thick_shell = (Rmajor_outer - Rmajor_core)/
 (Rminor_outer - Rminor_core)*
 
 In terms of the original radii
 
-*polar_core = equat_core * X_core*
+*polar_core = radius_equat_core * X_core*
 
-*equat_shell = equat_core + T_shell*
+*equat_shell = radius_equat_core + Thick_shell*
 
-*polar_shell = equat_core * X_core + T_shell * XpolarShell*
+*polar_shell = radius_equat_core * X_core + Thick_shell * XpolarShell*
 
 (where we note that "shell" perhaps confusingly, relates to the outer radius)
@@ -68,7 +68,7 @@
         single particle scattering amplitude.
         [Parameters]:
-        equat_core = equatorial radius of core,
+        radius_equat_core = equatorial radius of core,
         x_core = ratio of core polar/equatorial radii,
-        t_shell = equatorial radius of outer surface,
+        thick_shell = equatorial radius of outer surface,
         x_polar_shell = ratio of polar shell thickness to equatorial shell thickness,
         sld_core = SLD_core
@@ -88,7 +88,7 @@
 #             ["name", "units", default, [lower, upper], "type", "description"],
 parameters = [
-    ["equat_core",    "Ang",       20,   [0, inf],    "volume",      "Equatorial radius of core"],
+    ["radius_equat_core","Ang",     20,   [0, inf],    "volume",      "Equatorial radius of core"],
     ["x_core",        "None",       3,   [0, inf],    "volume",      "axial ratio of core, X = r_polar/r_equatorial"],
-    ["t_shell",       "Ang",       30,   [0, inf],    "volume",      "thickness of shell at equator"],
+    ["thick_shell",   "Ang",       30,   [0, inf],    "volume",      "thickness of shell at equator"],
     ["x_polar_shell", "",           1,   [0, inf],    "volume",      "ratio of thickness of shell at pole to that at equator"],
     ["sld_core",      "1e-6/Ang^2", 2,   [-inf, inf], "sld",         "Core scattering length density"],
@@ -103,18 +103,18 @@
           "core_shell_ellipsoid_xt.c"]
 
-def ER(equat_core, x_core, t_shell, x_polar_shell):
+def ER(radius_equat_core, x_core, thick_shell, x_polar_shell):
     """
         Returns the effective radius used in the S*P calculation
     """
     from .ellipsoid import ER as ellipsoid_ER
-    polar_outer = equat_core*x_core + t_shell*x_polar_shell
-    equat_outer = equat_core + t_shell
+    polar_outer = radius_equat_core*x_core + thick_shell*x_polar_shell
+    equat_outer = radius_equat_core + thick_shell
     return ellipsoid_ER(polar_outer, equat_outer)
 
 
 demo = dict(scale=0.05, background=0.001,
-            equat_core=20.0,
+            radius_equat_core=20.0,
             x_core=3.0,
-            t_shell=30.0,
+            thick_shell=30.0,
             x_polar_shell=1.0,
             sld_core=2.0,
@@ -131,7 +131,7 @@
 tests = [
     # Accuracy tests based on content in test/utest_coreshellellipsoidXTmodel.py
-    [{'equat_core': 200.0,
+    [{'radius_equat_core': 200.0,
       'x_core': 0.1,
-      't_shell': 50.0,
+      'thick_shell': 50.0,
       'x_polar_shell': 0.2,
       'sld_core': 2.0,
@@ -145,7 +145,7 @@
     [{'background': 0.01}, 0.1, 11.6915],
 
-    [{'equat_core': 20.0,
+    [{'radius_equat_core': 20.0,
       'x_core': 200.0,
-      't_shell': 54.0,
+      'thick_shell': 54.0,
       'x_polar_shell': 3.0,
       'sld_core': 20.0,
@@ -158,7 +158,7 @@
     [{'background': 0.001}, (0.4, 0.5), 0.00690673],
 
-    [{'equat_core': 20.0,
+    [{'radius_equat_core': 20.0,
       'x_core': 200.0,
-      't_shell': 54.0,
+      'thick_shell': 54.0,
       'x_polar_shell': 3.0,
       'sld_core': 20.0,
Index: sasmodels/models/core_shell_parallelepiped.c
===================================================================
--- sasmodels/models/core_shell_parallelepiped.c	(revision abdd01cc0315960ae6e5951909d2866515e37bae)
+++ sasmodels/models/core_shell_parallelepiped.c	(revision 22221346d45e39a667fe231ce7ca5ecfc79b0ac5)
@@ -1,20 +1,20 @@
-double form_volume(double a_side, double b_side, double c_side, 
-                   double arim_thickness, double brim_thickness, double crim_thickness);
+double form_volume(double length_a, double length_b, double length_c, 
+                   double thick_rim_a, double thick_rim_b, double thick_rim_c);
 double Iq(double q, double core_sld, double arim_sld, double brim_sld, double crim_sld,
-          double solvent_sld, double a_side, double b_side, double c_side,
-          double arim_thickness, double brim_thickness, double crim_thickness);
+          double solvent_sld, double length_a, double length_b, double length_c,
+          double thick_rim_a, double thick_rim_b, double thick_rim_c);
 double Iqxy(double qx, double qy, double core_sld, double arim_sld, double brim_sld,
-            double crim_sld, double solvent_sld, double a_side, double b_side,
-            double c_side, double arim_thickness, double brim_thickness,
-            double crim_thickness, double theta, double phi, double psi);
-
-double form_volume(double a_side, double b_side, double c_side, 
-                   double arim_thickness, double brim_thickness, double crim_thickness)
+            double crim_sld, double solvent_sld, double length_a, double length_b,
+            double length_c, double thick_rim_a, double thick_rim_b,
+            double thick_rim_c, double theta, double phi, double psi);
+
+double form_volume(double length_a, double length_b, double length_c, 
+                   double thick_rim_a, double thick_rim_b, double thick_rim_c)
 {
-    //return a_side * b_side * c_side;
-    return a_side * b_side * c_side + 
-           2.0 * arim_thickness * b_side * c_side + 
-           2.0 * brim_thickness * a_side * c_side +
-           2.0 * crim_thickness * a_side * b_side;
+    //return length_a * length_b * length_c;
+    return length_a * length_b * length_c + 
+           2.0 * thick_rim_a * length_b * length_c + 
+           2.0 * thick_rim_b * length_a * length_c +
+           2.0 * thick_rim_c * length_a * length_b;
 }
 
@@ -25,10 +25,10 @@
     double crim_sld,
     double solvent_sld,
-    double a_side,
-    double b_side,
-    double c_side,
-    double arim_thickness,
-    double brim_thickness,
-    double crim_thickness)
+    double length_a,
+    double length_b,
+    double length_c,
+    double thick_rim_a,
+    double thick_rim_b,
+    double thick_rim_c)
 {
     // Code converted from functions CSPPKernel and CSParallelepiped in libCylinder.c_scaled
@@ -36,16 +36,16 @@
     
     double t1, t2, t3, t4, tmp, answer;   
-    double mu = q * b_side;
+    double mu = q * length_b;
     
     //calculate volume before rescaling (in original code, but not used)
-    //double vol = form_volume(a_side, b_side, c_side, arim_thickness, brim_thickness, crim_thickness);		
-    //double vol = a_side * b_side * c_side + 
-    //       2.0 * arim_thickness * b_side * c_side + 
-    //       2.0 * brim_thickness * a_side * c_side +
-    //       2.0 * crim_thickness * a_side * b_side;
+    //double vol = form_volume(length_a, length_b, length_c, thick_rim_a, thick_rim_b, thick_rim_c);		
+    //double vol = length_a * length_b * length_c + 
+    //       2.0 * thick_rim_a * length_b * length_c + 
+    //       2.0 * thick_rim_b * length_a * length_c +
+    //       2.0 * thick_rim_c * length_a * length_b;
     
     // Scale sides by B
-    double a_scaled = a_side / b_side;
-    double c_scaled = c_side / b_side;
+    double a_scaled = length_a / length_b;
+    double c_scaled = length_c / length_b;
 
     // DelRho values (note that drC is not used later)       
@@ -74,11 +74,11 @@
             double mudum = mu * sqrt(1.0-sigma*sigma);
 
-	        double Vin = a_side * b_side * c_side;
-	        //double Vot = (a_side * b_side * c_side +
-            //            2.0 * arim_thickness * b_side * c_side +
-            //            2.0 * a_side * brim_thickness * c_side +
-            //            2.0 * a_side * b_side * crim_thickness);
-	        double V1 = (2.0 * arim_thickness * b_side * c_side);    // incorrect V1 (aa*bb*cc+2*ta*bb*cc)
-	        double V2 = (2.0 * a_side * brim_thickness * c_side);    // incorrect V2(aa*bb*cc+2*aa*tb*cc)
+	        double Vin = length_a * length_b * length_c;
+	        //double Vot = (length_a * length_b * length_c +
+            //            2.0 * thick_rim_a * length_b * length_c +
+            //            2.0 * length_a * thick_rim_b * length_c +
+            //            2.0 * length_a * length_b * thick_rim_c);
+	        double V1 = (2.0 * thick_rim_a * length_b * length_c);    // incorrect V1 (aa*bb*cc+2*ta*bb*cc)
+	        double V2 = (2.0 * length_a * thick_rim_b * length_c);    // incorrect V2(aa*bb*cc+2*aa*tb*cc)
 	
             // ta and tb correspond to the definitions in CSPPKernel, but they don't make sense to me (MG)
@@ -86,6 +86,6 @@
             // while in cspkernel in csparallelepiped.cpp (used for the 2D), all the definitions
             // for ta, tb, tc use also A + 2*rim_thickness (but not scaled by B!!!)            
-            double ta = (a_scaled+2.0*arim_thickness)/b_side; 
-            double tb = (a_scaled+2.0*brim_thickness)/b_side;
+            double ta = (a_scaled+2.0*thick_rim_a)/length_b; 
+            double tb = (a_scaled+2.0*thick_rim_b)/length_b;
     
 	        double arg1 = (0.5*mudum*a_scaled) * sin(0.5*M_PI*uu);
@@ -160,10 +160,10 @@
     double crim_sld,
     double solvent_sld,
-    double a_side,
-    double b_side,
-    double c_side,
-    double arim_thickness,
-    double brim_thickness,
-    double crim_thickness,
+    double length_a,
+    double length_b,
+    double length_c,
+    double thick_rim_a,
+    double thick_rim_b,
+    double thick_rim_c,
     double theta,
     double phi,
@@ -217,23 +217,23 @@
 	double drB = brim_sld-solvent_sld;
 	double drC = crim_sld-solvent_sld;
-	double Vin = a_side * b_side * c_side;
+	double Vin = length_a * length_b * length_c;
     // As for the 1D case, Vot is not used
-	//double Vot = (a_side * b_side * c_side +
-    //              2.0 * arim_thickness * b_side * c_side +
-    //              2.0 * a_side * brim_thickness * c_side +
-    //              2.0 * a_side * b_side * crim_thickness);
-	double V1 = (2.0 * arim_thickness * b_side * c_side);    // incorrect V1 (aa*bb*cc+2*ta*bb*cc)
-	double V2 = (2.0 * a_side * brim_thickness * c_side);    // incorrect V2(aa*bb*cc+2*aa*tb*cc)
-    double V3 = (2.0 * a_side * b_side * crim_thickness);
+	//double Vot = (length_a * length_b * length_c +
+    //              2.0 * thick_rim_a * length_b * length_c +
+    //              2.0 * length_a * thick_rim_b * length_c +
+    //              2.0 * length_a * length_b * thick_rim_c);
+	double V1 = (2.0 * thick_rim_a * length_b * length_c);    // incorrect V1 (aa*bb*cc+2*ta*bb*cc)
+	double V2 = (2.0 * length_a * thick_rim_b * length_c);    // incorrect V2(aa*bb*cc+2*aa*tb*cc)
+    double V3 = (2.0 * length_a * length_b * thick_rim_c);
     // The definitions of ta, tb, tc are not the same as in the 1D case because there is no
-    // the scaling by B. The use of a_side for the 3 of them seems clearly a mistake to me,
+    // the scaling by B. The use of length_a for the 3 of them seems clearly a mistake to me,
     // but for the moment I let it like this until understanding better the code.
-	double ta = a_side + 2.0*arim_thickness;
-    double tb = a_side + 2.0*brim_thickness;
-    double tc = a_side + 2.0*crim_thickness;
+	double ta = length_a + 2.0*thick_rim_a;
+    double tb = length_a + 2.0*thick_rim_b;
+    double tc = length_a + 2.0*thick_rim_c;
     //handle arg=0 separately, as sin(t)/t -> 1 as t->0
-    double argA = 0.5*q*a_side*cos_val_a;
-    double argB = 0.5*q*b_side*cos_val_b;
-    double argC = 0.5*q*c_side*cos_val_c;
+    double argA = 0.5*q*length_a*cos_val_a;
+    double argB = 0.5*q*length_b*cos_val_b;
+    double argC = 0.5*q*length_c*cos_val_c;
     double argtA = 0.5*q*ta*cos_val_a;
     double argtB = 0.5*q*tb*cos_val_b;
Index: sasmodels/models/core_shell_parallelepiped.py
===================================================================
--- sasmodels/models/core_shell_parallelepiped.py	(revision 42356c8890c04b71169941b12a36fc0e07e2034b)
+++ sasmodels/models/core_shell_parallelepiped.py	(revision 22221346d45e39a667fe231ce7ca5ecfc79b0ac5)
@@ -124,15 +124,15 @@
               ["sld_solvent", "1e-6/Ang^2", 6, [-inf, inf], "sld",
                "Solvent scattering length density"],
-              ["a_side", "Ang", 35, [0, inf], "volume",
+              ["length_a", "Ang", 35, [0, inf], "volume",
                "Shorter side of the parallelepiped"],
-              ["b_side", "Ang", 75, [0, inf], "volume",
+              ["length_b", "Ang", 75, [0, inf], "volume",
                "Second side of the parallelepiped"],
-              ["c_side", "Ang", 400, [0, inf], "volume",
+              ["length_c", "Ang", 400, [0, inf], "volume",
                "Larger side of the parallelepiped"],
-              ["arim_thickness", "Ang", 10, [0, inf], "volume",
+              ["thick_rim_a", "Ang", 10, [0, inf], "volume",
                "Thickness of A rim"],
-              ["brim_thickness", "Ang", 10, [0, inf], "volume",
+              ["thick_rim_b", "Ang", 10, [0, inf], "volume",
                "Thickness of B rim"],
-              ["crim_thickness", "Ang", 10, [0, inf], "volume",
+              ["thick_rim_c", "Ang", 10, [0, inf], "volume",
                "Thickness of C rim"],
               ["theta", "degrees", 0, [-inf, inf], "orientation",
@@ -147,5 +147,5 @@
 
 
-def ER(a_side, b_side, c_side, arim_thickness, brim_thickness, crim_thickness):
+def ER(length_a, length_b, length_c, thick_rim_a, thick_rim_b, thick_rim_c):
     """
         Return equivalent radius (ER)
@@ -153,7 +153,7 @@
 
     # surface average radius (rough approximation)
-    surf_rad = sqrt((a_side + 2.0*arim_thickness) * (b_side + 2.0*brim_thickness) / pi)
+    surf_rad = sqrt((length_a + 2.0*thick_rim_a) * (length_b + 2.0*thick_rim_b) / pi)
 
-    height = c_side + 2.0*crim_thickness
+    height = length_c + 2.0*thick_rim_c
 
     ddd = 0.75 * surf_rad * (2 * surf_rad * height + (height + surf_rad) * (height + pi * surf_rad))
@@ -166,13 +166,13 @@
             sld_core=1e-6, sld_a=2e-6, sld_b=4e-6,
             sld_c=2e-6, sld_solvent=6e-6,
-            a_side=35, b_side=75, c_side=400,
-            arim_thickness=10, brim_thickness=10, crim_thickness=10,
+            length_a=35, length_b=75, length_c=400,
+            thick_rim_a=10, thick_rim_b=10, thick_rim_c=10,
             theta=0, phi=0, psi=0,
-            a_side_pd=0.1, a_side_pd_n=1,
-            b_side_pd=0.1, b_side_pd_n=1,
-            c_side_pd=0.1, c_side_pd_n=1,
-            arim_thickness_pd=0.1, arim_thickness_pd_n=1,
-            brim_thickness_pd=0.1, brim_thickness_pd_n=1,
-            crim_thickness_pd=0.1, crim_thickness_pd_n=1,
+            length_a_pd=0.1, length_a_pd_n=1,
+            length_b_pd=0.1, length_b_pd_n=1,
+            length_c_pd=0.1, length_c_pd_n=1,
+            thick_rim_a_pd=0.1, thick_rim_a_pd_n=1,
+            thick_rim_b_pd=0.1, thick_rim_b_pd_n=1,
+            thick_rim_c_pd=0.1, thick_rim_c_pd_n=1,
             theta_pd=10, theta_pd_n=1,
             phi_pd=10, phi_pd_n=1,
