Index: sasmodels/sasview_model.py
===================================================================
--- sasmodels/sasview_model.py	(revision 117c02a6b865d8d26e44868f181338e79d9e9785)
+++ sasmodels/sasview_model.py	(revision 84f29620067dee7dc1c9d0c004c375ea633f98a9)
@@ -381,8 +381,5 @@
                 continue
             self.params[p.name] = p.default
-            if p.limits is not None:
-                self.details[p.id] = [p.units if not p.choices else p.choices, p.limits[0], p.limits[1]]
-            else:
-                self.details[p.id] = [p.units if not p.choices else p.choices, None, None]
+            self.details[p.id] = [p.units, p.limits[0], p.limits[1]]
             if p.polydisperse:
                 self.details[p.id+".width"] = [
@@ -543,7 +540,9 @@
             # pylint: disable=unpacking-non-sequence
             q, phi = x
-            return self.calculate_Iq([q*math.cos(phi)], [q*math.sin(phi)])[0]
-        else:
-            return self.calculate_Iq([x])[0]
+            result, _ = self.calculate_Iq([q*math.cos(phi)], [q*math.sin(phi)])
+            return result[0]
+        else:
+            result, _ = self.calculate_Iq([x])
+            return result[0]
 
 
@@ -560,7 +559,9 @@
         """
         if isinstance(x, (list, tuple)):
-            return self.calculate_Iq([x[0]], [x[1]])[0]
-        else:
-            return self.calculate_Iq([x])[0]
+            result, _ = self.calculate_Iq([x[0]], [x[1]])
+            return result[0]
+        else:
+            result, _ = self.calculate_Iq([x])
+            return result[0]
 
     def evalDistribution(self, qdist):
@@ -596,9 +597,11 @@
             # Check whether we have a list of ndarrays [qx,qy]
             qx, qy = qdist
-            return self.calculate_Iq(qx, qy)
+            result, _ = self.calculate_Iq(qx, qy)
+            return result
 
         elif isinstance(qdist, np.ndarray):
             # We have a simple 1D distribution of q-values
-            return self.calculate_Iq(qdist)
+            result, _ = self.calculate_Iq(qdist)
+            return result
 
         else:
@@ -640,13 +643,18 @@
         if composition and composition[0] == 'product': # only P*S for now
             with calculation_lock:
-                self._calculate_Iq(qx)
-                # for compatibility with sasview 4.3
-                results = self._intermediate_results()
-                return results["P(Q)"], results["S(Q)"]
+                _, lazy_results = self._calculate_Iq(qx)
+                # for compatibility with sasview 4.x
+                results = lazy_results()
+                pq_data = results.get("P(Q)")
+                sq_data = results.get("S(Q)")
+                return pq_data, sq_data
         else:
             return None
 
-    def calculate_Iq(self, qx, qy=None):
-        # type: (Sequence[float], Optional[Sequence[float]]) -> np.ndarray
+    def calculate_Iq(self,
+                     qx,     # type: Sequence[float]
+                     qy=None # type: Optional[Sequence[float]]
+                     ):
+        # type: (...) -> Tuple[np.ndarray, Callable[[], collections.OrderedDict[str, np.ndarray]]]
         """
         Calculate Iq for one set of q with the current parameters.
@@ -656,4 +664,8 @@
         This should NOT be used for fitting since it copies the *q* vectors
         to the card for each evaluation.
+
+        The returned tuple contains the scattering intensity followed by a
+        callable which returns a dictionary of intermediate data from
+        ProductKernel.
         """
         ## uncomment the following when trying to debug the uncoordinated calls
@@ -688,9 +700,12 @@
         result = calculator(call_details, values, cutoff=self.cutoff,
                             magnetic=is_magnetic)
+        lazy_results = getattr(calculator, 'results',
+                               lambda: collections.OrderedDict())
         #print("result", result)
-        self._intermediate_results = getattr(calculator, 'results', None)
+
         calculator.release()
         #self._model.release()
-        return result
+
+        return result, lazy_results
 
     def calculate_ER(self):
@@ -881,5 +896,5 @@
     q = np.linspace(-0.35, 0.35, 500)
     qx, qy = np.meshgrid(q, q)
-    result = model.calculate_Iq(qx.flatten(), qy.flatten())
+    result, _ = model.calculate_Iq(qx.flatten(), qy.flatten())
     result = result.reshape(qx.shape)
 
