Index: sasmodels/models/correlation_length.py
===================================================================
--- sasmodels/models/correlation_length.py	(revision 40a87fa5096610e24c3ead10299f609e99f093f2)
+++ sasmodels/models/correlation_length.py	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -16,5 +16,5 @@
 multiplicative factors $A$ and $C$, and the two exponents $n$ and $m$ are
 used as fitting parameters. (Respectively *porod_scale*, *lorentz_scale*,
-*exponent_p* and *exponent_l* in the parameter list.) The remaining
+*porod_exp* and *lorentz_exp* in the parameter list.) The remaining
 parameter $\xi$ (*cor_length* in the parameter list) is a correlation
 length for the polymer chains. Note that when $m=2$ this functional form
@@ -48,16 +48,16 @@
               ["porod_scale", "", 1e-06, [0, inf], "", "Porod Scaling Factor"],
               ["cor_length", "Ang", 50.0, [0, inf], "", "Correlation length, xi, in Lorentzian"],
-              ["exponent_p", "", 3.0, [0, inf], "", "Porod Exponent, n, in q^-n"],
-              ["exponent_l", "1/Ang^2", 2.0, [0, inf], "", "Lorentzian Exponent, m, in 1/( 1 + (q.xi)^m)"],
+              ["porod_exp", "", 3.0, [0, inf], "", "Porod Exponent, n, in q^-n"],
+              ["lorentz_exp", "1/Ang^2", 2.0, [0, inf], "", "Lorentzian Exponent, m, in 1/( 1 + (q.xi)^m)"],
              ]
 # pylint: enable=bad-continuation, line-too-long
 
-def Iq(q, lorentz_scale, porod_scale, cor_length, exponent_p, exponent_l):
+def Iq(q, lorentz_scale, porod_scale, cor_length, porod_exp, lorentz_exp):
     """
     1D calculation of the Correlation length model
     """
     with errstate(divide='ignore'):
-        porod = porod_scale / q**exponent_p
-        lorentz = lorentz_scale / (1.0 + (q * cor_length)**exponent_l)
+        porod = porod_scale / q**porod_exp
+        lorentz = lorentz_scale / (1.0 + (q * cor_length)**lorentz_exp)
     inten = porod + lorentz
     return inten
@@ -66,5 +66,5 @@
 # parameters for demo
 demo = dict(lorentz_scale=10.0, porod_scale=1.0e-06, cor_length=50.0,
-            exponent_p=3.0, exponent_l=2.0, background=0.1,
+            porod_exp=3.0, lorentz_exp=2.0, background=0.1,
            )
 
Index: sasmodels/models/dab.py
===================================================================
--- sasmodels/models/dab.py	(revision 2c74c11fc4544381ecf9949bd1618c67ff624c6d)
+++ sasmodels/models/dab.py	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -55,10 +55,10 @@
 
 #             ["name", "units", default, [lower, upper], "type", "description"],
-parameters = [["length", "Ang", 50.0, [0, inf], "", "correlation length"],
+parameters = [["cor_length", "Ang", 50.0, [0, inf], "", "correlation length"],
              ]
 
 Iq = """
-    double numerator   = pow(length, 3);
-    double denominator = pow(1 + pow(q*length,2), 2);
+    double numerator   = pow(cor_length, 3);
+    double denominator = pow(1 + pow(q*cor_length,2), 2);
     
     return numerator / denominator ;
@@ -69,3 +69,3 @@
 # VR defaults to 1.0
 
-demo = dict(scale=1, background=0, length=50)
+demo = dict(scale=1, background=0, cor_length=50)
Index: sasmodels/models/ellipsoid.c
===================================================================
--- sasmodels/models/ellipsoid.c	(revision 50e1e40cf14d4ded28bf96e61a3cfaf35003b899)
+++ sasmodels/models/ellipsoid.c	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -1,12 +1,12 @@
-double form_volume(double rpolar, double requatorial);
-double Iq(double q, double sld, double solvent_sld, double rpolar, double requatorial);
-double Iqxy(double qx, double qy, double sld, double solvent_sld,
-    double rpolar, double requatorial, double theta, double phi);
+double form_volume(double radius_polar, double radius_equatorial);
+double Iq(double q, double sld, double sld_solvent, double radius_polar, double radius_equatorial);
+double Iqxy(double qx, double qy, double sld, double sld_solvent,
+    double radius_polar, double radius_equatorial, double theta, double phi);
 
-double _ellipsoid_kernel(double q, double rpolar, double requatorial, double sin_alpha);
-double _ellipsoid_kernel(double q, double rpolar, double requatorial, double sin_alpha)
+double _ellipsoid_kernel(double q, double radius_polar, double radius_equatorial, double sin_alpha);
+double _ellipsoid_kernel(double q, double radius_polar, double radius_equatorial, double sin_alpha)
 {
-    double ratio = rpolar/requatorial;
-    const double u = q*requatorial*sqrt(1.0
+    double ratio = radius_polar/radius_equatorial;
+    const double u = q*radius_equatorial*sqrt(1.0
                    + sin_alpha*sin_alpha*(ratio*ratio - 1.0));
     const double f = sph_j1c(u);
@@ -15,14 +15,14 @@
 }
 
-double form_volume(double rpolar, double requatorial)
+double form_volume(double radius_polar, double radius_equatorial)
 {
-    return M_4PI_3*rpolar*requatorial*requatorial;
+    return M_4PI_3*radius_polar*radius_equatorial*radius_equatorial;
 }
 
 double Iq(double q,
     double sld,
-    double solvent_sld,
-    double rpolar,
-    double requatorial)
+    double sld_solvent,
+    double radius_polar,
+    double radius_equatorial)
 {
     // translate a point in [-1,1] to a point in [0, 1]
@@ -33,9 +33,9 @@
         //const double sin_alpha = (Gauss76Z[i]*(upper-lower) + upper + lower)/2;
         const double sin_alpha = Gauss76Z[i]*zm + zb;
-        total += Gauss76Wt[i] * _ellipsoid_kernel(q, rpolar, requatorial, sin_alpha);
+        total += Gauss76Wt[i] * _ellipsoid_kernel(q, radius_polar, radius_equatorial, sin_alpha);
     }
     // translate dx in [-1,1] to dx in [lower,upper]
     const double form = total*zm;
-    const double s = (sld - solvent_sld) * form_volume(rpolar, requatorial);
+    const double s = (sld - sld_solvent) * form_volume(radius_polar, radius_equatorial);
     return 1.0e-4 * s * s * form;
 }
@@ -43,7 +43,7 @@
 double Iqxy(double qx, double qy,
     double sld,
-    double solvent_sld,
-    double rpolar,
-    double requatorial,
+    double sld_solvent,
+    double radius_polar,
+    double radius_equatorial,
     double theta,
     double phi)
@@ -55,6 +55,6 @@
     // TODO: check if this is actually sin(alpha), not cos(alpha)
     const double cos_alpha = cn*cos(phi*M_PI_180)*(qx/q) + sn*(qy/q);
-    const double form = _ellipsoid_kernel(q, rpolar, requatorial, cos_alpha);
-    const double s = (sld - solvent_sld) * form_volume(rpolar, requatorial);
+    const double form = _ellipsoid_kernel(q, radius_polar, radius_equatorial, cos_alpha);
+    const double s = (sld - sld_solvent) * form_volume(radius_polar, radius_equatorial);
 
     return 1.0e-4 * form * s * s;
Index: sasmodels/models/ellipsoid.py
===================================================================
--- sasmodels/models/ellipsoid.py	(revision 42356c8890c04b71169941b12a36fc0e07e2034b)
+++ sasmodels/models/ellipsoid.py	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -74,5 +74,5 @@
     calculated from our 2D model and the intensity from the NIST SANS
     analysis software. The parameters used were: *scale* = 1.0,
-    *r_polar* = 20 |Ang|, *r_equatorial* = 400 |Ang|,
+    *radius_polar* = 20 |Ang|, *radius_equatorial* = 400 |Ang|,
     *contrast* = 3e-6 |Ang^-2|, and *background* = 0.0 |cm^-1|.
 
@@ -122,7 +122,7 @@
               ["sld_solvent", "1e-6/Ang^2", 1, [-inf, inf], "sld",
                "Solvent scattering length density"],
-              ["r_polar", "Ang", 20, [0, inf], "volume",
+              ["radius_polar", "Ang", 20, [0, inf], "volume",
                "Polar radius"],
-              ["r_equatorial", "Ang", 400, [0, inf], "volume",
+              ["radius_equatorial", "Ang", 400, [0, inf], "volume",
                "Equatorial radius"],
               ["theta", "degrees", 60, [-inf, inf], "orientation",
@@ -134,15 +134,15 @@
 source = ["lib/sph_j1c.c", "lib/gauss76.c", "ellipsoid.c"]
 
-def ER(r_polar, r_equatorial):
+def ER(radius_polar, radius_equatorial):
     import numpy as np
 
-    ee = np.empty_like(r_polar)
-    idx = r_polar > r_equatorial
-    ee[idx] = (r_polar[idx] ** 2 - r_equatorial[idx] ** 2) / r_polar[idx] ** 2
-    idx = r_polar < r_equatorial
-    ee[idx] = (r_equatorial[idx] ** 2 - r_polar[idx] ** 2) / r_equatorial[idx] ** 2
-    idx = r_polar == r_equatorial
-    ee[idx] = 2 * r_polar[idx]
-    valid = (r_polar * r_equatorial != 0)
+    ee = np.empty_like(radius_polar)
+    idx = radius_polar > radius_equatorial
+    ee[idx] = (radius_polar[idx] ** 2 - radius_equatorial[idx] ** 2) / radius_polar[idx] ** 2
+    idx = radius_polar < radius_equatorial
+    ee[idx] = (radius_equatorial[idx] ** 2 - radius_polar[idx] ** 2) / radius_equatorial[idx] ** 2
+    idx = radius_polar == radius_equatorial
+    ee[idx] = 2 * radius_polar[idx]
+    valid = (radius_polar * radius_equatorial != 0)
     bd = 1.0 - ee[valid]
     e1 = np.sqrt(ee[valid])
@@ -152,6 +152,6 @@
     delta = 0.75 * b1 * b2
 
-    ddd = np.zeros_like(r_polar)
-    ddd[valid] = 2.0 * (delta + 1.0) * r_polar * r_equatorial ** 2
+    ddd = np.zeros_like(radius_polar)
+    ddd[valid] = 2.0 * (delta + 1.0) * radius_polar * radius_equatorial ** 2
     return 0.5 * ddd ** (1.0 / 3.0)
 
@@ -159,8 +159,8 @@
 demo = dict(scale=1, background=0,
             sld=6, sld_solvent=1,
-            r_polar=50, r_equatorial=30,
+            radius_polar=50, radius_equatorial=30,
             theta=30, phi=15,
-            r_polar_pd=.2, r_polar_pd_n=15,
-            r_equatorial_pd=.2, r_equatorial_pd_n=15,
+            radius_polar_pd=.2, radius_polar_pd_n=15,
+            radius_equatorial_pd=.2, radius_equatorial_pd_n=15,
             theta_pd=15, theta_pd_n=45,
             phi_pd=15, phi_pd_n=1)
Index: sasmodels/models/elliptical_cylinder.c
===================================================================
--- sasmodels/models/elliptical_cylinder.c	(revision 40a87fa5096610e24c3ead10299f609e99f093f2)
+++ sasmodels/models/elliptical_cylinder.c	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -1,16 +1,16 @@
-double form_volume(double r_minor, double r_ratio, double length);
-double Iq(double q, double r_minor, double r_ratio, double length,
+double form_volume(double radius_minor, double r_ratio, double length);
+double Iq(double q, double radius_minor, double r_ratio, double length,
           double sld, double solvent_sld);
-double Iqxy(double qx, double qy, double r_minor, double r_ratio, double length,
+double Iqxy(double qx, double qy, double radius_minor, double r_ratio, double length,
             double sld, double solvent_sld, double theta, double phi, double psi);
 
 
-double _elliptical_cylinder_kernel(double q, double r_minor, double r_ratio, double theta);
+double _elliptical_cylinder_kernel(double q, double radius_minor, double r_ratio, double theta);
 
-double _elliptical_cylinder_kernel(double q, double r_minor, double r_ratio, double theta)
+double _elliptical_cylinder_kernel(double q, double radius_minor, double r_ratio, double theta)
 {
     // This is the function LAMBDA1^2 in Feigin's notation
     // q is the q-value for the calculation (1/A)
-    // r_minor is the transformed radius"a" in Feigin's notation
+    // radius_minor is the transformed radius"a" in Feigin's notation
     // r_ratio is the ratio (major radius)/(minor radius) of the Ellipsoid [=] ---
     // theta is the dummy variable of the integration
@@ -18,5 +18,5 @@
     double retval,arg;
 
-    arg = q*r_minor*sqrt((1.0+r_ratio*r_ratio)/2+(1.0-r_ratio*r_ratio)*cos(theta)/2);
+    arg = q*radius_minor*sqrt((1.0+r_ratio*r_ratio)/2+(1.0-r_ratio*r_ratio)*cos(theta)/2);
     //retval = 2.0*J1(arg)/arg;
     retval = sas_J1c(arg);
@@ -25,10 +25,10 @@
 
 
-double form_volume(double r_minor, double r_ratio, double length)
+double form_volume(double radius_minor, double r_ratio, double length)
 {
-    return M_PI * r_minor * r_minor * r_ratio * length;
+    return M_PI * radius_minor * radius_minor * r_ratio * length;
 }
 
-double Iq(double q, double r_minor, double r_ratio, double length,
+double Iq(double q, double radius_minor, double r_ratio, double length,
           double sld, double solvent_sld) {
 
@@ -55,5 +55,5 @@
         summj=0;
         zi = ( Gauss76Z[i]*(vb-va) + va + vb )/2.0;     //the "x" dummy
-        arg = r_minor*sqrt(1.0-zi*zi);
+        arg = radius_minor*sqrt(1.0-zi*zi);
         for(int j=0;j<nordj;j++) {
             //20 gauss points for the inner integral
@@ -77,10 +77,10 @@
     answer *= delrho*delrho;
 
-    const double vol = form_volume(r_minor, r_ratio, length);
+    const double vol = form_volume(radius_minor, r_ratio, length);
     return answer*vol*vol*1.0e-4;
 }
 
 
-double Iqxy(double qx, double qy, double r_minor, double r_ratio, double length,
+double Iqxy(double qx, double qy, double radius_minor, double r_ratio, double length,
             double sld, double solvent_sld, double theta, double phi, double psi) {
     const double _theta = theta * M_PI / 180.0;
@@ -139,6 +139,6 @@
     }
 
-    const double r_major = r_ratio * r_minor;
-    const double qr = q*sqrt( r_major*r_major*cos_nu*cos_nu + r_minor*r_minor*cos_mu*cos_mu );
+    const double r_major = r_ratio * radius_minor;
+    const double qr = q*sqrt( r_major*r_major*cos_nu*cos_nu + radius_minor*radius_minor*cos_mu*cos_mu );
     const double qL = q*length*cos_val/2.0;
 
@@ -159,5 +159,5 @@
 
     const double k = 2.0 * Be * Si;
-    const double vol = form_volume(r_minor, r_ratio, length);
+    const double vol = form_volume(radius_minor, r_ratio, length);
     return (sld - solvent_sld) * (sld - solvent_sld) * k * k *vol*vol*1.0e-4;
 }
Index: sasmodels/models/elliptical_cylinder.py
===================================================================
--- sasmodels/models/elliptical_cylinder.py	(revision 40a87fa5096610e24c3ead10299f609e99f093f2)
+++ sasmodels/models/elliptical_cylinder.py	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -110,5 +110,5 @@
 # pylint: disable=bad-whitespace, line-too-long
 #             ["name", "units", default, [lower, upper], "type","description"],
-parameters = [["r_minor",     "Ang",        20.0,  [0, inf],    "volume",      "Ellipse minor radius"],
+parameters = [["radius_minor",     "Ang",        20.0,  [0, inf],    "volume",      "Ellipse minor radius"],
               ["axis_ratio",   "",          1.5,   [1, inf],    "volume",      "Ratio of major radius over minor radius"],
               ["length",      "Ang",        400.0, [1, inf],    "volume",      "Length of the cylinder"],
@@ -124,16 +124,16 @@
           "elliptical_cylinder.c"]
 
-demo = dict(scale=1, background=0, r_minor=100, axis_ratio=1.5, length=400.0,
+demo = dict(scale=1, background=0, radius_minor=100, axis_ratio=1.5, length=400.0,
             sld=4.0, sld_solvent=1.0, theta=10.0, phi=20, psi=30,
             theta_pd=10, phi_pd=2, psi_pd=3)
 
-def ER(r_minor, axis_ratio, length):
+def ER(radius_minor, axis_ratio, length):
     """
         Equivalent radius
-        @param r_minor: Ellipse minor radius
+        @param radius_minor: Ellipse minor radius
         @param axis_ratio: Ratio of major radius over minor radius
         @param length: Length of the cylinder
     """
-    radius = sqrt(r_minor * r_minor * axis_ratio)
+    radius = sqrt(radius_minor * radius_minor * axis_ratio)
     ddd = 0.75 * radius * (2 * radius * length
                            + (length + radius) * (length + pi * radius))
@@ -141,9 +141,9 @@
 
 tests = [
-    [{'r_minor': 20.0, 'axis_ratio': 1.5, 'length':400.0}, 'ER', 79.89245454155024],
-    [{'r_minor': 20.0, 'axis_ratio': 1.2, 'length':300.0}, 'VR', 1],
+    [{'radius_minor': 20.0, 'axis_ratio': 1.5, 'length':400.0}, 'ER', 79.89245454155024],
+    [{'radius_minor': 20.0, 'axis_ratio': 1.2, 'length':300.0}, 'VR', 1],
 
     # The SasView test result was 0.00169, with a background of 0.001
-    [{'r_minor': 20.0, 'axis_ratio': 1.5, 'sld': 4.0, 'length':400.0,
+    [{'radius_minor': 20.0, 'axis_ratio': 1.5, 'sld': 4.0, 'length':400.0,
       'sld_solvent':1.0, 'background':0.0},
      0.001, 675.504402],
Index: sasmodels/models/fractal_core_shell.c
===================================================================
--- sasmodels/models/fractal_core_shell.c	(revision 2c74c11fc4544381ecf9949bd1618c67ff624c6d)
+++ sasmodels/models/fractal_core_shell.c	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -8,5 +8,5 @@
           double solvent_sld,
           double volfraction,
-          double frac_dim,
+          double fractal_dim,
           double cor_length);
 
@@ -23,5 +23,5 @@
           double solvent_sld,
           double volfraction,
-          double frac_dim,
+          double fractal_dim,
           double cor_length) {
 
@@ -34,10 +34,10 @@
                               solvent_sld);
     //calculate S(q)
-    double frac_1 = frac_dim-1.0;
+    double frac_1 = fractal_dim-1.0;
     double qr = q*radius;
 
-    double t1 = frac_dim*sas_gamma(frac_1)*sin(frac_1*atan(q*cor_length));
+    double t1 = fractal_dim*sas_gamma(frac_1)*sin(frac_1*atan(q*cor_length));
     double t2 = (1.0 + 1.0/(q*cor_length)/(q*cor_length));
-    double t3 = pow(qr, frac_dim) * pow(t2, (frac_1/2.0));
+    double t3 = pow(qr, fractal_dim) * pow(t2, (frac_1/2.0));
     double sq = t1/t3;
     sq += 1.0;
Index: sasmodels/models/fractal_core_shell.py
===================================================================
--- sasmodels/models/fractal_core_shell.py	(revision 42356c8890c04b71169941b12a36fc0e07e2034b)
+++ sasmodels/models/fractal_core_shell.py	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -31,5 +31,5 @@
     {(qr_c)^{D_f}\left(1+\frac{1}{q^2\xi ^2} \right)^{\frac{D_f-1}{2}}}
 
-where $D_f$ = frac_dim, |xi| = cor_length, $r_c$ = (core) radius, and
+where $D_f$ = fractal_dim, |xi| = cor_length, $r_c$ = (core) radius, and
 $scale$ = volume fraction.
 
@@ -69,5 +69,5 @@
     ["sld_solvent", "1e-6/Ang^2", 3.0,  [-inf, inf], "sld",    "Solvent scattering length density"],
     ["volfraction", "",           1.0,  [0, inf],    "",       "Volume fraction of building block spheres"],
-    ["frac_dim",    "",           2.0,  [-inf, inf], "",       "Fractal dimension"],
+    ["fractal_dim",    "",           2.0,  [-inf, inf], "",       "Fractal dimension"],
     ["cor_length",  "Ang",      100.0,  [0, inf],    "",       "Correlation length of fractal-like aggregates"]]
 # pylint: enable=bad-whitespace, line-too-long
@@ -83,5 +83,5 @@
             sld_solvent=6.35,
             volfraction=0.05,
-            frac_dim=2.0,
+            fractal_dim=2.0,
             cor_length=100.0)
 
Index: sasmodels/models/gauss_lorentz_gel.py
===================================================================
--- sasmodels/models/gauss_lorentz_gel.py	(revision 40a87fa5096610e24c3ead10299f609e99f093f2)
+++ sasmodels/models/gauss_lorentz_gel.py	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -56,30 +56,30 @@
 # pylint: disable=bad-whitespace, line-too-long
 #            ["name", "units", default, [lower, upper], "type", "description"],
-parameters = [["gauss_scale_factor",   "",    100.0,  [-inf, inf], "", "Gauss scale factor"],
-              ["static_cor_length",    "Ang", 100.0,  [0, inf],    "", "Static correlation length"],
-              ["lorentz_scale_factor", "",     50.0,  [-inf, inf], "", "Lorentzian scale factor"],
-              ["dynamic_cor_length",   "Ang",  20.0,  [0, inf],    "", "Dynamic correlation length"],
+parameters = [["gauss_scale",   "",    100.0,  [-inf, inf], "", "Gauss scale factor"],
+              ["cor_length_static",    "Ang", 100.0,  [0, inf],    "", "Static correlation length"],
+              ["lorentz_scale", "",     50.0,  [-inf, inf], "", "Lorentzian scale factor"],
+              ["cor_length_dynamic",   "Ang",  20.0,  [0, inf],    "", "Dynamic correlation length"],
              ]
 # pylint: enable=bad-whitespace, line-too-long
 
 def Iq(q,
-       gauss_scale_factor=100.0,
-       static_cor_length=100.0,
-       lorentz_scale_factor=50.0,
-       dynamic_cor_length=20.0):
+       gauss_scale=100.0,
+       cor_length_static=100.0,
+       lorentz_scale=50.0,
+       cor_length_dynamic=20.0):
     """
 
     :param q:                    Input q-value
-    :param gauss_scale_factor:   Gauss scale factor
-    :param static_cor_length:    Static correlation length
-    :param lorentz_scale_factor: Lorentzian scale factor
-    :param dynamic_cor_length:   Dynamic correlation length
+    :param gauss_scale:   Gauss scale factor
+    :param cor_length_static:    Static correlation length
+    :param lorentz_scale: Lorentzian scale factor
+    :param cor_length_dynamic:   Dynamic correlation length
     :return:                     1-D intensity
     """
 
-    term1 = gauss_scale_factor *\
-            exp(-1.0*q*q*static_cor_length*static_cor_length/2.0)
-    term2 = lorentz_scale_factor /\
-            (1.0+(q*dynamic_cor_length)*(q*dynamic_cor_length))
+    term1 = gauss_scale *\
+            exp(-1.0*q*q*cor_length_static*cor_length_static/2.0)
+    term2 = lorentz_scale /\
+            (1.0+(q*cor_length_dynamic)*(q*cor_length_dynamic))
 
     return term1 + term2
@@ -89,48 +89,48 @@
 
 demo = dict(scale=1, background=0.1,
-            gauss_scale_factor=100.0,
-            static_cor_length=100.0,
-            lorentz_scale_factor=50.0,
-            dynamic_cor_length=20.0)
+            gauss_scale=100.0,
+            cor_length_static=100.0,
+            lorentz_scale=50.0,
+            cor_length_dynamic=20.0)
 
 tests = [
 
     # Accuracy tests based on content in test/utest_extra_models.py
-    [{'gauss_scale_factor':  100.0,
-      'static_cor_length':   100.0,
-      'lorentz_scale_factor': 50.0,
-      'dynamic_cor_length':   20.0,
+    [{'gauss_scale':  100.0,
+      'cor_length_static':   100.0,
+      'lorentz_scale': 50.0,
+      'cor_length_dynamic':   20.0,
      }, 0.001, 149.482],
 
-    [{'gauss_scale_factor':  100.0,
-      'static_cor_length':   100.0,
-      'lorentz_scale_factor': 50.0,
-      'dynamic_cor_length':   20.0,
+    [{'gauss_scale':  100.0,
+      'cor_length_static':   100.0,
+      'lorentz_scale': 50.0,
+      'cor_length_dynamic':   20.0,
      }, 0.105363, 9.1913],
 
-    [{'gauss_scale_factor':  100.0,
-      'static_cor_length':   100.0,
-      'lorentz_scale_factor': 50.0,
-      'dynamic_cor_length':   20.0,
+    [{'gauss_scale':  100.0,
+      'cor_length_static':   100.0,
+      'lorentz_scale': 50.0,
+      'cor_length_dynamic':   20.0,
      }, 0.441623, 0.633811],
 
     # Additional tests with larger range of parameters
-    [{'gauss_scale_factor':  10.0,
-      'static_cor_length':  100.0,
-      'lorentz_scale_factor': 3.0,
-      'dynamic_cor_length':   1.0,
+    [{'gauss_scale':  10.0,
+      'cor_length_static':  100.0,
+      'lorentz_scale': 3.0,
+      'cor_length_dynamic':   1.0,
      }, 0.1, 2.9712970297],
 
-    [{'gauss_scale_factor':  10.0,
-      'static_cor_length':  100.0,
-      'lorentz_scale_factor': 3.0,
-      'dynamic_cor_length':   1.0,
+    [{'gauss_scale':  10.0,
+      'cor_length_static':  100.0,
+      'lorentz_scale': 3.0,
+      'cor_length_dynamic':   1.0,
       'background':         100.0
      }, 5.0, 100.116384615],
 
-    [{'gauss_scale_factor':  10.0,
-      'static_cor_length':  100.0,
-      'lorentz_scale_factor': 3.0,
-      'dynamic_cor_length':   1.0,
+    [{'gauss_scale':  10.0,
+      'cor_length_static':  100.0,
+      'lorentz_scale': 3.0,
+      'cor_length_dynamic':   1.0,
       'background':           0.0,
      }, 200., 7.49981250469e-05],
Index: sasmodels/models/gaussian_peak.py
===================================================================
--- sasmodels/models/gaussian_peak.py	(revision 7f1ee7932f23740bda233dc59203791f93062d5c)
+++ sasmodels/models/gaussian_peak.py	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -34,10 +34,10 @@
 description = """
     Model describes a Gaussian shaped peak including a flat background
-    Provide F(q) = scale*exp( -1/2 *[(q-q0)/sigma]^2 )+ background
+    Provide F(q) = scale*exp( -1/2 *[(q-peak_pos)/sigma]^2 )+ background
 """
 category = "shape-independent"
 
 #             ["name", "units", default, [lower, upper], "type","description"],
-parameters = [["q0", "1/Ang", 0.05, [-inf, inf], "", "Peak position"],
+parameters = [["peak_pos", "1/Ang", 0.05, [-inf, inf], "", "Peak position"],
               ["sigma", "1/Ang", 0.005, [0, inf], "",
                "Peak width (standard deviation)"],
@@ -45,5 +45,5 @@
 
 Iq = """
-    double scaled_dq = (q - q0)/sigma;
+    double scaled_dq = (q - peak_pos)/sigma;
     return exp(-0.5*scaled_dq*scaled_dq); //sqrt(2*M_PI*sigma*sigma);
     """
@@ -51,3 +51,3 @@
 # VR defaults to 1.0
 
-demo = dict(scale=1, background=0, q0=0.05, sigma=0.005)
+demo = dict(scale=1, background=0, peak_pos=0.05, sigma=0.005)
Index: sasmodels/models/gel_fit.c
===================================================================
--- sasmodels/models/gel_fit.c	(revision 03cac087353e872f40154bf57ef8161eb5367fd4)
+++ sasmodels/models/gel_fit.c	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -1,7 +1,7 @@
 static double Iq(double q,
           double guinier_scale,
-          double lorentzian_scale,
-          double gyration_radius,
-          double fractal_exp,
+          double lorentz_scale,
+          double rg,
+          double fractal_dim,
           double cor_length)
 {
@@ -9,14 +9,14 @@
     ////////////////////////double a(x[i]*x[i]*zeta*zeta);
     double lorentzian_term = square(q*cor_length);
-    lorentzian_term = 1.0 + ((fractal_exp + 1.0)/3.0)*lorentzian_term;
-    lorentzian_term = pow(lorentzian_term, (fractal_exp/2.0) );
+    lorentzian_term = 1.0 + ((fractal_dim + 1.0)/3.0)*lorentzian_term;
+    lorentzian_term = pow(lorentzian_term, (fractal_dim/2.0) );
 
     // Exponential Term
     ////////////////////////double d(x[i]*x[i]*rg*rg);
-    double exp_term = square(q*gyration_radius);
+    double exp_term = square(q*rg);
     exp_term = exp(-1.0*(exp_term/3.0));
 
     // Scattering Law
-    double result = lorentzian_scale/lorentzian_term + guinier_scale*exp_term;
+    double result = lorentz_scale/lorentzian_term + guinier_scale*exp_term;
     return result;
 }
Index: sasmodels/models/gel_fit.py
===================================================================
--- sasmodels/models/gel_fit.py	(revision 40a87fa5096610e24c3ead10299f609e99f093f2)
+++ sasmodels/models/gel_fit.py	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -62,7 +62,7 @@
 #             ["name", "units", default, [lower, upper], "type","description"],
 parameters = [["guinier_scale",    "cm^-1",   1.7, [-inf, inf], "", "Guinier length scale"],
-              ["lorentzian_scale", "cm^-1",   3.5, [-inf, inf], "", "Lorentzian length scale"],
-              ["gyration_radius",  "Ang",     104.0, [2, inf],    "", "Radius of gyration"],
-              ["fractal_exp",      "",          2.0, [0, inf],    "", "Fractal exponent"],
+              ["lorentz_scale", "cm^-1",   3.5, [-inf, inf], "", "Lorentzian length scale"],
+              ["rg",  "Ang",     104.0, [2, inf],    "", "Radius of gyration"],
+              ["fractal_dim",      "",          2.0, [0, inf],    "", "Fractal exponent"],
               ["cor_length",       "Ang",      16.0, [0, inf],    "", "Correlation length"]
              ]
@@ -73,13 +73,13 @@
 demo = dict(background=0.01,
             guinier_scale=1.7,
-            lorentzian_scale=3.5,
-            gyration_radius=104,
-            fractal_exp=2.0,
+            lorentz_scale=3.5,
+            rg=104,
+            fractal_dim=2.0,
             cor_length=16.0)
 
 tests = [[{'guinier_scale': 1.0,
-           'lorentzian_scale': 1.0,
-           'gyration_radius': 10.0,
-           'fractal_exp': 10.0,
+           'lorentz_scale': 1.0,
+           'rg': 10.0,
+           'fractal_dim': 10.0,
            'cor_length': 20.0,
            'background': 0.0,
@@ -87,7 +87,7 @@
 
          [{'guinier_scale': 4.0,
-           'lorentzian_scale': 10.0,
-           'gyration_radius': 500.0,
-           'fractal_exp': 1.0,
+           'lorentz_scale': 10.0,
+           'rg': 500.0,
+           'fractal_dim': 1.0,
            'cor_length': 20.0,
            'background': 20.0,
Index: sasmodels/models/guinier_porod.py
===================================================================
--- sasmodels/models/guinier_porod.py	(revision 40a87fa5096610e24c3ead10299f609e99f093f2)
+++ sasmodels/models/guinier_porod.py	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -72,11 +72,11 @@
 description = """\
          I(q) = scale/q^s* exp ( - R_g^2 q^2 / (3-s) ) for q<= ql
-         = scale/q^m*exp((-ql^2*Rg^2)/(3-s))*ql^(m-s) for q>=ql
-                        where ql = sqrt((m-s)(3-s)/2)/Rg.
+         = scale/q^porod_exp*exp((-ql^2*Rg^2)/(3-s))*ql^(porod_exp-s) for q>=ql
+                        where ql = sqrt((porod_exp-s)(3-s)/2)/Rg.
                         List of parameters:
                         scale = Guinier Scale
                         s = Dimension Variable
                         Rg = Radius of Gyration [A] 
-                        m = Porod Exponent
+                        porod_exp = Porod Exponent
                         background  = Background [1/cm]"""
 
@@ -87,14 +87,14 @@
 parameters = [["rg", "Ang", 60.0, [0, inf], "", "Radius of gyration"],
               ["s",  "",    1.0,  [0, inf], "", "Dimension variable"],
-              ["m",  "",    3.0,  [0, inf], "", "Porod exponent"]]
+              ["porod_exp",  "",    3.0,  [0, inf], "", "Porod exponent"]]
 # pylint: enable=bad-whitespace, line-too-long
 
 # pylint: disable=C0103
-def Iq(q, rg, s, m):
+def Iq(q, rg, s, porod_exp):
     """
     @param q: Input q-value
     """
     n = 3.0 - s
-    ms = 0.5*(m-s) # =(n-3+m)/2
+    ms = 0.5*(porod_exp-s) # =(n-3+porod_exp)/2
 
     # preallocate return value
@@ -109,10 +109,10 @@
     with errstate(divide='ignore'):
         iq[idx] = q[idx]**-s * exp(-(q[idx]*rg)**2/n)
-        iq[~idx] = q[~idx]**-m * (exp(-ms) * (n*ms/rg**2)**ms)
+        iq[~idx] = q[~idx]**-porod_exp * (exp(-ms) * (n*ms/rg**2)**ms)
     return iq
 
 Iq.vectorized = True # Iq accepts an array of q values
 
-demo = dict(scale=1.5, background=0.5, rg=60, s=1.0, m=3.0)
+demo = dict(scale=1.5, background=0.5, rg=60, s=1.0, porod_exp=3.0)
 
 tests = [[{'scale': 1.5, 'background':0.5}, 0.04, 5.290096890253155]]
Index: sasmodels/models/hayter_msa.py
===================================================================
--- sasmodels/models/hayter_msa.py	(revision 0bef47b278e819df7ea6b572375dd7bc9607227e)
+++ sasmodels/models/hayter_msa.py	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -51,5 +51,5 @@
 #  dp[2] = volfraction();
 #  dp[3] = temperature();
-#  dp[4] = salt_concentration();
+#  dp[4] = concentration_salt();
 #  dp[5] = dielectconst();
 
@@ -76,5 +76,5 @@
     ["charge",        "e",   19.0,    [0, inf],    "", "charge on sphere (in electrons)"],
     ["temperature",   "K",  318.16,   [0, inf],    "", "temperature, in Kelvin, for Debye length calculation"],
-    ["salt_concentration",      "M",    0.0,    [-inf, inf], "", "conc of salt, moles/litre, 1:1 electolyte, for Debye length"],
+    ["concentration_salt",      "M",    0.0,    [-inf, inf], "", "conc of salt, moles/litre, 1:1 electolyte, for Debye length"],
     ["dielectconst",  "None",    71.08,   [-inf, inf], "", "dielectric constant (relative permittivity) of solvent, default water, for Debye length"]
     ]
@@ -93,10 +93,10 @@
 # note the calculation varies in different limiting cases so a wide range of
 # parameters will be required for a thorough test!
-# odd that the default st has salt_concentration zero
+# odd that the default st has concentration_salt zero
 demo = dict(radius_effective=20.75,
             charge=19.0,
             volfraction=0.0192,
             temperature=318.16,
-            salt_concentration=0.05,
+            concentration_salt=0.05,
             dielectconst=71.08,
             radius_effective_pd=0.1,
@@ -113,5 +113,5 @@
       'volfraction': 0.0192,
       'temperature': 298.0,
-      'salt_concentration': 0,
+      'concentration_salt': 0,
       'dielectconst': 78.0,
       'radius_effective_pd': 0},
@@ -123,5 +123,5 @@
       'volfraction': 0.0192,
       'temperature': 298.0,
-      'salt_concentration': 0.05,
+      'concentration_salt': 0.05,
       'dielectconst': 78.0,
       'radius_effective_pd': 0.1,
Index: sasmodels/models/hollow_cylinder.c
===================================================================
--- sasmodels/models/hollow_cylinder.c	(revision f95556fd6a37eef3bf883d75fe7a776c38ef3cef)
+++ sasmodels/models/hollow_cylinder.c	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -1,10 +1,10 @@
-double form_volume(double radius, double core_radius, double length);
+double form_volume(double radius, double radius_core, double length);
 
-double Iq(double q, double radius, double core_radius, double length, double sld,
+double Iq(double q, double radius, double radius_core, double length, double sld,
 	double solvent_sld);
-double Iqxy(double qx, double qy, double radius, double core_radius, double length, double sld,
+double Iqxy(double qx, double qy, double radius, double radius_core, double length, double sld,
 	double solvent_sld, double theta, double phi);
 
-#define INVALID(v) (v.core_radius >= v.radius)
+#define INVALID(v) (v.radius_core >= v.radius)
 
 // From Igor library
@@ -27,11 +27,11 @@
 
 static double _hollow_cylinder_kernel(
-    double q, double core_radius, double radius, double length, double dum)
+    double q, double radius_core, double radius, double length, double dum)
 {
     const double qs = q*sqrt(1.0-dum*dum);
     const double lam1 = sas_J1c(radius*qs);
-    const double lam2 = sas_J1c(core_radius*qs);
-    const double gamma_sq = square(core_radius/radius);
-    //Note: lim_{r -> r_c} psi = J0(core_radius*qs)
+    const double lam2 = sas_J1c(radius_core*qs);
+    const double gamma_sq = square(radius_core/radius);
+    //Note: lim_{r -> r_c} psi = J0(radius_core*qs)
     const double psi = (lam1 - gamma_sq*lam2)/(1.0 - gamma_sq);	//SRK 10/19/00
     const double t2 = sinc(q*length*dum/2.0);
@@ -41,5 +41,5 @@
 
 static double hollow_cylinder_analytical_2D_scaled(
-    double q, double q_x, double q_y, double radius, double core_radius,
+    double q, double q_x, double q_y, double radius, double radius_core,
     double length, double sld, double solvent_sld, double theta, double phi)
 {
@@ -65,7 +65,7 @@
     cos_val = cyl_x*q_x + cyl_y*q_y;// + cyl_z*q_z;
 
-    answer = _hollow_cylinder_kernel(q, core_radius, radius, length, cos_val);
+    answer = _hollow_cylinder_kernel(q, radius_core, radius, length, cos_val);
 
-    vol = form_volume(radius, core_radius, length);
+    vol = form_volume(radius, radius_core, length);
     answer = hollow_cylinder_scaling(answer, delrho, vol);
 
@@ -74,12 +74,12 @@
 
 
-double form_volume(double radius, double core_radius, double length)
+double form_volume(double radius, double radius_core, double length)
 {
-    double v_shell = M_PI*length*(radius*radius-core_radius*core_radius);
+    double v_shell = M_PI*length*(radius*radius-radius_core*radius_core);
     return(v_shell);
 }
 
 
-double Iq(double q, double radius, double core_radius, double length,
+double Iq(double q, double radius, double radius_core, double length,
     double sld, double solvent_sld)
 {
@@ -95,10 +95,10 @@
     for (i=0;i<76;i++) {
         zi = ( Gauss76Z[i] * (upper-lower) + lower + upper )/2.0;
-        inter = Gauss76Wt[i] * _hollow_cylinder_kernel(q, core_radius, radius, length, zi);
+        inter = Gauss76Wt[i] * _hollow_cylinder_kernel(q, radius_core, radius, length, zi);
         summ += inter;
     }
 
     norm = summ*(upper-lower)/2.0;
-    volume = form_volume(radius, core_radius, length);
+    volume = form_volume(radius, radius_core, length);
     delrho = solvent_sld - sld;
     answer = hollow_cylinder_scaling(norm, delrho, volume);
@@ -108,8 +108,8 @@
 
 
-double Iqxy(double qx, double qy, double radius, double core_radius,
+double Iqxy(double qx, double qy, double radius, double radius_core,
     double length, double sld, double solvent_sld, double theta, double phi)
 {
     const double q = sqrt(qx*qx+qy*qy);
-    return hollow_cylinder_analytical_2D_scaled(q, qx/q, qy/q, radius, core_radius, length, sld, solvent_sld, theta, phi);
+    return hollow_cylinder_analytical_2D_scaled(q, qx/q, qy/q, radius, radius_core, length, sld, solvent_sld, theta, phi);
 }
Index: sasmodels/models/hollow_cylinder.py
===================================================================
--- sasmodels/models/hollow_cylinder.py	(revision 58210db589ed9c4e04967d8c494d63b2a5d6f627)
+++ sasmodels/models/hollow_cylinder.py	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -39,5 +39,5 @@
 
 In the parameters, the contrast represents SLD :sub:`shell` - SLD :sub:`solvent`
-and the *radius* is $R_\text{shell}$ while *core_radius* is $R_\text{core}$.
+and the *radius* is $R_\text{shell}$ while *radius_core* is $R_\text{core}$.
 
 To provide easy access to the orientation of the core-shell cylinder, we define
@@ -58,5 +58,5 @@
 description = """
 P(q) = scale*<f*f>/Vol + background, where f is the scattering amplitude.
-core_radius = the radius of core
+radius_core = the radius of core
 radius = the radius of shell
 length = the total length of the cylinder
@@ -70,5 +70,5 @@
 parameters = [
     ["radius",      "Ang",     30.0, [0, inf],    "volume",      "Cylinder radius"],
-    ["core_radius", "Ang",     20.0, [0, inf],    "volume",      "Hollow core radius"],
+    ["radius_core", "Ang",     20.0, [0, inf],    "volume",      "Hollow core radius"],
     ["length",      "Ang",    400.0, [0, inf],    "volume",      "Cylinder length"],
     ["sld",         "1/Ang^2",  6.3, [-inf, inf], "sld",         "Cylinder sld"],
@@ -82,8 +82,8 @@
 
 # pylint: disable=W0613
-def ER(radius, core_radius, length):
+def ER(radius, radius_core, length):
     """
     :param radius:      Cylinder radius
-    :param core_radius: Hollow core radius, UNUSED
+    :param radius_core: Hollow core radius, UNUSED
     :param length:      Cylinder length
     :return:            Effective radius
@@ -99,12 +99,12 @@
     return diam
 
-def VR(radius, core_radius, length):
+def VR(radius, radius_core, length):
     """
     :param radius:      Cylinder radius
-    :param core_radius: Hollow core radius
+    :param radius_core: Hollow core radius
     :param length:      Cylinder length
     :return:            Volf ratio for P(q)*S(q)
     """
-    vol_core = pi*core_radius*core_radius*length
+    vol_core = pi*radius_core*radius_core*length
     vol_total = pi*radius*radius*length
     vol_shell = vol_total - vol_core
@@ -113,8 +113,8 @@
 # parameters for demo
 demo = dict(scale=1.0, background=0.0, length=400.0, radius=30.0,
-            core_radius=20.0, sld=6.3, sld_solvent=1, theta=90, phi=0,
+            radius_core=20.0, sld=6.3, sld_solvent=1, theta=90, phi=0,
             radius_pd=.2, radius_pd_n=9,
             length_pd=.2, length_pd_n=10,
-            core_radius_pd=.2, core_radius_pd_n=9,
+            radius_core_pd=.2, radius_core_pd_n=9,
             theta_pd=10, theta_pd_n=5,
            )
Index: sasmodels/models/hollow_rectangular_prism.c
===================================================================
--- sasmodels/models/hollow_rectangular_prism.c	(revision deb7ee06caa9916d8c0504bdc15ffbc16df623f6)
+++ sasmodels/models/hollow_rectangular_prism.c	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -1,17 +1,17 @@
-double form_volume(double a_side, double b2a_ratio, double c2a_ratio, double thickness);
-double Iq(double q, double sld, double solvent_sld, double a_side, 
+double form_volume(double length_a, double b2a_ratio, double c2a_ratio, double thickness);
+double Iq(double q, double sld, double solvent_sld, double length_a, 
           double b2a_ratio, double c2a_ratio, double thickness);
 double Iqxy(double qx, double qy, double sld, double solvent_sld, 
-            double a_side, double b2a_ratio, double c2a_ratio, double thickness);
+            double length_a, double b2a_ratio, double c2a_ratio, double thickness);
 
-double form_volume(double a_side, double b2a_ratio, double c2a_ratio, double thickness)
+double form_volume(double length_a, double b2a_ratio, double c2a_ratio, double thickness)
 {
-    double b_side = a_side * b2a_ratio;
-    double c_side = a_side * c2a_ratio;
-    double a_core = a_side - 2.0*thickness;
+    double b_side = length_a * b2a_ratio;
+    double c_side = length_a * c2a_ratio;
+    double a_core = length_a - 2.0*thickness;
     double b_core = b_side - 2.0*thickness;
     double c_core = c_side - 2.0*thickness;
     double vol_core = a_core * b_core * c_core;
-    double vol_total = a_side * b_side * c_side;
+    double vol_total = length_a * b_side * c_side;
     double vol_shell = vol_total - vol_core;
     return vol_shell;
@@ -21,5 +21,5 @@
     double sld,
     double solvent_sld,
-    double a_side,
+    double length_a,
     double b2a_ratio,
     double c2a_ratio,
@@ -28,7 +28,7 @@
     double termA1, termA2, termB1, termB2, termC1, termC2;
     
-    double b_side = a_side * b2a_ratio;
-    double c_side = a_side * c2a_ratio;
-    double a_half = 0.5 * a_side;
+    double b_side = length_a * b2a_ratio;
+    double c_side = length_a * c2a_ratio;
+    double a_half = 0.5 * length_a;
     double b_half = 0.5 * b_side;
     double c_half = 0.5 * c_side;
@@ -73,5 +73,5 @@
 	        if (fabs(arg) > 1.e-16) {termB2 = sin(arg)/arg;} else {termB2 = 1.0;}
 
-            double AP1 = (a_side*b_side*c_side) * termA1 * termB1 * termC1;
+            double AP1 = (length_a*b_side*c_side) * termA1 * termB1 * termC1;
             double AP2 = 8.0 * (a_half-thickness) * (b_half-thickness) * (c_half-thickness) * termA2 * termB2 * termC2;
             double AP = AP1 - AP2;
@@ -105,5 +105,5 @@
     double sld,
     double solvent_sld,
-    double a_side,
+    double length_a,
     double b2a_ratio,
     double c2a_ratio,
@@ -111,5 +111,5 @@
 {
     double q = sqrt(qx*qx + qy*qy);
-    double intensity = Iq(q, sld, solvent_sld, a_side, b2a_ratio, c2a_ratio, thickness); 
+    double intensity = Iq(q, sld, solvent_sld, length_a, b2a_ratio, c2a_ratio, thickness); 
     return intensity;    
 }
Index: sasmodels/models/hollow_rectangular_prism.py
===================================================================
--- sasmodels/models/hollow_rectangular_prism.py	(revision 40a87fa5096610e24c3ead10299f609e99f093f2)
+++ sasmodels/models/hollow_rectangular_prism.py	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -105,5 +105,5 @@
               ["sld_solvent", "1e-6/Ang^2", 1, [-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"],
               ["b2a_ratio", "Ang", 1, [0, inf], "volume",
@@ -117,29 +117,29 @@
 source = ["lib/gauss76.c", "hollow_rectangular_prism.c"]
 
-def ER(a_side, b2a_ratio, c2a_ratio, thickness):
+def ER(length_a, b2a_ratio, c2a_ratio, thickness):
     """
     Return equivalent radius (ER)
     thickness parameter not used
     """
-    b_side = a_side * b2a_ratio
-    c_side = a_side * c2a_ratio
+    b_side = length_a * b2a_ratio
+    c_side = length_a * c2a_ratio
 
     # surface average radius (rough approximation)
-    surf_rad = sqrt(a_side * b_side / pi)
+    surf_rad = sqrt(length_a * b_side / pi)
 
     ddd = 0.75 * surf_rad * (2 * surf_rad * c_side + (c_side + surf_rad) * (c_side + pi * surf_rad))
     return 0.5 * (ddd) ** (1. / 3.)
 
-def VR(a_side, b2a_ratio, c2a_ratio, thickness):
+def VR(length_a, b2a_ratio, c2a_ratio, thickness):
     """
     Return shell volume and total volume
     """
-    b_side = a_side * b2a_ratio
-    c_side = a_side * c2a_ratio
-    a_core = a_side - 2.0*thickness
+    b_side = length_a * b2a_ratio
+    c_side = length_a * c2a_ratio
+    a_core = length_a - 2.0*thickness
     b_core = b_side - 2.0*thickness
     c_core = c_side - 2.0*thickness
     vol_core = a_core * b_core * c_core
-    vol_total = a_side * b_side * c_side
+    vol_total = length_a * b_side * c_side
     vol_shell = vol_total - vol_core
     return vol_total, vol_shell
@@ -149,6 +149,6 @@
 demo = dict(scale=1, background=0,
             sld=6.3e-6, sld_solvent=1.0e-6,
-            a_side=35, b2a_ratio=1, c2a_ratio=1, thickness=1,
-            a_side_pd=0.1, a_side_pd_n=10,
+            length_a=35, b2a_ratio=1, c2a_ratio=1, thickness=1,
+            length_a_pd=0.1, length_a_pd_n=10,
             b2a_ratio_pd=0.1, b2a_ratio_pd_n=1,
             c2a_ratio_pd=0.1, c2a_ratio_pd_n=1)
Index: sasmodels/models/hollow_rectangular_prism_thin_walls.c
===================================================================
--- sasmodels/models/hollow_rectangular_prism_thin_walls.c	(revision 3d8283b2c240f54cc6f2667de0f1784412a1c426)
+++ sasmodels/models/hollow_rectangular_prism_thin_walls.c	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -1,13 +1,13 @@
-double form_volume(double a_side, double b2a_ratio, double c2a_ratio);
-double Iq(double q, double sld, double solvent_sld, double a_side, 
+double form_volume(double length_a, double b2a_ratio, double c2a_ratio);
+double Iq(double q, double sld, double solvent_sld, double length_a, 
           double b2a_ratio, double c2a_ratio);
 double Iqxy(double qx, double qy, double sld, double solvent_sld, 
-            double a_side, double b2a_ratio, double c2a_ratio);
+            double length_a, double b2a_ratio, double c2a_ratio);
 
-double form_volume(double a_side, double b2a_ratio, double c2a_ratio)
+double form_volume(double length_a, double b2a_ratio, double c2a_ratio)
 {
-    double b_side = a_side * b2a_ratio;
-    double c_side = a_side * c2a_ratio;
-    double vol_shell = 2.0 * (a_side*b_side + a_side*c_side + b_side*c_side);
+    double b_side = length_a * b2a_ratio;
+    double c_side = length_a * c2a_ratio;
+    double vol_shell = 2.0 * (length_a*b_side + length_a*c_side + b_side*c_side);
     return vol_shell;
 }
@@ -16,11 +16,11 @@
     double sld,
     double solvent_sld,
-    double a_side,
+    double length_a,
     double b2a_ratio,
     double c2a_ratio)
 {
-    double b_side = a_side * b2a_ratio;
-    double c_side = a_side * c2a_ratio;
-    double a_half = 0.5 * a_side;
+    double b_side = length_a * b2a_ratio;
+    double c_side = length_a * c2a_ratio;
+    double a_half = 0.5 * length_a;
     double b_half = 0.5 * b_side;
     double c_half = 0.5 * c_side;
@@ -88,10 +88,10 @@
     double sld,
     double solvent_sld,
-    double a_side,
+    double length_a,
     double b2a_ratio,
     double c2a_ratio)
 {
     double q = sqrt(qx*qx + qy*qy);
-    double intensity = Iq(q, sld, solvent_sld, a_side, b2a_ratio, c2a_ratio); 
+    double intensity = Iq(q, sld, solvent_sld, length_a, b2a_ratio, c2a_ratio); 
     return intensity;    
 }
Index: sasmodels/models/hollow_rectangular_prism_thin_walls.py
===================================================================
--- sasmodels/models/hollow_rectangular_prism_thin_walls.py	(revision 42356c8890c04b71169941b12a36fc0e07e2034b)
+++ sasmodels/models/hollow_rectangular_prism_thin_walls.py	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -91,5 +91,5 @@
               ["sld_solvent", "1e-6/Ang^2", 1, [-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"],
               ["b2a_ratio", "Ang", 1, [0, inf], "volume",
@@ -101,25 +101,25 @@
 source = ["lib/gauss76.c", "hollow_rectangular_prism_thin_walls.c"]
 
-def ER(a_side, b2a_ratio, c2a_ratio):
+def ER(length_a, b2a_ratio, c2a_ratio):
     """
         Return equivalent radius (ER)
     """
-    b_side = a_side * b2a_ratio
-    c_side = a_side * c2a_ratio
+    b_side = length_a * b2a_ratio
+    c_side = length_a * c2a_ratio
 
     # surface average radius (rough approximation)
-    surf_rad = sqrt(a_side * b_side / pi)
+    surf_rad = sqrt(length_a * b_side / pi)
 
     ddd = 0.75 * surf_rad * (2 * surf_rad * c_side + (c_side + surf_rad) * (c_side + pi * surf_rad))
     return 0.5 * (ddd) ** (1. / 3.)
 
-def VR(a_side, b2a_ratio, c2a_ratio):
+def VR(length_a, b2a_ratio, c2a_ratio):
     """
         Return shell volume and total volume
     """
-    b_side = a_side * b2a_ratio
-    c_side = a_side * c2a_ratio
-    vol_total = a_side * b_side * c_side
-    vol_shell = 2.0 * (a_side*b_side + a_side*c_side + b_side*c_side)
+    b_side = length_a * b2a_ratio
+    c_side = length_a * c2a_ratio
+    vol_total = length_a * b_side * c_side
+    vol_shell = 2.0 * (length_a*b_side + length_a*c_side + b_side*c_side)
     return vol_shell, vol_total
 
@@ -128,6 +128,6 @@
 demo = dict(scale=1, background=0,
             sld=6.3e-6, sld_solvent=1.0e-6,
-            a_side=35, b2a_ratio=1, c2a_ratio=1,
-            a_side_pd=0.1, a_side_pd_n=10,
+            length_a=35, b2a_ratio=1, c2a_ratio=1,
+            length_a_pd=0.1, length_a_pd_n=10,
             b2a_ratio_pd=0.1, b2a_ratio_pd_n=1,
             c2a_ratio_pd=0.1, c2a_ratio_pd_n=1)
Index: sasmodels/models/lamellar_hg.py
===================================================================
--- sasmodels/models/lamellar_hg.py	(revision 40a87fa5096610e24c3ead10299f609e99f093f2)
+++ sasmodels/models/lamellar_hg.py	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -25,5 +25,5 @@
         \right\rbrace^2
 
-where $\delta_T$ is *tail_length*, $\delta_H$ is *head_length*,
+where $\delta_T$ is *length_tail*, $\delta_H$ is *length_head*,
 $\Delta\rho_H$ is the head contrast (*sld_head* $-$ *sld_solvent*),
 and $\Delta\rho_T$ is tail contrast (*sld* $-$ *sld_solvent*).
@@ -67,6 +67,6 @@
 # pylint: disable=bad-whitespace, line-too-long
 #             ["name", "units", default, [lower, upper], "type","description"],
-parameters = [["tail_length", "Ang",       15,   [0, inf],  "volume",  "Tail thickness ( total = H+T+T+H)"],
-              ["head_length", "Ang",       10,   [0, inf],  "volume",  "Head thickness"],
+parameters = [["length_tail", "Ang",       15,   [0, inf],  "volume",  "Tail thickness ( total = H+T+T+H)"],
+              ["length_head", "Ang",       10,   [0, inf],  "volume",  "Head thickness"],
               ["sld",         "1e-6/Ang^2", 0.4, [-inf,inf], "sld",    "Tail scattering length density"],
               ["sld_head",    "1e-6/Ang^2", 3.0, [-inf,inf], "sld",    "Head scattering length density"],
@@ -84,7 +84,7 @@
     const double drh = sld_head - sld_solvent;
     const double drt = sld - sld_solvent;    //correction 13FEB06 by L.Porcar
-    const double qT = q*tail_length;
+    const double qT = q*length_tail;
     double Pq, inten;
-    Pq = drh*(sin(q*(head_length+tail_length))-sin(qT)) + drt*sin(qT);
+    Pq = drh*(sin(q*(length_head+length_tail))-sin(qT)) + drt*sin(qT);
     Pq *= Pq;
     Pq *= 4.0/(qsq);
@@ -93,5 +93,5 @@
 
     // normalize by the bilayer thickness
-    inten /= 2.0*(head_length+tail_length);
+    inten /= 2.0*(length_head+length_tail);
 
     return inten;
@@ -102,12 +102,12 @@
 
 demo = dict(scale=1, background=0,
-            tail_length=15, head_length=10,
+            length_tail=15, length_head=10,
             sld=0.4, sld_head=3.0, sld_solvent=6.0,
-            tail_length_pd=0.2, tail_length_pd_n=40,
-            head_length_pd=0.01, head_length_pd_n=40)
+            length_tail_pd=0.2, length_tail_pd_n=40,
+            length_head_pd=0.01, length_head_pd_n=40)
 
 #
 tests = [
-    [{'scale': 1.0, 'background': 0.0, 'tail_length': 15.0, 'head_length': 10.0,
+    [{'scale': 1.0, 'background': 0.0, 'length_tail': 15.0, 'length_head': 10.0,
       'sld': 0.4, 'sld_head': 3.0, 'sld_solvent': 6.0},
      [0.001], [653143.9209]],
Index: sasmodels/models/lamellar_hg_stack_caille.c
===================================================================
--- sasmodels/models/lamellar_hg_stack_caille.c	(revision 0bef47b278e819df7ea6b572375dd7bc9607227e)
+++ sasmodels/models/lamellar_hg_stack_caille.c	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -4,6 +4,6 @@
 
 double Iq(double qval,
-      double tail_length,
-      double head_length,
+      double length_tail,
+      double length_head,
       double Nlayers, 
       double dd,
@@ -14,6 +14,6 @@
 
 double Iq(double qval,
-      double tail_length,
-      double head_length,
+      double length_tail,
+      double length_head,
       double Nlayers, 
       double dd,
@@ -34,6 +34,6 @@
   NN = trunc(Nlayers);    //be sure that NN is an integer
   
-  Pq = (head_sld-solvent_sld)*(sin(qval*(head_length+tail_length))-sin(qval*tail_length)) +
-              (tail_sld-solvent_sld)*sin(qval*tail_length);
+  Pq = (head_sld-solvent_sld)*(sin(qval*(length_head+length_tail))-sin(qval*length_tail)) +
+              (tail_sld-solvent_sld)*sin(qval*length_tail);
   Pq *= Pq;
   Pq *= 4.0/(qval*qval);
Index: sasmodels/models/lamellar_hg_stack_caille.py
===================================================================
--- sasmodels/models/lamellar_hg_stack_caille.py	(revision 0bef47b278e819df7ea6b572375dd7bc9607227e)
+++ sasmodels/models/lamellar_hg_stack_caille.py	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -42,6 +42,6 @@
 
 
-$\delta_T$ is the tail length (or *tail_length*), $\delta_H$ is the head
-thickness (or *head_length*), $\Delta\rho_H$ is SLD(headgroup) - SLD(solvent),
+$\delta_T$ is the tail length (or *length_tail*), $\delta_H$ is the head
+thickness (or *length_head*), $\Delta\rho_H$ is SLD(headgroup) - SLD(solvent),
 and $\Delta\rho_T$ is SLD(tail) - SLD(headgroup). Here $d$ is (repeat) spacing,
 $K$ is smectic bending elasticity, $B$ is compression modulus, and $N$ is the
@@ -94,7 +94,7 @@
     #   [ "name", "units", default, [lower, upper], "type",
     #     "description" ],
-    ["tail_length", "Ang", 10, [0, inf], "volume",
+    ["length_tail", "Ang", 10, [0, inf], "volume",
      "Tail thickness"],
-    ["head_length", "Ang", 2, [0, inf], "volume",
+    ["length_head", "Ang", 2, [0, inf], "volume",
      "head thickness"],
     ["Nlayers", "", 30, [0, inf], "",
@@ -126,16 +126,16 @@
     scale=1, background=0,
     Nlayers=20, spacing=200., Caille_parameter=0.05,
-    tail_length=15, head_length=10,
+    length_tail=15, length_head=10,
     #sld=-1, sld_head=4.0, sld_solvent=6.0,
     sld=-1, sld_head=4.1, sld_solvent=6.0,
-    tail_length_pd=0.1, tail_length_pd_n=20,
-    head_length_pd=0.05, head_length_pd_n=30,
+    length_tail_pd=0.1, length_tail_pd_n=20,
+    length_head_pd=0.05, length_head_pd_n=30,
     spacing_pd=0.2, spacing_pd_n=40,
     )
 
 #
-tests = [[{'scale': 1.0, 'background': 0.0, 'tail_length': 10.0, 'head_length': 2.0,
+tests = [[{'scale': 1.0, 'background': 0.0, 'length_tail': 10.0, 'length_head': 2.0,
            'Nlayers': 30.0, 'spacing': 40., 'Caille_parameter': 0.001, 'sld': 0.4,
-           'sld_head': 2.0, 'sld_solvent': 6.0, 'tail_length_pd': 0.0,
-           'head_length_pd': 0.0, 'spacing_pd': 0.0}, [0.001], [6838238.571488]]]
+           'sld_head': 2.0, 'sld_solvent': 6.0, 'length_tail_pd': 0.0,
+           'length_head_pd': 0.0, 'spacing_pd': 0.0}, [0.001], [6838238.571488]]]
 # ADDED by: RKH  ON: 18Mar2016  converted from sasview previously, now renaming everything & sorting the docs
Index: sasmodels/models/mass_fractal.c
===================================================================
--- sasmodels/models/mass_fractal.c	(revision 2c74c11fc4544381ecf9949bd1618c67ff624c6d)
+++ sasmodels/models/mass_fractal.c	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -3,14 +3,14 @@
 double Iq(double q,
           double radius,
-          double mass_dim,
+          double fractal_dim_mass,
           double cutoff_length);
 
 static double _mass_fractal_kernel(double q,
           double radius,
-          double mass_dim,
+          double fractal_dim_mass,
           double cutoff_length)
 {
     // Actively check the argument.
-    if (mass_dim <= 1.0){
+    if (fractal_dim_mass <= 1.0){
        return 0.0;
     }
@@ -21,5 +21,5 @@
 
     //calculate S(q)
-    double mmo = mass_dim-1.0;
+    double mmo = fractal_dim_mass-1.0;
     double sq = sas_gamma(mmo)*sin((mmo)*atan(q*cutoff_length));
     sq *= pow(cutoff_length, mmo);
@@ -39,10 +39,10 @@
 double Iq(double q,
           double radius,
-          double mass_dim,
+          double fractal_dim_mass,
           double cutoff_length)
 {
     return _mass_fractal_kernel(q,
            radius,
-           mass_dim,
+           fractal_dim_mass,
            cutoff_length);
 }
Index: sasmodels/models/mass_fractal.py
===================================================================
--- sasmodels/models/mass_fractal.py	(revision ec45c4f5ff6e17014d968da6eb80308c2c8791f0)
+++ sasmodels/models/mass_fractal.py	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -68,9 +68,9 @@
         where delta = sldParticle -sldSolv.
         radius       =  Particle radius
-        mass_dim  =  Mass fractal dimension
+        fractal_dim_mass  =  Mass fractal dimension
         cutoff_length  =  Cut-off length
         background   =  background
         Ref.:Mildner, Hall,J Phys D Appl Phys(1986), 9, 1535-1545
-        Note I: This model is valid for 1<mass_dim<6.
+        Note I: This model is valid for 1<fractal_dim_mass<6.
         Note II: This model is not in absolute scale.
         """
@@ -80,5 +80,5 @@
 #             ["name", "units", default, [lower, upper], "type","description"],
 parameters = [["radius",        "Ang",  10.0, [0.0, inf], "", "Particle radius"],
-              ["mass_dim",      "",      1.9, [1.0, 6.0], "", "Mass fractal dimension"],
+              ["fractal_dim_mass",      "",      1.9, [1.0, 6.0], "", "Mass fractal dimension"],
               ["cutoff_length", "Ang", 100.0, [0.0, inf], "", "Cut-off length"],
              ]
@@ -89,5 +89,5 @@
 demo = dict(scale=1, background=0,
             radius=10.0,
-            mass_dim=1.9,
+            fractal_dim_mass=1.9,
             cutoff_length=100.0)
 
@@ -96,5 +96,5 @@
     # Accuracy tests based on content in test/utest_other_models.py
     [{'radius':         10.0,
-      'mass_dim':        1.9,
+      'fractal_dim_mass':        1.9,
       'cutoff_length': 100.0,
      }, 0.05, 279.59422],
@@ -102,10 +102,10 @@
     # Additional tests with larger range of parameters
     [{'radius':        2.0,
-      'mass_dim':      3.3,
+      'fractal_dim_mass':      3.3,
       'cutoff_length': 1.0,
      }, 0.5, 1.29116774904],
 
     [{'radius':        1.0,
-      'mass_dim':      1.3,
+      'fractal_dim_mass':      1.3,
       'cutoff_length': 1.0,
       'background':    0.8,
@@ -113,5 +113,5 @@
 
     [{'radius':        1.0,
-      'mass_dim':      2.3,
+      'fractal_dim_mass':      2.3,
       'cutoff_length': 1.0,
       'scale':        10.0,
Index: sasmodels/models/mass_surface_fractal.c
===================================================================
--- sasmodels/models/mass_surface_fractal.c	(revision 2c74c11fc4544381ecf9949bd1618c67ff624c6d)
+++ sasmodels/models/mass_surface_fractal.c	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -2,21 +2,21 @@
 
 double Iq(double q,
-          double mass_dim,
-          double surface_dim,
-          double cluster_rg,
+          double fractal_dim_mass,
+          double fractal_dim_surf,
+          double rg_cluster,
           double primary_rg);
 
 static double _mass_surface_fractal_kernel(double q,
-          double mass_dim,
-          double surface_dim,
-          double cluster_rg,
+          double fractal_dim_mass,
+          double fractal_dim_surf,
+          double rg_cluster,
           double primary_rg)
 {
      //computation
-    double tot_dim = 6.0 - surface_dim - mass_dim;
-    mass_dim /= 2.0;
+    double tot_dim = 6.0 - fractal_dim_surf - fractal_dim_mass;
+    fractal_dim_mass /= 2.0;
     tot_dim /= 2.0;
 
-    double rc_norm = cluster_rg * cluster_rg / (3.0 * mass_dim);
+    double rc_norm = rg_cluster * rg_cluster / (3.0 * fractal_dim_mass);
     double rp_norm = primary_rg * primary_rg / (3.0 * tot_dim);
 
@@ -25,5 +25,5 @@
     double x_val2 = 1.0 +  q * q * rp_norm;
 
-    double inv_form = pow(x_val1, mass_dim) * pow(x_val2, tot_dim);
+    double inv_form = pow(x_val1, fractal_dim_mass) * pow(x_val2, tot_dim);
 
     //another singular
@@ -41,13 +41,13 @@
 
 double Iq(double q,
-          double mass_dim,
-          double surface_dim,
-          double cluster_rg,
+          double fractal_dim_mass,
+          double fractal_dim_surf,
+          double rg_cluster,
           double primary_rg)
 {
     return _mass_surface_fractal_kernel(q,
-            mass_dim,
-            surface_dim,
-            cluster_rg,
+            fractal_dim_mass,
+            fractal_dim_surf,
+            rg_cluster,
             primary_rg);
 }
Index: sasmodels/models/mass_surface_fractal.py
===================================================================
--- sasmodels/models/mass_surface_fractal.py	(revision ec45c4f5ff6e17014d968da6eb80308c2c8791f0)
+++ sasmodels/models/mass_surface_fractal.py	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -66,7 +66,7 @@
         b = rg^2/(3*(6-Ds-Dm)/2)
         scale        =  scale factor * N*Volume^2*contrast^2
-        mass_dim       =  Dm (mass fractal dimension)
-        surface_dim  =  Ds
-        cluster_rg  =  Rg
+        fractal_dim_mass       =  Dm (mass fractal dimension)
+        fractal_dim_surf  =  Ds
+        rg_cluster  =  Rg
         primary_rg    =  rg
         background   =  background
@@ -79,9 +79,9 @@
 # pylint: disable=bad-whitespace, line-too-long
 #             ["name", "units", default, [lower, upper], "type","description"],
-parameters = [["mass_dim",      "",    1.8, [1e-16, 6.0], "",
+parameters = [["fractal_dim_mass",      "",    1.8, [1e-16, 6.0], "",
                "Mass fractal dimension"],
-              ["surface_dim",   "",    2.3, [1e-16, 6.0], "",
+              ["fractal_dim_surf",   "",    2.3, [1e-16, 6.0], "",
                "Surface fractal dimension"],
-              ["cluster_rg", "Ang",   86.7, [0.0, inf], "",
+              ["rg_cluster", "Ang",   86.7, [0.0, inf], "",
                "Cluster radius of gyration"],
               ["primary_rg", "Ang", 4000.,  [0.0, inf], "",
@@ -93,7 +93,7 @@
 
 demo = dict(scale=1, background=0,
-            mass_dim=1.8,
-            surface_dim=2.3,
-            cluster_rg=86.7,
+            fractal_dim_mass=1.8,
+            fractal_dim_surf=2.3,
+            rg_cluster=86.7,
             primary_rg=4000.0)
 
@@ -101,7 +101,7 @@
 
     # Accuracy tests based on content in test/utest_other_models.py
-    [{'mass_dim':      1.8,
-      'surface_dim':   2.3,
-      'cluster_rg':   86.7,
+    [{'fractal_dim_mass':      1.8,
+      'fractal_dim_surf':   2.3,
+      'rg_cluster':   86.7,
       'primary_rg': 4000.0,
       'background':    0.0,
@@ -109,20 +109,20 @@
 
     # Additional tests with larger range of parameters
-    [{'mass_dim':      3.3,
-      'surface_dim':   1.0,
-      'cluster_rg':   90.0,
+    [{'fractal_dim_mass':      3.3,
+      'fractal_dim_surf':   1.0,
+      'rg_cluster':   90.0,
       'primary_rg': 4000.0,
      }, 0.001, 0.18562699016],
 
-    [{'mass_dim':      1.3,
-      'surface_dim':   1.0,
-      'cluster_rg':   90.0,
+    [{'fractal_dim_mass':      1.3,
+      'fractal_dim_surf':   1.0,
+      'rg_cluster':   90.0,
       'primary_rg': 2000.0,
       'background':    0.8,
      }, 0.001, 1.16539753641],
 
-    [{'mass_dim':      2.3,
-      'surface_dim':   1.0,
-      'cluster_rg':   90.0,
+    [{'fractal_dim_mass':      2.3,
+      'fractal_dim_surf':   1.0,
+      'rg_cluster':   90.0,
       'primary_rg': 1000.0,
       'scale':        10.0,
Index: sasmodels/models/mono_gauss_coil.py
===================================================================
--- sasmodels/models/mono_gauss_coil.py	(revision 40a87fa5096610e24c3ead10299f609e99f093f2)
+++ sasmodels/models/mono_gauss_coil.py	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -71,12 +71,12 @@
 parameters = [
     ["i_zero", "1/cm", 70.0, [0.0, inf], "", "Intensity at q=0"],
-    ["radius_gyration", "Ang", 75.0, [0.0, inf], "", "Radius of gyration"],
+    ["rg", "Ang", 75.0, [0.0, inf], "", "Radius of gyration"],
     ]
 # pylint: enable=bad-whitespace, line-too-long
 
 # NB: Scale and Background are implicit parameters on every model
-def Iq(q, i_zero, radius_gyration):
+def Iq(q, i_zero, rg):
     # pylint: disable = missing-docstring
-    z = (q * radius_gyration)**2
+    z = (q * rg)**2
 
     with errstate(invalid='ignore'):
@@ -86,9 +86,9 @@
 Iq.vectorized = True # Iq accepts an array of q values
 
-demo = dict(scale=1.0, i_zero=70.0, radius_gyration=75.0, background=0.0)
+demo = dict(scale=1.0, i_zero=70.0, rg=75.0, background=0.0)
 
 # these unit test values taken from SasView 3.1.2
 tests = [
-    [{'scale': 1.0, 'i_zero': 70.0, 'radius_gyration': 75.0, 'background': 0.0},
+    [{'scale': 1.0, 'i_zero': 70.0, 'rg': 75.0, 'background': 0.0},
      [0.0106939, 0.469418], [57.1241, 0.112859]],
     ]
Index: sasmodels/models/parallelepiped.c
===================================================================
--- sasmodels/models/parallelepiped.c	(revision deb7ee06caa9916d8c0504bdc15ffbc16df623f6)
+++ sasmodels/models/parallelepiped.c	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -1,6 +1,6 @@
-double form_volume(double a_side, double b_side, double c_side);
-double Iq(double q, double sld, double solvent_sld, double a_side, double b_side, double c_side);
+double form_volume(double length_a, double length_b, double length_c);
+double Iq(double q, double sld, double solvent_sld, double length_a, double length_b, double length_c);
 double Iqxy(double qx, double qy, double sld, double solvent_sld,
-    double a_side, double b_side, double c_side, double theta, double phi, double psi);
+    double length_a, double length_b, double length_c, double theta, double phi, double psi);
 
 // From Igor library
@@ -32,7 +32,7 @@
 
 
-double form_volume(double a_side, double b_side, double c_side)
+double form_volume(double length_a, double length_b, double length_c)
 {
-    return a_side * b_side * c_side;
+    return length_a * length_b * length_c;
 }
 
@@ -41,15 +41,15 @@
     double sld,
     double solvent_sld,
-    double a_side,
-    double b_side,
-    double c_side)
+    double length_a,
+    double length_b,
+    double length_c)
 {
     double tmp1, tmp2;
     
-    double mu = q * b_side;
+    double mu = q * 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;
         
     //Order of integration
@@ -102,5 +102,5 @@
     }	
    
-    const double vd = (sld-solvent_sld) * form_volume(a_side, b_side, c_side);
+    const double vd = (sld-solvent_sld) * form_volume(length_a, length_b, length_c);
     
     // convert from [1e-12 A-1] to [cm-1] and 0.5 factor for outer integral
@@ -113,7 +113,7 @@
     double sld,
     double solvent_sld,
-    double a_side,
-    double b_side,
-    double c_side,
+    double length_a,
+    double length_b,
+    double length_c,
     double theta,
     double phi,
@@ -161,8 +161,8 @@
     
     // Call the IGOR library function to get the kernel
-    double form = _pkernel( q*a_side, q*b_side, q*c_side, cos_val_a, cos_val_b, cos_val_c);
+    double form = _pkernel( q*length_a, q*length_b, q*length_c, cos_val_a, cos_val_b, cos_val_c);
   
     // Multiply by contrast^2
-    const double vd = (sld - solvent_sld) * form_volume(a_side, b_side, c_side);
+    const double vd = (sld - solvent_sld) * form_volume(length_a, length_b, length_c);
     return 1.0e-4 * vd * vd * form;
 }
Index: sasmodels/models/parallelepiped.py
===================================================================
--- sasmodels/models/parallelepiped.py	(revision 9a4811ac2bdb93459d640d111cba9f1016660790)
+++ sasmodels/models/parallelepiped.py	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -190,9 +190,9 @@
               ["sld_solvent", "1e-6/Ang^2", 1, [-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"],
               ["theta", "degrees", 60, [-inf, inf], "orientation",
@@ -206,5 +206,5 @@
 source = ["lib/gauss76.c", "parallelepiped.c"]
 
-def ER(a_side, b_side, c_side):
+def ER(length_a, length_b, length_c):
     """
         Return effective radius (ER) for P(q)*S(q)
@@ -212,7 +212,7 @@
 
     # surface average radius (rough approximation)
-    surf_rad = sqrt(a_side * b_side / pi)
-
-    ddd = 0.75 * surf_rad * (2 * surf_rad * c_side + (c_side + surf_rad) * (c_side + pi * surf_rad))
+    surf_rad = sqrt(length_a * length_b / pi)
+
+    ddd = 0.75 * surf_rad * (2 * surf_rad * length_c + (length_c + surf_rad) * (length_c + pi * surf_rad))
     return 0.5 * (ddd) ** (1. / 3.)
 
@@ -222,9 +222,9 @@
 demo = dict(scale=1, background=0,
             sld=6.3e-6, sld_solvent=1.0e-6,
-            a_side=35, b_side=75, c_side=400,
+            length_a=35, length_b=75, length_c=400,
             theta=45, phi=30, psi=15,
-            a_side_pd=0.1, a_side_pd_n=10,
-            b_side_pd=0.1, b_side_pd_n=1,
-            c_side_pd=0.1, c_side_pd_n=1,
+            length_a_pd=0.1, length_a_pd_n=10,
+            length_b_pd=0.1, length_b_pd_n=1,
+            length_c_pd=0.1, length_c_pd_n=1,
             theta_pd=10, theta_pd_n=1,
             phi_pd=10, phi_pd_n=1,
Index: sasmodels/models/pearl_necklace.c
===================================================================
--- sasmodels/models/pearl_necklace.c	(revision 2f5c6d4a9ea74b4cc7a58030e36695b0634eb349)
+++ sasmodels/models/pearl_necklace.c	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -1,16 +1,16 @@
-double _pearl_necklace_kernel(double q, double radius, double edge_separation,
+double _pearl_necklace_kernel(double q, double radius, double edge_sep,
 	double thick_string, double num_pearls, double sld_pearl,
 	double sld_string, double sld_solv);
-double form_volume(double radius, double edge_separation,
-	double string_thickness, double number_of_pearls);
+double form_volume(double radius, double edge_sep,
+	double thick_string, double num_pearls);
 
-double Iq(double q, double radius, double edge_separation,
-	double string_thickness, double number_of_pearls, double sld, 
+double Iq(double q, double radius, double edge_sep,
+	double thick_string, double num_pearls, double sld, 
 	double string_sld, double solvent_sld);
 
-#define INVALID(v) (v.string_thickness >= v.radius || v.number_of_pearls <= 0)
+#define INVALID(v) (v.thick_string >= v.radius || v.num_pearls <= 0)
 
 // From Igor library
-double _pearl_necklace_kernel(double q, double radius, double edge_separation, double thick_string,
+double _pearl_necklace_kernel(double q, double radius, double edge_sep, double thick_string,
 	double num_pearls, double sld_pearl, double sld_string, double sld_solv)
 {
@@ -27,5 +27,5 @@
 	
 	// center to center distance between the neighboring pearls
-	double A_s = edge_separation + 2.0 * radius;
+	double A_s = edge_sep + 2.0 * radius;
 	
 	// Repeated Calculations
@@ -33,8 +33,8 @@
 	double oneminussinc = 1 - sincasq;
 	double q_r = q * radius;
-	double q_edge = q * edge_separation;
+	double q_edge = q * edge_sep;
 	
 	// each volume
-	double string_vol = edge_separation * pi * thick_string * thick_string / 4.0;
+	double string_vol = edge_sep * pi * thick_string * thick_string / 4.0;
 	double pearl_vol = 4.0 / 3.0 * pi * radius * radius * radius;
 
@@ -105,30 +105,30 @@
 }
 
-double form_volume(double radius, double edge_separation,
-	double string_thickness, double number_of_pearls)
+double form_volume(double radius, double edge_sep,
+	double thick_string, double num_pearls)
 {
 	double total_vol;
 
 	double pi = 4.0*atan(1.0);
-	double number_of_strings = number_of_pearls - 1.0;
+	double number_of_strings = num_pearls - 1.0;
 	
-	double string_vol = edge_separation * pi * string_thickness * string_thickness / 4.0;
+	double string_vol = edge_sep * pi * thick_string * thick_string / 4.0;
 	double pearl_vol = 4.0 / 3.0 * pi * radius * radius * radius;
 
 	total_vol = number_of_strings * string_vol;
-	total_vol += number_of_pearls * pearl_vol;
+	total_vol += num_pearls * pearl_vol;
 
 	return(total_vol);
 }
 
-double Iq(double q, double radius, double edge_separation,
-	double string_thickness, double number_of_pearls, double sld, 
+double Iq(double q, double radius, double edge_sep,
+	double thick_string, double num_pearls, double sld, 
 	double string_sld, double solvent_sld)
 {
 	double value, tot_vol;
 	
-	value = _pearl_necklace_kernel(q, radius, edge_separation, string_thickness,
-		number_of_pearls, sld, string_sld, solvent_sld);
-	tot_vol = form_volume(radius, edge_separation, string_thickness, number_of_pearls);
+	value = _pearl_necklace_kernel(q, radius, edge_sep, thick_string,
+		num_pearls, sld, string_sld, solvent_sld);
+	tot_vol = form_volume(radius, edge_sep, thick_string, num_pearls);
 
 	return value*tot_vol;
Index: sasmodels/models/pearl_necklace.py
===================================================================
--- sasmodels/models/pearl_necklace.py	(revision 42356c8890c04b71169941b12a36fc0e07e2034b)
+++ sasmodels/models/pearl_necklace.py	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -46,5 +46,5 @@
 pearl_necklace model are the following
 
-NB: *number_of_pearls* must be an integer.
+NB: *num_pearls* must be an integer.
 
 References
@@ -68,8 +68,8 @@
 sld_string: the SLD of the strings
 sld_solvent: the SLD of the solvent
-number_of_pearls: number of the pearls
+num_pearls: number of the pearls
 radius: the radius of a pearl
-edge_separation: the length of string segment; surface to surface
-string_thickness: thickness (ie, diameter) of the string
+edge_sep: the length of string segment; surface to surface
+thick_string: thickness (ie, diameter) of the string
 """
 category = "shape:cylinder"
@@ -78,9 +78,9 @@
 parameters = [["radius", "Ang", 80.0, [0, inf], "volume",
                "Mean radius of the chained spheres"],
-              ["edge_separation", "Ang", 350.0, [0, inf], "volume",
+              ["edge_sep", "Ang", 350.0, [0, inf], "volume",
                "Mean separation of chained particles"],
-              ["string_thickness", "Ang", 2.5, [0, inf], "volume",
+              ["thick_string", "Ang", 2.5, [0, inf], "volume",
                "Thickness of the chain linkage"],
-              ["number_of_pearls", "none", 3, [0, inf], "volume",
+              ["num_pearls", "none", 3, [0, inf], "volume",
                "Number of pearls in the necklace (must be integer)"],
               ["sld", "1e-6/Ang^2", 1.0, [-inf, inf], "sld",
@@ -95,32 +95,32 @@
 single = False  # use double precision unless told otherwise
 
-def volume(radius, edge_separation, string_thickness, number_of_pearls):
+def volume(radius, edge_sep, thick_string, num_pearls):
     """
     Calculates the total particle volume of the necklace.
     Redundant with form_volume.
     """
-    number_of_strings = number_of_pearls - 1.0
-    string_vol = edge_separation * pi * pow((string_thickness / 2.0), 2.0)
+    number_of_strings = num_pearls - 1.0
+    string_vol = edge_sep * pi * pow((thick_string / 2.0), 2.0)
     pearl_vol = 4.0 /3.0 * pi * pow(radius, 3.0)
     total_vol = number_of_strings * string_vol
-    total_vol += number_of_pearls * pearl_vol
+    total_vol += num_pearls * pearl_vol
     return total_vol
 
-def ER(radius, edge_separation, string_thickness, number_of_pearls):
+def ER(radius, edge_sep, thick_string, num_pearls):
     """
     Calculation for effective radius.
     """
-    tot_vol = volume(radius, edge_separation, string_thickness, number_of_pearls)
+    tot_vol = volume(radius, edge_sep, thick_string, num_pearls)
     rad_out = pow((3.0*tot_vol/4.0/pi), 0.33333)
     return rad_out
 
 # parameters for demo
-demo = dict(scale=1, background=0, radius=80.0, edge_separation=350.0,
-            number_of_pearls=3, sld=1, sld_solvent=6.3, sld_string=1,
-            string_thickness=2.5,
+demo = dict(scale=1, background=0, radius=80.0, edge_sep=350.0,
+            num_pearls=3, sld=1, sld_solvent=6.3, sld_string=1,
+            thick_string=2.5,
             radius_pd=.2, radius_pd_n=5,
-            edge_separation_pd=25.0, edge_separation_pd_n=5,
-            number_of_pearls_pd=0, number_of_pearls_pd_n=0,
-            string_thickness_pd=0.2, string_thickness_pd_n=5,
+            edge_sep_pd=25.0, edge_sep_pd_n=5,
+            num_pearls_pd=0, num_pearls_pd_n=0,
+            thick_string_pd=0.2, thick_string_pd_n=5,
            )
 
Index: sasmodels/models/poly_gauss_coil.py
===================================================================
--- sasmodels/models/poly_gauss_coil.py	(revision 40a87fa5096610e24c3ead10299f609e99f093f2)
+++ sasmodels/models/poly_gauss_coil.py	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -74,5 +74,5 @@
 parameters = [
     ["i_zero",          "1/cm", 70.0, [0.0, inf], "", "Intensity at q=0"],
-    ["radius_gyration",  "Ang", 75.0, [0.0, inf], "", "Radius of gyration"],
+    ["rg",  "Ang", 75.0, [0.0, inf], "", "Radius of gyration"],
     ["polydispersity",  "None",  2.0, [1.0, inf], "", "Polymer Mw/Mn"],
     ]
@@ -80,8 +80,8 @@
 
 # NB: Scale and Background are implicit parameters on every model
-def Iq(q, i_zero, radius_gyration, polydispersity):
+def Iq(q, i_zero, rg, polydispersity):
     # pylint: disable = missing-docstring
     u = polydispersity - 1.0
-    z = (q*radius_gyration)**2 / (1.0 + 2.0*u)
+    z = (q*rg)**2 / (1.0 + 2.0*u)
     # need to trap the case of the polydispersity being 1 (ie, monodisperse!)
     if polydispersity == 1.0:
@@ -97,5 +97,5 @@
 demo = dict(scale=1.0,
             i_zero=70.0,
-            radius_gyration=75.0,
+            rg=75.0,
             polydispersity=2.0,
             background=0.0)
@@ -103,5 +103,5 @@
 # these unit test values taken from SasView 3.1.2
 tests = [
-    [{'scale': 1.0, 'i_zero': 70.0, 'radius_gyration': 75.0,
+    [{'scale': 1.0, 'i_zero': 70.0, 'rg': 75.0,
       'polydispersity': 2.0, 'background': 0.0},
      [0.0106939, 0.469418], [57.6405, 0.169016]],
Index: sasmodels/models/polymer_micelle.c
===================================================================
--- sasmodels/models/polymer_micelle.c	(revision 0bef47b278e819df7ea6b572375dd7bc9607227e)
+++ sasmodels/models/polymer_micelle.c	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -7,5 +7,5 @@
         double corona_sld,
         double radius_core,
-        double radius_gyr,
+        double rg,
         double d_penetration,
         double n_aggreg);
@@ -19,5 +19,5 @@
         double corona_sld,
         double radius_core,
-        double radius_gyr,
+        double rg,
         double d_penetration,
         double n_aggreg)
@@ -35,5 +35,5 @@
 
     // Self-correlation term of the chains
-    const double qrg2 = q*radius_gyr*q*radius_gyr;
+    const double qrg2 = q*rg*q*rg;
     const double debye_chain = (qrg2 == 0.0) ? 1.0 : 2.0*(expm1(-qrg2)+qrg2)/(qrg2*qrg2);
     const double term2 = n_aggreg * beta_corona * beta_corona * debye_chain;
@@ -41,5 +41,5 @@
     // Interference cross-term between core and chains
     const double chain_ampl = (qrg2 == 0.0) ? 1.0 : -expm1(-qrg2)/qrg2;
-    const double bes_corona = sinc(q*(radius_core + d_penetration * radius_gyr));
+    const double bes_corona = sinc(q*(radius_core + d_penetration * rg));
     const double term3 = 2 * n_aggreg * n_aggreg * beta_core * beta_corona *
                  bes_core * chain_ampl * bes_corona;
@@ -70,5 +70,5 @@
         double corona_sld,
         double radius_core,
-        double radius_gyr,
+        double rg,
         double d_penetration,
         double n_aggreg)
@@ -82,5 +82,5 @@
             corona_sld,
             radius_core,
-            radius_gyr,
+            rg,
             d_penetration,
             n_aggreg);
Index: sasmodels/models/polymer_micelle.py
===================================================================
--- sasmodels/models/polymer_micelle.py	(revision 0bef47b278e819df7ea6b572375dd7bc9607227e)
+++ sasmodels/models/polymer_micelle.py	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -45,6 +45,6 @@
     ["sld_core",      "1e-6/Ang^2", 0.34, [0.0, inf], "sld", "Core scattering length density"],
     ["sld_corona",    "1e-6/Ang^2", 0.8,  [0.0, inf], "sld", "Corona scattering length density"],
-    ["radius_core",   "Ang",       45.0,  [0.0, inf], "", "Radius of core ( must be >> radius_gyr )"],
-    ["radius_gyr",    "Ang",       20.0,  [0.0, inf], "", "Radius of gyration of chains in corona"],
+    ["radius_core",   "Ang",       45.0,  [0.0, inf], "", "Radius of core ( must be >> rg )"],
+    ["rg",    "Ang",       20.0,  [0.0, inf], "", "Radius of gyration of chains in corona"],
     ["d_penetration", "",           1.0,  [-inf, inf], "", "Factor to mimic non-penetration of Gaussian chains"],
     ["n_aggreg",      "",           6.0,  [-inf, inf], "", "Aggregation number of the micelle"],
@@ -64,5 +64,5 @@
             sld_corona=0.8,
             radius_core=45.0,
-            radius_gyr=20.0,
+            rg=20.0,
             d_penetration=1.0,
             n_aggreg=6.0)
Index: sasmodels/models/rectangular_prism.c
===================================================================
--- sasmodels/models/rectangular_prism.c	(revision deb7ee06caa9916d8c0504bdc15ffbc16df623f6)
+++ sasmodels/models/rectangular_prism.c	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -1,11 +1,11 @@
-double form_volume(double a_side, double b2a_ratio, double c2a_ratio);
-double Iq(double q, double sld, double solvent_sld, double a_side, 
+double form_volume(double length_a, double b2a_ratio, double c2a_ratio);
+double Iq(double q, double sld, double solvent_sld, double length_a, 
           double b2a_ratio, double c2a_ratio);
 double Iqxy(double qx, double qy, double sld, double solvent_sld, 
-            double a_side, double b2a_ratio, double c2a_ratio);
+            double length_a, double b2a_ratio, double c2a_ratio);
 
-double form_volume(double a_side, double b2a_ratio, double c2a_ratio)
+double form_volume(double length_a, double b2a_ratio, double c2a_ratio)
 {
-    return a_side * (a_side*b2a_ratio) * (a_side*c2a_ratio);
+    return length_a * (length_a*b2a_ratio) * (length_a*c2a_ratio);
 }
 
@@ -13,5 +13,5 @@
     double sld,
     double solvent_sld,
-    double a_side,
+    double length_a,
     double b2a_ratio,
     double c2a_ratio)
@@ -19,8 +19,8 @@
     double termA, termB, termC;
     
-    double b_side = a_side * b2a_ratio;
-    double c_side = a_side * c2a_ratio;
-    double volume = a_side * b_side * c_side;
-    double a_half = 0.5 * a_side;
+    double b_side = length_a * b2a_ratio;
+    double c_side = length_a * c2a_ratio;
+    double volume = length_a * b_side * c_side;
+    double a_half = 0.5 * length_a;
     double b_half = 0.5 * b_side;
     double c_half = 0.5 * c_side;
@@ -92,10 +92,10 @@
     double sld,
     double solvent_sld,
-    double a_side,
+    double length_a,
     double b2a_ratio,
     double c2a_ratio)
 {
     double q = sqrt(qx*qx + qy*qy);
-    double intensity = Iq(q, sld, solvent_sld, a_side, b2a_ratio, c2a_ratio); 
+    double intensity = Iq(q, sld, solvent_sld, length_a, b2a_ratio, c2a_ratio); 
     return intensity;    
 }
Index: sasmodels/models/rectangular_prism.py
===================================================================
--- sasmodels/models/rectangular_prism.py	(revision 42356c8890c04b71169941b12a36fc0e07e2034b)
+++ sasmodels/models/rectangular_prism.py	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -99,5 +99,5 @@
               ["sld_solvent", "1e-6/Ang^2", 1, [-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"],
               ["b2a_ratio", "Ang", 1, [0, inf], "volume",
@@ -109,13 +109,13 @@
 source = ["lib/gauss76.c", "rectangular_prism.c"]
 
-def ER(a_side, b2a_ratio, c2a_ratio):
+def ER(length_a, b2a_ratio, c2a_ratio):
     """
         Return equivalent radius (ER)
     """
-    b_side = a_side * b2a_ratio
-    c_side = a_side * c2a_ratio
+    b_side = length_a * b2a_ratio
+    c_side = length_a * c2a_ratio
 
     # surface average radius (rough approximation)
-    surf_rad = sqrt(a_side * b_side / pi)
+    surf_rad = sqrt(length_a * b_side / pi)
 
     ddd = 0.75 * surf_rad * (2 * surf_rad * c_side + (c_side + surf_rad) * (c_side + pi * surf_rad))
@@ -126,6 +126,6 @@
 demo = dict(scale=1, background=0,
             sld=6.3e-6, sld_solvent=1.0e-6,
-            a_side=35, b2a_ratio=1, c2a_ratio=1,
-            a_side_pd=0.1, a_side_pd_n=10,
+            length_a=35, b2a_ratio=1, c2a_ratio=1,
+            length_a_pd=0.1, length_a_pd_n=10,
             b2a_ratio_pd=0.1, b2a_ratio_pd_n=1,
             c2a_ratio_pd=0.1, c2a_ratio_pd_n=1)
Index: sasmodels/models/stacked_disks.c
===================================================================
--- sasmodels/models/stacked_disks.c	(revision 2c74c11fc4544381ecf9949bd1618c67ff624c6d)
+++ sasmodels/models/stacked_disks.c	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -1,13 +1,13 @@
-double form_volume(double core_thick,
-                   double layer_thick,
+double form_volume(double thick_core,
+                   double thick_layer,
                    double radius,
                    double n_stacking);
 
 double Iq(double q,
-          double core_thick,
-          double layer_thick,
+          double thick_core,
+          double thick_layer,
           double radius,
           double n_stacking,
-          double sigma_d,
+          double sigma_dnn,
           double core_sld,
           double layer_sld,
@@ -21,7 +21,7 @@
                double solvent_sld,
                double halfheight,
-               double layer_thick,
+               double thick_layer,
                double zi,
-               double sigma_d,
+               double sigma_dnn,
                double d,
                double n_stacking)
@@ -38,5 +38,5 @@
 
 	const double sinarg1 = qq*halfheight*cos(zi);
-	const double sinarg2 = qq*(halfheight+layer_thick)*cos(zi);
+	const double sinarg2 = qq*(halfheight+thick_layer)*cos(zi);
 
 	const double be1 = sas_J1c(besarg1);
@@ -48,5 +48,5 @@
 	const double dr2 = (layer_sld-solvent_sld);
 	const double area = M_PI*radius*radius;
-	const double totald=2.0*(layer_thick+halfheight);
+	const double totald=2.0*(thick_layer+halfheight);
 
 	const double t1 = area*(2.0*halfheight)*dr1*(si1)*(be1);
@@ -59,5 +59,5 @@
 	double sqq=0.0;
 	for(int kk=1;kk<n_stacking;kk+=1) {
-		double dexpt=qq*cos(zi)*qq*cos(zi)*d*d*sigma_d*sigma_d*kk/2.0;
+		double dexpt=qq*cos(zi)*qq*cos(zi)*d*d*sigma_dnn*sigma_dnn*kk/2.0;
 		sqq=sqq+(n_stacking-kk)*cos(qq*cos(zi)*d*kk)*exp(-1.*dexpt);
 	}
@@ -74,9 +74,9 @@
 static
 double stacked_disks_kernel(double q,
-                            double core_thick,
-                            double layer_thick,
+                            double thick_core,
+                            double thick_layer,
                             double radius,
                             double n_stacking,
-                            double sigma_d,
+                            double sigma_dnn,
                             double core_sld,
                             double layer_sld,
@@ -88,6 +88,6 @@
 	double summ = 0.0;	//initialize integral
 
-	double d=2.0*layer_thick+core_thick;
-	double halfheight = core_thick/2.0;
+	double d=2.0*thick_layer+thick_core;
+	double halfheight = thick_core/2.0;
 
 	for(int i=0;i<N_POINTS_76;i++) {
@@ -100,7 +100,7 @@
 		                   solvent_sld,
 		                   halfheight,
-		                   layer_thick,
+		                   thick_layer,
 		                   zi,
-		                   sigma_d,
+		                   sigma_dnn,
 		                   d,
 		                   n_stacking);
@@ -117,9 +117,9 @@
 
 static double stacked_disks_kernel_2d(double q, double q_x, double q_y,
-                            double core_thick,
-                            double layer_thick,
+                            double thick_core,
+                            double thick_layer,
                             double radius,
                             double n_stacking,
-                            double sigma_d,
+                            double sigma_dnn,
                             double core_sld,
                             double layer_sld,
@@ -154,6 +154,6 @@
 
     // Call the IGOR library function to get the kernel
-    double d = 2 * layer_thick + core_thick;
-    double halfheight = core_thick/2.0;
+    double d = 2 * thick_layer + thick_core;
+    double halfheight = thick_core/2.0;
     double answer = _kernel(q,
                      radius,
@@ -162,7 +162,7 @@
                      solvent_sld,
                      halfheight,
-                     layer_thick,
+                     thick_layer,
                      alpha,
-                     sigma_d,
+                     sigma_dnn,
                      d,
                      n_stacking);
@@ -175,18 +175,18 @@
 }
 
-double form_volume(double core_thick,
-                   double layer_thick,
+double form_volume(double thick_core,
+                   double thick_layer,
                    double radius,
                    double n_stacking){
-    double d = 2 * layer_thick + core_thick;
+    double d = 2 * thick_layer + thick_core;
     return acos(-1.0) * radius * radius * d * n_stacking;
 }
 
 double Iq(double q,
-          double core_thick,
-          double layer_thick,
+          double thick_core,
+          double thick_layer,
           double radius,
           double n_stacking,
-          double sigma_d,
+          double sigma_dnn,
           double core_sld,
           double layer_sld,
@@ -194,9 +194,9 @@
 {
     return stacked_disks_kernel(q,
-                    core_thick,
-                    layer_thick,
+                    thick_core,
+                    thick_layer,
                     radius,
                     n_stacking,
-                    sigma_d,
+                    sigma_dnn,
                     core_sld,
                     layer_sld,
Index: sasmodels/models/stacked_disks.py
===================================================================
--- sasmodels/models/stacked_disks.py	(revision 40a87fa5096610e24c3ead10299f609e99f093f2)
+++ sasmodels/models/stacked_disks.py	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -54,21 +54,21 @@
     \right]^2 \sin{\alpha}\ d\alpha
 
-where $d$ = thickness of the layer (*layer_thick*),
-$2h$ = core thickness (*core_thick*), and $R$ = radius of the disc (*radius*).
+where $d$ = thickness of the layer (*thick_layer*),
+$2h$ = core thickness (*thick_core*), and $R$ = radius of the disc (*radius*).
 
 .. math::
 
     S(q) = 1 + \frac{1}{2}\sum_{k=1}^n(n-k)\cos{(kDq\cos{\alpha})}
-    \exp\left[ -k(q\cos{\alpha})^2\sigma_D/2\right]
+    \exp\left[ -k(q\cos{\alpha})^2\sigma_Dnn/2\right]
 
 where $n$ is the total number of the disc stacked (*n_stacking*),
 $D = 2(d+h)$ is the next neighbor center-to-center distance (d-spacing),
-and $\sigma_D$ = the Gaussian standard deviation of the d-spacing (*sigma_d*).
+and $\sigma_Dnn$ = the Gaussian standard deviation of the d-spacing (*sigma_dnn*).
 
 .. note::
-    Each assmebly in the stack is layer/core/layer, so the spacing of the
+    Each assembly in the stack is layer/core/layer, so the spacing of the
     cores is core plus two layers. The 2nd virial coefficient of the cylinder
     is calculated based on the *radius* and *length*
-    = *n_stacking* * (*core_thick* + 2 * *layer_thick*)
+    = *n_stacking* * (*thick_core* + 2 * *thick_layer*)
     values, and used as the effective radius for $S(Q)$ when $P(Q) * S(Q)$
     is applied.
@@ -114,10 +114,10 @@
     One layer of disk consists of a core, a top layer, and a bottom layer.
     radius =  the radius of the disk
-    core_thick = thickness of the core
-    layer_thick = thickness of a layer
+    thick_core = thickness of the core
+    thick_layer = thickness of a layer
     sld_core = the SLD of the core
     sld_layer = the SLD of the layers
     n_stacking = the number of the disks
-    sigma_d =  Gaussian STD of d-spacing
+    sigma_dnn =  Gaussian STD of d-spacing
     sld_solvent = the SLD of the solvent
     """
@@ -127,9 +127,9 @@
 #   ["name", "units", default, [lower, upper], "type","description"],
 parameters = [
-    ["core_thick",  "Ang",        10.0, [0, inf],    "volume",      "Thickness of the core disk"],
-    ["layer_thick", "Ang",        10.0, [0, inf],    "volume",      "Thickness of layer each side of core"],
+    ["thick_core",  "Ang",        10.0, [0, inf],    "volume",      "Thickness of the core disk"],
+    ["thick_layer", "Ang",        10.0, [0, inf],    "volume",      "Thickness of layer each side of core"],
     ["radius",      "Ang",        15.0, [0, inf],    "volume",      "Radius of the stacked disk"],
     ["n_stacking",  "",            1.0, [0, inf],    "volume",      "Number of stacked layer/core/layer disks"],
-    ["sigma_d",     "Ang",         0,   [0, inf],    "",            "GSD of disks sigma_d"],
+    ["sigma_dnn",   "Ang",         0,   [0, inf],    "",            "Sigma of nearest neighbor spacing"],
     ["sld_core",    "1e-6/Ang^2",  4,   [-inf, inf], "sld",         "Core scattering length density"],
     ["sld_layer",   "1e-6/Ang^2",  0.0, [-inf, inf], "sld",         "Layer scattering length density"],
@@ -144,9 +144,9 @@
 demo = dict(background=0.001,
             scale=0.01,
-            core_thick=10.0,
-            layer_thick=10.0,
+            thick_core=10.0,
+            thick_layer=10.0,
             radius=15.0,
             n_stacking=1,
-            sigma_d=0,
+            sigma_dnn=0,
             sld_core=4,
             sld_layer=0.0,
@@ -158,9 +158,9 @@
     # Accuracy tests based on content in test/utest_extra_models.py.
     # Added 2 tests with n_stacked = 5 using SasView 3.1.2 - PDB
-    [{'core_thick': 10.0,
-      'layer_thick': 15.0,
-      'radius': 3000.0,
-      'n_stacking': 1.0,
-      'sigma_d': 0.0,
+    [{'thick_core': 10.0,
+      'thick_layer': 15.0,
+      'radius': 3000.0,
+      'n_stacking': 1.0,
+      'sigma_dnn': 0.0,
       'sld_core': 4.0,
       'sld_layer': -0.4,
@@ -172,9 +172,9 @@
      }, 0.001, 5075.12],
 
-    [{'core_thick': 10.0,
-      'layer_thick': 15.0,
+    [{'thick_core': 10.0,
+      'thick_layer': 15.0,
       'radius': 3000.0,
       'n_stacking': 5.0,
-      'sigma_d': 0.0,
+      'sigma_dnn': 0.0,
       'sld_core': 4.0,
       'sld_layer': -0.4,
@@ -186,9 +186,9 @@
      }, 0.001, 5065.12793824],
 
-    [{'core_thick': 10.0,
-      'layer_thick': 15.0,
+    [{'thick_core': 10.0,
+      'thick_layer': 15.0,
       'radius': 3000.0,
       'n_stacking': 5.0,
-      'sigma_d': 0.0,
+      'sigma_dnn': 0.0,
       'sld_core': 4.0,
       'sld_layer': -0.4,
@@ -200,9 +200,9 @@
      }, 0.164, 0.0127673597265],
 
-    [{'core_thick': 10.0,
-      'layer_thick': 15.0,
-      'radius': 3000.0,
-      'n_stacking': 1.0,
-      'sigma_d': 0.0,
+    [{'thick_core': 10.0,
+      'thick_layer': 15.0,
+      'radius': 3000.0,
+      'n_stacking': 1.0,
+      'sigma_dnn': 0.0,
       'sld_core': 4.0,
       'sld_layer': -0.4,
@@ -214,9 +214,9 @@
      }, [0.001, 90.0], [5075.12, 0.001]],
 
-    [{'core_thick': 10.0,
-      'layer_thick': 15.0,
-      'radius': 3000.0,
-      'n_stacking': 1.0,
-      'sigma_d': 0.0,
+    [{'thick_core': 10.0,
+      'thick_layer': 15.0,
+      'radius': 3000.0,
+      'n_stacking': 1.0,
+      'sigma_dnn': 0.0,
       'sld_core': 4.0,
       'sld_layer': -0.4,
@@ -228,9 +228,9 @@
      }, ([0.4, 0.5]), [0.00105074, 0.00121761]],
 
-    [{'core_thick': 10.0,
-      'layer_thick': 15.0,
-      'radius': 3000.0,
-      'n_stacking': 1.0,
-      'sigma_d': 0.0,
+    [{'thick_core': 10.0,
+      'thick_layer': 15.0,
+      'radius': 3000.0,
+      'n_stacking': 1.0,
+      'sigma_dnn': 0.0,
       'sld_core': 4.0,
       'sld_layer': -0.4,
Index: sasmodels/models/surface_fractal.c
===================================================================
--- sasmodels/models/surface_fractal.c	(revision 2c74c11fc4544381ecf9949bd1618c67ff624c6d)
+++ sasmodels/models/surface_fractal.c	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -3,10 +3,10 @@
 double Iq(double q,
           double radius,
-          double surface_dim,
+          double fractal_dim_surf,
           double cutoff_length);
 
 static double _surface_fractal_kernel(double q,
     double radius,
-    double surface_dim,
+    double fractal_dim_surf,
     double cutoff_length)
 {
@@ -20,5 +20,5 @@
 
     //calculate S(q)
-    mmo = 5.0 - surface_dim;
+    mmo = 5.0 - fractal_dim_surf;
     sq  = sas_gamma(mmo)*sin(-(mmo)*atan(q*cutoff_length));
     sq *= pow(cutoff_length, mmo);
@@ -38,8 +38,8 @@
 double Iq(double q,
     double radius,
-    double surface_dim,
+    double fractal_dim_surf,
     double cutoff_length
     )
 {
-    return _surface_fractal_kernel(q, radius, surface_dim, cutoff_length);
+    return _surface_fractal_kernel(q, radius, fractal_dim_surf, cutoff_length);
 }
Index: sasmodels/models/surface_fractal.py
===================================================================
--- sasmodels/models/surface_fractal.py	(revision 33875e363f17e84f1f20f93fc0c802619155b23c)
+++ sasmodels/models/surface_fractal.py	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -66,10 +66,10 @@
         delta        =  sldParticle -sldSolv.
         radius       =  Particle radius
-        surface_dim  =  Surface fractal dimension (Ds)
+        fractal_dim_surf  =  Surface fractal dimension (Ds)
         co_length    =  Cut-off length
         background   =  background
 
         Ref.   :Mildner, Hall,J Phys D Appl Phys(1986), 19, 1535-1545
-        Note I : This model is valid for 1<surface_dim<3 with limited q range.
+        Note I : This model is valid for 1<fractal_dim_surf<3 with limited q range.
         Note II: This model is not in absolute scale.
 """
@@ -80,5 +80,5 @@
 parameters = [["radius",        "Ang", 10.0, [0, inf],   "",
                "Particle radius"],
-              ["surface_dim",   "",    2.0,  [1, 3],   "",
+              ["fractal_dim_surf",   "",    2.0,  [1, 3],   "",
                "Surface fractal dimension"],
               ["cutoff_length", "Ang", 500., [0.0, inf], "",
@@ -90,10 +90,10 @@
 
 demo = dict(scale=1, background=0,
-            radius=10, surface_dim=2.0, cutoff_length=500)
+            radius=10, fractal_dim_surf=2.0, cutoff_length=500)
 
 tests = [
     # Accuracy tests based on content in test/utest_other_models.py
     [{'radius': 10.0,
-      'surface_dim': 2.0,
+      'fractal_dim_surf': 2.0,
       'cutoff_length': 500.0,
      }, 0.05, 301428.66016],
@@ -101,10 +101,10 @@
     # Additional tests with larger range of parameters
     [{'radius': 1.0,
-      'surface_dim': 1.0,
+      'fractal_dim_surf': 1.0,
       'cutoff_length': 10.0,
      }, 0.332070182643, 1125.00421004],
 
     [{'radius': 3.5,
-      'surface_dim': 0.1,
+      'fractal_dim_surf': 0.1,
       'cutoff_length': 30.0,
       'background': 0.01,
@@ -112,5 +112,5 @@
 
     [{'radius': 3.0,
-      'surface_dim': 1.0,
+      'fractal_dim_surf': 1.0,
       'cutoff_length': 33.0,
       'scale': 0.1,
Index: sasmodels/models/triaxial_ellipsoid.c
===================================================================
--- sasmodels/models/triaxial_ellipsoid.c	(revision 2f5c6d4a9ea74b4cc7a58030e36695b0634eb349)
+++ sasmodels/models/triaxial_ellipsoid.c	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -1,22 +1,22 @@
-double form_volume(double req_minor, double req_major, double rpolar);
-double Iq(double q, double sld, double solvent_sld,
-    double req_minor, double req_major, double rpolar);
-double Iqxy(double qx, double qy, double sld, double solvent_sld,
-    double req_minor, double req_major, double rpolar, double theta, double phi, double psi);
+double form_volume(double radius_equat_minor, double radius_equat_major, double radius_polar);
+double Iq(double q, double sld, double sld_solvent,
+    double radius_equat_minor, double radius_equat_major, double radius_polar);
+double Iqxy(double qx, double qy, double sld, double sld_solvent,
+    double radius_equat_minor, double radius_equat_major, double radius_polar, double theta, double phi, double psi);
 
-//#define INVALID(v) (v.req_minor > v.req_major || v.req_major > v.rpolar)
+//#define INVALID(v) (v.radius_equat_minor > v.radius_equat_major || v.radius_equat_major > v.radius_polar)
 
 
-double form_volume(double req_minor, double req_major, double rpolar)
+double form_volume(double radius_equat_minor, double radius_equat_major, double radius_polar)
 {
-    return 1.333333333333333*M_PI*req_minor*req_major*rpolar;
+    return 1.333333333333333*M_PI*radius_equat_minor*radius_equat_major*radius_polar;
 }
 
 double Iq(double q,
     double sld,
-    double solvent_sld,
-    double req_minor,
-    double req_major,
-    double rpolar)
+    double sld_solvent,
+    double radius_equat_minor,
+    double radius_equat_major,
+    double radius_polar)
 {
     double sn, cn;
@@ -29,7 +29,7 @@
         const double x = 0.5*(Gauss76Z[i] + 1.0);
         SINCOS(M_PI_2*x, sn, cn);
-        const double acosx2 = req_minor*req_minor*cn*cn;
-        const double bsinx2 = req_major*req_major*sn*sn;
-        const double c2 = rpolar*rpolar;
+        const double acosx2 = radius_equat_minor*radius_equat_minor*cn*cn;
+        const double bsinx2 = radius_equat_major*radius_equat_major*sn*sn;
+        const double c2 = radius_polar*radius_polar;
 
         double inner = 0.0;
@@ -44,5 +44,5 @@
     // translate dx in [-1,1] to dx in [lower,upper]
     const double fqsq = outer*zm;
-    const double s = (sld - solvent_sld) * form_volume(req_minor, req_major, rpolar);
+    const double s = (sld - sld_solvent) * form_volume(radius_equat_minor, radius_equat_major, radius_polar);
     return 1.0e-4 * s * s * fqsq;
 }
@@ -50,8 +50,8 @@
 double Iqxy(double qx, double qy,
     double sld,
-    double solvent_sld,
-    double req_minor,
-    double req_major,
-    double rpolar,
+    double sld_solvent,
+    double radius_equat_minor,
+    double radius_equat_major,
+    double radius_polar,
     double theta,
     double phi,
@@ -71,9 +71,9 @@
     const double cnu = (-cphi*spsi*stheta + sphi*cpsi)*qxhat + spsi*ctheta*qyhat;
     const double cmu = (-stheta*cpsi*cphi - spsi*sphi)*qxhat + ctheta*cpsi*qyhat;
-    const double t = q*sqrt(req_minor*req_minor*cnu*cnu
-                          + req_major*req_major*cmu*cmu
-                          + rpolar*rpolar*calpha*calpha);
+    const double t = q*sqrt(radius_equat_minor*radius_equat_minor*cnu*cnu
+                          + radius_equat_major*radius_equat_major*cmu*cmu
+                          + radius_polar*radius_polar*calpha*calpha);
     const double fq = sph_j1c(t);
-    const double s = (sld - solvent_sld) * form_volume(req_minor, req_major, rpolar);
+    const double s = (sld - sld_solvent) * form_volume(radius_equat_minor, radius_equat_major, radius_polar);
 
     return 1.0e-4 * square(s * fq);
Index: sasmodels/models/triaxial_ellipsoid.py
===================================================================
--- sasmodels/models/triaxial_ellipsoid.py	(revision 42356c8890c04b71169941b12a36fc0e07e2034b)
+++ sasmodels/models/triaxial_ellipsoid.py	(revision a8072067ae8a224e45d23ba71f663aadbe1ba4a9)
@@ -88,11 +88,11 @@
 parameters = [["sld", "1e-6/Ang^2", 4, [-inf, inf], "sld",
                "Ellipsoid scattering length density"],
-              ["solvent_sld", "1e-6/Ang^2", 1, [-inf, inf], "sld",
+              ["sld_solvent", "1e-6/Ang^2", 1, [-inf, inf], "sld",
                "Solvent scattering length density"],
-              ["req_minor", "Ang", 20, [0, inf], "volume",
+              ["radius_equat_minor", "Ang", 20, [0, inf], "volume",
                "Minor equatorial radius"],
-              ["req_major", "Ang", 400, [0, inf], "volume",
+              ["radius_equat_major", "Ang", 400, [0, inf], "volume",
                "Major equatorial radius"],
-              ["rpolar", "Ang", 10, [0, inf], "volume",
+              ["radius_polar", "Ang", 10, [0, inf], "volume",
                "Polar radius"],
               ["theta", "degrees", 60, [-inf, inf], "orientation",
@@ -106,5 +106,5 @@
 source = ["lib/sph_j1c.c", "lib/gauss76.c", "triaxial_ellipsoid.c"]
 
-def ER(req_minor, req_major, rpolar):
+def ER(radius_equat_minor, radius_equat_major, radius_polar):
     """
         Returns the effective radius used in the S*P calculation
@@ -112,13 +112,13 @@
     import numpy as np
     from .ellipsoid import ER as ellipsoid_ER
-    return ellipsoid_ER(rpolar, np.sqrt(req_minor * req_major))
+    return ellipsoid_ER(radius_polar, np.sqrt(radius_equat_minor * radius_equat_major))
 
 demo = dict(scale=1, background=0,
-            sld=6, solvent_sld=1,
+            sld=6, sld_solvent=1,
             theta=30, phi=15, psi=5,
-            req_minor=25, req_major=36, rpolar=50,
-            req_minor_pd=0, req_minor_pd_n=1,
-            req_major_pd=0, req_major_pd_n=1,
-            rpolar_pd=.2, rpolar_pd_n=30,
+            radius_equat_minor=25, radius_equat_major=36, radius_polar=50,
+            radius_equat_minor_pd=0, radius_equat_minor_pd_n=1,
+            radius_equat_major_pd=0, radius_equat_major_pd_n=1,
+            radius_polar_pd=.2, radius_polar_pd_n=30,
             theta_pd=15, theta_pd_n=45,
             phi_pd=15, phi_pd_n=1,
