Changeset b00414d in sasview

Timestamp:

Jul 25, 2017 5:36:45 AM (7 years ago)

Author:

Piotr Rozyczko <rozyczko@…>

Branches:

ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc

Children:

0d13814

Parents:

2a8bd705

Message:

SASVIEW-272: initial implementation of magnetic model/view

Location:

src/sas/qtgui

Files:

• MainWindow/UI/MainWindowUI.ui (modified) (1 diff)
• Perspectives/Fitting/FittingWidget.py (modified) (14 diffs)
• Perspectives/Fitting/ViewDelegate.py (modified) (1 diff)

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

@@ -324 +324 @@
   <action name="actionCategry_Manager">
    <property name="text">
-    <string>Categry Manager</string>
+    <string>Category Manager</string>
+   </property>
+   <property name="toolTip">
+    <string>Category Manager</string>
    </property>
   </action>

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

@@ -36 +36 @@
 from sas.qtgui.Perspectives.Fitting.ViewDelegate import ModelViewDelegate
 from sas.qtgui.Perspectives.Fitting.ViewDelegate import PolyViewDelegate
+from sas.qtgui.Perspectives.Fitting.ViewDelegate import MagnetismViewDelegate
 
 TAB_MAGNETISM = 4
@@ -166 +167 @@
         # Which shell is being currently displayed?
         self.current_shell_displayed = 0
+
+        # Error column presence in parameter display
         self.has_error_column = False
         self.has_poly_error_column = False
+        self.has_magnet_error_column = False
 
         # signal communicator
@@ -259 +263 @@
         self.setMagneticModel()
         self.setTableProperties(self.lstMagnetic)
+        # Delegates for custom editing and display
+        self.lstMagnetic.setItemDelegate(MagnetismViewDelegate(self))
 
     def initializeCategoryCombo(self):
@@ -369 +375 @@
 
         # Respond to change in parameters from the UI
-        self._model_model.itemChanged.connect(self.updateParamsFromModel)
+        self._model_model.itemChanged.connect(self.onMainParamsChange)
         self._poly_model.itemChanged.connect(self.onPolyModelChange)
-
-        # TODO after the poly_model prototype accepted
-        #self._magnet_model.itemChanged.connect(self.onMagneticModelChange)
+        self._magnet_model.itemChanged.connect(self.onMagnetModelChange)
 
         # Signals from separate tabs asking for replot
@@ -501 +505 @@
                 if parameter_name in self.parameters_to_fit:
                     self.parameters_to_fit.remove(parameter_name)
+            self.cmdFit.setEnabled(self.parameters_to_fit != [] and self.logic.data_is_loaded)
             return
         elif model_column in [self.lstPoly.itemDelegate().poly_min, self.lstPoly.itemDelegate().poly_max]:
@@ -525 +530 @@
             self.kernel_module.setParam(parameter_name + '.' + \
                                         self.lstPoly.itemDelegate().columnDict()[model_column], value)
+
+    def onMagnetModelChange(self, item):
+        """
+        Callback method for updating the sasmodel magnetic parameters with the GUI values
+        """
+        model_column = item.column()
+        model_row = item.row()
+        name_index = self._magnet_model.index(model_row, 0)
+        parameter_name = str(self._magnet_model.data(name_index).toPyObject())
+
+        if model_column == 0:
+            value = item.checkState()
+            if value == QtCore.Qt.Checked:
+                self.parameters_to_fit.append(parameter_name)
+            else:
+                if parameter_name in self.parameters_to_fit:
+                    self.parameters_to_fit.remove(parameter_name)
+            self.cmdFit.setEnabled(self.parameters_to_fit != [] and self.logic.data_is_loaded)
+            # Update state stack
+            self.updateUndo()
+            return
+
+        # Extract changed value.
+        try:
+            value = float(item.text())
+        except ValueError:
+            # Unparsable field
+            return
+
+        property_index = self._magnet_model.headerData(1, model_column).toInt()[0]-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:
+            self.recalculatePlotData()
+
+        # Update state stack
+        self.updateUndo()
 
     def onHelp(self):
@@ -667 +715 @@
         self.updatePolyModelFromList(param_dict)
 
+        self.updateMagnetModelFromList(param_dict)
+
         # update charts
         self.onPlot()
@@ -758 +808 @@
         if not dict:
             return
+
+        def iterateOverPolyModel(func):
+            """
+            Take func and throw it inside the poly model row loop
+            """
+            for row_i in xrange(self._poly_model.rowCount()):
+                func(row_i)
 
         def updateFittedValues(row_i):
@@ -795 +852 @@
         # updating charts with every single model change on the end of fitting
         self._poly_model.blockSignals(True)
-        self.iterateOverModel(updateFittedValues)
+        iterateOverPolyModel(updateFittedValues)
         self._poly_model.blockSignals(False)
 
@@ -803 +860 @@
         self.lstPoly.itemDelegate().addErrorColumn()
         error_column = []
-        self.iterateOverModel(createErrorColumn)
+        iterateOverPolyModel(createErrorColumn)
 
         # switch off reponse to model change
@@ -812 +869 @@
 
         self.has_poly_error_column = True
+
+    def updateMagnetModelFromList(self, param_dict):
+        """
+        Update the magnetic model with new parameters, create the errors column
+        """
+        assert isinstance(param_dict, dict)
+        if not dict:
+            return
+
+        def iterateOverMagnetModel(func):
+            """
+            Take func and throw it inside the magnet model row loop
+            """
+            for row_i in xrange(self._model_model.rowCount()):
+                func(row_i)
+
+        def updateFittedValues(row):
+            # Utility function for main model update
+            # internal so can use closure for param_dict
+            param_name = str(self._magnet_model.item(row, 0).text())
+            if param_name not in param_dict.keys():
+                return
+            # modify the param value
+            param_repr = GuiUtils.formatNumber(param_dict[param_name][0], high=True)
+            self._magnet_model.item(row, 1).setText(param_repr)
+            if self.has_magnet_error_column:
+                error_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
+                self._magnet_model.item(row, 2).setText(error_repr)
+
+        def createErrorColumn(row):
+            # Utility function for error column update
+            item = QtGui.QStandardItem()
+            def createItem(param_name):
+                error_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
+                item.setText(error_repr)
+            def curr_param():
+                return str(self._magnet_model.item(row, 0).text())
+
+            [createItem(param_name) for param_name in param_dict.keys() if curr_param() == param_name]
+
+            error_column.append(item)
+
+        # 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)
+        iterateOverMagnetModel(updateFittedValues)
+        self._magnet_model.blockSignals(False)
+
+        if self.has_magnet_error_column:
+            return
+
+        self.lstMagnetic.itemDelegate().addErrorColumn()
+        error_column = []
+        iterateOverMagnetModel(createErrorColumn)
+
+        # 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)
+
+        self.has_magnet_error_column = True
 
     def onPlot(self):
@@ -1039 +1158 @@
         self._last_model_row = self._model_model.rowCount()
 
-    def updateParamsFromModel(self, item):
+    def onMainParamsChange(self, item):
         """
         Callback method for updating the sasmodel parameters with the GUI values
@@ -1055 +1174 @@
         name_index = self._model_model.index(model_row, 0)
 
-        # Extract changed value. Assumes proper validation by QValidator/Delegate
+        # Extract changed value.
         try:
             value = float(item.text())
@@ -1101 +1220 @@
         main_params = self.checkedListFromModel(self._model_model)
         poly_params = self.checkedListFromModel(self._poly_model)
+        magnet_params = self.checkedListFromModel(self._magnet_model)
+
         # Retrieve poly params names
         poly_params = [param.rsplit()[-1] + '.width' for param in poly_params]
-        # TODO : add magnetic params
-
-        self.parameters_to_fit = main_params + poly_params
+
+        self.parameters_to_fit = main_params + poly_params + magnet_params
 
     def checkedListFromModel(self, model):

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

@@ -178 +178 @@
             # Just the default paint
             QtGui.QStyledItemDelegate.paint(self, painter, option, index)
+
+class MagnetismViewDelegate(QtGui.QStyledItemDelegate):
+    """
+    Custom delegate for appearance and behavior control of the magnetism view
+    """
+    def __init__(self, parent=None):
+        """
+        Overwrite generic constructor to allow for some globals
+        """
+        super(QtGui.QStyledItemDelegate, self).__init__()
+
+        self.mag_parameter = 0
+        self.mag_value = 1
+        self.mag_min = 2
+        self.mag_max = 3
+        self.mag_unit = 4
+
+    def editableParameters(self):
+        return [self.mag_min, self.mag_max]
+
+    def addErrorColumn(self):
+        """
+        Modify local column pointers
+        Note: the reverse is never required!
+        """
+        self.mag_parameter = 0
+        self.mag_value = 1
+        self.mag_min = 3
+        self.mag_max = 4
+        self.mag_unit = 5
+
+    def createEditor(self, widget, option, index):
+        # Remember the current choice
+        current_text = index.data().toString()
+        if not index.isValid():
+            return 0
+        if index.column() in self.editableParameters():
+            editor = QtGui.QLineEdit(widget)
+            validator = QtGui.QDoubleValidator()
+            editor.setValidator(validator)
+            return editor
+        else:
+            QtGui.QStyledItemDelegate.createEditor(self, widget, option, index)
+
+    def paint(self, painter, option, index):
+        """
+        Overwrite generic painter for certain columns
+        """
+        if index.column() in (self.mag_min, self.mag_max):
+            # Units - present in nice HTML
+            options = QtGui.QStyleOptionViewItemV4(option)
+            self.initStyleOption(options,index)
+
+            style = QtGui.QApplication.style() if options.widget is None else options.widget.style()
+
+            # Prepare document for inserting into cell
+            doc = QtGui.QTextDocument()
+
+            # Convert the unit description into HTML
+            text_html = GuiUtils.convertUnitToHTML(str(options.text))
+            doc.setHtml(text_html)
+
+            # delete the original content
+            options.text = ""
+            style.drawControl(QtGui.QStyle.CE_ItemViewItem, options, painter, options.widget);
+
+            context = QtGui.QAbstractTextDocumentLayout.PaintContext()
+            textRect = style.subElementRect(QtGui.QStyle.SE_ItemViewItemText, options)
+
+            painter.save()
+            painter.translate(textRect.topLeft())
+            painter.setClipRect(textRect.translated(-textRect.topLeft()))
+            # Draw the QTextDocument in the cell
+            doc.documentLayout().draw(painter, context)
+            painter.restore()
+        else:
+            # Just the default paint
+            QtGui.QStyledItemDelegate.paint(self, painter, option, index)