Changes in src/sas/qtgui/Perspectives/Fitting/FittingWidget.py [5a96a72:0dcb71d] in sasview

File:

• src/sas/qtgui/Perspectives/Fitting/FittingWidget.py (modified) (9 diffs)

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

@@ -1841 +1841 @@
         data_to_show = self.data if self.data_is_loaded else self.model_data
         if data_to_show is not None:
-            self.communicate.plotRequestedSignal.emit([data_to_show])
+            self.communicate.plotRequestedSignal.emit([data_to_show], self.tab_id)
 
     def onOptionsUpdate(self):
@@ -2229 +2229 @@
         # TODO: multishell params in self.kernel_module.details[??] = value
 
-        # handle display of effective radius parameter according to radius_effective_mode; pass ER into model if
-        # necessary
-        self.processEffectiveRadius()
-
         # Force the chart update when actual parameters changed
         if model_column == 1:
@@ -2239 +2235 @@
         # Update state stack
         self.updateUndo()
-
-    def processEffectiveRadius(self):
-        """
-        Checks the value of radius_effective_mode, if existent, and processes radius_effective as necessary.
-        * mode == 0: This means 'unconstrained'; ensure use can specify ER.
-        * mode > 0: This means it is constrained to a P(Q)-computed value in sasmodels; prevent user from editing ER.
-
-        Note: If ER has been computed, it is passed back to SasView as an intermediate result. That value must be
-        displayed for the user; that is not dealt with here, but in complete1D.
-        """
-        ER_row = self.getRowFromName("radius_effective")
-        if ER_row is None:
-            return
-
-        ER_mode_row = self.getRowFromName("radius_effective_mode")
-        if ER_mode_row is None:
-            return
-
-        try:
-            ER_mode = int(self._model_model.item(ER_mode_row, 1).text())
-        except ValueError:
-            logging.error("radius_effective_mode was set to an invalid value.")
-            return
-
-        if ER_mode == 0:
-            # ensure the ER value can be modified by user
-            self.setParamEditableByRow(ER_row, True)
-        elif ER_mode > 0:
-            # ensure the ER value cannot be modified by user
-            self.setParamEditableByRow(ER_row, False)
-        else:
-            logging.error("radius_effective_mode was set to an invalid value.")
-
-    def setParamEditableByRow(self, row, editable=True):
-        """
-        Sets whether the user can edit a parameter in the table. If they cannot, the parameter name's font is changed,
-        the value itself cannot be edited if clicked on, and the parameter may not be fitted.
-        """
-        item_name = self._model_model.item(row, 0)
-        item_value = self._model_model.item(row, 1)
-
-        item_value.setEditable(editable)
-
-        if editable:
-            # reset font
-            item_name.setFont(QtGui.QFont())
-            # reset colour
-            item_name.setForeground(QtGui.QBrush())
-            # make checkable
-            item_name.setCheckable(True)
-        else:
-            # change font
-            font = QtGui.QFont()
-            font.setItalic(True)
-            item_name.setFont(font)
-            # change colour
-            item_name.setForeground(QtGui.QBrush(QtGui.QColor(50, 50, 50)))
-            # make not checkable (and uncheck)
-            item_name.setCheckState(QtCore.Qt.Unchecked)
-            item_name.setCheckable(False)
 
     def isCheckable(self, row):
@@ -2351 +2287 @@
             fitted_data.symbol = "Line"
             self.createTheoryIndex(fitted_data)
+            # Switch to the theory tab for user's glee
+            self.communicate.changeDataExplorerTabSignal.emit(1)
 
     def updateModelIndex(self, fitted_data):
@@ -2486 +2424 @@
 
         if self.data_is_loaded:
+            # delete any plots associated with the data that were not updated (e.g. to remove beta(Q), S_eff(Q))
             GuiUtils.deleteRedundantPlots(self.all_data[self.data_index], new_plots)
+            pass
         else:
             # delete theory items for the model, in order to get rid of any redundant items, e.g. beta(Q), S_eff(Q)
@@ -2500 +2440 @@
         for plot in new_plots:
             self.communicate.plotUpdateSignal.emit([plot])
-
-        # Update radius_effective if relevant
-        def updateRadiusEffective():
-            ER_mode_row = self.getRowFromName("radius_effective_mode")
-            if ER_mode_row is None:
-                return
-            try:
-                ER_mode = int(self._model_model.item(ER_mode_row, 1).text())
-            except ValueError:
-                logging.error("radius_effective_mode was set to an invalid value.")
-                return
-            if ER_mode < 1:
-                # does not need updating if it is not being computed
-                return
-
-            ER_row = self.getRowFromName("radius_effective")
-            if ER_row is None:
-                return
-
-            scalar_results = self.logic.getScalarIntermediateResults(return_data)
-            ER_value = scalar_results.get("effective_radius") # note name of key
-            if ER_value is None:
-                return
-            # ensure the model does not recompute when updating the value
-            self._model_model.blockSignals(True)
-            self._model_model.item(ER_row, 1).setText(str(ER_value))
-            self._model_model.blockSignals(False)
-            # ensure the view is updated immediately
-            self._model_model.layoutChanged.emit()
-
-        updateRadiusEffective()
 
     def complete2D(self, return_data):
@@ -3220 +3129 @@
             param_value = str(self._model_model.item(row, 1).text())
             param_error = None
+            param_min = None
+            param_max = None
             column_offset = 0
             if self.has_error_column:
                 param_error = str(self._model_model.item(row, 2).text())
                 column_offset = 1
-            param_min = str(self._model_model.item(row, 2+column_offset).text())
-            param_max = str(self._model_model.item(row, 3+column_offset).text())
+
+            try:
+                param_min = str(self._model_model.item(row, 2+column_offset).text())
+                param_max = str(self._model_model.item(row, 3+column_offset).text())
+            except:
+                pass
+
             param_list.append([param_name, param_checked, param_value, param_error, param_min, param_max])
 
@@ -3315 +3231 @@
 
                 # limits
-                limit_lo = item[3]
-                context[name].append(limit_lo)
-                limit_hi = item[4]
-                context[name].append(limit_hi)
+                try:
+                    limit_lo = item[3]
+                    context[name].append(limit_lo)
+                    limit_hi = item[4]
+                    context[name].append(limit_hi)
+                except:
+                    pass
 
                 # Polydisp
@@ -3377 +3296 @@
                 ioffset = 1
             # min/max
-            param_repr = GuiUtils.formatNumber(param_dict[param_name][2+ioffset], high=True)
-            self._model_model.item(row, 2+ioffset).setText(param_repr)
-            param_repr = GuiUtils.formatNumber(param_dict[param_name][3+ioffset], high=True)
-            self._model_model.item(row, 3+ioffset).setText(param_repr)
+            try:
+                param_repr = GuiUtils.formatNumber(param_dict[param_name][2+ioffset], high=True)
+                self._model_model.item(row, 2+ioffset).setText(param_repr)
+                param_repr = GuiUtils.formatNumber(param_dict[param_name][3+ioffset], high=True)
+                self._model_model.item(row, 3+ioffset).setText(param_repr)
+            except:
+                pass
+
             self.setFocus()
+