Changes in / [e0da307:dd2c2a31] in sasview

Files:

• .gitignore (modified) (1 diff)
• src/sas/qtgui/MainWindow/DataExplorer.py (modified) (8 diffs)
• src/sas/qtgui/MainWindow/GuiManager.py (modified) (3 diffs)
• src/sas/qtgui/MainWindow/UI/MainWindowUI.ui (modified) (2 diffs)
• src/sas/qtgui/Perspectives/Fitting/AssociatedComboBox.py (added)
• src/sas/qtgui/Perspectives/Fitting/FittingLogic.py (modified) (4 diffs)
• src/sas/qtgui/Perspectives/Fitting/FittingUtilities.py (modified) (11 diffs)
• src/sas/qtgui/Perspectives/Fitting/FittingWidget.py (modified) (48 diffs)
• src/sas/qtgui/Perspectives/Fitting/ModelThread.py (modified) (4 diffs)
• src/sas/qtgui/Perspectives/Fitting/UI/OptionsWidgetUI.ui (modified) (2 diffs)
• src/sas/qtgui/Perspectives/Fitting/UnitTesting/FittingLogicTest.py (modified) (2 diffs)
• src/sas/qtgui/Perspectives/Fitting/UnitTesting/FittingOptionsTest.py (modified) (1 diff)
• src/sas/qtgui/Perspectives/Fitting/UnitTesting/FittingWidgetTest.py (modified) (21 diffs)
• src/sas/qtgui/Plotting/Plotter.py (modified) (4 diffs)
• src/sas/qtgui/Utilities/GuiUtils.py (modified) (1 diff)

.gitignore

@@ -16 +16 @@
 *.pyproj
 *.sln
+.*.swp
 .DS_Store
 /.settings

src/sas/qtgui/MainWindow/DataExplorer.py

@@ -42 +42 @@
         # Main model for keeping loaded data
         self.model = QtGui.QStandardItemModel(self)
-
         # Secondary model for keeping frozen data sets
         self.theory_model = QtGui.QStandardItemModel(self)
@@ -98 +97 @@
         self.communicator.plotUpdateSignal.connect(self.updatePlot)
         self.communicator.maskEditorSignal.connect(self.showEditDataMask)
+        self.communicator.extMaskEditorSignal.connect(self.extShowEditDataMask)
 
         self.cbgraph.editTextChanged.connect(self.enableGraphCombo)
@@ -598 +598 @@
         plot2D.plot(plot_set)
         self.addPlot(plot2D)
-        self.active_plots[plot2D.data.id] = plot2D
+        self.active_plots[plot2D.data.name] = plot2D
         #============================================
         # Experimental hook for silx charts
@@ -626 +626 @@
                 new_plot.plot(plot_set, transform=transform)
                 # active_plots may contain multiple charts
-                self.active_plots[plot_set.id] = new_plot
+                self.active_plots[plot_set.name] = new_plot
             elif isinstance(plot_set, Data2D):
                 self.addDataPlot2D(plot_set, item)
@@ -697 +697 @@
                 old_plot.plot()
                 # need this for lookup - otherwise this plot will never update
-                self.active_plots[plot_set.id] = old_plot
+                self.active_plots[plot_set.name] = old_plot
 
     def updatePlot(self, data):
@@ -711 +711 @@
 
         ids_keys = list(self.active_plots.keys())
-        ids_vals = [val.data.id for val in self.active_plots.values()]
-
-        data_id = data.id
+        ids_vals = [val.data.name for val in self.active_plots.values()]
+
+        data_id = data.name
         if data_id in ids_keys:
             self.active_plots[data_id].replacePlot(data_id, data)
@@ -952 +952 @@
         model = proxy.sourceModel()
 
-        if index.isValid():
-            model_item = model.itemFromIndex(proxy.mapToSource(index))
-            # Find the mapped index
-            orig_index = model_item.isCheckable()
-            if orig_index:
-                # Check the data to enable/disable actions
-                is_2D = isinstance(GuiUtils.dataFromItem(model_item), Data2D)
-                self.actionQuick3DPlot.setEnabled(is_2D)
-                self.actionEditMask.setEnabled(is_2D)
-                # Fire up the menu
-                self.context_menu.exec_(self.current_view.mapToGlobal(position))
+        if not index.isValid():
+            return
+        model_item = model.itemFromIndex(proxy.mapToSource(index))
+        # Find the mapped index
+        orig_index = model_item.isCheckable()
+        if not orig_index:
+            return
+        # Check the data to enable/disable actions
+        is_2D = isinstance(GuiUtils.dataFromItem(model_item), Data2D)
+        self.actionQuick3DPlot.setEnabled(is_2D)
+        self.actionEditMask.setEnabled(is_2D)
+        # Fire up the menu
+        self.context_menu.exec_(self.current_view.mapToGlobal(position))
 
     def showDataInfo(self):
@@ -1059 +1061 @@
         self.new_plot.show()
 
+    def extShowEditDataMask(self):
+        self.showEditDataMask()
+
     def showEditDataMask(self, data=None):
         """
         Mask Editor for 2D plots
         """
-        if data is None or not isinstance(data, Data2D):
-            index = self.current_view.selectedIndexes()[0]
-            proxy = self.current_view.model()
-            model = proxy.sourceModel()
-            model_item = model.itemFromIndex(proxy.mapToSource(index))
-
-            data = GuiUtils.dataFromItem(model_item)
+        try:
+            if data is None or not isinstance(data, Data2D):
+                index = self.current_view.selectedIndexes()[0]
+                proxy = self.current_view.model()
+                model = proxy.sourceModel()
+                model_item = model.itemFromIndex(proxy.mapToSource(index))
+
+                data = GuiUtils.dataFromItem(model_item)
+
+            if data is None or not isinstance(data, Data2D):
+                msg = QtWidgets.QMessageBox()
+                msg.setIcon(QtWidgets.QMessageBox.Information)
+                msg.setText("Error: cannot apply mask. \
+                                Please select a 2D dataset.")
+                msg.setStandardButtons(QtWidgets.QMessageBox.Cancel)
+                msg.exec_()
+                return
+        except:
+            msg = QtWidgets.QMessageBox()
+            msg.setIcon(QtWidgets.QMessageBox.Information)
+            msg.setText("Error: No dataset selected. \
+                            Please select a 2D dataset.")
+            msg.setStandardButtons(QtWidgets.QMessageBox.Cancel)
+            msg.exec_()
+            return
 
         mask_editor = MaskEditor(self, data)

src/sas/qtgui/MainWindow/GuiManager.py

@@ -422 +422 @@
         self._workspace.actionExcel.triggered.connect(self.actionExcel)
         self._workspace.actionLatex.triggered.connect(self.actionLatex)
-
         # View
         self._workspace.actionShow_Grid_Window.triggered.connect(self.actionShow_Grid_Window)
@@ -452 +451 @@
         self._workspace.actionManage_Custom_Models.triggered.connect(self.actionManage_Custom_Models)
         self._workspace.actionAddMult_Models.triggered.connect(self.actionAddMult_Models)
+        self._workspace.actionEditMask.triggered.connect(self.actionEditMask)
+
         # Window
         self._workspace.actionCascade.triggered.connect(self.actionCascade)
@@ -781 +782 @@
         self.add_mult_editor.show()
 
+    def actionEditMask(self):
+
+        self.communicate.extMaskEditorSignal.emit()
+
     #============ ANALYSIS =================
     def actionFitting(self):

src/sas/qtgui/MainWindow/UI/MainWindowUI.ui

@@ -113 +113 @@
     <addaction name="actionManage_Custom_Models"/>
     <addaction name="actionAddMult_Models"/>
+    <addaction name="separator"/>
+    <addaction name="actionEditMask"/>
    </widget>
    <widget class="QMenu" name="menuWindow">
@@ -413 +415 @@
    </property>
   </action>
+    <action name="actionEditMask">
+   <property name="text">
+    <string>Edit Mask</string>
+   </property>
+  </action>
   <action name="actionCascade">
    <property name="text">

src/sas/qtgui/Perspectives/Fitting/FittingLogic.py

@@ -161 +161 @@
         Create a new 1D data instance based on fitting results
         """
-        # Unpack return data from Calc1D
-        x, y, page_id, state, weight,\
-        fid, toggle_mode_on, \
-        elapsed, index, model, \
-        data, update_chisqr, source, \
-        unsmeared_output, unsmeared_data, unsmeared_error, \
-        pq_values, sq_values = return_data
-
-        return self._create1DPlot(tab_id, x, y, model, data)
+        return self._create1DPlot(tab_id, return_data['x'], return_data['y'],
+                                  return_data['model'], return_data['data'])
 
     def new2DPlot(self, return_data):
@@ -175 +168 @@
         Create a new 2D data instance based on fitting results
         """
-        image, data, page_id, model, state, toggle_mode_on,\
-        elapsed, index, fid, qmin, qmax, weight, \
-        update_chisqr, source = return_data
+        image = return_data['image']
+        data = return_data['data']
+        model = return_data['model']
 
         np.nan_to_num(image)
@@ -183 +176 @@
         new_plot.name = model.name + '2d'
         new_plot.title = "Analytical model 2D "
-        new_plot.id = str(page_id) + " " + data.name
-        new_plot.group_id = str(page_id) + " Model2D"
+        new_plot.id = str(return_data['page_id']) + " " + data.name
+        new_plot.group_id = str(return_data['page_id']) + " Model2D"
         new_plot.detector = data.detector
         new_plot.source = data.source
@@ -218 +211 @@
         (pq_plot, sq_plot). If either are unavailable, the corresponding plot is None.
         """
-        # Unpack return data from Calc1D
-        x, y, page_id, state, weight, \
-        fid, toggle_mode_on, \
-        elapsed, index, model, \
-        data, update_chisqr, source, \
-        unsmeared_output, unsmeared_data, unsmeared_error, \
-        pq_values, sq_values = return_data
-
-        pq_plot = None
-        sq_plot = None
-
-        if pq_values is not None:
-            pq_plot = self._create1DPlot(tab_id, x, pq_values, model, data, component="P(Q)")
-        if sq_values is not None:
-            sq_plot = self._create1DPlot(tab_id, x, sq_values, model, data, component="S(Q)")
-
-        return pq_plot, sq_plot
+        plots = []
+        for name, result in return_data['intermediate_results'].items():
+            plots.append(self._create1DPlot(tab_id, return_data['x'], result,
+                         return_data['model'], return_data['data'],
+                         component=name))
+        return plots
 
     def computeDataRange(self):

src/sas/qtgui/Perspectives/Fitting/FittingUtilities.py

@@ -8 +8 @@
 from sas.qtgui.Plotting.PlotterData import Data1D
 from sas.qtgui.Plotting.PlotterData import Data2D
+
+from sas.qtgui.Perspectives.Fitting.AssociatedComboBox import AssociatedComboBox
 
 model_header_captions = ['Parameter', 'Value', 'Min', 'Max', 'Units']
@@ -61 +63 @@
     return (param_name, param_length)
 
-def addParametersToModel(parameters, kernel_module, is2D):
-    """
-    Update local ModelModel with sasmodel parameters
+def createFixedChoiceComboBox(param, item_row):
+    """
+    Determines whether param is a fixed-choice parameter, modifies items in item_row appropriately and returns a combo
+    box containing the fixed choices. Returns None if param is not fixed-choice.
+    
+    item_row is a list of QStandardItem objects for insertion into the parameter table. 
+    """
+
+    # Determine whether this is a fixed-choice parameter. There are lots of conditionals, simply because the
+    # implementation is not yet concrete; there are several possible indicators that the parameter is fixed-choice.
+    # TODO: (when the sasmodels implementation is concrete, clean this up)
+    choices = None
+    if isinstance(param.choices, (list, tuple)) and len(param.choices) > 0:
+        # The choices property is concrete in sasmodels, probably will use this
+        choices = param.choices
+    elif isinstance(param.units, (list, tuple)):
+        choices = [str(x) for x in param.units]
+
+    cbox = None
+    if choices is not None:
+        # Use combo box for input, if it is fixed-choice
+        cbox = AssociatedComboBox(item_row[1], idx_as_value=True)
+        cbox.addItems(choices)
+        item_row[2].setEditable(False)
+        item_row[3].setEditable(False)
+
+    return cbox
+
+def addParametersToModel(parameters, kernel_module, is2D, model=None, view=None):
+    """
+    Update local ModelModel with sasmodel parameters.
+    Actually appends to model, if model and view params are not None.
+    Always returns list of lists of QStandardItems.
     """
     multishell_parameters = getIterParams(parameters)
@@ -72 +104 @@
     else:
         params = parameters.iq_parameters
-    item = []
+
+    rows = []
     for param in params:
         # don't include shell parameters
         if param.name == multishell_param_name:
             continue
+
         # Modify parameter name from <param>[n] to <param>1
         item_name = param.name
         if param in multishell_parameters:
             continue
-        #    item_name = replaceShellName(param.name, 1)
 
         item1 = QtGui.QStandardItem(item_name)
         item1.setCheckable(True)
         item1.setEditable(False)
-        # item_err = QtGui.QStandardItem()
+
         # check for polydisp params
         if param.polydisperse:
@@ -93 +126 @@
             item1_1 = QtGui.QStandardItem("Distribution")
             item1_1.setEditable(False)
+
             # Find param in volume_params
             for p in parameters.form_volume_parameters:
@@ -99 +133 @@
                 width = kernel_module.getParam(p.name+'.width')
                 ptype = kernel_module.getParam(p.name+'.type')
-
                 item1_2 = QtGui.QStandardItem(str(width))
                 item1_2.setEditable(False)
@@ -110 +143 @@
                 poly_item.appendRow([item1_1, item1_2, item1_3, item1_4, item1_5])
                 break
+
             # Add the polydisp item as a child
             item1.appendRow([poly_item])
+
         # Param values
         item2 = QtGui.QStandardItem(str(param.default))
-        # TODO: the error column.
-        # Either add a proxy model or a custom view delegate
-        #item_err = QtGui.QStandardItem()
         item3 = QtGui.QStandardItem(str(param.limits[0]))
         item4 = QtGui.QStandardItem(str(param.limits[1]))
-        item5 = QtGui.QStandardItem(param.units)
+        item5 = QtGui.QStandardItem(str(param.units))
         item5.setEditable(False)
-        item.append([item1, item2, item3, item4, item5])
-    return item
-
-def addSimpleParametersToModel(parameters, is2D):
-    """
-    Update local ModelModel with sasmodel parameters
+
+        # Check if fixed-choice (returns combobox, if so, also makes some items uneditable)
+        row = [item1, item2, item3, item4, item5]
+        cbox = createFixedChoiceComboBox(param, row)
+
+        # Append to the model and use the combobox, if required
+        if None not in (model, view):
+            model.appendRow(row)
+            if cbox:
+                view.setIndexWidget(item2.index(), cbox)
+        rows.append(row)
+
+    return rows
+
+def addSimpleParametersToModel(parameters, is2D, parameters_original=None, model=None, view=None, row_num=None):
+    """
+    Update local ModelModel with sasmodel parameters (non-dispersed, non-magnetic)
+    Actually appends to model, if model and view params are not None.
+    Always returns list of lists of QStandardItems.
+
+    parameters_original: list of parameters before any tagging on their IDs, e.g. for product model (so that those are
+    the display names; see below)
     """
     if is2D:
@@ -132 +180 @@
     else:
         params = parameters.iq_parameters
-    item = []
-    for param in params:
+
+    if parameters_original:
+        # 'parameters_original' contains the parameters as they are to be DISPLAYED, while 'parameters'
+        # contains the parameters as they were renamed; this is for handling name collisions in product model.
+        # The 'real name' of the parameter will be stored in the item's user data.
+        if is2D:
+            params_orig = [p for p in parameters_original.kernel_parameters if p.type != 'magnetic']
+        else:
+            params_orig = parameters_original.iq_parameters
+    else:
+        # no difference in names anyway
+        params_orig = params
+
+    rows = []
+    for param, param_orig in zip(params, params_orig):
         # Create the top level, checkable item
-        item_name = param.name
+        item_name = param_orig.name
         item1 = QtGui.QStandardItem(item_name)
+        item1.setData(param.name, QtCore.Qt.UserRole)
         item1.setCheckable(True)
         item1.setEditable(False)
+
         # Param values
         # TODO: add delegate for validation of cells
         item2 = QtGui.QStandardItem(str(param.default))
-        item4 = QtGui.QStandardItem(str(param.limits[0]))
-        item5 = QtGui.QStandardItem(str(param.limits[1]))
-        item6 = QtGui.QStandardItem(param.units)
-        item6.setEditable(False)
-        item.append([item1, item2, item4, item5, item6])
-    return item
+        item3 = QtGui.QStandardItem(str(param.limits[0]))
+        item4 = QtGui.QStandardItem(str(param.limits[1]))
+        item5 = QtGui.QStandardItem(str(param.units))
+        item5.setEditable(False)
+
+        # Check if fixed-choice (returns combobox, if so, also makes some items uneditable)
+        row = [item1, item2, item3, item4, item5]
+        cbox = createFixedChoiceComboBox(param, row)
+
+        # Append to the model and use the combobox, if required
+        if None not in (model, view):
+            if row_num is None:
+                model.appendRow(row)
+            else:
+                model.insertRow(row_num, row)
+                row_num += 1
+
+            if cbox:
+                view.setIndexWidget(item2.index(), cbox)
+
+        rows.append(row)
+
+    return rows
 
 def markParameterDisabled(model, row):
@@ -182 +262 @@
     model.appendRow(item_list)
 
+def addHeadingRowToModel(model, name):
+    """adds a non-interactive top-level row to the model"""
+    header_row = [QtGui.QStandardItem() for i in range(5)]
+    header_row[0].setText(name)
+
+    font = header_row[0].font()
+    font.setBold(True)
+    header_row[0].setFont(font)
+
+    for item in header_row:
+        item.setEditable(False)
+        item.setCheckable(False)
+        item.setSelectable(False)
+
+    model.appendRow(header_row)
+
 def addHeadersToModel(model):
     """
@@ -227 +323 @@
     model.header_tooltips = copy.copy(poly_header_error_tooltips)
 
-def addShellsToModel(parameters, model, index):
-    """
-    Find out multishell parameters and update the model with the requested number of them
+def addShellsToModel(parameters, model, index, row_num=None, view=None):
+    """
+    Find out multishell parameters and update the model with the requested number of them.
+    Inserts them after the row at row_num, if not None; otherwise, appends to end.
+    If view param is not None, supports fixed-choice params.
+    Returns a list of lists of QStandardItem objects.
     """
     multishell_parameters = getIterParams(parameters)
 
+    rows = []
     for i in range(index):
         for par in multishell_parameters:
@@ -250 +350 @@
                     item1_3 = QtGui.QStandardItem(str(p.limits[0]))
                     item1_4 = QtGui.QStandardItem(str(p.limits[1]))
-                    item1_5 = QtGui.QStandardItem(p.units)
+                    item1_5 = QtGui.QStandardItem(str(p.units))
                     poly_item.appendRow([item1_1, item1_2, item1_3, item1_4, item1_5])
                     break
@@ -258 +358 @@
             item3 = QtGui.QStandardItem(str(par.limits[0]))
             item4 = QtGui.QStandardItem(str(par.limits[1]))
-            item5 = QtGui.QStandardItem(par.units)
-            model.appendRow([item1, item2, item3, item4, item5])
+            item5 = QtGui.QStandardItem(str(par.units))
+            item5.setEditable(False)
+
+            # Check if fixed-choice (returns combobox, if so, also makes some items uneditable)
+            row = [item1, item2, item3, item4, item5]
+            cbox = createFixedChoiceComboBox(par, row)
+
+            # Always add to the model
+            if row_num is None:
+                model.appendRow(row)
+            else:
+                model.insertRow(row_num, row)
+                row_num += 1
+
+            # Apply combobox if required
+            if None not in (view, cbox):
+                view.setIndexWidget(item2.index(), cbox)
+
+            rows.append(row)
+
+    return rows
 
 def calculateChi2(reference_data, current_data):

src/sas/qtgui/Perspectives/Fitting/FittingWidget.py

@@ -48 +48 @@
 from sas.qtgui.Perspectives.Fitting.ReportPageLogic import ReportPageLogic
 
-
 TAB_MAGNETISM = 4
 TAB_POLY = 3
@@ -91 +90 @@
     fittingFinishedSignal = QtCore.pyqtSignal(tuple)
     batchFittingFinishedSignal = QtCore.pyqtSignal(tuple)
-    Calc1DFinishedSignal = QtCore.pyqtSignal(tuple)
-    Calc2DFinishedSignal = QtCore.pyqtSignal(tuple)
+    Calc1DFinishedSignal = QtCore.pyqtSignal(dict)
+    Calc2DFinishedSignal = QtCore.pyqtSignal(dict)
 
     def __init__(self, parent=None, data=None, tab_id=1):
@@ -188 +187 @@
 
         # Overwrite data type descriptor
+
         self.is2D = True if isinstance(self.logic.data, Data2D) else False
 
@@ -219 +219 @@
         # Utility variable to enable unselectable option in category combobox
         self._previous_category_index = 0
-        # Utility variable for multishell display
-        self._last_model_row = 0
+        # Utility variables for multishell display
+        self._n_shells_row = 0
+        self._num_shell_params = 0
         # Dictionary of {model name: model class} for the current category
         self.models = {}
@@ -247 +248 @@
         # copy of current kernel model
         self.kernel_module_copy = None
+
+        # dictionaries of current params
+        self.poly_params = {}
+        self.magnet_params = {}
 
         # Page id for fitting
@@ -558 +563 @@
         When clicked on white space: model description
         """
-        rows = [s.row() for s in self.lstParams.selectionModel().selectedRows()]
+        rows = [s.row() for s in self.lstParams.selectionModel().selectedRows()
+                if self.isCheckable(s.row())]
         menu = self.showModelDescription() if not rows else self.modelContextMenu(rows)
         try:
@@ -672 +678 @@
         Return list of all parameters for the current model
         """
-        return [self._model_model.item(row).text() for row in range(self._model_model.rowCount())]
+        return [self._model_model.item(row).text()
+                for row in range(self._model_model.rowCount())
+                if self.isCheckable(row)]
 
     def modifyViewOnRow(self, row, font=None, brush=None):
@@ -700 +708 @@
         assert isinstance(constraint, Constraint)
         assert 0 <= row <= self._model_model.rowCount()
+        assert self.isCheckable(row)
 
         item = QtGui.QStandardItem()
@@ -720 +729 @@
         max_col = self.lstParams.itemDelegate().param_max
         for row in self.selectedParameters():
+            assert(self.isCheckable(row))
             param = self._model_model.item(row, 0).text()
             value = self._model_model.item(row, 1).text()
@@ -762 +772 @@
         max_col = self.lstParams.itemDelegate().param_max
         for row in range(self._model_model.rowCount()):
+            if not self.isCheckable(row):
+                continue
             if not self.rowHasConstraint(row):
                 continue
@@ -788 +800 @@
     def getConstraintForRow(self, row):
         """
-        For the given row, return its constraint, if any
-        """
+        For the given row, return its constraint, if any (otherwise None)
+        """
+        if not self.isCheckable(row):
+            return None
+        item = self._model_model.item(row, 1)
         try:
-            item = self._model_model.item(row, 1)
             return item.child(0).data()
         except AttributeError:
-            # return none when no constraints
             return None
 
@@ -801 +814 @@
         Finds out if row of the main model has a constraint child
         """
+        if not self.isCheckable(row):
+            return False
         item = self._model_model.item(row, 1)
-        if item.hasChildren():
-            c = item.child(0).data()
-            if isinstance(c, Constraint):
-                return True
+        if not item.hasChildren():
+            return False
+        c = item.child(0).data()
+        if isinstance(c, Constraint):
+            return True
         return False
 
@@ -812 +828 @@
         Finds out if row of the main model has an active constraint child
         """
+        if not self.isCheckable(row):
+            return False
         item = self._model_model.item(row, 1)
-        if item.hasChildren():
-            c = item.child(0).data()
-            if isinstance(c, Constraint) and c.active:
-                return True
+        if not item.hasChildren():
+            return False
+        c = item.child(0).data()
+        if isinstance(c, Constraint) and c.active:
+            return True
         return False
 
@@ -823 +842 @@
         Finds out if row of the main model has an active, nontrivial constraint child
         """
+        if not self.isCheckable(row):
+            return False
         item = self._model_model.item(row, 1)
-        if item.hasChildren():
-            c = item.child(0).data()
-            if isinstance(c, Constraint) and c.func and c.active:
-                return True
+        if not item.hasChildren():
+            return False
+        c = item.child(0).data()
+        if isinstance(c, Constraint) and c.func and c.active:
+            return True
         return False
 
@@ -1037 +1059 @@
             # Show constraint, if present
             row = rows[0].row()
-            if self.rowHasConstraint(row):
-                func = self.getConstraintForRow(row).func
-                if func is not None:
-                    self.communicate.statusBarUpdateSignal.emit("Active constrain: "+func)
+            if not self.rowHasConstraint(row):
+                return
+            func = self.getConstraintForRow(row).func
+            if func is not None:
+                self.communicate.statusBarUpdateSignal.emit("Active constrain: "+func)
 
     def replaceConstraintName(self, old_name, new_name=""):
@@ -1186 +1209 @@
             # Update the sasmodel
             # PD[ratio] -> width, npts -> npts, nsigs -> nsigmas
-            self.kernel_module.setParam(parameter_name + '.' + delegate.columnDict()[model_column], value)
+            #self.kernel_module.setParam(parameter_name + '.' + delegate.columnDict()[model_column], value)
+            key = parameter_name + '.' + delegate.columnDict()[model_column]
+            self.poly_params[key] = value
 
             # Update plot
@@ -1195 +1220 @@
             row = self.getRowFromName(parameter_name)
             param_item = self._model_model.item(row)
+            self._model_model.blockSignals(True)
             param_item.child(0).child(0, model_column).setText(item.text())
+            self._model_model.blockSignals(False)
 
     def onMagnetModelChange(self, item):
@@ -1224 +1251 @@
             # Unparsable field
             return
-
-        property_index = self._magnet_model.headerData(1, model_column)-1 # Value, min, max, etc.
-
-        # Update the parameter value - note: this supports +/-inf as well
-        self.kernel_module.params[parameter_name] = value
-
-        # min/max to be changed in self.kernel_module.details[parameter_name] = ['Ang', 0.0, inf]
-        self.kernel_module.details[parameter_name][property_index] = value
-
-        # Force the chart update when actual parameters changed
-        if model_column == 1:
+        delegate = self.lstMagnetic.itemDelegate()
+
+        if model_column > 1:
+            if model_column == delegate.mag_min:
+                pos = 1
+            elif model_column == delegate.mag_max:
+                pos = 2
+            elif model_column == delegate.mag_unit:
+                pos = 0
+            else:
+                raise AttributeError("Wrong column in magnetism table.")
+            # min/max to be changed in self.kernel_module.details[parameter_name] = ['Ang', 0.0, inf]
+            self.kernel_module.details[parameter_name][pos] = value
+        else:
+            self.magnet_params[parameter_name] = value
+            #self.kernel_module.setParam(parameter_name) = value
+            # Force the chart update when actual parameters changed
             self.recalculatePlotData()
 
@@ -1481 +1514 @@
         # update charts
         self.onPlot()
+        #self.recalculatePlotData()
+
 
         # Read only value - we can get away by just printing it here
@@ -1495 +1530 @@
         # Data going in
         data = self.logic.data
-        model = self.kernel_module
+        model = copy.deepcopy(self.kernel_module)
         qmin = self.q_range_min
         qmax = self.q_range_max
+        # add polydisperse/magnet parameters if asked
+        self.updateKernelModelWithExtraParams(model)
 
         params_to_fit = self.main_params_to_fit
@@ -1561 +1598 @@
             # internal so can use closure for param_dict
             param_name = str(self._model_model.item(row, 0).text())
-            if param_name not in list(param_dict.keys()):
+            if not self.isCheckable(row) or param_name not in list(param_dict.keys()):
                 return
             # modify the param value
             param_repr = GuiUtils.formatNumber(param_dict[param_name][0], high=True)
             self._model_model.item(row, 1).setText(param_repr)
+            self.kernel_module.setParam(param_name, param_dict[param_name][0])
             if self.has_error_column:
                 error_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
@@ -1573 +1611 @@
             # Utility function for updateof polydispersity part of the main model
             param_name = str(self._model_model.item(row, 0).text())+'.width'
-            if param_name not in list(param_dict.keys()):
+            if not self.isCheckable(row) or param_name not in list(param_dict.keys()):
                 return
             # modify the param value
@@ -1607 +1645 @@
             poly_item.insertColumn(2, [QtGui.QStandardItem("")])
 
-        # block signals temporarily, so we don't end up
-        # updating charts with every single model change on the end of fitting
-        self._model_model.blockSignals(True)
-
         if not self.has_error_column:
             # create top-level error column
@@ -1617 +1651 @@
             self.iterateOverModel(createErrorColumn)
 
-            # we need to enable signals for this, otherwise the final column mysteriously disappears (don't ask, I don't
-            # know)
-            self._model_model.blockSignals(False)
             self._model_model.insertColumn(2, error_column)
-            self._model_model.blockSignals(True)
 
             FittingUtilities.addErrorHeadersToModel(self._model_model)
@@ -1630 +1660 @@
             self.has_error_column = True
 
+        # block signals temporarily, so we don't end up
+        # updating charts with every single model change on the end of fitting
+        self._model_model.itemChanged.disconnect()
         self.iterateOverModel(updateFittedValues)
         self.iterateOverModel(updatePolyValues)
-
-        self._model_model.blockSignals(False)
+        self._model_model.itemChanged.connect(self.onMainParamsChange)
 
         # Adjust the table cells width.
@@ -1668 +1700 @@
             param_repr = GuiUtils.formatNumber(param_dict[param_name][0], high=True)
             self._poly_model.item(row_i, 1).setText(param_repr)
+            self.kernel_module.setParam(param_name, param_dict[param_name][0])
             if self.has_poly_error_column:
                 error_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
                 self._poly_model.item(row_i, 2).setText(error_repr)
-
 
         def createErrorColumn(row_i):
@@ -1692 +1724 @@
         # block signals temporarily, so we don't end up
         # updating charts with every single model change on the end of fitting
-        self._poly_model.blockSignals(True)
+        self._poly_model.itemChanged.disconnect()
         self.iterateOverPolyModel(updateFittedValues)
-        self._poly_model.blockSignals(False)
+        self._poly_model.itemChanged.connect(self.onPolyModelChange)
 
         if self.has_poly_error_column:
@@ -1704 +1736 @@
 
         # switch off reponse to model change
-        self._poly_model.blockSignals(True)
         self._poly_model.insertColumn(2, error_column)
-        self._poly_model.blockSignals(False)
         FittingUtilities.addErrorPolyHeadersToModel(self._poly_model)
 
@@ -1739 +1769 @@
             param_repr = GuiUtils.formatNumber(param_dict[param_name][0], high=True)
             self._magnet_model.item(row, 1).setText(param_repr)
+            self.kernel_module.setParam(param_name, param_dict[param_name][0])
             if self.has_magnet_error_column:
                 error_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
@@ -1758 +1789 @@
         # block signals temporarily, so we don't end up
         # updating charts with every single model change on the end of fitting
-        self._magnet_model.blockSignals(True)
+        self._magnet_model.itemChanged.disconnect()
         self.iterateOverMagnetModel(updateFittedValues)
-        self._magnet_model.blockSignals(False)
+        self._magnet_model.itemChanged.connect(self.onMagnetModelChange)
 
         if self.has_magnet_error_column:
@@ -1770 +1801 @@
 
         # switch off reponse to model change
-        self._magnet_model.blockSignals(True)
         self._magnet_model.insertColumn(2, error_column)
-        self._magnet_model.blockSignals(False)
         FittingUtilities.addErrorHeadersToModel(self._magnet_model)
 
@@ -1784 +1813 @@
         self.cmdPlot.setText("Show Plot")
         # Force data recalculation so existing charts are updated
+        self.showPlot()
+        # This is an important processEvent.
+        # This allows charts to be properly updated in order
+        # of plots being applied.
+        QtWidgets.QApplication.processEvents()
         self.recalculatePlotData()
-        self.showPlot()
 
     def onSmearingOptionsUpdate(self):
@@ -1950 +1983 @@
         # Crete/overwrite model items
         self._model_model.clear()
-
-        # First, add parameters from the main model
-        if model_name is not None:
+        self._poly_model.clear()
+        self._magnet_model.clear()
+
+        if model_name is None:
+            if structure_factor not in (None, "None"):
+                # S(Q) on its own, treat the same as a form factor
+                self.kernel_module = None
+                self.fromStructureFactorToQModel(structure_factor)
+            else:
+                # No models selected
+                return
+        else:
             self.fromModelToQModel(model_name)
-
-        # Then, add structure factor derived parameters
-        if structure_factor is not None and structure_factor != "None":
-            if model_name is None:
-                # Instantiate the current sasmodel for SF-only models
-                self.kernel_module = self.models[structure_factor]()
-            self.fromStructureFactorToQModel(structure_factor)
-        else:
+            self.addExtraShells()
+
             # Allow the SF combobox visibility for the given sasmodel
             self.enableStructureFactorControl(structure_factor)
+        
+            # Add S(Q)
             if self.cbStructureFactor.isEnabled():
                 structure_factor = self.cbStructureFactor.currentText()
                 self.fromStructureFactorToQModel(structure_factor)
 
-        # Then, add multishells
-        if model_name is not None:
-            # Multishell models need additional treatment
-            self.addExtraShells()
-
-        # Add polydispersity to the model
-        self.setPolyModel()
-        # Add magnetic parameters to the model
-        self.setMagneticModel()
+            # Add polydispersity to the model
+            self.poly_params = {}
+            self.setPolyModel()
+            # Add magnetic parameters to the model
+            self.magnet_params = {}
+            self.setMagneticModel()
 
         # Adjust the table cells width
@@ -2049 +2084 @@
         self.shell_names = self.shellNamesList()
 
+        # Add heading row
+        FittingUtilities.addHeadingRowToModel(self._model_model, model_name)
+
         # Update the QModel
-        new_rows = FittingUtilities.addParametersToModel(self.model_parameters, self.kernel_module, self.is2D)
-
-        for row in new_rows:
-            self._model_model.appendRow(row)
-        # Update the counter used for multishell display
-        self._last_model_row = self._model_model.rowCount()
+        FittingUtilities.addParametersToModel(
+                self.model_parameters,
+                self.kernel_module,
+                self.is2D,
+                self._model_model,
+                self.lstParams)
 
     def fromStructureFactorToQModel(self, structure_factor):
@@ -2063 +2101 @@
         if structure_factor is None or structure_factor=="None":
             return
-        structure_module = generate.load_kernel_module(structure_factor)
-        structure_parameters = modelinfo.make_parameter_table(getattr(structure_module, 'parameters', []))
-
-        structure_kernel = self.models[structure_factor]()
-        form_kernel = self.kernel_module
-
-        self.kernel_module = MultiplicationModel(form_kernel, structure_kernel)
-
-        new_rows = FittingUtilities.addSimpleParametersToModel(structure_parameters, self.is2D)
-        for row in new_rows:
-            self._model_model.appendRow(row)
-            # disable fitting of parameters not listed in self.kernel_module (probably radius_effective)
-            if row[0].text() not in self.kernel_module.params.keys():
-                row_num = self._model_model.rowCount() - 1
-                FittingUtilities.markParameterDisabled(self._model_model, row_num)
-
-        # Update the counter used for multishell display
-        self._last_model_row = self._model_model.rowCount()
+
+        product_params = None
+
+        if self.kernel_module is None:
+            # Structure factor is the only selected model; build it and show all its params
+            self.kernel_module = self.models[structure_factor]()
+            s_params = self.kernel_module._model_info.parameters
+            s_params_orig = s_params
+        else:
+            s_kernel = self.models[structure_factor]()
+            p_kernel = self.kernel_module
+
+            p_pars_len = len(p_kernel._model_info.parameters.kernel_parameters)
+            s_pars_len = len(s_kernel._model_info.parameters.kernel_parameters)
+
+            self.kernel_module = MultiplicationModel(p_kernel, s_kernel)
+            all_params = self.kernel_module._model_info.parameters.kernel_parameters
+            all_param_names = [param.name for param in all_params]
+
+            # S(Q) params from the product model are not necessarily the same as those from the S(Q) model; any
+            # conflicting names with P(Q) params will cause a rename
+
+            if "radius_effective_mode" in all_param_names:
+                # Show all parameters
+                # In this case, radius_effective is NOT pruned by sasmodels.product
+                s_params = modelinfo.ParameterTable(all_params[p_pars_len:p_pars_len+s_pars_len])
+                s_params_orig = modelinfo.ParameterTable(s_kernel._model_info.parameters.kernel_parameters)
+                product_params = modelinfo.ParameterTable(
+                        self.kernel_module._model_info.parameters.kernel_parameters[p_pars_len+s_pars_len:])
+            else:
+                # Ensure radius_effective is not displayed
+                s_params_orig = modelinfo.ParameterTable(s_kernel._model_info.parameters.kernel_parameters[1:])
+                if "radius_effective" in all_param_names:
+                    # In this case, radius_effective is NOT pruned by sasmodels.product
+                    s_params = modelinfo.ParameterTable(all_params[p_pars_len+1:p_pars_len+s_pars_len])
+                    product_params = modelinfo.ParameterTable(
+                            self.kernel_module._model_info.parameters.kernel_parameters[p_pars_len+s_pars_len:])
+                else:
+                    # In this case, radius_effective is pruned by sasmodels.product
+                    s_params = modelinfo.ParameterTable(all_params[p_pars_len:p_pars_len+s_pars_len-1])
+                    product_params = modelinfo.ParameterTable(
+                            self.kernel_module._model_info.parameters.kernel_parameters[p_pars_len+s_pars_len-1:])
+
+        # Add heading row
+        FittingUtilities.addHeadingRowToModel(self._model_model, structure_factor)
+
+        # Get new rows for QModel
+        # Any renamed parameters are stored as data in the relevant item, for later handling
+        FittingUtilities.addSimpleParametersToModel(
+                parameters=s_params,
+                is2D=self.is2D,
+                parameters_original=s_params_orig,
+                model=self._model_model,
+                view=self.lstParams)
+
+        # Insert product-only params into QModel
+        if product_params:
+            prod_rows = FittingUtilities.addSimpleParametersToModel(
+                    parameters=product_params,
+                    is2D=self.is2D,
+                    parameters_original=None,
+                    model=self._model_model,
+                    view=self.lstParams,
+                    row_num=2)
+
+            # Since this all happens after shells are dealt with and we've inserted rows, fix this counter
+            self._n_shells_row += len(prod_rows)
 
     def haveParamsToFit(self):
@@ -2106 +2193 @@
         model_row = item.row()
         name_index = self._model_model.index(model_row, 0)
+        name_item = self._model_model.itemFromIndex(name_index)
 
         # Extract changed value.
@@ -2114 +2202 @@
             return
 
-        parameter_name = str(self._model_model.data(name_index)) # sld, background etc.
+        # if the item has user data, this is the actual parameter name (e.g. to handle duplicate names)
+        if name_item.data(QtCore.Qt.UserRole):
+            parameter_name = str(name_item.data(QtCore.Qt.UserRole))
+        else:
+            parameter_name = str(self._model_model.data(name_index))
 
         # Update the parameter value - note: this supports +/-inf as well
@@ -2237 +2329 @@
         return self.completed1D if isinstance(self.data, Data1D) else self.completed2D
 
+    def updateKernelModelWithExtraParams(self, model=None):
+        """
+        Updates kernel model 'model' with extra parameters from
+        the polydisp and magnetism tab, if the tabs are enabled
+        """
+        if model is None: return
+        if not hasattr(model, 'setParam'): return
+
+        # add polydisperse parameters if asked
+        if self.chkPolydispersity.isChecked():
+            for key, value in self.poly_params.items():
+                model.setParam(key, value)
+        # add magnetic params if asked
+        if self.chkMagnetism.isChecked():
+            for key, value in self.magnet_params.items():
+                model.setParam(key, value)
+
     def calculateQGridForModelExt(self, data=None, model=None, completefn=None, use_threads=True):
         """
@@ -2244 +2353 @@
             data = self.data
         if model is None:
-            model = self.kernel_module
+            model = copy.deepcopy(self.kernel_module)
+            self.updateKernelModelWithExtraParams(model)
+
         if completefn is None:
             completefn = self.methodCompleteForData()
@@ -2317 +2428 @@
 
         # Create plots for intermediate product data
-        pq_data, sq_data = self.logic.new1DProductPlots(return_data, self.tab_id)
-        if pq_data is not None:
-            pq_data.symbol = "Line"
-            self.createNewIndex(pq_data)
-            # self.communicate.plotUpdateSignal.emit([pq_data])
-            new_plots.append(pq_data)
-        if sq_data is not None:
-            sq_data.symbol = "Line"
-            self.createNewIndex(sq_data)
-            # self.communicate.plotUpdateSignal.emit([sq_data])
-            new_plots.append(sq_data)
+        plots = self.logic.new1DProductPlots(return_data, self.tab_id)
+        for plot in plots:
+            plot.symbol = "Line"
+            self.createNewIndex(plot)
+            new_plots.append(plot)
+
+        for plot in new_plots:
+            self.communicate.plotUpdateSignal.emit([plot])
+
+    def complete2D(self, return_data):
+        """
+        Plot the current 2D data
+        """
+        fitted_data = self.logic.new2DPlot(return_data)
+        residuals = self.calculateResiduals(fitted_data)
+        self.model_data = fitted_data
+        new_plots = [fitted_data]
+        if residuals is not None:
+            new_plots.append(residuals)
 
         # Update/generate plots
         for plot in new_plots:
             self.communicate.plotUpdateSignal.emit([plot])
-
-    def complete2D(self, return_data):
-        """
-        Plot the current 2D data
-        """
-        fitted_data = self.logic.new2DPlot(return_data)
-        self.calculateResiduals(fitted_data)
-        self.model_data = fitted_data
 
     def calculateResiduals(self, fitted_data):
@@ -2470 +2581 @@
         _, min, max = self.kernel_module.details[param_name]
 
+        # Update local param dict
+        self.poly_params[param_name + '.width'] = width
+        self.poly_params[param_name + '.npts'] = npts
+        self.poly_params[param_name + '.nsigmas'] = nsigs
+
         # Construct a row with polydisp. related variable.
         # This will get added to the polydisp. model
@@ -2517 +2633 @@
         def updateFunctionCaption(row):
             # Utility function for update of polydispersity function name in the main model
+            if not self.isCheckable(row):
+                return
+            self._model_model.blockSignals(True)
             param_name = str(self._model_model.item(row, 0).text())
+            self._model_model.blockSignals(False)
             if param_name !=  param.name:
                 return
             # Modify the param value
+            self._model_model.blockSignals(True)
             if self.has_error_column:
                 # err column changes the indexing
@@ -2526 +2647 @@
             else:
                 self._model_model.item(row, 0).child(0).child(0,4).setText(combo_string)
+            self._model_model.blockSignals(False)
 
         if combo_string == 'array':
@@ -2644 +2766 @@
                         param.units]
 
+        self.magnet_params[param.name] = param.default
+
         FittingUtilities.addCheckedListToModel(model, checked_list)
 
@@ -2683 +2807 @@
 
         self.lstParams.setIndexWidget(shell_index, func)
-        self._last_model_row = self._model_model.rowCount()
+        self._n_shells_row = shell_row - 1
 
         # Set the index to the state-kept value
@@ -2694 +2818 @@
         """
         # Find row location of the combobox
-        last_row = self._last_model_row
-        remove_rows = self._model_model.rowCount() - last_row
+        first_row = self._n_shells_row + 1
+        remove_rows = self._num_shell_params
 
         if remove_rows > 1:
-            self._model_model.removeRows(last_row, remove_rows)
-
-        FittingUtilities.addShellsToModel(self.model_parameters, self._model_model, index)
+            self._model_model.removeRows(first_row, remove_rows)
+
+        new_rows = FittingUtilities.addShellsToModel(
+                self.model_parameters,
+                self._model_model,
+                index,
+                first_row,
+                self.lstParams)
+
+        self._num_shell_params = len(new_rows)
         self.current_shell_displayed = index
+
+        # Change 'n' in the parameter model, thereby updating the underlying model
+        self._model_model.item(self._n_shells_row, 1).setText(str(index))
 
         # Update relevant models
@@ -3046 +3180 @@
             formatted_output = FittingUtilities.formatParameters(param_list)
         elif format == "Excel":
-            formatted_output = FittingUtilities.formatParametersExcel(param_list)
+            formatted_output = FittingUtilities.formatParametersExcel(param_list[1:])
         elif format == "Latex":
-            formatted_output = FittingUtilities.formatParametersLatex(param_list)
+            formatted_output = FittingUtilities.formatParametersLatex(param_list[1:])
         else:
             raise AttributeError("Bad format specifier.")
@@ -3213 +3347 @@
         self._poly_model.blockSignals(False)
 
+
+

src/sas/qtgui/Perspectives/Fitting/ModelThread.py

@@ -101 +101 @@
         elapsed = time.time() - self.starttime
 
+        res = dict(image = output, data = self.data, page_id = self.page_id,
+            model = self.model, state = self.state,
+            toggle_mode_on = self.toggle_mode_on, elapsed = elapsed,
+            index = index_model, fid = self.fid,
+            qmin = self.qmin, qmax = self.qmax,
+            weight = self.weight, update_chisqr = self.update_chisqr,
+            source = self.source)
+
         if LocalConfig.USING_TWISTED:
-            return (output,
-                    self.data,
-                    self.page_id,
-                    self.model,
-                    self.state,
-                    self.toggle_mode_on,
-                    elapsed,
-                    index_model,
-                    self.fid,
-                    self.qmin,
-                    self.qmax,
-                    self.weight,
-                    self.update_chisqr,
-                    self.source)
-        else:
-            self.completefn((output,
-                           self.data,
-                           self.page_id,
-                           self.model,
-                           self.state,
-                           self.toggle_mode_on,
-                           elapsed,
-                           index_model,
-                           self.fid,
-                           self.qmin,
-                           self.qmax,
-                           self.weight,
-                           #qstep=self.qstep,
-                           self.update_chisqr,
-                           self.source))
-
+            return res
+        else:
+            self.completefn(res)
 
 class Calc1D(CalcThread):
@@ -184 +164 @@
         index = (self.qmin <= self.data.x) & (self.data.x <= self.qmax)
 
+        intermediate_results = None
+
         # If we use a smearer, also return the unsmeared model
         unsmeared_output = None
@@ -194 +176 @@
             mask = self.data.x[first_bin:last_bin+1]
             unsmeared_output = numpy.zeros((len(self.data.x)))
-            unsmeared_output[first_bin:last_bin+1] = self.model.evalDistribution(mask)
+
+            return_data = self.model.calculate_Iq(mask)
+            if isinstance(return_data, tuple):
+                # see sasmodels beta_approx: SasviewModel.calculate_Iq
+                # TODO: implement intermediate results in smearers
+                return_data, _ = return_data
+            unsmeared_output[first_bin:last_bin+1] = return_data
             output = self.smearer(unsmeared_output, first_bin, last_bin)
 
@@ -213 +201 @@
                 unsmeared_error=unsmeared_error
         else:
-            output[index] = self.model.evalDistribution(self.data.x[index])
-
-        sq_values = None
-        pq_values = None
-        s_model = None
-        p_model = None
-        if isinstance(self.model, MultiplicationModel):
-            s_model = self.model.s_model
-            p_model = self.model.p_model
-        elif hasattr(self.model, "calc_composition_models"):
-            results = self.model.calc_composition_models(self.data.x[index])
-            if results is not None:
-                pq_values, sq_values = results
-
-        if pq_values is None or sq_values is None:
-            if p_model is not None and s_model is not None:
-                sq_values = numpy.zeros((len(self.data.x)))
-                pq_values = numpy.zeros((len(self.data.x)))
-                sq_values[index] = s_model.evalDistribution(self.data.x[index])
-                pq_values[index] = p_model.evalDistribution(self.data.x[index])
+            return_data = self.model.calculate_Iq(self.data.x[index])
+            if isinstance(return_data, tuple):
+                # see sasmodels beta_approx: SasviewModel.calculate_Iq
+                return_data, intermediate_results = return_data
+            output[index] = return_data
+
+        if intermediate_results:
+            # the model returns a callable which is then used to retrieve the data
+            intermediate_results = intermediate_results()
+        else:
+            # TODO: this conditional branch needs refactoring
+            sq_values = None
+            pq_values = None
+            s_model = None
+            p_model = None
+
+            if isinstance(self.model, MultiplicationModel):
+                s_model = self.model.s_model
+                p_model = self.model.p_model
+
+            elif hasattr(self.model, "calc_composition_models"):
+                results = self.model.calc_composition_models(self.data.x[index])
+                if results is not None:
+                    pq_values, sq_values = results
+
+            if pq_values is None or sq_values is None:
+                if p_model is not None and s_model is not None:
+                    sq_values = numpy.zeros((len(self.data.x)))
+                    pq_values = numpy.zeros((len(self.data.x)))
+                    sq_values[index] = s_model.evalDistribution(self.data.x[index])
+                    pq_values[index] = p_model.evalDistribution(self.data.x[index])
+
+            if pq_values is not None and sq_values is not None:
+                intermediate_results  = {
+                    "P(Q)": pq_values,
+                    "S(Q)": sq_values
+                }
+            else:
+                intermediate_results = {}
 
         elapsed = time.time() - self.starttime
 
+        res = dict(x = self.data.x[index], y = output[index],
+            page_id = self.page_id, state = self.state, weight = self.weight,
+            fid = self.fid, toggle_mode_on = self.toggle_mode_on,
+            elapsed = elapsed, index = index, model = self.model,
+            data = self.data, update_chisqr = self.update_chisqr,
+            source = self.source, unsmeared_output = unsmeared_output,
+            unsmeared_data = unsmeared_data, unsmeared_error = unsmeared_error,
+            intermediate_results = intermediate_results)
+
         if LocalConfig.USING_TWISTED:
-            return (self.data.x[index], output[index],
-                    self.page_id,
-                    self.state,
-                    self.weight,
-                    self.fid,
-                    self.toggle_mode_on,
-                    elapsed, index, self.model,
-                    self.data,
-                    self.update_chisqr,
-                    self.source,
-                    unsmeared_output, unsmeared_data, unsmeared_error,
-                    pq_values, sq_values)
-        else:
-            self.completefn((self.data.x[index], output[index],
-                        self.page_id,
-                        self.state,
-                        self.weight,
-                        self.fid,
-                        self.toggle_mode_on,
-                        elapsed, index, self.model,
-                        self.data,
-                        self.update_chisqr,
-                        self.source,
-                        unsmeared_output, unsmeared_data, unsmeared_error,
-                        pq_values, sq_values))
+            return res
+        else:
+            self.completefn(res)
 
     def results(self):

src/sas/qtgui/Perspectives/Fitting/UI/OptionsWidgetUI.ui

@@ -32 +32 @@
         <item row="0" column="1">
          <widget class="QLineEdit" name="txtMinRange">
+          <property name="minimumSize">
+           <size>
+            <width>80</width>
+            <height>0</height>
+           </size>
+          </property>
           <property name="toolTip">
            <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Minimum value of Q.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
@@ -54 +60 @@
         <item row="1" column="1">
          <widget class="QLineEdit" name="txtMaxRange">
+          <property name="minimumSize">
+           <size>
+            <width>80</width>
+            <height>0</height>
+           </size>
+          </property>
           <property name="toolTip">
            <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Maximum value of Q.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>

src/sas/qtgui/Perspectives/Fitting/UnitTesting/FittingLogicTest.py

@@ -99 +99 @@
         data.name = "boop"
         data.id = "poop"
-        return_data = (data.x,data.y, 7, None, None,
-                       0, True, 0.0, 1, data,
-                       data, False, None,
-                       None, None, None,
-                       None, None)
+        # Condensed return data (new1DPlot only uses these fields)
+        return_data = dict(x = data.x,
+                           y = data.y,
+                           model = data,
+                           data = data)
+        # return_data = (data.x,data.y, 7, None, None,
+        #                0, True, 0.0, 1, data,
+        #                data, False, None,
+        #                None, None, None,
+        #                None, None)
 
         new_plot = self.logic.new1DPlot(return_data=return_data, tab_id=0)
@@ -139 +144 @@
         qmin, qmax, npts = self.logic.computeDataRange()
 
-        return_data = (x_0, data, 7, data, None,
-                        True, 0.0, 1, 0, qmin, qmax,
-                        0.1, False, None)
+        # Condensed return data (new2DPlot only uses these fields)
+        return_data = dict(image = x_0,
+                           data = data,
+                           page_id = 7,
+                           model = data)
+        # return_data = (x_0, data, 7, data, None,
+        #                 True, 0.0, 1, 0, qmin, qmax,
+        #                 0.1, False, None)
 
         new_plot = self.logic.new2DPlot(return_data=return_data)

src/sas/qtgui/Perspectives/Fitting/UnitTesting/FittingOptionsTest.py

@@ -38 +38 @@
         # The combo box
         self.assertIsInstance(self.widget.cbAlgorithm, QtWidgets.QComboBox)
-        self.assertEqual(self.widget.cbAlgorithm.count(), 5)
+        self.assertEqual(self.widget.cbAlgorithm.count(), 6)
         self.assertEqual(self.widget.cbAlgorithm.itemText(0), 'Nelder-Mead Simplex')
         self.assertEqual(self.widget.cbAlgorithm.itemText(4), 'Levenberg-Marquardt')

src/sas/qtgui/Perspectives/Fitting/UnitTesting/FittingWidgetTest.py

@@ -256 +256 @@
         self.widget.cbStructureFactor.setCurrentIndex(structure_index)
 
-        # We have 4 more rows now
+        # We have 3 more param rows now (radius_effective is removed), and a new heading
         self.assertEqual(self.widget._model_model.rowCount(), rowcount+4)
 
@@ -276 +276 @@
         last_index = self.widget.cbStructureFactor.count()
         self.widget.cbStructureFactor.setCurrentIndex(last_index-1)
-        # Do we have all the rows?
-        self.assertEqual(self.widget._model_model.rowCount(), 4)
+        # Do we have all the rows (incl. radius_effective & heading row)?
+        self.assertEqual(self.widget._model_model.rowCount(), 5)
 
         # Are the command buttons properly enabled?
@@ -445 +445 @@
         self.assertEqual(self.widget.kernel_module.details['radius_bell'][1], 1.0)
 
+        #self.widget.show()
+        #QtWidgets.QApplication.exec_()
+
         # Change the number of points
-        self.assertEqual(self.widget.kernel_module.getParam('radius_bell.npts'), 35)
+        self.assertEqual(self.widget.poly_params['radius_bell.npts'], 35)
         self.widget._poly_model.item(0,4).setText("22")
-        self.assertEqual(self.widget.kernel_module.getParam('radius_bell.npts'), 22)
+        self.assertEqual(self.widget.poly_params['radius_bell.npts'], 22)
         # try something stupid
         self.widget._poly_model.item(0,4).setText("butt")
         # see that this didn't annoy the control at all
-        self.assertEqual(self.widget.kernel_module.getParam('radius_bell.npts'), 22)
+        self.assertEqual(self.widget.poly_params['radius_bell.npts'], 22)
 
         # Change the number of sigmas
-        self.assertEqual(self.widget.kernel_module.getParam('radius_bell.nsigmas'), 3)
+        self.assertEqual(self.widget.poly_params['radius_bell.nsigmas'], 3)
         self.widget._poly_model.item(0,5).setText("222")
-        self.assertEqual(self.widget.kernel_module.getParam('radius_bell.nsigmas'), 222)
+        self.assertEqual(self.widget.poly_params['radius_bell.nsigmas'], 222)
         # try something stupid again
         self.widget._poly_model.item(0,4).setText("beer")
         # no efect
-        self.assertEqual(self.widget.kernel_module.getParam('radius_bell.nsigmas'), 222)
+        self.assertEqual(self.widget.poly_params['radius_bell.nsigmas'], 222)
 
     def testOnPolyComboIndexChange(self):
@@ -482 +485 @@
         self.widget.onPolyComboIndexChange('rectangle', 0)
         # check values
-        self.assertEqual(self.widget.kernel_module.getParam('radius_bell.npts'), 35)
-        self.assertAlmostEqual(self.widget.kernel_module.getParam('radius_bell.nsigmas'), 1.73205, 5)
+        self.assertEqual(self.widget.poly_params['radius_bell.npts'], 35)
+        self.assertAlmostEqual(self.widget.poly_params['radius_bell.nsigmas'], 1.73205, 5)
         # Change the index
         self.widget.onPolyComboIndexChange('lognormal', 0)
         # check values
-        self.assertEqual(self.widget.kernel_module.getParam('radius_bell.npts'), 80)
-        self.assertEqual(self.widget.kernel_module.getParam('radius_bell.nsigmas'), 8)
+        self.assertEqual(self.widget.poly_params['radius_bell.npts'], 80)
+        self.assertEqual(self.widget.poly_params['radius_bell.nsigmas'], 8)
         # Change the index
         self.widget.onPolyComboIndexChange('schulz', 0)
         # check values
-        self.assertEqual(self.widget.kernel_module.getParam('radius_bell.npts'), 80)
-        self.assertEqual(self.widget.kernel_module.getParam('radius_bell.nsigmas'), 8)
+        self.assertEqual(self.widget.poly_params['radius_bell.npts'], 80)
+        self.assertEqual(self.widget.poly_params['radius_bell.nsigmas'], 8)
 
         # mock up file load
@@ -506 +509 @@
         Test opening of the load file dialog for 'array' polydisp. function
         """
+
+        # open a non-existent file
         filename = os.path.join("UnitTesting", "testdata_noexist.txt")
+        with self.assertRaises(OSError, msg="testdata_noexist.txt should be a non-existent file"):
+            os.stat(filename)
         QtWidgets.QFileDialog.getOpenFileName = MagicMock(return_value=(filename,''))
         self.widget.show()
@@ -522 +529 @@
 
         # good file
+        # TODO: this depends on the working directory being src/sas/qtgui,
+        # TODO: which isn't convenient if you want to run this test suite
+        # TODO: individually
         filename = os.path.join("UnitTesting", "testdata.txt")
+        try:
+            os.stat(filename)
+        except OSError:
+            self.assertTrue(False, "testdata.txt does not exist")
         QtWidgets.QFileDialog.getOpenFileName = MagicMock(return_value=(filename,''))
 
@@ -588 +602 @@
 
         # Assure we have the combobox available
-        last_row = self.widget._last_model_row
-        func_index = self.widget._model_model.index(last_row-1, 1)
+        cbox_row = self.widget._n_shells_row
+        func_index = self.widget._model_model.index(cbox_row, 1)
         self.assertIsInstance(self.widget.lstParams.indexWidget(func_index), QtWidgets.QComboBox)
+
+        # get number of rows before changing shell count
+        last_row = self.widget._model_model.rowCount()
 
         # Change the combo box index
@@ -1024 +1041 @@
 
          # Check the model
-        self.assertEqual(self.widget._model_model.rowCount(), 6)
+        self.assertEqual(self.widget._model_model.rowCount(), 7)
         self.assertEqual(self.widget._model_model.columnCount(), 5)
 
@@ -1140 +1157 @@
         # two rows selected
         index1 = self.widget.lstParams.model().index(1, 0, QtCore.QModelIndex())
-        index2 = self.widget.lstParams.model().index(2, 0, QtCore.QModelIndex())
+        index2 = self.widget.lstParams.model().index(3, 0, QtCore.QModelIndex())
         selection_model = self.widget.lstParams.selectionModel()
         selection_model.select(index1, selection_model.Select | selection_model.Rows)
@@ -1176 +1193 @@
         # several random parameters
         self.assertEqual(self.widget.getRowFromName('scale'), 0)
-        self.assertEqual(self.widget.getRowFromName('length'), 5)
+        self.assertEqual(self.widget.getRowFromName('length'), 6)
 
     def testGetParamNames(self):
@@ -1213 +1230 @@
         # Create a constraint object
         const = Constraint(parent=None, value=7.0)
-        row = 2
+        row = 3
 
         spy = QtSignalSpy(self.widget, self.widget.constraintAddedSignal)
@@ -1232 +1249 @@
         # assign complex constraint now
         const = Constraint(parent=None, param='radius', func='5*sld')
-        row = 4
+        row = 5
         # call the method tested
         self.widget.addConstraintToRow(constraint=const, row=row)
@@ -1291 +1308 @@
         self.widget.cbModel.setCurrentIndex(model_index)
 
+        row1 = 1
+        row2 = 5
+
+        param1 = "background"
+        param2 = "radius"
+
+        #default_value1 = "0.001"
+        default_value2 = "20"
+
         # select two rows
-        row1 = 1
-        row2 = 4
         index1 = self.widget.lstParams.model().index(row1, 0, QtCore.QModelIndex())
         index2 = self.widget.lstParams.model().index(row2, 0, QtCore.QModelIndex())
@@ -1310 +1334 @@
 
         # delete one of the constraints
-        self.widget.deleteConstraintOnParameter(param='background')
+        self.widget.deleteConstraintOnParameter(param=param1)
 
         # see that the other constraint is still present
-        cons = self.widget.getConstraintForRow(4) # 4 = radius
-        self.assertEqual(cons.param, "radius")
-        self.assertEqual(cons.value, "20")
+        cons = self.widget.getConstraintForRow(row2)
+        self.assertEqual(cons.param, param2)
+        self.assertEqual(cons.value, default_value2)
 
         # kill the other constraint
@@ -1321 +1345 @@
 
         # see that the other constraint is still present
-        self.assertEqual(self.widget.getConstraintsForModel(), [('radius', None)])
+        self.assertEqual(self.widget.getConstraintsForModel(), [(param2, None)])
 
     def testGetConstraintForRow(self):
@@ -1341 +1365 @@
         self.widget.cbModel.setCurrentIndex(model_index)
 
+        row1 = 1
+        row2 = 5
+
         # select two rows
-        row1 = 1
-        row2 = 4
         index1 = self.widget.lstParams.model().index(row1, 0, QtCore.QModelIndex())
         index2 = self.widget.lstParams.model().index(row2, 0, QtCore.QModelIndex())
@@ -1353 +1378 @@
         self.widget.addSimpleConstraint()
 
-        con_list = [False, True, False, False, True, False]
+        con_list = [False, True, False, False, False, True, False]
         new_list = []
         for row in range(self.widget._model_model.rowCount()):
@@ -1371 +1396 @@
         self.widget.cbModel.setCurrentIndex(model_index)
 
+        row1 = 1
+        row2 = 5
+
         # select two rows
-        row1 = 1
-        row2 = 4
         index1 = self.widget.lstParams.model().index(row1, 0, QtCore.QModelIndex())
         index2 = self.widget.lstParams.model().index(row2, 0, QtCore.QModelIndex())
@@ -1387 +1413 @@
         constraint_objects[0].active = False
 
-        con_list = [False, False, False, False, True, False]
+        con_list = [False, False, False, False, False, True, False]
         new_list = []
         for row in range(self.widget._model_model.rowCount()):
@@ -1408 +1434 @@
         self.assertEqual(self.widget.getConstraintsForModel(),[])
 
+        row1 = 1
+        row2 = 5
+
+        param1 = "background"
+        param2 = "radius"
+
+        default_value1 = "0.001"
+        default_value2 = "20"
+
         # select two rows
-        row1 = 1
-        row2 = 4
         index1 = self.widget.lstParams.model().index(row1, 0, QtCore.QModelIndex())
         index2 = self.widget.lstParams.model().index(row2, 0, QtCore.QModelIndex())
@@ -1422 +1455 @@
         # simple constraints
         # self.assertEqual(self.widget.getConstraintsForModel(), [('background', '0.001'), ('radius', '20')])
-        cons = self.widget.getConstraintForRow(1) # 1 - background
-        self.assertEqual(cons.param, "background")
-        self.assertEqual(cons.value, "0.001")
-        cons = self.widget.getConstraintForRow(4) # 4 = radius
-        self.assertEqual(cons.param, "radius")
-        self.assertEqual(cons.value, "20")
+        cons = self.widget.getConstraintForRow(row1)
+        self.assertEqual(cons.param, param1)
+        self.assertEqual(cons.value, default_value1)
+        cons = self.widget.getConstraintForRow(row2)
+        self.assertEqual(cons.param, param2)
+        self.assertEqual(cons.value, default_value2)
 
         objects = self.widget.getConstraintObjectsForModel()
         self.assertEqual(len(objects), 2)
-        self.assertEqual(objects[1].value, '20')
-        self.assertEqual(objects[0].param, 'background')
+        self.assertEqual(objects[1].value, default_value2)
+        self.assertEqual(objects[0].param, param1)
+
+        row = 0
+        param = "scale"
+        func = "5*sld"
 
         # add complex constraint
-        const = Constraint(parent=None, param='scale', func='5*sld')
-        row = 0
+        const = Constraint(parent=None, param=param, func=func)
         self.widget.addConstraintToRow(constraint=const, row=row)
         #self.assertEqual(self.widget.getConstraintsForModel(),[('scale', '5*sld'), ('background', '0.001'), ('radius', None)])
-        cons = self.widget.getConstraintForRow(4) # 4 = radius
-        self.assertEqual(cons.param, "radius")
-        self.assertEqual(cons.value, "20")
+        cons = self.widget.getConstraintForRow(row2)
+        self.assertEqual(cons.param, param2)
+        self.assertEqual(cons.value, default_value2)
 
         objects = self.widget.getConstraintObjectsForModel()
         self.assertEqual(len(objects), 3)
-        self.assertEqual(objects[0].func, '5*sld')
+        self.assertEqual(objects[0].func, func)
 
     def testReplaceConstraintName(self):

src/sas/qtgui/Plotting/Plotter.py

@@ -30 +30 @@
         # Dictionary of {plot_id:Data1d}
         self.plot_dict = {}
-
+        # Dictionaty of {plot_id:line}
+
+        self.plot_lines = {}
         # Window for text add
         self.addText = AddText(self)
@@ -180 +182 @@
 
         # Update the list of data sets (plots) in chart
-        self.plot_dict[self._data.id] = self.data
+        self.plot_dict[self._data.name] = self.data
+
+        self.plot_lines[self._data.name] = line
 
         # Now add the legend with some customizations.
@@ -196 +200 @@
 
         # refresh canvas
-        self.canvas.draw_idle()
-        # This is an important processEvent.
-        # This allows charts to be properly updated in order
-        # of plots being applied.
-        QtWidgets.QApplication.processEvents()
+        self.canvas.draw()
 
     def createContextMenu(self):
@@ -470 +470 @@
         """
         selected_plot = self.plot_dict[id]
-
+        selected_line = self.plot_lines[id]
         # Old style color - single integer for enum color
         # New style color - #hhhhhh

src/sas/qtgui/Utilities/GuiUtils.py

@@ -265 +265 @@
     # Mask Editor requested
     maskEditorSignal = QtCore.pyqtSignal(Data2D)
+
+    #second Mask Editor for external
+    extMaskEditorSignal = QtCore.pyqtSignal()
 
     # Fitting parameter copy to clipboard