Changeset cb39d66 in sasview for src/sas/qtgui/Perspectives/Fitting

Timestamp:

Sep 25, 2018 3:50:43 PM (6 years ago)

Author:

GitHub <noreply@…>

Branches:

ESS_GUI, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc

Children:

49699a3

Parents:

34f13a83 (diff), d99b1a5 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

git-author:

Torin Cooper-Bennun <40573959+tcbennun@…> (09/25/18 15:50:43)

git-committer:

GitHub <noreply@…> (09/25/18 15:50:43)

Message:

Merge pull request #184 from SasView?/ESS_GUI_iss1052

SASVIEW-1052: Let user choose if radius_effective is computed from form factor, or free/fittable

Location:

src/sas/qtgui/Perspectives/Fitting

Files:

• FittingLogic.py (modified) (1 diff)
• FittingWidget.py (modified) (4 diffs)
• FittingPerspective.py (modified) (4 diffs)
• FittingUtilities.py (modified) (2 diffs)
• SmearingWidget.py (modified) (2 diffs)
• UnitTesting/FittingWidgetTest.py (modified) (2 diffs)

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

@@ -223 +223 @@
         return plots
 
+    def getScalarIntermediateResults(self, return_data):
+        """
+        Returns a dict of scalar-only intermediate results from the return data.
+        """
+        res = {}
+        for name, int_res in return_data["intermediate_results"].items():
+            if isinstance(int_res, np.ndarray):
+                continue
+            res[name] = int_res
+        return res
+
     def computeDataRange(self):
         """

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

@@ -2297 +2297 @@
         # 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:
@@ -2303 +2307 @@
         # 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):
@@ -2535 +2599 @@
             self.communicate.plotUpdateSignal.emit([plot])
 
+        # Update radius_effective if relevant
+        self.updateEffectiveRadius(return_data)
+
     def complete2D(self, return_data):
         """
@@ -2561 +2628 @@
         for plot in new_plots:
             self.communicate.plotUpdateSignal.emit([plot])
+
+    def updateEffectiveRadius(self, return_data):
+        """
+        Given return data from sasmodels, update the effective radius parameter in the GUI table with the new
+        calculated value as returned by sasmodels (if the value was returned).
+        """
+        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()
 
     def calculateResiduals(self, fitted_data):

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

@@ -63 +63 @@
         self.fittingStoppedSignal.connect(self.onFittingStopped)
 
+        self.communicate.copyFitParamsSignal.connect(self.onParamCopy)
+        self.communicate.pasteFitParamsSignal.connect(self.onParamPaste)
+
         # Perspective window not allowed to close by default
         self._allow_close = False
@@ -94 +97 @@
 
         self._allow_close = value
+
+    def onParamCopy(self):
+        self.currentTab.onParameterCopy("")
+
+    def onParamPaste(self):
+        self.currentTab.onParameterPaste()
 
     def closeEvent(self, event):
@@ -298 +307 @@
             page_name = "Page%s"%tab_object.tab_id
             if any([page_name in tab for tab in tabs_for_fitting]):
-                tab_object.setFittingStarted()
+                tab_object.disableInteractiveElements()
 
         pass
@@ -315 +324 @@
             page_name = "Page%s"%tab_object.tab_id
             if any([page_name in tab for tab in tabs_for_fitting]):
-                tab_object.setFittingStopped()
+                tab_object.enableInteractiveElements()
 
         pass

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

@@ -484 +484 @@
                     endl = i
                     break
-            # make sure we have correct lengths
-            assert len(x_current) == len(x_reference[begin:end-endl])
 
             y = (fn - gn[begin:end-endl])/en
@@ -549 +547 @@
                       "Data2D": residualsData2D}
 
-    residuals = residuals_dict[method_name](reference_data, data_copy)
+    try:
+        residuals = residuals_dict[method_name](reference_data, data_copy)
+    except ValueError:
+        return None
 
     theory_name = str(current_data.name.split()[0])

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

@@ -61 +61 @@
         self.data = None
         self.current_smearer = None
+        self.kernel_model = None
 
         # Let only floats in the line edits
@@ -110 +111 @@
         if data is None:
             self.setElementsVisibility(False)
-        elif isinstance(data, Data1D):
+
+    def updateKernelModel(self, kernel_model=None):
+        """
+        Update the model
+        """
+        self.kernel_model = kernel_model
+        if self.data is None:
+            self.setElementsVisibility(False)
+            return
+        if self.kernel_model is None:
+            return
+        elif isinstance(self.data, Data1D):
             self.cbSmearing.addItems(SMEARING_1D)
         else:
             self.cbSmearing.addItems(SMEARING_2D)
         self.cbSmearing.setCurrentIndex(0)
-
-    def updateKernelModel(self, kernel_model=None):
-        """
-        Update the model
-        """
-        self.kernel_model = kernel_model
 
     def smearer(self):

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

@@ -393 +393 @@
 
         # Test tooltips
-        self.assertEqual(len(self.widget._poly_model.header_tooltips), 9)
+        self.assertEqual(len(self.widget._poly_model.header_tooltips), 8)
 
         header_tooltips = ['Select parameter for fitting',
@@ -702 +702 @@
         # Force same data into logic
         self.widget.data = item
+
         category_index = self.widget.cbCategory.findText("Sphere")
         self.widget.cbCategory.setCurrentIndex(category_index)
-
-        self.widget.show()
 
         # Test no fitting params