source: sasview/src/sas/qtgui/Perspectives/Fitting/FittingWidget.py @ e20870b

ESS_GUIESS_GUI_Pr_fixesESS_GUI_iss879ESS_GUI_iss959ESS_GUI_project_save
Last change on this file since e20870b was e20870b, checked in by Piotr Rozyczko <rozyczko@…>, 5 months ago

Masking dialog for fitting

  • Property mode set to 100644
File size: 104.4 KB
Line 
1import json
2import os
3import copy
4from collections import defaultdict
5
6import copy
7import logging
8import traceback
9from twisted.internet import threads
10import numpy as np
11import webbrowser
12
13from PyQt5 import QtCore
14from PyQt5 import QtGui
15from PyQt5 import QtWidgets
16
17from sasmodels import product
18from sasmodels import generate
19from sasmodels import modelinfo
20from sasmodels.sasview_model import load_standard_models
21from sasmodels.weights import MODELS as POLYDISPERSITY_MODELS
22
23from sas.sascalc.fit.BumpsFitting import BumpsFit as Fit
24from sas.sascalc.fit.pagestate import PageState
25
26import sas.qtgui.Utilities.GuiUtils as GuiUtils
27import sas.qtgui.Utilities.LocalConfig as LocalConfig
28from sas.qtgui.Utilities.CategoryInstaller import CategoryInstaller
29from sas.qtgui.Plotting.PlotterData import Data1D
30from sas.qtgui.Plotting.PlotterData import Data2D
31
32from sas.qtgui.Perspectives.Fitting.UI.FittingWidgetUI import Ui_FittingWidgetUI
33from sas.qtgui.Perspectives.Fitting.FitThread import FitThread
34from sas.qtgui.Perspectives.Fitting.ConsoleUpdate import ConsoleUpdate
35
36from sas.qtgui.Perspectives.Fitting.ModelThread import Calc1D
37from sas.qtgui.Perspectives.Fitting.ModelThread import Calc2D
38from sas.qtgui.Perspectives.Fitting.FittingLogic import FittingLogic
39from sas.qtgui.Perspectives.Fitting import FittingUtilities
40from sas.qtgui.Perspectives.Fitting import ModelUtilities
41from sas.qtgui.Perspectives.Fitting.SmearingWidget import SmearingWidget
42from sas.qtgui.Perspectives.Fitting.OptionsWidget import OptionsWidget
43from sas.qtgui.Perspectives.Fitting.FitPage import FitPage
44from sas.qtgui.Perspectives.Fitting.ViewDelegate import ModelViewDelegate
45from sas.qtgui.Perspectives.Fitting.ViewDelegate import PolyViewDelegate
46from sas.qtgui.Perspectives.Fitting.ViewDelegate import MagnetismViewDelegate
47from sas.qtgui.Perspectives.Fitting.Constraint import Constraint
48from sas.qtgui.Perspectives.Fitting.MultiConstraint import MultiConstraint
49from sas.qtgui.Perspectives.Fitting.ReportPageLogic import ReportPageLogic
50
51
52
53TAB_MAGNETISM = 4
54TAB_POLY = 3
55CATEGORY_DEFAULT = "Choose category..."
56CATEGORY_STRUCTURE = "Structure Factor"
57CATEGORY_CUSTOM = "Plugin Models"
58STRUCTURE_DEFAULT = "None"
59
60DEFAULT_POLYDISP_FUNCTION = 'gaussian'
61
62
63class ToolTippedItemModel(QtGui.QStandardItemModel):
64    """
65    Subclass from QStandardItemModel to allow displaying tooltips in
66    QTableView model.
67    """
68    def __init__(self, parent=None):
69        QtGui.QStandardItemModel.__init__(self,parent)
70
71    def headerData(self, section, orientation, role=QtCore.Qt.DisplayRole):
72        """
73        Displays tooltip for each column's header
74        :param section:
75        :param orientation:
76        :param role:
77        :return:
78        """
79        if role == QtCore.Qt.ToolTipRole:
80            if orientation == QtCore.Qt.Horizontal:
81                return str(self.header_tooltips[section])
82
83        return QtGui.QStandardItemModel.headerData(self, section, orientation, role)
84
85class FittingWidget(QtWidgets.QWidget, Ui_FittingWidgetUI):
86    """
87    Main widget for selecting form and structure factor models
88    """
89    constraintAddedSignal = QtCore.pyqtSignal(list)
90    newModelSignal = QtCore.pyqtSignal()
91    fittingFinishedSignal = QtCore.pyqtSignal(tuple)
92    batchFittingFinishedSignal = QtCore.pyqtSignal(tuple)
93    Calc1DFinishedSignal = QtCore.pyqtSignal(tuple)
94    Calc2DFinishedSignal = QtCore.pyqtSignal(tuple)
95
96    def __init__(self, parent=None, data=None, tab_id=1):
97
98        super(FittingWidget, self).__init__()
99
100        # Necessary globals
101        self.parent = parent
102
103        # Which tab is this widget displayed in?
104        self.tab_id = tab_id
105
106        # Globals
107        self.initializeGlobals()
108
109        # Set up desired logging level
110        logging.disable(LocalConfig.DISABLE_LOGGING)
111
112        # data index for the batch set
113        self.data_index = 0
114        # Main Data[12]D holders
115        # Logics.data contains a single Data1D/Data2D object
116        self._logic = [FittingLogic()]
117
118        # Main GUI setup up
119        self.setupUi(self)
120        self.setWindowTitle("Fitting")
121
122        # Set up tabs widgets
123        self.initializeWidgets()
124
125        # Set up models and views
126        self.initializeModels()
127
128        # Defaults for the structure factors
129        self.setDefaultStructureCombo()
130
131        # Make structure factor and model CBs disabled
132        self.disableModelCombo()
133        self.disableStructureCombo()
134
135        # Generate the category list for display
136        self.initializeCategoryCombo()
137
138        # Connect signals to controls
139        self.initializeSignals()
140
141        # Initial control state
142        self.initializeControls()
143
144        if data is not None:
145            self.data = data
146
147        # New font to display angstrom symbol
148        new_font = 'font-family: -apple-system, "Helvetica Neue", "Ubuntu";'
149        self.label_17.setStyleSheet(new_font)
150        self.label_19.setStyleSheet(new_font)
151
152    @property
153    def logic(self):
154        # make sure the logic contains at least one element
155        assert(self._logic)
156        # logic connected to the currently shown data
157        return self._logic[self.data_index]
158
159    @property
160    def data(self):
161        return self.logic.data
162
163    @data.setter
164    def data(self, value):
165        """ data setter """
166        # Value is either a list of indices for batch fitting or a simple index
167        # for standard fitting. Assure we have a list, regardless.
168        if isinstance(value, list):
169            self.is_batch_fitting = True
170        else:
171            value = [value]
172
173        assert isinstance(value[0], QtGui.QStandardItem)
174
175        # Keep reference to all datasets for batch
176        self.all_data = value
177
178        # Create logics with data items
179        # Logics.data contains only a single Data1D/Data2D object
180        if len(value) == 1:
181            # single data logic is already defined, update data on it
182            self._logic[0].data = GuiUtils.dataFromItem(value[0])
183        else:
184            # batch datasets
185            for data_item in value:
186                logic = FittingLogic(data=GuiUtils.dataFromItem(data_item))
187                self._logic.append(logic)
188
189        # Overwrite data type descriptor
190        self.is2D = True if isinstance(self.logic.data, Data2D) else False
191
192        # Let others know we're full of data now
193        self.data_is_loaded = True
194
195        # Enable/disable UI components
196        self.setEnablementOnDataLoad()
197
198    def initializeGlobals(self):
199        """
200        Initialize global variables used in this class
201        """
202        # SasModel is loaded
203        self.model_is_loaded = False
204        # Data[12]D passed and set
205        self.data_is_loaded = False
206        # Batch/single fitting
207        self.is_batch_fitting = False
208        self.is_chain_fitting = False
209        # Is the fit job running?
210        self.fit_started=False
211        # The current fit thread
212        self.calc_fit = None
213        # Current SasModel in view
214        self.kernel_module = None
215        # Current SasModel view dimension
216        self.is2D = False
217        # Current SasModel is multishell
218        self.model_has_shells = False
219        # Utility variable to enable unselectable option in category combobox
220        self._previous_category_index = 0
221        # Utility variable for multishell display
222        self._last_model_row = 0
223        # Dictionary of {model name: model class} for the current category
224        self.models = {}
225        # Parameters to fit
226        self.parameters_to_fit = None
227        # Fit options
228        self.q_range_min = 0.005
229        self.q_range_max = 0.1
230        self.npts = 25
231        self.log_points = False
232        self.weighting = 0
233        self.chi2 = None
234        # Does the control support UNDO/REDO
235        # temporarily off
236        self.undo_supported = False
237        self.page_stack = []
238        self.all_data = []
239        # custom plugin models
240        # {model.name:model}
241        self.custom_models = self.customModels()
242        # Polydisp widget table default index for function combobox
243        self.orig_poly_index = 3
244        # copy of current kernel model
245        self.kernel_module_copy = None
246
247        # Page id for fitting
248        # To keep with previous SasView values, use 200 as the start offset
249        self.page_id = 200 + self.tab_id
250
251        # Data for chosen model
252        self.model_data = None
253
254        # Which shell is being currently displayed?
255        self.current_shell_displayed = 0
256        # List of all shell-unique parameters
257        self.shell_names = []
258
259        # Error column presence in parameter display
260        self.has_error_column = False
261        self.has_poly_error_column = False
262        self.has_magnet_error_column = False
263
264        # signal communicator
265        self.communicate = self.parent.communicate
266
267    def initializeWidgets(self):
268        """
269        Initialize widgets for tabs
270        """
271        # Options widget
272        layout = QtWidgets.QGridLayout()
273        self.options_widget = OptionsWidget(self, self.logic)
274        layout.addWidget(self.options_widget)
275        self.tabOptions.setLayout(layout)
276
277        # Smearing widget
278        layout = QtWidgets.QGridLayout()
279        self.smearing_widget = SmearingWidget(self)
280        layout.addWidget(self.smearing_widget)
281        self.tabResolution.setLayout(layout)
282
283        # Define bold font for use in various controls
284        self.boldFont = QtGui.QFont()
285        self.boldFont.setBold(True)
286
287        # Set data label
288        self.label.setFont(self.boldFont)
289        self.label.setText("No data loaded")
290        self.lblFilename.setText("")
291
292        # Magnetic angles explained in one picture
293        self.magneticAnglesWidget = QtWidgets.QWidget()
294        labl = QtWidgets.QLabel(self.magneticAnglesWidget)
295        pixmap = QtGui.QPixmap(GuiUtils.IMAGES_DIRECTORY_LOCATION + '/M_angles_pic.bmp')
296        labl.setPixmap(pixmap)
297        self.magneticAnglesWidget.setFixedSize(pixmap.width(), pixmap.height())
298
299    def initializeModels(self):
300        """
301        Set up models and views
302        """
303        # Set the main models
304        # We can't use a single model here, due to restrictions on flattening
305        # the model tree with subclassed QAbstractProxyModel...
306        self._model_model = ToolTippedItemModel()
307        self._poly_model = ToolTippedItemModel()
308        self._magnet_model = ToolTippedItemModel()
309
310        # Param model displayed in param list
311        self.lstParams.setModel(self._model_model)
312        self.readCategoryInfo()
313
314        self.model_parameters = None
315
316        # Delegates for custom editing and display
317        self.lstParams.setItemDelegate(ModelViewDelegate(self))
318
319        self.lstParams.setAlternatingRowColors(True)
320        stylesheet = """
321
322            QTreeView {
323                paint-alternating-row-colors-for-empty-area:0;
324            }
325
326            QTreeView::item:hover {
327                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #e7effd, stop: 1 #cbdaf1);
328                border: 1px solid #bfcde4;
329            }
330
331            QTreeView::item:selected {
332                border: 1px solid #567dbc;
333            }
334
335            QTreeView::item:selected:active{
336                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #6ea1f1, stop: 1 #567dbc);
337            }
338
339            QTreeView::item:selected:!active {
340                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #6b9be8, stop: 1 #577fbf);
341            }
342           """
343        self.lstParams.setStyleSheet(stylesheet)
344        self.lstParams.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
345        self.lstParams.customContextMenuRequested.connect(self.showModelContextMenu)
346        self.lstParams.setAttribute(QtCore.Qt.WA_MacShowFocusRect, False)
347        # Poly model displayed in poly list
348        self.lstPoly.setModel(self._poly_model)
349        self.setPolyModel()
350        self.setTableProperties(self.lstPoly)
351        # Delegates for custom editing and display
352        self.lstPoly.setItemDelegate(PolyViewDelegate(self))
353        # Polydispersity function combo response
354        self.lstPoly.itemDelegate().combo_updated.connect(self.onPolyComboIndexChange)
355        self.lstPoly.itemDelegate().filename_updated.connect(self.onPolyFilenameChange)
356
357        # Magnetism model displayed in magnetism list
358        self.lstMagnetic.setModel(self._magnet_model)
359        self.setMagneticModel()
360        self.setTableProperties(self.lstMagnetic)
361        # Delegates for custom editing and display
362        self.lstMagnetic.setItemDelegate(MagnetismViewDelegate(self))
363
364    def initializeCategoryCombo(self):
365        """
366        Model category combo setup
367        """
368        category_list = sorted(self.master_category_dict.keys())
369        self.cbCategory.addItem(CATEGORY_DEFAULT)
370        self.cbCategory.addItems(category_list)
371        self.cbCategory.addItem(CATEGORY_STRUCTURE)
372        self.cbCategory.setCurrentIndex(0)
373
374    def setEnablementOnDataLoad(self):
375        """
376        Enable/disable various UI elements based on data loaded
377        """
378        # Tag along functionality
379        self.label.setText("Data loaded from: ")
380        self.lblFilename.setText(self.logic.data.filename)
381        self.updateQRange()
382        # Switch off Data2D control
383        self.chk2DView.setEnabled(False)
384        self.chk2DView.setVisible(False)
385        self.chkMagnetism.setEnabled(self.is2D)
386        self.tabFitting.setTabEnabled(TAB_MAGNETISM, self.chkMagnetism.isChecked())
387        # Combo box or label for file name"
388        if self.is_batch_fitting:
389            self.lblFilename.setVisible(False)
390            for dataitem in self.all_data:
391                filename = GuiUtils.dataFromItem(dataitem).filename
392                self.cbFileNames.addItem(filename)
393            self.cbFileNames.setVisible(True)
394            self.chkChainFit.setEnabled(True)
395            self.chkChainFit.setVisible(True)
396            # This panel is not designed to view individual fits, so disable plotting
397            self.cmdPlot.setVisible(False)
398        # Similarly on other tabs
399        self.options_widget.setEnablementOnDataLoad()
400        self.onSelectModel()
401        # Smearing tab
402        self.smearing_widget.updateData(self.data)
403
404    def acceptsData(self):
405        """ Tells the caller this widget can accept new dataset """
406        return not self.data_is_loaded
407
408    def disableModelCombo(self):
409        """ Disable the combobox """
410        self.cbModel.setEnabled(False)
411        self.lblModel.setEnabled(False)
412
413    def enableModelCombo(self):
414        """ Enable the combobox """
415        self.cbModel.setEnabled(True)
416        self.lblModel.setEnabled(True)
417
418    def disableStructureCombo(self):
419        """ Disable the combobox """
420        self.cbStructureFactor.setEnabled(False)
421        self.lblStructure.setEnabled(False)
422
423    def enableStructureCombo(self):
424        """ Enable the combobox """
425        self.cbStructureFactor.setEnabled(True)
426        self.lblStructure.setEnabled(True)
427
428    def togglePoly(self, isChecked):
429        """ Enable/disable the polydispersity tab """
430        self.tabFitting.setTabEnabled(TAB_POLY, isChecked)
431
432    def toggleMagnetism(self, isChecked):
433        """ Enable/disable the magnetism tab """
434        self.tabFitting.setTabEnabled(TAB_MAGNETISM, isChecked)
435
436    def toggleChainFit(self, isChecked):
437        """ Enable/disable chain fitting """
438        self.is_chain_fitting = isChecked
439
440    def toggle2D(self, isChecked):
441        """ Enable/disable the controls dependent on 1D/2D data instance """
442        self.chkMagnetism.setEnabled(isChecked)
443        self.is2D = isChecked
444        # Reload the current model
445        if self.kernel_module:
446            self.onSelectModel()
447
448    @classmethod
449    def customModels(cls):
450        """ Reads in file names in the custom plugin directory """
451        return ModelUtilities._find_models()
452
453    def initializeControls(self):
454        """
455        Set initial control enablement
456        """
457        self.cbFileNames.setVisible(False)
458        self.cmdFit.setEnabled(False)
459        self.cmdPlot.setEnabled(False)
460        self.options_widget.cmdComputePoints.setVisible(False) # probably redundant
461        self.chkPolydispersity.setEnabled(True)
462        self.chkPolydispersity.setCheckState(False)
463        self.chk2DView.setEnabled(True)
464        self.chk2DView.setCheckState(False)
465        self.chkMagnetism.setEnabled(False)
466        self.chkMagnetism.setCheckState(False)
467        self.chkChainFit.setEnabled(False)
468        self.chkChainFit.setVisible(False)
469        # Tabs
470        self.tabFitting.setTabEnabled(TAB_POLY, False)
471        self.tabFitting.setTabEnabled(TAB_MAGNETISM, False)
472        self.lblChi2Value.setText("---")
473        # Smearing tab
474        self.smearing_widget.updateData(self.data)
475        # Line edits in the option tab
476        self.updateQRange()
477
478    def initializeSignals(self):
479        """
480        Connect GUI element signals
481        """
482        # Comboboxes
483        self.cbStructureFactor.currentIndexChanged.connect(self.onSelectStructureFactor)
484        self.cbCategory.currentIndexChanged.connect(self.onSelectCategory)
485        self.cbModel.currentIndexChanged.connect(self.onSelectModel)
486        self.cbFileNames.currentIndexChanged.connect(self.onSelectBatchFilename)
487        # Checkboxes
488        self.chk2DView.toggled.connect(self.toggle2D)
489        self.chkPolydispersity.toggled.connect(self.togglePoly)
490        self.chkMagnetism.toggled.connect(self.toggleMagnetism)
491        self.chkChainFit.toggled.connect(self.toggleChainFit)
492        # Buttons
493        self.cmdFit.clicked.connect(self.onFit)
494        self.cmdPlot.clicked.connect(self.onPlot)
495        self.cmdHelp.clicked.connect(self.onHelp)
496        self.cmdMagneticDisplay.clicked.connect(self.onDisplayMagneticAngles)
497
498        # Respond to change in parameters from the UI
499        self._model_model.itemChanged.connect(self.onMainParamsChange)
500        #self.constraintAddedSignal.connect(self.modifyViewOnConstraint)
501        self._poly_model.itemChanged.connect(self.onPolyModelChange)
502        self._magnet_model.itemChanged.connect(self.onMagnetModelChange)
503        self.lstParams.selectionModel().selectionChanged.connect(self.onSelectionChanged)
504
505        # Local signals
506        self.batchFittingFinishedSignal.connect(self.batchFitComplete)
507        self.fittingFinishedSignal.connect(self.fitComplete)
508        self.Calc1DFinishedSignal.connect(self.complete1D)
509        self.Calc2DFinishedSignal.connect(self.complete2D)
510
511        # Signals from separate tabs asking for replot
512        self.options_widget.plot_signal.connect(self.onOptionsUpdate)
513        self.options_widget.plot_signal.connect(self.onOptionsUpdate)
514
515        # Signals from other widgets
516        self.communicate.customModelDirectoryChanged.connect(self.onCustomModelChange)
517        self.communicate.saveAnalysisSignal.connect(self.savePageState)
518        self.smearing_widget.smearingChangedSignal.connect(self.onSmearingOptionsUpdate)
519        #self.communicate.saveReportSignal.connect(self.saveReport)
520
521    def modelName(self):
522        """
523        Returns model name, by default M<tab#>, e.g. M1, M2
524        """
525        return "M%i" % self.tab_id
526
527    def nameForFittedData(self, name):
528        """
529        Generate name for the current fit
530        """
531        if self.is2D:
532            name += "2d"
533        name = "%s [%s]" % (self.modelName(), name)
534        return name
535
536    def showModelContextMenu(self, position):
537        """
538        Show context specific menu in the parameter table.
539        When clicked on parameter(s): fitting/constraints options
540        When clicked on white space: model description
541        """
542        rows = [s.row() for s in self.lstParams.selectionModel().selectedRows()]
543        menu = self.showModelDescription() if not rows else self.modelContextMenu(rows)
544        try:
545            menu.exec_(self.lstParams.viewport().mapToGlobal(position))
546        except AttributeError as ex:
547            logging.error("Error generating context menu: %s" % ex)
548        return
549
550    def modelContextMenu(self, rows):
551        """
552        Create context menu for the parameter selection
553        """
554        menu = QtWidgets.QMenu()
555        num_rows = len(rows)
556        if num_rows < 1:
557            return menu
558        # Select for fitting
559        param_string = "parameter " if num_rows==1 else "parameters "
560        to_string = "to its current value" if num_rows==1 else "to their current values"
561        has_constraints = any([self.rowHasConstraint(i) for i in rows])
562
563        self.actionSelect = QtWidgets.QAction(self)
564        self.actionSelect.setObjectName("actionSelect")
565        self.actionSelect.setText(QtCore.QCoreApplication.translate("self", "Select "+param_string+" for fitting"))
566        # Unselect from fitting
567        self.actionDeselect = QtWidgets.QAction(self)
568        self.actionDeselect.setObjectName("actionDeselect")
569        self.actionDeselect.setText(QtCore.QCoreApplication.translate("self", "De-select "+param_string+" from fitting"))
570
571        self.actionConstrain = QtWidgets.QAction(self)
572        self.actionConstrain.setObjectName("actionConstrain")
573        self.actionConstrain.setText(QtCore.QCoreApplication.translate("self", "Constrain "+param_string + to_string))
574
575        self.actionRemoveConstraint = QtWidgets.QAction(self)
576        self.actionRemoveConstraint.setObjectName("actionRemoveConstrain")
577        self.actionRemoveConstraint.setText(QtCore.QCoreApplication.translate("self", "Remove constraint"))
578
579        self.actionMultiConstrain = QtWidgets.QAction(self)
580        self.actionMultiConstrain.setObjectName("actionMultiConstrain")
581        self.actionMultiConstrain.setText(QtCore.QCoreApplication.translate("self", "Constrain selected parameters to their current values"))
582
583        self.actionMutualMultiConstrain = QtWidgets.QAction(self)
584        self.actionMutualMultiConstrain.setObjectName("actionMutualMultiConstrain")
585        self.actionMutualMultiConstrain.setText(QtCore.QCoreApplication.translate("self", "Mutual constrain of selected parameters..."))
586
587        menu.addAction(self.actionSelect)
588        menu.addAction(self.actionDeselect)
589        menu.addSeparator()
590
591        if has_constraints:
592            menu.addAction(self.actionRemoveConstraint)
593            #if num_rows == 1:
594            #    menu.addAction(self.actionEditConstraint)
595        else:
596            menu.addAction(self.actionConstrain)
597            if num_rows == 2:
598                menu.addAction(self.actionMutualMultiConstrain)
599
600        # Define the callbacks
601        self.actionConstrain.triggered.connect(self.addSimpleConstraint)
602        self.actionRemoveConstraint.triggered.connect(self.deleteConstraint)
603        self.actionMutualMultiConstrain.triggered.connect(self.showMultiConstraint)
604        self.actionSelect.triggered.connect(self.selectParameters)
605        self.actionDeselect.triggered.connect(self.deselectParameters)
606        return menu
607
608    def showMultiConstraint(self):
609        """
610        Show the constraint widget and receive the expression
611        """
612        selected_rows = self.lstParams.selectionModel().selectedRows()
613        # There have to be only two rows selected. The caller takes care of that
614        # but let's check the correctness.
615        assert(len(selected_rows)==2)
616
617        params_list = [s.data() for s in selected_rows]
618        # Create and display the widget for param1 and param2
619        mc_widget = MultiConstraint(self, params=params_list)
620        if mc_widget.exec_() != QtWidgets.QDialog.Accepted:
621            return
622
623        constraint = Constraint()
624        c_text = mc_widget.txtConstraint.text()
625
626        # widget.params[0] is the parameter we're constraining
627        constraint.param = mc_widget.params[0]
628        # parameter should have the model name preamble
629        model_name = self.kernel_module.name
630        # param_used is the parameter we're using in constraining function
631        param_used = mc_widget.params[1]
632        # Replace param_used with model_name.param_used
633        updated_param_used = model_name + "." + param_used
634        new_func = c_text.replace(param_used, updated_param_used)
635        constraint.func = new_func
636        # Which row is the constrained parameter in?
637        row = self.getRowFromName(constraint.param)
638
639        # Create a new item and add the Constraint object as a child
640        self.addConstraintToRow(constraint=constraint, row=row)
641
642    def getRowFromName(self, name):
643        """
644        Given parameter name get the row number in self._model_model
645        """
646        for row in range(self._model_model.rowCount()):
647            row_name = self._model_model.item(row).text()
648            if row_name == name:
649                return row
650        return None
651
652    def getParamNames(self):
653        """
654        Return list of all parameters for the current model
655        """
656        return [self._model_model.item(row).text() for row in range(self._model_model.rowCount())]
657
658    def modifyViewOnRow(self, row, font=None, brush=None):
659        """
660        Chage how the given row of the main model is shown
661        """
662        fields_enabled = False
663        if font is None:
664            font = QtGui.QFont()
665            fields_enabled = True
666        if brush is None:
667            brush = QtGui.QBrush()
668            fields_enabled = True
669        self._model_model.blockSignals(True)
670        # Modify font and foreground of affected rows
671        for column in range(0, self._model_model.columnCount()):
672            self._model_model.item(row, column).setForeground(brush)
673            self._model_model.item(row, column).setFont(font)
674            self._model_model.item(row, column).setEditable(fields_enabled)
675        self._model_model.blockSignals(False)
676
677    def addConstraintToRow(self, constraint=None, row=0):
678        """
679        Adds the constraint object to requested row
680        """
681        # Create a new item and add the Constraint object as a child
682        assert(isinstance(constraint, Constraint))
683        assert(0<=row<=self._model_model.rowCount())
684
685        item = QtGui.QStandardItem()
686        item.setData(constraint)
687        self._model_model.item(row, 1).setChild(0, item)
688        # Set min/max to the value constrained
689        self.constraintAddedSignal.emit([row])
690        # Show visual hints for the constraint
691        font = QtGui.QFont()
692        font.setItalic(True)
693        brush = QtGui.QBrush(QtGui.QColor('blue'))
694        self.modifyViewOnRow(row, font=font, brush=brush)
695        self.communicate.statusBarUpdateSignal.emit('Constraint added')
696
697    def addSimpleConstraint(self):
698        """
699        Adds a constraint on a single parameter.
700        """
701        min_col = self.lstParams.itemDelegate().param_min
702        max_col = self.lstParams.itemDelegate().param_max
703        for row in self.selectedParameters():
704            param = self._model_model.item(row, 0).text()
705            value = self._model_model.item(row, 1).text()
706            min_t = self._model_model.item(row, min_col).text()
707            max_t = self._model_model.item(row, max_col).text()
708            # Create a Constraint object
709            constraint = Constraint(param=param, value=value, min=min_t, max=max_t)
710            # Create a new item and add the Constraint object as a child
711            item = QtGui.QStandardItem()
712            item.setData(constraint)
713            self._model_model.item(row, 1).setChild(0, item)
714            # Assumed correctness from the validator
715            value = float(value)
716            # BUMPS calculates log(max-min) without any checks, so let's assign minor range
717            min_v = value - (value/10000.0)
718            max_v = value + (value/10000.0)
719            # Set min/max to the value constrained
720            self._model_model.item(row, min_col).setText(str(min_v))
721            self._model_model.item(row, max_col).setText(str(max_v))
722            self.constraintAddedSignal.emit([row])
723            # Show visual hints for the constraint
724            font = QtGui.QFont()
725            font.setItalic(True)
726            brush = QtGui.QBrush(QtGui.QColor('blue'))
727            self.modifyViewOnRow(row, font=font, brush=brush)
728        self.communicate.statusBarUpdateSignal.emit('Constraint added')
729
730    def deleteConstraint(self):
731        """
732        Delete constraints from selected parameters.
733        """
734        params =  [s.data() for s in self.lstParams.selectionModel().selectedRows()
735                   if self.isCheckable(s.row())]
736        for param in params:
737            self.deleteConstraintOnParameter(param=param)
738
739    def deleteConstraintOnParameter(self, param=None):
740        """
741        Delete the constraint on model parameter 'param'
742        """
743        min_col = self.lstParams.itemDelegate().param_min
744        max_col = self.lstParams.itemDelegate().param_max
745        for row in range(self._model_model.rowCount()):
746            if not self.rowHasConstraint(row):
747                continue
748            # Get the Constraint object from of the model item
749            item = self._model_model.item(row, 1)
750            constraint = self.getConstraintForRow(row)
751            if constraint is None:
752                continue
753            if not isinstance(constraint, Constraint):
754                continue
755            if param and constraint.param != param:
756                continue
757            # Now we got the right row. Delete the constraint and clean up
758            # Retrieve old values and put them on the model
759            if constraint.min is not None:
760                self._model_model.item(row, min_col).setText(constraint.min)
761            if constraint.max is not None:
762                self._model_model.item(row, max_col).setText(constraint.max)
763            # Remove constraint item
764            item.removeRow(0)
765            self.constraintAddedSignal.emit([row])
766            self.modifyViewOnRow(row)
767
768        self.communicate.statusBarUpdateSignal.emit('Constraint removed')
769
770    def getConstraintForRow(self, row):
771        """
772        For the given row, return its constraint, if any
773        """
774        try:
775            item = self._model_model.item(row, 1)
776            return item.child(0).data()
777        except AttributeError:
778            # return none when no constraints
779            return None
780
781    def rowHasConstraint(self, row):
782        """
783        Finds out if row of the main model has a constraint child
784        """
785        item = self._model_model.item(row,1)
786        if item.hasChildren():
787            c = item.child(0).data()
788            if isinstance(c, Constraint):
789                return True
790        return False
791
792    def rowHasActiveConstraint(self, row):
793        """
794        Finds out if row of the main model has an active constraint child
795        """
796        item = self._model_model.item(row,1)
797        if item.hasChildren():
798            c = item.child(0).data()
799            if isinstance(c, Constraint) and c.active:
800                return True
801        return False
802
803    def rowHasActiveComplexConstraint(self, row):
804        """
805        Finds out if row of the main model has an active, nontrivial constraint child
806        """
807        item = self._model_model.item(row,1)
808        if item.hasChildren():
809            c = item.child(0).data()
810            if isinstance(c, Constraint) and c.func and c.active:
811                return True
812        return False
813
814    def selectParameters(self):
815        """
816        Selected parameter is chosen for fitting
817        """
818        status = QtCore.Qt.Checked
819        self.setParameterSelection(status)
820
821    def deselectParameters(self):
822        """
823        Selected parameters are removed for fitting
824        """
825        status = QtCore.Qt.Unchecked
826        self.setParameterSelection(status)
827
828    def selectedParameters(self):
829        """ Returns list of selected (highlighted) parameters """
830        return [s.row() for s in self.lstParams.selectionModel().selectedRows()
831                if self.isCheckable(s.row())]
832
833    def setParameterSelection(self, status=QtCore.Qt.Unchecked):
834        """
835        Selected parameters are chosen for fitting
836        """
837        # Convert to proper indices and set requested enablement
838        for row in self.selectedParameters():
839            self._model_model.item(row, 0).setCheckState(status)
840
841    def getConstraintsForModel(self):
842        """
843        Return a list of tuples. Each tuple contains constraints mapped as
844        ('constrained parameter', 'function to constrain')
845        e.g. [('sld','5*sld_solvent')]
846        """
847        param_number = self._model_model.rowCount()
848        params = [(self._model_model.item(s, 0).text(),
849                    self._model_model.item(s, 1).child(0).data().func)
850                    for s in range(param_number) if self.rowHasActiveConstraint(s)]
851        return params
852
853    def getComplexConstraintsForModel(self):
854        """
855        Return a list of tuples. Each tuple contains constraints mapped as
856        ('constrained parameter', 'function to constrain')
857        e.g. [('sld','5*M2.sld_solvent')].
858        Only for constraints with defined VALUE
859        """
860        param_number = self._model_model.rowCount()
861        params = [(self._model_model.item(s, 0).text(),
862                    self._model_model.item(s, 1).child(0).data().func)
863                    for s in range(param_number) if self.rowHasActiveComplexConstraint(s)]
864        return params
865
866    def getConstraintObjectsForModel(self):
867        """
868        Returns Constraint objects present on the whole model
869        """
870        param_number = self._model_model.rowCount()
871        constraints = [self._model_model.item(s, 1).child(0).data()
872                       for s in range(param_number) if self.rowHasConstraint(s)]
873
874        return constraints
875
876    def getConstraintsForFitting(self):
877        """
878        Return a list of constraints in format ready for use in fiting
879        """
880        # Get constraints
881        constraints = self.getComplexConstraintsForModel()
882        # See if there are any constraints across models
883        multi_constraints = [cons for cons in constraints if self.isConstraintMultimodel(cons[1])]
884
885        if multi_constraints:
886            # Let users choose what to do
887            msg = "The current fit contains constraints relying on other fit pages.\n"
888            msg += "Parameters with those constraints are:\n" +\
889                '\n'.join([cons[0] for cons in multi_constraints])
890            msg += "\n\nWould you like to remove these constraints or cancel fitting?"
891            msgbox = QtWidgets.QMessageBox(self)
892            msgbox.setIcon(QtWidgets.QMessageBox.Warning)
893            msgbox.setText(msg)
894            msgbox.setWindowTitle("Existing Constraints")
895            # custom buttons
896            button_remove = QtWidgets.QPushButton("Remove")
897            msgbox.addButton(button_remove, QtWidgets.QMessageBox.YesRole)
898            button_cancel = QtWidgets.QPushButton("Cancel")
899            msgbox.addButton(button_cancel, QtWidgets.QMessageBox.RejectRole)
900            retval = msgbox.exec_()
901            if retval == QtWidgets.QMessageBox.RejectRole:
902                # cancel fit
903                raise ValueError("Fitting cancelled")
904            else:
905                # remove constraint
906                for cons in multi_constraints:
907                    self.deleteConstraintOnParameter(param=cons[0])
908                # re-read the constraints
909                constraints = self.getComplexConstraintsForModel()
910
911        return constraints
912
913    def showModelDescription(self):
914        """
915        Creates a window with model description, when right clicked in the treeview
916        """
917        msg = 'Model description:\n'
918        if self.kernel_module is not None:
919            if str(self.kernel_module.description).rstrip().lstrip() == '':
920                msg += "Sorry, no information is available for this model."
921            else:
922                msg += self.kernel_module.description + '\n'
923        else:
924            msg += "You must select a model to get information on this"
925
926        menu = QtWidgets.QMenu()
927        label = QtWidgets.QLabel(msg)
928        action = QtWidgets.QWidgetAction(self)
929        action.setDefaultWidget(label)
930        menu.addAction(action)
931        return menu
932
933    def onSelectModel(self):
934        """
935        Respond to select Model from list event
936        """
937        model = self.cbModel.currentText()
938
939        # empty combobox forced to be read
940        if not model:
941            return
942        # Reset structure factor
943        self.cbStructureFactor.setCurrentIndex(0)
944
945        # Reset parameters to fit
946        self.parameters_to_fit = None
947        self.has_error_column = False
948        self.has_poly_error_column = False
949
950        self.respondToModelStructure(model=model, structure_factor=None)
951
952    def onSelectBatchFilename(self, data_index):
953        """
954        Update the logic based on the selected file in batch fitting
955        """
956        self.data_index = data_index
957        self.updateQRange()
958
959    def onSelectStructureFactor(self):
960        """
961        Select Structure Factor from list
962        """
963        model = str(self.cbModel.currentText())
964        category = str(self.cbCategory.currentText())
965        structure = str(self.cbStructureFactor.currentText())
966        if category == CATEGORY_STRUCTURE:
967            model = None
968        self.respondToModelStructure(model=model, structure_factor=structure)
969
970    def onCustomModelChange(self):
971        """
972        Reload the custom model combobox
973        """
974        self.custom_models = self.customModels()
975        self.readCustomCategoryInfo()
976        # See if we need to update the combo in-place
977        if self.cbCategory.currentText() != CATEGORY_CUSTOM: return
978
979        current_text = self.cbModel.currentText()
980        self.cbModel.blockSignals(True)
981        self.cbModel.clear()
982        self.cbModel.blockSignals(False)
983        self.enableModelCombo()
984        self.disableStructureCombo()
985        # Retrieve the list of models
986        model_list = self.master_category_dict[CATEGORY_CUSTOM]
987        # Populate the models combobox
988        self.cbModel.addItems(sorted([model for (model, _) in model_list]))
989        new_index = self.cbModel.findText(current_text)
990        if new_index != -1:
991            self.cbModel.setCurrentIndex(self.cbModel.findText(current_text))
992
993    def onSelectionChanged(self):
994        """
995        React to parameter selection
996        """
997        rows = self.lstParams.selectionModel().selectedRows()
998        # Clean previous messages
999        self.communicate.statusBarUpdateSignal.emit("")
1000        if len(rows) == 1:
1001            # Show constraint, if present
1002            row = rows[0].row()
1003            if self.rowHasConstraint(row):
1004                func = self.getConstraintForRow(row).func
1005                if func is not None:
1006                    self.communicate.statusBarUpdateSignal.emit("Active constrain: "+func)
1007
1008    def replaceConstraintName(self, old_name, new_name=""):
1009        """
1010        Replace names of models in defined constraints
1011        """
1012        param_number = self._model_model.rowCount()
1013        # loop over parameters
1014        for row in range(param_number):
1015            if self.rowHasConstraint(row):
1016                func = self._model_model.item(row, 1).child(0).data().func
1017                if old_name in func:
1018                    new_func = func.replace(old_name, new_name)
1019                    self._model_model.item(row, 1).child(0).data().func = new_func
1020
1021    def isConstraintMultimodel(self, constraint):
1022        """
1023        Check if the constraint function text contains current model name
1024        """
1025        current_model_name = self.kernel_module.name
1026        if current_model_name in constraint:
1027            return False
1028        else:
1029            return True
1030
1031    def updateData(self):
1032        """
1033        Helper function for recalculation of data used in plotting
1034        """
1035        # Update the chart
1036        if self.data_is_loaded:
1037            self.cmdPlot.setText("Show Plot")
1038            self.calculateQGridForModel()
1039        else:
1040            self.cmdPlot.setText("Calculate")
1041            # Create default datasets if no data passed
1042            self.createDefaultDataset()
1043
1044    def respondToModelStructure(self, model=None, structure_factor=None):
1045        # Set enablement on calculate/plot
1046        self.cmdPlot.setEnabled(True)
1047
1048        # kernel parameters -> model_model
1049        self.SASModelToQModel(model, structure_factor)
1050
1051        # Update plot
1052        self.updateData()
1053
1054        # Update state stack
1055        self.updateUndo()
1056
1057        # Let others know
1058        self.newModelSignal.emit()
1059
1060    def onSelectCategory(self):
1061        """
1062        Select Category from list
1063        """
1064        category = self.cbCategory.currentText()
1065        # Check if the user chose "Choose category entry"
1066        if category == CATEGORY_DEFAULT:
1067            # if the previous category was not the default, keep it.
1068            # Otherwise, just return
1069            if self._previous_category_index != 0:
1070                # We need to block signals, or else state changes on perceived unchanged conditions
1071                self.cbCategory.blockSignals(True)
1072                self.cbCategory.setCurrentIndex(self._previous_category_index)
1073                self.cbCategory.blockSignals(False)
1074            return
1075
1076        if category == CATEGORY_STRUCTURE:
1077            self.disableModelCombo()
1078            self.enableStructureCombo()
1079            self._model_model.clear()
1080            return
1081
1082        # Safely clear and enable the model combo
1083        self.cbModel.blockSignals(True)
1084        self.cbModel.clear()
1085        self.cbModel.blockSignals(False)
1086        self.enableModelCombo()
1087        self.disableStructureCombo()
1088
1089        self._previous_category_index = self.cbCategory.currentIndex()
1090        # Retrieve the list of models
1091        model_list = self.master_category_dict[category]
1092        # Populate the models combobox
1093        self.cbModel.addItems(sorted([model for (model, _) in model_list]))
1094
1095    def onPolyModelChange(self, item):
1096        """
1097        Callback method for updating the main model and sasmodel
1098        parameters with the GUI values in the polydispersity view
1099        """
1100        model_column = item.column()
1101        model_row = item.row()
1102        name_index = self._poly_model.index(model_row, 0)
1103        parameter_name = str(name_index.data()).lower() # "distribution of sld" etc.
1104        if "distribution of" in parameter_name:
1105            # just the last word
1106            parameter_name = parameter_name.rsplit()[-1]
1107
1108        # Extract changed value.
1109        if model_column == self.lstPoly.itemDelegate().poly_parameter:
1110            # Is the parameter checked for fitting?
1111            value = item.checkState()
1112            parameter_name = parameter_name + '.width'
1113            if value == QtCore.Qt.Checked:
1114                self.parameters_to_fit.append(parameter_name)
1115            else:
1116                if parameter_name in self.parameters_to_fit:
1117                    self.parameters_to_fit.remove(parameter_name)
1118            self.cmdFit.setEnabled(self.parameters_to_fit != [] and self.logic.data_is_loaded)
1119            return
1120        elif model_column in [self.lstPoly.itemDelegate().poly_min, self.lstPoly.itemDelegate().poly_max]:
1121            try:
1122                value = GuiUtils.toDouble(item.text())
1123            except TypeError:
1124                # Can't be converted properly, bring back the old value and exit
1125                return
1126
1127            current_details = self.kernel_module.details[parameter_name]
1128            current_details[model_column-1] = value
1129        elif model_column == self.lstPoly.itemDelegate().poly_function:
1130            # name of the function - just pass
1131            return
1132        else:
1133            try:
1134                value = GuiUtils.toDouble(item.text())
1135            except TypeError:
1136                # Can't be converted properly, bring back the old value and exit
1137                return
1138
1139            # Update the sasmodel
1140            # PD[ratio] -> width, npts -> npts, nsigs -> nsigmas
1141            self.kernel_module.setParam(parameter_name + '.' + \
1142                                        self.lstPoly.itemDelegate().columnDict()[model_column], value)
1143
1144            # Update plot
1145            self.updateData()
1146
1147    def onMagnetModelChange(self, item):
1148        """
1149        Callback method for updating the sasmodel magnetic parameters with the GUI values
1150        """
1151        model_column = item.column()
1152        model_row = item.row()
1153        name_index = self._magnet_model.index(model_row, 0)
1154        parameter_name = str(self._magnet_model.data(name_index))
1155
1156        if model_column == 0:
1157            value = item.checkState()
1158            if value == QtCore.Qt.Checked:
1159                self.parameters_to_fit.append(parameter_name)
1160            else:
1161                if parameter_name in self.parameters_to_fit:
1162                    self.parameters_to_fit.remove(parameter_name)
1163            self.cmdFit.setEnabled(self.parameters_to_fit != [] and self.logic.data_is_loaded)
1164            # Update state stack
1165            self.updateUndo()
1166            return
1167
1168        # Extract changed value.
1169        try:
1170            value = GuiUtils.toDouble(item.text())
1171        except TypeError:
1172            # Unparsable field
1173            return
1174
1175        property_index = self._magnet_model.headerData(1, model_column)-1 # Value, min, max, etc.
1176
1177        # Update the parameter value - note: this supports +/-inf as well
1178        self.kernel_module.params[parameter_name] = value
1179
1180        # min/max to be changed in self.kernel_module.details[parameter_name] = ['Ang', 0.0, inf]
1181        self.kernel_module.details[parameter_name][property_index] = value
1182
1183        # Force the chart update when actual parameters changed
1184        if model_column == 1:
1185            self.recalculatePlotData()
1186
1187        # Update state stack
1188        self.updateUndo()
1189
1190    def onHelp(self):
1191        """
1192        Show the "Fitting" section of help
1193        """
1194        tree_location = "/user/qtgui/Perspectives/Fitting/"
1195
1196        # Actual file will depend on the current tab
1197        tab_id = self.tabFitting.currentIndex()
1198        helpfile = "fitting.html"
1199        if tab_id == 0:
1200            helpfile = "fitting_help.html"
1201        elif tab_id == 1:
1202            helpfile = "residuals_help.html"
1203        elif tab_id == 2:
1204            helpfile = "resolution.html"
1205        elif tab_id == 3:
1206            helpfile = "pd/polydispersity.html"
1207        elif tab_id == 4:
1208            helpfile = "magnetism/magnetism.html"
1209        help_location = tree_location + helpfile
1210
1211        self.showHelp(help_location)
1212
1213    def showHelp(self, url):
1214        """
1215        Calls parent's method for opening an HTML page
1216        """
1217        self.parent.showHelp(url)
1218
1219    def onDisplayMagneticAngles(self):
1220        """
1221        Display a simple image showing direction of magnetic angles
1222        """
1223        self.magneticAnglesWidget.show()
1224
1225    def onFit(self):
1226        """
1227        Perform fitting on the current data
1228        """
1229        if self.fit_started:
1230            self.stopFit()
1231            return
1232
1233        # initialize fitter constants
1234        fit_id = 0
1235        handler = None
1236        batch_inputs = {}
1237        batch_outputs = {}
1238        #---------------------------------
1239        if LocalConfig.USING_TWISTED:
1240            handler = None
1241            updater = None
1242        else:
1243            handler = ConsoleUpdate(parent=self.parent,
1244                                    manager=self,
1245                                    improvement_delta=0.1)
1246            updater = handler.update_fit
1247
1248        # Prepare the fitter object
1249        try:
1250            fitters, _ = self.prepareFitters()
1251        except ValueError as ex:
1252            # This should not happen! GUI explicitly forbids this situation
1253            self.communicate.statusBarUpdateSignal.emit(str(ex))
1254            return
1255
1256        # keep local copy of kernel parameters, as they will change during the update
1257        self.kernel_module_copy = copy.deepcopy(self.kernel_module)
1258
1259        # Create the fitting thread, based on the fitter
1260        completefn = self.batchFittingCompleted if self.is_batch_fitting else self.fittingCompleted
1261
1262        self.calc_fit = FitThread(handler=handler,
1263                            fn=fitters,
1264                            batch_inputs=batch_inputs,
1265                            batch_outputs=batch_outputs,
1266                            page_id=[[self.page_id]],
1267                            updatefn=updater,
1268                            completefn=completefn,
1269                            reset_flag=self.is_chain_fitting)
1270
1271        if LocalConfig.USING_TWISTED:
1272            # start the trhrhread with twisted
1273            calc_thread = threads.deferToThread(self.calc_fit.compute)
1274            calc_thread.addCallback(completefn)
1275            calc_thread.addErrback(self.fitFailed)
1276        else:
1277            # Use the old python threads + Queue
1278            self.calc_fit.queue()
1279            self.calc_fit.ready(2.5)
1280
1281        self.communicate.statusBarUpdateSignal.emit('Fitting started...')
1282        self.fit_started = True
1283        # Disable some elements
1284        self.setFittingStarted()
1285
1286    def stopFit(self):
1287        """
1288        Attempt to stop the fitting thread
1289        """
1290        if self.calc_fit is None or not self.calc_fit.isrunning():
1291            return
1292        self.calc_fit.stop()
1293        #self.fit_started=False
1294        #re-enable the Fit button
1295        self.setFittingStopped()
1296
1297        msg = "Fitting cancelled."
1298        self.communicate.statusBarUpdateSignal.emit(msg)
1299
1300    def updateFit(self):
1301        """
1302        """
1303        print("UPDATE FIT")
1304        pass
1305
1306    def fitFailed(self, reason):
1307        """
1308        """
1309        self.setFittingStopped()
1310        msg = "Fitting failed with: "+ str(reason)
1311        self.communicate.statusBarUpdateSignal.emit(msg)
1312
1313    def batchFittingCompleted(self, result):
1314        """
1315        Send the finish message from calculate threads to main thread
1316        """
1317        self.batchFittingFinishedSignal.emit(result)
1318
1319    def batchFitComplete(self, result):
1320        """
1321        Receive and display batch fitting results
1322        """
1323        #re-enable the Fit button
1324        self.setFittingStopped()
1325
1326        if result is None:
1327            msg = "Fitting failed."
1328            self.communicate.statusBarUpdateSignal.emit(msg)
1329            return
1330
1331        # Show the grid panel
1332        self.communicate.sendDataToGridSignal.emit(result[0])
1333
1334        elapsed = result[1]
1335        msg = "Fitting completed successfully in: %s s.\n" % GuiUtils.formatNumber(elapsed)
1336        self.communicate.statusBarUpdateSignal.emit(msg)
1337
1338        # Run over the list of results and update the items
1339        for res_index, res_list in enumerate(result[0]):
1340            # results
1341            res = res_list[0]
1342            param_dict = self.paramDictFromResults(res)
1343
1344            # create local kernel_module
1345            kernel_module = FittingUtilities.updateKernelWithResults(self.kernel_module, param_dict)
1346            # pull out current data
1347            data = self._logic[res_index].data
1348
1349            # Switch indexes
1350            self.onSelectBatchFilename(res_index)
1351
1352            method = self.complete1D if isinstance(self.data, Data1D) else self.complete2D
1353            self.calculateQGridForModelExt(data=data, model=kernel_module, completefn=method, use_threads=False)
1354
1355        # Restore original kernel_module, so subsequent fits on the same model don't pick up the new params
1356        if self.kernel_module is not None:
1357            self.kernel_module = copy.deepcopy(self.kernel_module_copy)
1358
1359    def paramDictFromResults(self, results):
1360        """
1361        Given the fit results structure, pull out optimized parameters and return them as nicely
1362        formatted dict
1363        """
1364        if results.fitness is None or \
1365            not np.isfinite(results.fitness) or \
1366            np.any(results.pvec is None) or \
1367            not np.all(np.isfinite(results.pvec)):
1368            msg = "Fitting did not converge!"
1369            self.communicate.statusBarUpdateSignal.emit(msg)
1370            msg += results.mesg
1371            logging.error(msg)
1372            return
1373
1374        param_list = results.param_list # ['radius', 'radius.width']
1375        param_values = results.pvec     # array([ 0.36221662,  0.0146783 ])
1376        param_stderr = results.stderr   # array([ 1.71293015,  1.71294233])
1377        params_and_errors = list(zip(param_values, param_stderr))
1378        param_dict = dict(zip(param_list, params_and_errors))
1379
1380        return param_dict
1381
1382    def fittingCompleted(self, result):
1383        """
1384        Send the finish message from calculate threads to main thread
1385        """
1386        self.fittingFinishedSignal.emit(result)
1387
1388    def fitComplete(self, result):
1389        """
1390        Receive and display fitting results
1391        "result" is a tuple of actual result list and the fit time in seconds
1392        """
1393        #re-enable the Fit button
1394        self.setFittingStopped()
1395
1396        if result is None:
1397            msg = "Fitting failed."
1398            self.communicate.statusBarUpdateSignal.emit(msg)
1399            return
1400
1401        res_list = result[0][0]
1402        res = res_list[0]
1403        self.chi2 = res.fitness
1404        param_dict = self.paramDictFromResults(res)
1405
1406        elapsed = result[1]
1407        if self.calc_fit._interrupting:
1408            msg = "Fitting cancelled by user after: %s s." % GuiUtils.formatNumber(elapsed)
1409            logging.warning("\n"+msg+"\n")
1410        else:
1411            msg = "Fitting completed successfully in: %s s." % GuiUtils.formatNumber(elapsed)
1412        self.communicate.statusBarUpdateSignal.emit(msg)
1413
1414        # Dictionary of fitted parameter: value, error
1415        # e.g. param_dic = {"sld":(1.703, 0.0034), "length":(33.455, -0.0983)}
1416        self.updateModelFromList(param_dict)
1417
1418        self.updatePolyModelFromList(param_dict)
1419
1420        self.updateMagnetModelFromList(param_dict)
1421
1422        # update charts
1423        self.onPlot()
1424
1425        # Read only value - we can get away by just printing it here
1426        chi2_repr = GuiUtils.formatNumber(self.chi2, high=True)
1427        self.lblChi2Value.setText(chi2_repr)
1428
1429    def prepareFitters(self, fitter=None, fit_id=0):
1430        """
1431        Prepare the Fitter object for use in fitting
1432        """
1433        # fitter = None -> single/batch fitting
1434        # fitter = Fit() -> simultaneous fitting
1435
1436        # Data going in
1437        data = self.logic.data
1438        model = self.kernel_module
1439        qmin = self.q_range_min
1440        qmax = self.q_range_max
1441        params_to_fit = self.parameters_to_fit
1442        if (not params_to_fit):
1443            raise ValueError('Fitting requires at least one parameter to optimize.')
1444
1445        # Potential smearing added
1446        # Remember that smearing_min/max can be None ->
1447        # deal with it until Python gets discriminated unions
1448        self.addWeightingToData(data)
1449
1450        # Get the constraints.
1451        constraints = self.getComplexConstraintsForModel()
1452        if fitter is None:
1453            # For single fits - check for inter-model constraints
1454            constraints = self.getConstraintsForFitting()
1455
1456        smearer = self.smearing_widget.smearer()
1457        handler = None
1458        batch_inputs = {}
1459        batch_outputs = {}
1460
1461        fitters = []
1462        for fit_index in self.all_data:
1463            fitter_single = Fit() if fitter is None else fitter
1464            data = GuiUtils.dataFromItem(fit_index)
1465            # Potential weights added directly to data
1466            self.addWeightingToData(data)
1467            try:
1468                fitter_single.set_model(model, fit_id, params_to_fit, data=data,
1469                             constraints=constraints)
1470            except ValueError as ex:
1471                raise ValueError("Setting model parameters failed with: %s" % ex)
1472
1473            qmin, qmax, _ = self.logic.computeRangeFromData(data)
1474            fitter_single.set_data(data=data, id=fit_id, smearer=smearer, qmin=qmin,
1475                            qmax=qmax)
1476            fitter_single.select_problem_for_fit(id=fit_id, value=1)
1477            if fitter is None:
1478                # Assign id to the new fitter only
1479                fitter_single.fitter_id = [self.page_id]
1480            fit_id += 1
1481            fitters.append(fitter_single)
1482
1483        return fitters, fit_id
1484
1485    def iterateOverModel(self, func):
1486        """
1487        Take func and throw it inside the model row loop
1488        """
1489        for row_i in range(self._model_model.rowCount()):
1490            func(row_i)
1491
1492    def updateModelFromList(self, param_dict):
1493        """
1494        Update the model with new parameters, create the errors column
1495        """
1496        assert isinstance(param_dict, dict)
1497        if not dict:
1498            return
1499
1500        def updateFittedValues(row):
1501            # Utility function for main model update
1502            # internal so can use closure for param_dict
1503            param_name = str(self._model_model.item(row, 0).text())
1504            if param_name not in list(param_dict.keys()):
1505                return
1506            # modify the param value
1507            param_repr = GuiUtils.formatNumber(param_dict[param_name][0], high=True)
1508            self._model_model.item(row, 1).setText(param_repr)
1509            if self.has_error_column:
1510                error_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
1511                self._model_model.item(row, 2).setText(error_repr)
1512
1513        def updatePolyValues(row):
1514            # Utility function for updateof polydispersity part of the main model
1515            param_name = str(self._model_model.item(row, 0).text())+'.width'
1516            if param_name not in list(param_dict.keys()):
1517                return
1518            # modify the param value
1519            param_repr = GuiUtils.formatNumber(param_dict[param_name][0], high=True)
1520            self._model_model.item(row, 0).child(0).child(0,1).setText(param_repr)
1521
1522        def createErrorColumn(row):
1523            # Utility function for error column update
1524            item = QtGui.QStandardItem()
1525            def createItem(param_name):
1526                error_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
1527                item.setText(error_repr)
1528            def curr_param():
1529                return str(self._model_model.item(row, 0).text())
1530
1531            [createItem(param_name) for param_name in list(param_dict.keys()) if curr_param() == param_name]
1532
1533            error_column.append(item)
1534
1535        # block signals temporarily, so we don't end up
1536        # updating charts with every single model change on the end of fitting
1537        self._model_model.blockSignals(True)
1538        self.iterateOverModel(updateFittedValues)
1539        self.iterateOverModel(updatePolyValues)
1540        self._model_model.blockSignals(False)
1541
1542        if self.has_error_column:
1543            return
1544
1545        error_column = []
1546        self.lstParams.itemDelegate().addErrorColumn()
1547        self.iterateOverModel(createErrorColumn)
1548
1549        # switch off reponse to model change
1550        self._model_model.insertColumn(2, error_column)
1551        FittingUtilities.addErrorHeadersToModel(self._model_model)
1552        # Adjust the table cells width.
1553        # TODO: find a way to dynamically adjust column width while resized expanding
1554        self.lstParams.resizeColumnToContents(0)
1555        self.lstParams.resizeColumnToContents(4)
1556        self.lstParams.resizeColumnToContents(5)
1557        self.lstParams.setSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding, QtWidgets.QSizePolicy.Expanding)
1558
1559        self.has_error_column = True
1560
1561    def updatePolyModelFromList(self, param_dict):
1562        """
1563        Update the polydispersity model with new parameters, create the errors column
1564        """
1565        assert isinstance(param_dict, dict)
1566        if not dict:
1567            return
1568
1569        def iterateOverPolyModel(func):
1570            """
1571            Take func and throw it inside the poly model row loop
1572            """
1573            for row_i in range(self._poly_model.rowCount()):
1574                func(row_i)
1575
1576        def updateFittedValues(row_i):
1577            # Utility function for main model update
1578            # internal so can use closure for param_dict
1579            if row_i >= self._poly_model.rowCount():
1580                return
1581            param_name = str(self._poly_model.item(row_i, 0).text()).rsplit()[-1] + '.width'
1582            if param_name not in list(param_dict.keys()):
1583                return
1584            # modify the param value
1585            param_repr = GuiUtils.formatNumber(param_dict[param_name][0], high=True)
1586            self._poly_model.item(row_i, 1).setText(param_repr)
1587            if self.has_poly_error_column:
1588                error_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
1589                self._poly_model.item(row_i, 2).setText(error_repr)
1590
1591
1592        def createErrorColumn(row_i):
1593            # Utility function for error column update
1594            if row_i >= self._poly_model.rowCount():
1595                return
1596            item = QtGui.QStandardItem()
1597
1598            def createItem(param_name):
1599                error_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
1600                item.setText(error_repr)
1601
1602            def poly_param():
1603                return str(self._poly_model.item(row_i, 0).text()).rsplit()[-1] + '.width'
1604
1605            [createItem(param_name) for param_name in list(param_dict.keys()) if poly_param() == param_name]
1606
1607            error_column.append(item)
1608
1609        # block signals temporarily, so we don't end up
1610        # updating charts with every single model change on the end of fitting
1611        self._poly_model.blockSignals(True)
1612        iterateOverPolyModel(updateFittedValues)
1613        self._poly_model.blockSignals(False)
1614
1615        if self.has_poly_error_column:
1616            return
1617
1618        self.lstPoly.itemDelegate().addErrorColumn()
1619        error_column = []
1620        iterateOverPolyModel(createErrorColumn)
1621
1622        # switch off reponse to model change
1623        self._poly_model.blockSignals(True)
1624        self._poly_model.insertColumn(2, error_column)
1625        self._poly_model.blockSignals(False)
1626        FittingUtilities.addErrorPolyHeadersToModel(self._poly_model)
1627
1628        self.has_poly_error_column = True
1629
1630    def updateMagnetModelFromList(self, param_dict):
1631        """
1632        Update the magnetic model with new parameters, create the errors column
1633        """
1634        assert isinstance(param_dict, dict)
1635        if not dict:
1636            return
1637        if self._magnet_model.rowCount() == 0:
1638            return
1639
1640        def iterateOverMagnetModel(func):
1641            """
1642            Take func and throw it inside the magnet model row loop
1643            """
1644            for row_i in range(self._model_model.rowCount()):
1645                func(row_i)
1646
1647        def updateFittedValues(row):
1648            # Utility function for main model update
1649            # internal so can use closure for param_dict
1650            if self._magnet_model.item(row, 0) is None:
1651                return
1652            param_name = str(self._magnet_model.item(row, 0).text())
1653            if param_name not in list(param_dict.keys()):
1654                return
1655            # modify the param value
1656            param_repr = GuiUtils.formatNumber(param_dict[param_name][0], high=True)
1657            self._magnet_model.item(row, 1).setText(param_repr)
1658            if self.has_magnet_error_column:
1659                error_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
1660                self._magnet_model.item(row, 2).setText(error_repr)
1661
1662        def createErrorColumn(row):
1663            # Utility function for error column update
1664            item = QtGui.QStandardItem()
1665            def createItem(param_name):
1666                error_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
1667                item.setText(error_repr)
1668            def curr_param():
1669                return str(self._magnet_model.item(row, 0).text())
1670
1671            [createItem(param_name) for param_name in list(param_dict.keys()) if curr_param() == param_name]
1672
1673            error_column.append(item)
1674
1675        # block signals temporarily, so we don't end up
1676        # updating charts with every single model change on the end of fitting
1677        self._magnet_model.blockSignals(True)
1678        iterateOverMagnetModel(updateFittedValues)
1679        self._magnet_model.blockSignals(False)
1680
1681        if self.has_magnet_error_column:
1682            return
1683
1684        self.lstMagnetic.itemDelegate().addErrorColumn()
1685        error_column = []
1686        iterateOverMagnetModel(createErrorColumn)
1687
1688        # switch off reponse to model change
1689        self._magnet_model.blockSignals(True)
1690        self._magnet_model.insertColumn(2, error_column)
1691        self._magnet_model.blockSignals(False)
1692        FittingUtilities.addErrorHeadersToModel(self._magnet_model)
1693
1694        self.has_magnet_error_column = True
1695
1696    def onPlot(self):
1697        """
1698        Plot the current set of data
1699        """
1700        # Regardless of previous state, this should now be `plot show` functionality only
1701        self.cmdPlot.setText("Show Plot")
1702        # Force data recalculation so existing charts are updated
1703        self.recalculatePlotData()
1704        self.showPlot()
1705
1706    def onSmearingOptionsUpdate(self):
1707        """
1708        React to changes in the smearing widget
1709        """
1710        self.calculateQGridForModel()
1711
1712    def recalculatePlotData(self):
1713        """
1714        Generate a new dataset for model
1715        """
1716        if not self.data_is_loaded:
1717            self.createDefaultDataset()
1718        self.calculateQGridForModel()
1719
1720    def showPlot(self):
1721        """
1722        Show the current plot in MPL
1723        """
1724        # Show the chart if ready
1725        data_to_show = self.data if self.data_is_loaded else self.model_data
1726        if data_to_show is not None:
1727            self.communicate.plotRequestedSignal.emit([data_to_show])
1728
1729    def onOptionsUpdate(self):
1730        """
1731        Update local option values and replot
1732        """
1733        self.q_range_min, self.q_range_max, self.npts, self.log_points, self.weighting = \
1734            self.options_widget.state()
1735        # set Q range labels on the main tab
1736        self.lblMinRangeDef.setText(str(self.q_range_min))
1737        self.lblMaxRangeDef.setText(str(self.q_range_max))
1738        self.recalculatePlotData()
1739
1740    def setDefaultStructureCombo(self):
1741        """
1742        Fill in the structure factors combo box with defaults
1743        """
1744        structure_factor_list = self.master_category_dict.pop(CATEGORY_STRUCTURE)
1745        factors = [factor[0] for factor in structure_factor_list]
1746        factors.insert(0, STRUCTURE_DEFAULT)
1747        self.cbStructureFactor.clear()
1748        self.cbStructureFactor.addItems(sorted(factors))
1749
1750    def createDefaultDataset(self):
1751        """
1752        Generate default Dataset 1D/2D for the given model
1753        """
1754        # Create default datasets if no data passed
1755        if self.is2D:
1756            qmax = self.q_range_max/np.sqrt(2)
1757            qstep = self.npts
1758            self.logic.createDefault2dData(qmax, qstep, self.tab_id)
1759            return
1760        elif self.log_points:
1761            qmin = -10.0 if self.q_range_min < 1.e-10 else np.log10(self.q_range_min)
1762            qmax = 10.0 if self.q_range_max > 1.e10 else np.log10(self.q_range_max)
1763            interval = np.logspace(start=qmin, stop=qmax, num=self.npts, endpoint=True, base=10.0)
1764        else:
1765            interval = np.linspace(start=self.q_range_min, stop=self.q_range_max,
1766                                   num=self.npts, endpoint=True)
1767        self.logic.createDefault1dData(interval, self.tab_id)
1768
1769    def readCategoryInfo(self):
1770        """
1771        Reads the categories in from file
1772        """
1773        self.master_category_dict = defaultdict(list)
1774        self.by_model_dict = defaultdict(list)
1775        self.model_enabled_dict = defaultdict(bool)
1776
1777        categorization_file = CategoryInstaller.get_user_file()
1778        if not os.path.isfile(categorization_file):
1779            categorization_file = CategoryInstaller.get_default_file()
1780        with open(categorization_file, 'rb') as cat_file:
1781            self.master_category_dict = json.load(cat_file)
1782            self.regenerateModelDict()
1783
1784        # Load the model dict
1785        models = load_standard_models()
1786        for model in models:
1787            self.models[model.name] = model
1788
1789        self.readCustomCategoryInfo()
1790
1791    def readCustomCategoryInfo(self):
1792        """
1793        Reads the custom model category
1794        """
1795        #Looking for plugins
1796        self.plugins = list(self.custom_models.values())
1797        plugin_list = []
1798        for name, plug in self.custom_models.items():
1799            self.models[name] = plug
1800            plugin_list.append([name, True])
1801        self.master_category_dict[CATEGORY_CUSTOM] = plugin_list
1802
1803    def regenerateModelDict(self):
1804        """
1805        Regenerates self.by_model_dict which has each model name as the
1806        key and the list of categories belonging to that model
1807        along with the enabled mapping
1808        """
1809        self.by_model_dict = defaultdict(list)
1810        for category in self.master_category_dict:
1811            for (model, enabled) in self.master_category_dict[category]:
1812                self.by_model_dict[model].append(category)
1813                self.model_enabled_dict[model] = enabled
1814
1815    def addBackgroundToModel(self, model):
1816        """
1817        Adds background parameter with default values to the model
1818        """
1819        assert isinstance(model, QtGui.QStandardItemModel)
1820        checked_list = ['background', '0.001', '-inf', 'inf', '1/cm']
1821        FittingUtilities.addCheckedListToModel(model, checked_list)
1822        last_row = model.rowCount()-1
1823        model.item(last_row, 0).setEditable(False)
1824        model.item(last_row, 4).setEditable(False)
1825
1826    def addScaleToModel(self, model):
1827        """
1828        Adds scale parameter with default values to the model
1829        """
1830        assert isinstance(model, QtGui.QStandardItemModel)
1831        checked_list = ['scale', '1.0', '0.0', 'inf', '']
1832        FittingUtilities.addCheckedListToModel(model, checked_list)
1833        last_row = model.rowCount()-1
1834        model.item(last_row, 0).setEditable(False)
1835        model.item(last_row, 4).setEditable(False)
1836
1837    def addWeightingToData(self, data):
1838        """
1839        Adds weighting contribution to fitting data
1840        """
1841        # Send original data for weighting
1842        weight = FittingUtilities.getWeight(data=data, is2d=self.is2D, flag=self.weighting)
1843        if self.is2D:
1844            data.err_data = weight
1845        else:
1846            data.dy = weight
1847        pass
1848
1849    def updateQRange(self):
1850        """
1851        Updates Q Range display
1852        """
1853        if self.data_is_loaded:
1854            self.q_range_min, self.q_range_max, self.npts = self.logic.computeDataRange()
1855        # set Q range labels on the main tab
1856        self.lblMinRangeDef.setText(str(self.q_range_min))
1857        self.lblMaxRangeDef.setText(str(self.q_range_max))
1858        # set Q range labels on the options tab
1859        self.options_widget.updateQRange(self.q_range_min, self.q_range_max, self.npts)
1860
1861    def SASModelToQModel(self, model_name, structure_factor=None):
1862        """
1863        Setting model parameters into table based on selected category
1864        """
1865        # Crete/overwrite model items
1866        self._model_model.clear()
1867
1868        # First, add parameters from the main model
1869        if model_name is not None:
1870            self.fromModelToQModel(model_name)
1871
1872        # Then, add structure factor derived parameters
1873        if structure_factor is not None and structure_factor != "None":
1874            if model_name is None:
1875                # Instantiate the current sasmodel for SF-only models
1876                self.kernel_module = self.models[structure_factor]()
1877            self.fromStructureFactorToQModel(structure_factor)
1878        else:
1879            # Allow the SF combobox visibility for the given sasmodel
1880            self.enableStructureFactorControl(structure_factor)
1881
1882        # Then, add multishells
1883        if model_name is not None:
1884            # Multishell models need additional treatment
1885            self.addExtraShells()
1886
1887        # Add polydispersity to the model
1888        self.setPolyModel()
1889        # Add magnetic parameters to the model
1890        self.setMagneticModel()
1891
1892        # Adjust the table cells width
1893        self.lstParams.resizeColumnToContents(0)
1894        self.lstParams.setSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding, QtWidgets.QSizePolicy.Expanding)
1895
1896        # Now we claim the model has been loaded
1897        self.model_is_loaded = True
1898        # Change the model name to a monicker
1899        self.kernel_module.name = self.modelName()
1900        # Update the smearing tab
1901        self.smearing_widget.updateKernelModel(kernel_model=self.kernel_module)
1902
1903        # (Re)-create headers
1904        FittingUtilities.addHeadersToModel(self._model_model)
1905        self.lstParams.header().setFont(self.boldFont)
1906
1907        # Update Q Ranges
1908        self.updateQRange()
1909
1910    def fromModelToQModel(self, model_name):
1911        """
1912        Setting model parameters into QStandardItemModel based on selected _model_
1913        """
1914        name = model_name
1915        if self.cbCategory.currentText() == CATEGORY_CUSTOM:
1916            # custom kernel load requires full path
1917            name = os.path.join(ModelUtilities.find_plugins_dir(), model_name+".py")
1918        kernel_module = generate.load_kernel_module(name)
1919        self.model_parameters = modelinfo.make_parameter_table(getattr(kernel_module, 'parameters', []))
1920
1921        # Instantiate the current sasmodel
1922        self.kernel_module = self.models[model_name]()
1923
1924        # Explicitly add scale and background with default values
1925        temp_undo_state = self.undo_supported
1926        self.undo_supported = False
1927        self.addScaleToModel(self._model_model)
1928        self.addBackgroundToModel(self._model_model)
1929        self.undo_supported = temp_undo_state
1930
1931        self.shell_names = self.shellNamesList()
1932
1933        # Update the QModel
1934        new_rows = FittingUtilities.addParametersToModel(self.model_parameters, self.kernel_module, self.is2D)
1935
1936        for row in new_rows:
1937            self._model_model.appendRow(row)
1938        # Update the counter used for multishell display
1939        self._last_model_row = self._model_model.rowCount()
1940
1941    def fromStructureFactorToQModel(self, structure_factor):
1942        """
1943        Setting model parameters into QStandardItemModel based on selected _structure factor_
1944        """
1945        structure_module = generate.load_kernel_module(structure_factor)
1946        structure_parameters = modelinfo.make_parameter_table(getattr(structure_module, 'parameters', []))
1947        structure_kernel = self.models[structure_factor]()
1948
1949        self.kernel_module._model_info = product.make_product_info(self.kernel_module._model_info, structure_kernel._model_info)
1950
1951        new_rows = FittingUtilities.addSimpleParametersToModel(structure_parameters, self.is2D)
1952        for row in new_rows:
1953            self._model_model.appendRow(row)
1954        # Update the counter used for multishell display
1955        self._last_model_row = self._model_model.rowCount()
1956
1957    def onMainParamsChange(self, item):
1958        """
1959        Callback method for updating the sasmodel parameters with the GUI values
1960        """
1961        model_column = item.column()
1962
1963        if model_column == 0:
1964            self.checkboxSelected(item)
1965            self.cmdFit.setEnabled(self.parameters_to_fit != [] and self.logic.data_is_loaded)
1966            # Update state stack
1967            self.updateUndo()
1968            return
1969
1970        model_row = item.row()
1971        name_index = self._model_model.index(model_row, 0)
1972
1973        # Extract changed value.
1974        try:
1975            value = GuiUtils.toDouble(item.text())
1976        except TypeError:
1977            # Unparsable field
1978            return
1979
1980        parameter_name = str(self._model_model.data(name_index)) # sld, background etc.
1981
1982        # Update the parameter value - note: this supports +/-inf as well
1983        self.kernel_module.params[parameter_name] = value
1984
1985        # Update the parameter value - note: this supports +/-inf as well
1986        param_column = self.lstParams.itemDelegate().param_value
1987        min_column = self.lstParams.itemDelegate().param_min
1988        max_column = self.lstParams.itemDelegate().param_max
1989        if model_column == param_column:
1990            self.kernel_module.setParam(parameter_name, value)
1991        elif model_column == min_column:
1992            # min/max to be changed in self.kernel_module.details[parameter_name] = ['Ang', 0.0, inf]
1993            self.kernel_module.details[parameter_name][1] = value
1994        elif model_column == max_column:
1995            self.kernel_module.details[parameter_name][2] = value
1996        else:
1997            # don't update the chart
1998            return
1999
2000        # TODO: magnetic params in self.kernel_module.details['M0:parameter_name'] = value
2001        # TODO: multishell params in self.kernel_module.details[??] = value
2002
2003        # Force the chart update when actual parameters changed
2004        if model_column == 1:
2005            self.recalculatePlotData()
2006
2007        # Update state stack
2008        self.updateUndo()
2009
2010    def isCheckable(self, row):
2011        return self._model_model.item(row, 0).isCheckable()
2012
2013    def checkboxSelected(self, item):
2014        # Assure we're dealing with checkboxes
2015        if not item.isCheckable():
2016            return
2017        status = item.checkState()
2018
2019        # If multiple rows selected - toggle all of them, filtering uncheckable
2020        # Switch off signaling from the model to avoid recursion
2021        self._model_model.blockSignals(True)
2022        # Convert to proper indices and set requested enablement
2023        self.setParameterSelection(status)
2024        #[self._model_model.item(row, 0).setCheckState(status) for row in self.selectedParameters()]
2025        self._model_model.blockSignals(False)
2026
2027        # update the list of parameters to fit
2028        main_params = self.checkedListFromModel(self._model_model)
2029        poly_params = self.checkedListFromModel(self._poly_model)
2030        magnet_params = self.checkedListFromModel(self._magnet_model)
2031
2032        # Retrieve poly params names
2033        poly_params = [param.rsplit()[-1] + '.width' for param in poly_params]
2034
2035        self.parameters_to_fit = main_params + poly_params + magnet_params
2036
2037    def checkedListFromModel(self, model):
2038        """
2039        Returns list of checked parameters for given model
2040        """
2041        def isChecked(row):
2042            return model.item(row, 0).checkState() == QtCore.Qt.Checked
2043
2044        return [str(model.item(row_index, 0).text())
2045                for row_index in range(model.rowCount())
2046                if isChecked(row_index)]
2047
2048    def createNewIndex(self, fitted_data):
2049        """
2050        Create a model or theory index with passed Data1D/Data2D
2051        """
2052        if self.data_is_loaded:
2053            if not fitted_data.name:
2054                name = self.nameForFittedData(self.data.filename)
2055                fitted_data.title = name
2056                fitted_data.name = name
2057                fitted_data.filename = name
2058                fitted_data.symbol = "Line"
2059            self.updateModelIndex(fitted_data)
2060        else:
2061            name = self.nameForFittedData(self.kernel_module.id)
2062            fitted_data.title = name
2063            fitted_data.name = name
2064            fitted_data.filename = name
2065            fitted_data.symbol = "Line"
2066            self.createTheoryIndex(fitted_data)
2067
2068    def updateModelIndex(self, fitted_data):
2069        """
2070        Update a QStandardModelIndex containing model data
2071        """
2072        name = self.nameFromData(fitted_data)
2073        # Make this a line if no other defined
2074        if hasattr(fitted_data, 'symbol') and fitted_data.symbol is None:
2075            fitted_data.symbol = 'Line'
2076        # Notify the GUI manager so it can update the main model in DataExplorer
2077        GuiUtils.updateModelItemWithPlot(self.all_data[self.data_index], fitted_data, name)
2078
2079    def createTheoryIndex(self, fitted_data):
2080        """
2081        Create a QStandardModelIndex containing model data
2082        """
2083        name = self.nameFromData(fitted_data)
2084        # Notify the GUI manager so it can create the theory model in DataExplorer
2085        new_item = GuiUtils.createModelItemWithPlot(fitted_data, name=name)
2086        self.communicate.updateTheoryFromPerspectiveSignal.emit(new_item)
2087
2088    def nameFromData(self, fitted_data):
2089        """
2090        Return name for the dataset. Terribly impure function.
2091        """
2092        if fitted_data.name is None:
2093            name = self.nameForFittedData(self.logic.data.filename)
2094            fitted_data.title = name
2095            fitted_data.name = name
2096            fitted_data.filename = name
2097        else:
2098            name = fitted_data.name
2099        return name
2100
2101    def methodCalculateForData(self):
2102        '''return the method for data calculation'''
2103        return Calc1D if isinstance(self.data, Data1D) else Calc2D
2104
2105    def methodCompleteForData(self):
2106        '''return the method for result parsin on calc complete '''
2107        return self.completed1D if isinstance(self.data, Data1D) else self.completed2D
2108
2109    def calculateQGridForModelExt(self, data=None, model=None, completefn=None, use_threads=True):
2110        """
2111        Wrapper for Calc1D/2D calls
2112        """
2113        if data is None:
2114            data = self.data
2115        if model is None:
2116            model = self.kernel_module
2117        if completefn is None:
2118            completefn = self.methodCompleteForData()
2119        smearer = self.smearing_widget.smearer()
2120        # Awful API to a backend method.
2121        calc_thread = self.methodCalculateForData()(data=data,
2122                                               model=model,
2123                                               page_id=0,
2124                                               qmin=self.q_range_min,
2125                                               qmax=self.q_range_max,
2126                                               smearer=smearer,
2127                                               state=None,
2128                                               weight=None,
2129                                               fid=None,
2130                                               toggle_mode_on=False,
2131                                               completefn=completefn,
2132                                               update_chisqr=True,
2133                                               exception_handler=self.calcException,
2134                                               source=None)
2135        if use_threads:
2136            if LocalConfig.USING_TWISTED:
2137                # start the thread with twisted
2138                thread = threads.deferToThread(calc_thread.compute)
2139                thread.addCallback(completefn)
2140                thread.addErrback(self.calculateDataFailed)
2141            else:
2142                # Use the old python threads + Queue
2143                calc_thread.queue()
2144                calc_thread.ready(2.5)
2145        else:
2146            results = calc_thread.compute()
2147            completefn(results)
2148
2149    def calculateQGridForModel(self):
2150        """
2151        Prepare the fitting data object, based on current ModelModel
2152        """
2153        if self.kernel_module is None:
2154            return
2155        self.calculateQGridForModelExt()
2156
2157    def calculateDataFailed(self, reason):
2158        """
2159        Thread returned error
2160        """
2161        print("Calculate Data failed with ", reason)
2162
2163    def completed1D(self, return_data):
2164        self.Calc1DFinishedSignal.emit(return_data)
2165
2166    def completed2D(self, return_data):
2167        self.Calc2DFinishedSignal.emit(return_data)
2168
2169    def complete1D(self, return_data):
2170        """
2171        Plot the current 1D data
2172        """
2173        fitted_data = self.logic.new1DPlot(return_data, self.tab_id)
2174        self.calculateResiduals(fitted_data)
2175        self.model_data = fitted_data
2176
2177    def complete2D(self, return_data):
2178        """
2179        Plot the current 2D data
2180        """
2181        fitted_data = self.logic.new2DPlot(return_data)
2182        self.calculateResiduals(fitted_data)
2183        self.model_data = fitted_data
2184
2185    def calculateResiduals(self, fitted_data):
2186        """
2187        Calculate and print Chi2 and display chart of residuals
2188        """
2189        # Create a new index for holding data
2190        fitted_data.symbol = "Line"
2191
2192        # Modify fitted_data with weighting
2193        self.addWeightingToData(fitted_data)
2194
2195        self.createNewIndex(fitted_data)
2196        # Calculate difference between return_data and logic.data
2197        self.chi2 = FittingUtilities.calculateChi2(fitted_data, self.logic.data)
2198        # Update the control
2199        chi2_repr = "---" if self.chi2 is None else GuiUtils.formatNumber(self.chi2, high=True)
2200        self.lblChi2Value.setText(chi2_repr)
2201
2202        self.communicate.plotUpdateSignal.emit([fitted_data])
2203
2204        # Plot residuals if actual data
2205        if not self.data_is_loaded:
2206            return
2207
2208        residuals_plot = FittingUtilities.plotResiduals(self.data, fitted_data)
2209        residuals_plot.id = "Residual " + residuals_plot.id
2210        self.createNewIndex(residuals_plot)
2211
2212    def calcException(self, etype, value, tb):
2213        """
2214        Thread threw an exception.
2215        """
2216        # TODO: remimplement thread cancellation
2217        logging.error("".join(traceback.format_exception(etype, value, tb)))
2218
2219    def setTableProperties(self, table):
2220        """
2221        Setting table properties
2222        """
2223        # Table properties
2224        table.verticalHeader().setVisible(False)
2225        table.setAlternatingRowColors(True)
2226        table.setSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding, QtWidgets.QSizePolicy.Expanding)
2227        table.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows)
2228        table.resizeColumnsToContents()
2229
2230        # Header
2231        header = table.horizontalHeader()
2232        header.setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
2233        header.ResizeMode(QtWidgets.QHeaderView.Interactive)
2234
2235        # Qt5: the following 2 lines crash - figure out why!
2236        # Resize column 0 and 7 to content
2237        #header.setSectionResizeMode(0, QtWidgets.QHeaderView.ResizeToContents)
2238        #header.setSectionResizeMode(7, QtWidgets.QHeaderView.ResizeToContents)
2239
2240    def setPolyModel(self):
2241        """
2242        Set polydispersity values
2243        """
2244        if not self.model_parameters:
2245            return
2246        self._poly_model.clear()
2247
2248        [self.setPolyModelParameters(i, param) for i, param in \
2249            enumerate(self.model_parameters.form_volume_parameters) if param.polydisperse]
2250        FittingUtilities.addPolyHeadersToModel(self._poly_model)
2251
2252    def setPolyModelParameters(self, i, param):
2253        """
2254        Standard of multishell poly parameter driver
2255        """
2256        param_name = param.name
2257        # see it the parameter is multishell
2258        if '[' in param.name:
2259            # Skip empty shells
2260            if self.current_shell_displayed == 0:
2261                return
2262            else:
2263                # Create as many entries as current shells
2264                for ishell in range(1, self.current_shell_displayed+1):
2265                    # Remove [n] and add the shell numeral
2266                    name = param_name[0:param_name.index('[')] + str(ishell)
2267                    self.addNameToPolyModel(i, name)
2268        else:
2269            # Just create a simple param entry
2270            self.addNameToPolyModel(i, param_name)
2271
2272    def addNameToPolyModel(self, i, param_name):
2273        """
2274        Creates a checked row in the poly model with param_name
2275        """
2276        # Polydisp. values from the sasmodel
2277        width = self.kernel_module.getParam(param_name + '.width')
2278        npts = self.kernel_module.getParam(param_name + '.npts')
2279        nsigs = self.kernel_module.getParam(param_name + '.nsigmas')
2280        _, min, max = self.kernel_module.details[param_name]
2281
2282        # Construct a row with polydisp. related variable.
2283        # This will get added to the polydisp. model
2284        # Note: last argument needs extra space padding for decent display of the control
2285        checked_list = ["Distribution of " + param_name, str(width),
2286                        str(min), str(max),
2287                        str(npts), str(nsigs), "gaussian      ",'']
2288        FittingUtilities.addCheckedListToModel(self._poly_model, checked_list)
2289
2290        # All possible polydisp. functions as strings in combobox
2291        func = QtWidgets.QComboBox()
2292        func.addItems([str(name_disp) for name_disp in POLYDISPERSITY_MODELS.keys()])
2293        # Set the default index
2294        func.setCurrentIndex(func.findText(DEFAULT_POLYDISP_FUNCTION))
2295        ind = self._poly_model.index(i,self.lstPoly.itemDelegate().poly_function)
2296        self.lstPoly.setIndexWidget(ind, func)
2297        func.currentIndexChanged.connect(lambda: self.onPolyComboIndexChange(str(func.currentText()), i))
2298
2299    def onPolyFilenameChange(self, row_index):
2300        """
2301        Respond to filename_updated signal from the delegate
2302        """
2303        # For the given row, invoke the "array" combo handler
2304        array_caption = 'array'
2305
2306        # Get the combo box reference
2307        ind = self._poly_model.index(row_index, self.lstPoly.itemDelegate().poly_function)
2308        widget = self.lstPoly.indexWidget(ind)
2309
2310        # Update the combo box so it displays "array"
2311        widget.blockSignals(True)
2312        widget.setCurrentIndex(self.lstPoly.itemDelegate().POLYDISPERSE_FUNCTIONS.index(array_caption))
2313        widget.blockSignals(False)
2314
2315        # Invoke the file reader
2316        self.onPolyComboIndexChange(array_caption, row_index)
2317
2318    def onPolyComboIndexChange(self, combo_string, row_index):
2319        """
2320        Modify polydisp. defaults on function choice
2321        """
2322        # Get npts/nsigs for current selection
2323        param = self.model_parameters.form_volume_parameters[row_index]
2324        file_index = self._poly_model.index(row_index, self.lstPoly.itemDelegate().poly_function)
2325        combo_box = self.lstPoly.indexWidget(file_index)
2326
2327        def updateFunctionCaption(row):
2328            # Utility function for update of polydispersity function name in the main model
2329            param_name = str(self._model_model.item(row, 0).text())
2330            if param_name !=  param.name:
2331                return
2332            # Modify the param value
2333            self._model_model.item(row, 0).child(0).child(0,4).setText(combo_string)
2334
2335        if combo_string == 'array':
2336            try:
2337                self.loadPolydispArray(row_index)
2338                # Update main model for display
2339                self.iterateOverModel(updateFunctionCaption)
2340                # disable the row
2341                lo = self.lstPoly.itemDelegate().poly_pd
2342                hi = self.lstPoly.itemDelegate().poly_function
2343                [self._poly_model.item(row_index, i).setEnabled(False) for i in range(lo, hi)]
2344                return
2345            except IOError:
2346                combo_box.setCurrentIndex(self.orig_poly_index)
2347                # Pass for cancel/bad read
2348                pass
2349
2350        # Enable the row in case it was disabled by Array
2351        self._poly_model.blockSignals(True)
2352        max_range = self.lstPoly.itemDelegate().poly_filename
2353        [self._poly_model.item(row_index, i).setEnabled(True) for i in range(7)]
2354        file_index = self._poly_model.index(row_index, self.lstPoly.itemDelegate().poly_filename)
2355        self._poly_model.setData(file_index, "")
2356        self._poly_model.blockSignals(False)
2357
2358        npts_index = self._poly_model.index(row_index, self.lstPoly.itemDelegate().poly_npts)
2359        nsigs_index = self._poly_model.index(row_index, self.lstPoly.itemDelegate().poly_nsigs)
2360
2361        npts = POLYDISPERSITY_MODELS[str(combo_string)].default['npts']
2362        nsigs = POLYDISPERSITY_MODELS[str(combo_string)].default['nsigmas']
2363
2364        self._poly_model.setData(npts_index, npts)
2365        self._poly_model.setData(nsigs_index, nsigs)
2366
2367        self.iterateOverModel(updateFunctionCaption)
2368        self.orig_poly_index = combo_box.currentIndex()
2369
2370    def loadPolydispArray(self, row_index):
2371        """
2372        Show the load file dialog and loads requested data into state
2373        """
2374        datafile = QtWidgets.QFileDialog.getOpenFileName(
2375            self, "Choose a weight file", "", "All files (*.*)", None,
2376            QtWidgets.QFileDialog.DontUseNativeDialog)[0]
2377
2378        if not datafile:
2379            logging.info("No weight data chosen.")
2380            raise IOError
2381
2382        values = []
2383        weights = []
2384        def appendData(data_tuple):
2385            """
2386            Fish out floats from a tuple of strings
2387            """
2388            try:
2389                values.append(float(data_tuple[0]))
2390                weights.append(float(data_tuple[1]))
2391            except (ValueError, IndexError):
2392                # just pass through if line with bad data
2393                return
2394
2395        with open(datafile, 'r') as column_file:
2396            column_data = [line.rstrip().split() for line in column_file.readlines()]
2397            [appendData(line) for line in column_data]
2398
2399        # If everything went well - update the sasmodel values
2400        self.disp_model = POLYDISPERSITY_MODELS['array']()
2401        self.disp_model.set_weights(np.array(values), np.array(weights))
2402        # + update the cell with filename
2403        fname = os.path.basename(str(datafile))
2404        fname_index = self._poly_model.index(row_index, self.lstPoly.itemDelegate().poly_filename)
2405        self._poly_model.setData(fname_index, fname)
2406
2407    def setMagneticModel(self):
2408        """
2409        Set magnetism values on model
2410        """
2411        if not self.model_parameters:
2412            return
2413        self._magnet_model.clear()
2414        [self.addCheckedMagneticListToModel(param, self._magnet_model) for param in \
2415            self.model_parameters.call_parameters if param.type == 'magnetic']
2416        FittingUtilities.addHeadersToModel(self._magnet_model)
2417
2418    def shellNamesList(self):
2419        """
2420        Returns list of names of all multi-shell parameters
2421        E.g. for sld[n], radius[n], n=1..3 it will return
2422        [sld1, sld2, sld3, radius1, radius2, radius3]
2423        """
2424        multi_names = [p.name[:p.name.index('[')] for p in self.model_parameters.iq_parameters if '[' in p.name]
2425        top_index = self.kernel_module.multiplicity_info.number
2426        shell_names = []
2427        for i in range(1, top_index+1):
2428            for name in multi_names:
2429                shell_names.append(name+str(i))
2430        return shell_names
2431
2432    def addCheckedMagneticListToModel(self, param, model):
2433        """
2434        Wrapper for model update with a subset of magnetic parameters
2435        """
2436        if param.name[param.name.index(':')+1:] in self.shell_names:
2437            # check if two-digit shell number
2438            try:
2439                shell_index = int(param.name[-2:])
2440            except ValueError:
2441                shell_index = int(param.name[-1:])
2442
2443            if shell_index > self.current_shell_displayed:
2444                return
2445
2446        checked_list = [param.name,
2447                        str(param.default),
2448                        str(param.limits[0]),
2449                        str(param.limits[1]),
2450                        param.units]
2451
2452        FittingUtilities.addCheckedListToModel(model, checked_list)
2453
2454    def enableStructureFactorControl(self, structure_factor):
2455        """
2456        Add structure factors to the list of parameters
2457        """
2458        if self.kernel_module.is_form_factor or structure_factor == 'None':
2459            self.enableStructureCombo()
2460        else:
2461            self.disableStructureCombo()
2462
2463    def addExtraShells(self):
2464        """
2465        Add a combobox for multiple shell display
2466        """
2467        param_name, param_length = FittingUtilities.getMultiplicity(self.model_parameters)
2468
2469        if param_length == 0:
2470            return
2471
2472        # cell 1: variable name
2473        item1 = QtGui.QStandardItem(param_name)
2474
2475        func = QtWidgets.QComboBox()
2476        # Available range of shells displayed in the combobox
2477        func.addItems([str(i) for i in range(param_length+1)])
2478
2479        # Respond to index change
2480        func.currentIndexChanged.connect(self.modifyShellsInList)
2481
2482        # cell 2: combobox
2483        item2 = QtGui.QStandardItem()
2484        self._model_model.appendRow([item1, item2])
2485
2486        # Beautify the row:  span columns 2-4
2487        shell_row = self._model_model.rowCount()
2488        shell_index = self._model_model.index(shell_row-1, 1)
2489
2490        self.lstParams.setIndexWidget(shell_index, func)
2491        self._last_model_row = self._model_model.rowCount()
2492
2493        # Set the index to the state-kept value
2494        func.setCurrentIndex(self.current_shell_displayed
2495                             if self.current_shell_displayed < func.count() else 0)
2496
2497    def modifyShellsInList(self, index):
2498        """
2499        Add/remove additional multishell parameters
2500        """
2501        # Find row location of the combobox
2502        last_row = self._last_model_row
2503        remove_rows = self._model_model.rowCount() - last_row
2504
2505        if remove_rows > 1:
2506            self._model_model.removeRows(last_row, remove_rows)
2507
2508        FittingUtilities.addShellsToModel(self.model_parameters, self._model_model, index)
2509        self.current_shell_displayed = index
2510
2511        # Update relevant models
2512        self.setPolyModel()
2513        self.setMagneticModel()
2514
2515    def setFittingStarted(self):
2516        """
2517        Set buttion caption on fitting start
2518        """
2519        # Notify the user that fitting is being run
2520        # Allow for stopping the job
2521        self.cmdFit.setStyleSheet('QPushButton {color: red;}')
2522        self.cmdFit.setText('Stop fit')
2523
2524    def setFittingStopped(self):
2525        """
2526        Set button caption on fitting stop
2527        """
2528        # Notify the user that fitting is available
2529        self.cmdFit.setStyleSheet('QPushButton {color: black;}')
2530        self.cmdFit.setText("Fit")
2531        self.fit_started = False
2532
2533    def readFitPage(self, fp):
2534        """
2535        Read in state from a fitpage object and update GUI
2536        """
2537        assert isinstance(fp, FitPage)
2538        # Main tab info
2539        self.logic.data.filename = fp.filename
2540        self.data_is_loaded = fp.data_is_loaded
2541        self.chkPolydispersity.setCheckState(fp.is_polydisperse)
2542        self.chkMagnetism.setCheckState(fp.is_magnetic)
2543        self.chk2DView.setCheckState(fp.is2D)
2544
2545        # Update the comboboxes
2546        self.cbCategory.setCurrentIndex(self.cbCategory.findText(fp.current_category))
2547        self.cbModel.setCurrentIndex(self.cbModel.findText(fp.current_model))
2548        if fp.current_factor:
2549            self.cbStructureFactor.setCurrentIndex(self.cbStructureFactor.findText(fp.current_factor))
2550
2551        self.chi2 = fp.chi2
2552
2553        # Options tab
2554        self.q_range_min = fp.fit_options[fp.MIN_RANGE]
2555        self.q_range_max = fp.fit_options[fp.MAX_RANGE]
2556        self.npts = fp.fit_options[fp.NPTS]
2557        self.log_points = fp.fit_options[fp.LOG_POINTS]
2558        self.weighting = fp.fit_options[fp.WEIGHTING]
2559
2560        # Models
2561        self._model_model = fp.model_model
2562        self._poly_model = fp.poly_model
2563        self._magnet_model = fp.magnetism_model
2564
2565        # Resolution tab
2566        smearing = fp.smearing_options[fp.SMEARING_OPTION]
2567        accuracy = fp.smearing_options[fp.SMEARING_ACCURACY]
2568        smearing_min = fp.smearing_options[fp.SMEARING_MIN]
2569        smearing_max = fp.smearing_options[fp.SMEARING_MAX]
2570        self.smearing_widget.setState(smearing, accuracy, smearing_min, smearing_max)
2571
2572        # TODO: add polidyspersity and magnetism
2573
2574    def saveToFitPage(self, fp):
2575        """
2576        Write current state to the given fitpage
2577        """
2578        assert isinstance(fp, FitPage)
2579
2580        # Main tab info
2581        fp.filename = self.logic.data.filename
2582        fp.data_is_loaded = self.data_is_loaded
2583        fp.is_polydisperse = self.chkPolydispersity.isChecked()
2584        fp.is_magnetic = self.chkMagnetism.isChecked()
2585        fp.is2D = self.chk2DView.isChecked()
2586        fp.data = self.data
2587
2588        # Use current models - they contain all the required parameters
2589        fp.model_model = self._model_model
2590        fp.poly_model = self._poly_model
2591        fp.magnetism_model = self._magnet_model
2592
2593        if self.cbCategory.currentIndex() != 0:
2594            fp.current_category = str(self.cbCategory.currentText())
2595            fp.current_model = str(self.cbModel.currentText())
2596
2597        if self.cbStructureFactor.isEnabled() and self.cbStructureFactor.currentIndex() != 0:
2598            fp.current_factor = str(self.cbStructureFactor.currentText())
2599        else:
2600            fp.current_factor = ''
2601
2602        fp.chi2 = self.chi2
2603        fp.parameters_to_fit = self.parameters_to_fit
2604        fp.kernel_module = self.kernel_module
2605
2606        # Algorithm options
2607        # fp.algorithm = self.parent.fit_options.selected_id
2608
2609        # Options tab
2610        fp.fit_options[fp.MIN_RANGE] = self.q_range_min
2611        fp.fit_options[fp.MAX_RANGE] = self.q_range_max
2612        fp.fit_options[fp.NPTS] = self.npts
2613        #fp.fit_options[fp.NPTS_FIT] = self.npts_fit
2614        fp.fit_options[fp.LOG_POINTS] = self.log_points
2615        fp.fit_options[fp.WEIGHTING] = self.weighting
2616
2617        # Resolution tab
2618        smearing, accuracy, smearing_min, smearing_max = self.smearing_widget.state()
2619        fp.smearing_options[fp.SMEARING_OPTION] = smearing
2620        fp.smearing_options[fp.SMEARING_ACCURACY] = accuracy
2621        fp.smearing_options[fp.SMEARING_MIN] = smearing_min
2622        fp.smearing_options[fp.SMEARING_MAX] = smearing_max
2623
2624        # TODO: add polidyspersity and magnetism
2625
2626
2627    def updateUndo(self):
2628        """
2629        Create a new state page and add it to the stack
2630        """
2631        if self.undo_supported:
2632            self.pushFitPage(self.currentState())
2633
2634    def currentState(self):
2635        """
2636        Return fit page with current state
2637        """
2638        new_page = FitPage()
2639        self.saveToFitPage(new_page)
2640
2641        return new_page
2642
2643    def pushFitPage(self, new_page):
2644        """
2645        Add a new fit page object with current state
2646        """
2647        self.page_stack.append(new_page)
2648
2649    def popFitPage(self):
2650        """
2651        Remove top fit page from stack
2652        """
2653        if self.page_stack:
2654            self.page_stack.pop()
2655
2656    def getReport(self):
2657        """
2658        Create and return HTML report with parameters and charts
2659        """
2660        index = None
2661        if self.all_data:
2662            index = self.all_data[self.data_index]
2663        report_logic = ReportPageLogic(self,
2664                                       kernel_module=self.kernel_module,
2665                                       data=self.data,
2666                                       index=index,
2667                                       model=self._model_model)
2668
2669        return report_logic.reportList()
2670
2671    def savePageState(self):
2672        """
2673        Create and serialize local PageState
2674        """
2675        from sas.sascalc.fit.pagestate import Reader
2676        model = self.kernel_module
2677
2678        # Old style PageState object
2679        state = PageState(model=model, data=self.data)
2680
2681        # Add parameter data to the state
2682        self.getCurrentFitState(state)
2683
2684        # Create the filewriter, aptly named 'Reader'
2685        state_reader = Reader(self.loadPageStateCallback)
2686        filepath = self.saveAsAnalysisFile()
2687        if filepath is None:
2688            return
2689        state_reader.write(filename=filepath, fitstate=state)
2690        pass
2691
2692    def saveAsAnalysisFile(self):
2693        """
2694        Show the save as... dialog and return the chosen filepath
2695        """
2696        default_name = "FitPage"+str(self.tab_id)+".fitv"
2697
2698        wildcard = "fitv files (*.fitv)"
2699        kwargs = {
2700            'caption'   : 'Save As',
2701            'directory' : default_name,
2702            'filter'    : wildcard,
2703            'parent'    : None,
2704        }
2705        # Query user for filename.
2706        filename_tuple = QtWidgets.QFileDialog.getSaveFileName(**kwargs)
2707        filename = filename_tuple[0]
2708        return filename
2709
2710    def loadPageStateCallback(self,state=None, datainfo=None, format=None):
2711        """
2712        This is a callback method called from the CANSAS reader.
2713        We need the instance of this reader only for writing out a file,
2714        so there's nothing here.
2715        Until Load Analysis is implemented, that is.
2716        """
2717        pass
2718
2719    def loadPageState(self, pagestate=None):
2720        """
2721        Load the PageState object and update the current widget
2722        """
2723        pass
2724
2725    def getCurrentFitState(self, state=None):
2726        """
2727        Store current state for fit_page
2728        """
2729        # save model option
2730        #if self.model is not None:
2731        #    self.disp_list = self.getDispParamList()
2732        #    state.disp_list = copy.deepcopy(self.disp_list)
2733        #    #state.model = self.model.clone()
2734
2735        # Comboboxes
2736        state.categorycombobox = self.cbCategory.currentText()
2737        state.formfactorcombobox = self.cbModel.currentText()
2738        if self.cbStructureFactor.isEnabled():
2739            state.structureCombobox = self.cbStructureFactor.currentText()
2740        state.tcChi = self.chi2
2741
2742        state.enable2D = self.is2D
2743
2744        #state.weights = copy.deepcopy(self.weights)
2745        # save data
2746        state.data = copy.deepcopy(self.data)
2747
2748        # save plotting range
2749        state.qmin = self.q_range_min
2750        state.qmax = self.q_range_max
2751        state.npts = self.npts
2752
2753        #    self.state.enable_disp = self.enable_disp.GetValue()
2754        #    self.state.disable_disp = self.disable_disp.GetValue()
2755
2756        #    self.state.enable_smearer = \
2757        #                        copy.deepcopy(self.enable_smearer.GetValue())
2758        #    self.state.disable_smearer = \
2759        #                        copy.deepcopy(self.disable_smearer.GetValue())
2760
2761        #self.state.pinhole_smearer = \
2762        #                        copy.deepcopy(self.pinhole_smearer.GetValue())
2763        #self.state.slit_smearer = copy.deepcopy(self.slit_smearer.GetValue())
2764        #self.state.dI_noweight = copy.deepcopy(self.dI_noweight.GetValue())
2765        #self.state.dI_didata = copy.deepcopy(self.dI_didata.GetValue())
2766        #self.state.dI_sqrdata = copy.deepcopy(self.dI_sqrdata.GetValue())
2767        #self.state.dI_idata = copy.deepcopy(self.dI_idata.GetValue())
2768
2769        p = self.model_parameters
2770        # save checkbutton state and txtcrtl values
2771        state.parameters = FittingUtilities.getStandardParam()
2772        state.orientation_params_disp = FittingUtilities.getOrientationParam()
2773
2774        #self._copy_parameters_state(self.orientation_params_disp, self.state.orientation_params_disp)
2775        #self._copy_parameters_state(self.parameters, self.state.parameters)
2776        #self._copy_parameters_state(self.fittable_param, self.state.fittable_param)
2777        #self._copy_parameters_state(self.fixed_param, self.state.fixed_param)
2778
2779
Note: See TracBrowser for help on using the repository browser.