Index: sasmodels/resolution.py
===================================================================
--- sasmodels/resolution.py	(revision 823e6204f35d6c2bf32f27a3a3c137a369a973cf)
+++ sasmodels/resolution.py	(revision 5925e909151e120132e72e91095ab06bad045240)
@@ -470,4 +470,11 @@
 
 def eval_form(q, form, pars):
+    """
+    Return the SAS model evaluated at *q*.
+
+    *form* is the SAS model returned from :fun:`core.load_model`.
+
+    *pars* are the parameter values to use when evaluating.
+    """
     from sasmodels import core
     kernel = core.make_kernel(form, [q])
@@ -478,4 +485,9 @@
 
 def gaussian(q, q0, dq):
+    """
+    Return the Gaussian resolution function.
+
+    *q0* is the center, *dq* is the width and *q* are the points to evaluate.
+    """
     from numpy import exp, pi
     return exp(-0.5*((q-q0)/dq)**2)/(sqrt(2*pi)*dq)
@@ -559,4 +571,7 @@
 
 class ResolutionTest(unittest.TestCase):
+    """
+    Test the resolution calculations.
+    """
 
     def setUp(self):
@@ -668,4 +683,7 @@
 
 class IgorComparisonTest(unittest.TestCase):
+    """
+    Test resolution calculations against those returned by Igor.
+    """
 
     def setUp(self):
@@ -675,5 +693,5 @@
         self.model = core.load_model(sphere, dtype='double')
 
-    def Iq_sphere(self, pars, resolution):
+    def _eval_sphere(self, pars, resolution):
         from sasmodels import core
         kernel = core.make_kernel(self.model, [resolution.q_calc])
@@ -683,5 +701,5 @@
         return result
 
-    def compare(self, q, output, answer, tolerance):
+    def _compare(self, q, output, answer, tolerance):
         #err = (output - answer)/answer
         #idx = abs(err) >= tolerance
@@ -700,6 +718,6 @@
         q, width, answer, _ = data
         resolution = Perfect1D(q)
-        output = self.Iq_sphere(pars, resolution)
-        self.compare(q, output, answer, 1e-6)
+        output = self._eval_sphere(pars, resolution)
+        self._compare(q, output, answer, 1e-6)
 
     def test_pinhole(self):
@@ -713,7 +731,7 @@
         q, q_width, answer = data
         resolution = Pinhole1D(q, q_width)
-        output = self.Iq_sphere(pars, resolution)
+        output = self._eval_sphere(pars, resolution)
         # TODO: relative error should be lower
-        self.compare(q, output, answer, 3e-4)
+        self._compare(q, output, answer, 3e-4)
 
     def test_pinhole_romberg(self):
@@ -736,14 +754,14 @@
         q_calc, tol = None, 0.01
         resolution = Pinhole1D(q, q_width, q_calc=q_calc)
-        output = self.Iq_sphere(pars, resolution)
+        output = self._eval_sphere(pars, resolution)
         if 0: # debug plot
             import matplotlib.pyplot as plt
             resolution = Perfect1D(q)
-            source = self.Iq_sphere(pars, resolution)
+            source = self._eval_sphere(pars, resolution)
             plt.loglog(q, source, '.')
             plt.loglog(q, answer, '-', hold=True)
             plt.loglog(q, output, '-', hold=True)
             plt.show()
-        self.compare(q, output, answer, tol)
+        self._compare(q, output, answer, tol)
 
     def test_slit(self):
@@ -757,9 +775,9 @@
         q, delta_qv, _, answer = data
         resolution = Slit1D(q, width=delta_qv, height=0)
-        output = self.Iq_sphere(pars, resolution)
+        output = self._eval_sphere(pars, resolution)
         # TODO: eliminate Igor test since it is too inaccurate to be useful.
         # This means we can eliminate the test data as well, and instead
         # use a generated q vector.
-        self.compare(q, output, answer, 0.5)
+        self._compare(q, output, answer, 0.5)
 
     def test_slit_romberg(self):
@@ -777,7 +795,7 @@
                                delta_qv[0], 0.)
         resolution = Slit1D(q, width=delta_qv, height=0, q_calc=q_calc)
-        output = self.Iq_sphere(pars, resolution)
+        output = self._eval_sphere(pars, resolution)
         # TODO: relative error should be lower
-        self.compare(q, output, answer, 0.025)
+        self._compare(q, output, answer, 0.025)
 
     def test_ellipsoid(self):
@@ -799,5 +817,5 @@
         # TODO: 10% is too much error; use better algorithm
         #print(np.max(abs(answer-output)/answer))
-        self.compare(q, output, answer, 0.1)
+        self._compare(q, output, answer, 0.1)
 
     #TODO: can sas q spacing be too sparse for the resolution calculation?
@@ -813,6 +831,6 @@
         q, q_width, answer = data[:, ::20] # Take every nth point
         resolution = Pinhole1D(q, q_width)
-        output = self.Iq_sphere(pars, resolution)
-        self.compare(q, output, answer, 1e-6)
+        output = self._eval_sphere(pars, resolution)
+        self._compare(q, output, answer, 1e-6)
 
 
@@ -1067,4 +1085,7 @@
 
 def demo_pinhole_1d():
+    """
+    Show example of pinhole smearing.
+    """
     q = np.logspace(-4, np.log10(0.2), 400)
     q_width = 0.1*q
@@ -1073,4 +1094,7 @@
 
 def demo_slit_1d():
+    """
+    Show example of slit smearing.
+    """
     q = np.logspace(-4, np.log10(0.2), 100)
     w = h = 0.
@@ -1083,4 +1107,7 @@
 
 def demo():
+    """
+    Run the resolution demos.
+    """
     import matplotlib.pyplot as plt
     plt.subplot(121)
