Changeset 04a269f in sasview for src

Timestamp:

Mar 28, 2019 6:54:29 AM (6 years ago)

Author:

ibressler

Branches:

ESS_GUI_bumps_abstraction

Children:

740a738

Parents:

aa47ea5

git-author:

Ingo Breßler <dev@…> (03/28/19 06:51:02)

git-committer:

Ingo Breßler <dev@…> (03/28/19 06:54:29)

Message:

FittingOptions?: using new FittingMethods? structure, updated FittingPerspective?

• tested, should work fine
• reading/writing bumps config now isolated in separate methods, will be handled by subclasses in the next step

Location:

src/sas/qtgui/Perspectives/Fitting

Files:

• FittingOptions.py (modified) (11 diffs)
• FittingPerspective.py (modified) (4 diffs)

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

@@ -20 +20 @@
 # Set the default optimizer
 
+def configToBumps(fittingMethod):
+    """
+    Writes the user settings of given fitting method back to be bumps module where it is used
+    once the 'fit' button is hit in the GUI.
+    """
+#    assert isinstance(fittingMethod, FittingMethod) # FIXME once FittingMethod is known here
+    # self.config.values[self.current_fitter_id][option] = new_value
+    fitConfig = bumps.options.FIT_CONFIG
+    fitConfig.selected_id = fittingMethod.shortName
+    for param in fittingMethod.params.values():
+        fitConfig.values[fittingMethod.shortName][param.shortName] = param.value
+
+def parse_int(value):
+    """
+    Converts user input to integer numbers. (from bumps)
+    """
+    float_value = float(value)
+    if int(float_value) != float_value:
+        raise ValueError("integer expected")
+    return int(float_value)
+
+class ChoiceList(object):
+    """
+    Validates user input for a distinct number of options.
+    """
+    def __init__(self, *choices):
+        self.choices = choices
+    def __call__(self, value):
+        if not value in self.choices:
+            raise ValueError('invalid option "%s": use %s'
+                    % (value, '|'.join(self.choices)))
+        else:
+            return value
+
 class FittingMethodParameter:
+    """
+    Descriptive meta data of a single parameter of an optimizer.
+    """
     _shortName = None
     _longName = None
@@ -122 +159 @@
         return [fm.shortName for fm in self._methods.values()]
 
-    def __getitem__(self, name):
-        return self._methods[name]
+    def __getitem__(self, longName):
+        return self._methods[longName]
 
     @property
@@ -152 +189 @@
     fit_option_changed = QtCore.pyqtSignal(str)
     # storing of fitting methods here for now, dependencies might indicate a better place later
-    fittingMethods = None
+    _fittingMethods = None
+
+    @property
+    def fittingMethods(self):
+        return self._fittingMethods
 
     def __init__(self, parent=None, config=None):
@@ -168 +209 @@
 
         # Fill up the algorithm combo, based on what BUMPS says is available
-        self.fittingMethods = FittingMethods()
+        self._fittingMethods = FittingMethods()
         # option 1: hardcode the list of bumps fitting methods according to forms
         # option 2: create forms dynamically based on selected fitting methods
@@ -202 +243 @@
     def assignValidators(self):
         """
-        Use options.FIT_FIELDS to assert which line edit gets what validator
-        """
-        for option in bumps.options.FIT_FIELDS.keys():
-            (f_name, f_type) = bumps.options.FIT_FIELDS[option]
+        Sets the appropriate validators to the line edits as defined by FittingMethodParameter
+        """
+        fm = self.fittingMethods[str(self.currentOptimizer)]
+        for param in fm.params.values():
             validator = None
-            if type(f_type) == types.FunctionType:
+            if type(param.type) == types.FunctionType:
                 validator = QtGui.QIntValidator()
                 validator.setBottom(0)
-            elif f_type == float:
+            elif param.type == float:
                 validator = GuiUtils.DoubleValidator()
                 validator.setBottom(0)
             else:
                 continue
-            for fitter_id in self.fittingMethods.ids:
-                line_edit = self.widgetFromOption(str(option), current_fitter=str(fitter_id))
-                if hasattr(line_edit, 'setValidator') and validator is not None:
-                    line_edit.setValidator(validator)
-                    line_edit.textChanged.connect(self.check_state)
-                    line_edit.textChanged.emit(line_edit.text())
+            line_edit = self.paramWidget(fm, param.shortName)
+            if hasattr(line_edit, 'setValidator') and validator is not None:
+                line_edit.setValidator(validator)
+                line_edit.textChanged.connect(self.check_state)
+                line_edit.textChanged.emit(line_edit.text())
 
     def check_state(self, *args, **kwargs):
@@ -240 +280 @@
         """
         # Find the algorithm ID from name
-        selectedName = str(self.cbAlgorithm.currentText())
+        selectedName = str(self.currentOptimizer)
         if selectedName in self.fittingMethods.longNames:
             self.current_fitter_id = self.fittingMethods[selectedName].shortName
@@ -268 +308 @@
         self.stackedWidget.setCurrentIndex(index_for_this_id)
 
-        self.updateWidgetFromBumps(self.current_fitter_id)
+        self.updateWidgetFromConfig()
 
         self.assignValidators()
@@ -278 +318 @@
         self.previous_index = index
 
+    def paramWidget(self, fittingMethod, paramShortName):
+        """
+        Returns the widget associated to a FittingMethodParameter.
+        """
+        if paramShortName not in fittingMethod.params:
+            return None
+        widget_name = 'self.'+paramShortName+'_'+fittingMethod.shortName
+        widget = None
+        try:
+            widget = eval(widget_name)
+        except AttributeError:
+            pass
+        return widget
+
     def onApply(self):
         """
         Update the fitter object
         """
-        options = self.config.values[self.current_fitter_id]
-        for option in options.keys():
-            # Find the widget name of the option
-            # e.g. 'samples' for 'dream' is 'self.samples_dream'
-            widget_name = 'self.'+option+'_'+self.current_fitter_id
-            try:
-                line_edit = eval(widget_name)
-            except AttributeError:
-                # Skip bumps monitors
-                continue
+        fm = self.fittingMethods[str(self.currentOptimizer)]
+        for param in fm.params.values():
+            line_edit = self.paramWidget(fm, param.shortName)
             if line_edit is None or not isinstance(line_edit, QtWidgets.QLineEdit):
                 continue
@@ -299 +346 @@
                 tooltip = "<html><b>Please enter valid values in all fields.</html>"
                 QtWidgets.QToolTip.showText(line_edit.mapToGlobal(
-                    QtCore.QPoint(line_edit.rect().right(), line_edit.rect().bottom() + 2)), tooltip)
+                    QtCore.QPoint(line_edit.rect().right(), line_edit.rect().bottom() + 2)),
+                    tooltip)
                 return
 
-        # Notify the perspective, so the window title is updated
-        self.fit_option_changed.emit(self.cbAlgorithm.currentText())
-
-        def bumpsUpdate(option):
-            """
-            Utility method for bumps state update
-            """
-            widget = self.widgetFromOption(option)
+        # update config values from widgets before any notification is sent
+        for param in fm.params.values():
+            widget = self.paramWidget(fm, param.shortName)
             if widget is None:
-                return
+                continue
             try:
                 if isinstance(widget, QtWidgets.QComboBox):
@@ -320 +363 @@
                     except ValueError:
                         new_value = float(widget.text())
-                #new_value = widget.currentText() if isinstance(widget, QtWidgets.QComboBox) \
-                #    else float(widget.text())
-                self.config.values[self.current_fitter_id][option] = new_value
+                fm.params[param.shortName].value = new_value
             except ValueError:
                 # Don't update bumps if widget has bad data
                 self.reject
 
-        # Update the BUMPS singleton
-        [bumpsUpdate(o) for o in self.config.values[self.current_fitter_id].keys()]
+        # Notify the perspective, so the window title is updated
+        self.fit_option_changed.emit(self.cbAlgorithm.currentText())
+        configToBumps(fm) # write the current settings to bumps module
         self.close()
 
@@ -345 +387 @@
         webbrowser.open('file://' + os.path.realpath(help_location))
 
-    def widgetFromOption(self, option_id, current_fitter=None):
-        """
-        returns widget's element linked to the given option_id
-        """
-        if current_fitter is None:
-            current_fitter = self.current_fitter_id
-        if option_id not in list(bumps.options.FIT_FIELDS.keys()): return None
-        option = option_id + '_' + current_fitter
-        if not hasattr(self, option): return None
-        return eval('self.' + option)
-
-    def getResults(self):
+    @property
+    def currentOptimizer(self):
         """
         Sends back the current choice of parameters
         """
-        algorithm = self.cbAlgorithm.currentText()
-        return algorithm
-
-    def updateWidgetFromBumps(self, fitter_id):
+        return self.cbAlgorithm.currentText()
+
+    def updateWidgetFromConfig(self):
         """
         Given the ID of the current optimizer, fetch the values
         and update the widget
         """
-        options = self.config.values[fitter_id]
-        for option in options.keys():
+        fm = self.fittingMethods[str(self.currentOptimizer)]
+        for param in fm.params.values():
             # Find the widget name of the option
             # e.g. 'samples' for 'dream' is 'self.samples_dream'
-            widget_name = 'self.'+option+'_'+fitter_id
-            if option not in bumps.options.FIT_FIELDS:
-                return
-            if isinstance(bumps.options.FIT_FIELDS[option][1], bumps.options.ChoiceList):
+            widget_name = 'self.'+param.shortName+'_'+(fm.shortName)
+            if isinstance(param.type, ChoiceList):
                 control = eval(widget_name)
-                control.setCurrentIndex(control.findText(str(options[option])))
+                control.setCurrentIndex(control.findText(str(param.value)))
             else:
-                eval(widget_name).setText(str(options[option]))
-
-        pass
+                eval(widget_name).setText(str(param.value))
+

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

@@ -39 +39 @@
         self.maxIndex = 1
 
-        # The default optimizer
-        self.optimizer = 'Levenberg-Marquardt'
-
         # Dataset index -> Fitting tab mapping
         self.dataToFitTab = {}
@@ -72 +69 @@
 
         # Fit options - uniform for all tabs
-        self.fit_options = options.FIT_CONFIG
-        self.fit_options_widget = FittingOptions(self, config=self.fit_options)
-        self.fit_options.selected_id = fitters.LevenbergMarquardtFit.id
+        self.fit_options_widget = FittingOptions(self)
+        # The default optimizer
+        self.optimizer = self.fit_options_widget.currentOptimizer
 
         # Listen to GUI Manager signal updating fit options
@@ -95 +92 @@
         Update the window title with the current optimizer name
         """
-        self.optimizer = self.fit_options.selected_name
         self.setWindowTitle('Fit panel - Active Fitting Optimizer: %s' % self.optimizer)
 
@@ -368 +364 @@
         React to the fitting algorithm change by modifying window title
         """
-        fitter = [f.id for f in options.FITTERS if f.name == str(fit_engine)][0]
+        self.optimizer = self.fit_options_widget.currentOptimizer
         # set the optimizer
-        self.fit_options.selected_id = str(fitter)
         # Update the title
         self.updateWindowTitle()