Index: sasmodels/sasview_model.py
===================================================================
--- sasmodels/sasview_model.py	(revision 3bcb88c5ccea91321b7eab3b1e6d9d32b005e376)
+++ sasmodels/sasview_model.py	(revision 9c1a59c7aad38fe9dd5dc541a713efe02e4a6804)
@@ -565,4 +565,5 @@
         parameters = self._model_info.parameters
         pairs = [self._get_weights(p) for p in parameters.call_parameters]
+        #weights.plot_weights(self._model_info, pairs)
         call_details, values, is_magnetic = make_kernel_args(calculator, pairs)
         #call_details.show()
@@ -618,14 +619,13 @@
             # remember them is kind of funky.
             # Note: can't seem to get disperser parameters from sasview
-            # (1) Could create a sasview model that has not yet # been
+            # (1) Could create a sasview model that has not yet been
             # converted, assign the disperser to one of its polydisperse
             # parameters, then retrieve the disperser parameters from the
-            # sasview model.  (2) Could write a disperser parameter retriever
-            # in sasview.  (3) Could modify sasview to use sasmodels.weights
-            # dispersers.
+            # sasview model.
+            # (2) Could write a disperser parameter retriever in sasview.
+            # (3) Could modify sasview to use sasmodels.weights dispersers.
             # For now, rely on the fact that the sasview only ever uses
             # new dispersers in the set_dispersion call and create a new
             # one instead of trying to assign parameters.
-            dispersion = weights.MODELS[dispersion.type]()
             self.dispersion[parameter] = dispersion.get_pars()
         else:
@@ -658,7 +658,10 @@
         elif par.polydisperse:
             dis = self.dispersion[par.name]
-            value, weight = weights.get_weights(
-                dis['type'], dis['npts'], dis['width'], dis['nsigmas'],
-                self.params[par.name], par.limits, par.relative_pd)
+            if dis['type'] == 'array':
+                value, weight = dis['values'], dis['weights']
+            else:
+                value, weight = weights.get_weights(
+                    dis['type'], dis['npts'], dis['width'], dis['nsigmas'],
+                    self.params[par.name], par.limits, par.relative_pd)
             return value, weight / np.sum(weight)
         else:
Index: sasmodels/weights.py
===================================================================
--- sasmodels/weights.py	(revision fa800e72ed892ce6d15aea12327ecc955f456bc9)
+++ sasmodels/weights.py	(revision 6cefbc90865e6f3018a8950d19ec28f6e14cd186)
@@ -3,5 +3,9 @@
 """
 # TODO: include dispersion docs with the disperser models
+from __future__ import division, print_function
+
 from math import sqrt  # type: ignore
+from collections import OrderedDict
+
 import numpy as np  # type: ignore
 from scipy.special import gammaln  # type: ignore
@@ -54,5 +58,6 @@
             else:
                 return np.array([], 'd'), np.array([], 'd')
-        return self._weights(center, sigma, lb, ub)
+        x, px = self._weights(center, sigma, lb, ub)
+        return x, px
 
     def _weights(self, center, sigma, lb, ub):
@@ -79,4 +84,7 @@
     default = dict(npts=35, width=0, nsigmas=3)
     def _weights(self, center, sigma, lb, ub):
+        # TODO: sample high probability regions more densely
+        # i.e., step uniformly in cumulative density rather than x value
+        # so weight = 1/Npts for all weights, but values are unevenly spaced
         x = self._linspace(center, sigma, lb, ub)
         px = np.exp((x-center)**2 / (-2.0 * sigma * sigma))
@@ -165,6 +173,8 @@
 
     def _weights(self, center, sigma, lb, ub):
-        # TODO: interpolate into the array dispersion using npts
-        x = center + self.values*sigma
+        # TODO: rebin the array dispersion using npts
+        # TODO: use a distribution that can be recentered and scaled
+        x = self.values
+        #x = center + self.values*sigma
         idx = (x >= lb) & (x <= ub)
         x = x[idx]
@@ -174,7 +184,12 @@
 
 # dispersion name -> disperser lookup table.
-MODELS = dict((d.type, d) for d in (
-    GaussianDispersion, RectangleDispersion,
-    ArrayDispersion, SchulzDispersion, LogNormalDispersion
+# Maintain order since this is used by sasview GUI to order the options in
+# the dispersion type combobox.
+MODELS = OrderedDict((d.type, d) for d in (
+    RectangleDispersion,
+    ArrayDispersion,
+    LogNormalDispersion,
+    GaussianDispersion,
+    SchulzDispersion,
 ))
 
@@ -194,5 +209,5 @@
     *value* is the value of the parameter in the model.
 
-    *limits* is [lb, ub], the lower and upper bound of the weight value.
+    *limits* is [lb, ub], the lower and upper bound on the possible values.
 
     *relative* is true if *width* is defined in proportion to the value
@@ -201,6 +216,32 @@
     Returns *(value, weight)*, where *value* and *weight* are vectors.
     """
+    if disperser == "array":
+        raise NotImplementedError("Don't handle arrays through get_weights; use values and weights directly")
     cls = MODELS[disperser]
     obj = cls(n, width, nsigmas)
     v, w = obj.get_weights(value, limits[0], limits[1], relative)
     return v, w
+
+
+def plot_weights(model_info, pairs):
+    # type: (ModelInfo, List[Tuple[np.ndarray, np.ndarray]]) -> None
+    """
+    Plot the weights returned by :func:`get_weights`.
+
+    *model_info* is
+    :param model_info:
+    :param pairs:
+    :return:
+    """
+    import pylab
+
+    if any(len(values)>1 for values, weights in pairs):
+        labels = [p.name for p in model_info.parameters.call_parameters]
+        pylab.interactive(True)
+        pylab.figure()
+        for (v,w), s in zip(pairs, labels):
+            if len(v) > 1:
+                #print("weights for", s, v, w)
+                pylab.plot(v, w, '-o', label=s)
+        pylab.grid(True)
+        pylab.legend()
