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

ESS_GUIESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalc
Last change on this file since 00b7ddf0 was 00b7ddf0, checked in by Torin Cooper-Bennun <torin.cooper-bennun@…>, 18 months ago

[CHERRY-PICK FROM 4f80a834f] put sub-heading creation into FittingUtilities?; fix a couple of caused issues; fix affected tests

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