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

ESS_GUIESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalc
Last change on this file since ce67f35 was ce67f35, checked in by Piotr Rozyczko <piotr.rozyczko@…>, 5 years ago

Change data index before Q range recalculation. SASVIEW-1118

  • Property mode set to 100644
File size: 161.4 KB
Line 
1import json
2import os
3import sys
4from collections import defaultdict
5
6import copy
7import logging
8import traceback
9from twisted.internet import threads
10import numpy as np
11import webbrowser
12
13from PyQt5 import QtCore
14from PyQt5 import QtGui
15from PyQt5 import QtWidgets
16
17from sasmodels import generate
18from sasmodels import modelinfo
19from sasmodels.sasview_model import load_standard_models
20from sasmodels.sasview_model import MultiplicationModel
21from sasmodels.weights import MODELS as POLYDISPERSITY_MODELS
22
23from sas.sascalc.fit.BumpsFitting import BumpsFit as Fit
24from sas.sascalc.fit.pagestate import PageState
25
26import sas.qtgui.Utilities.GuiUtils as GuiUtils
27import sas.qtgui.Utilities.LocalConfig as LocalConfig
28from sas.qtgui.Utilities.CategoryInstaller import CategoryInstaller
29from sas.qtgui.Plotting.PlotterData import Data1D
30from sas.qtgui.Plotting.PlotterData import Data2D
31from sas.qtgui.Plotting.Plotter import PlotterWidget
32
33from sas.qtgui.Perspectives.Fitting.UI.FittingWidgetUI import Ui_FittingWidgetUI
34from sas.qtgui.Perspectives.Fitting.FitThread import FitThread
35from sas.qtgui.Perspectives.Fitting.ConsoleUpdate import ConsoleUpdate
36
37from sas.qtgui.Perspectives.Fitting.ModelThread import Calc1D
38from sas.qtgui.Perspectives.Fitting.ModelThread import Calc2D
39from sas.qtgui.Perspectives.Fitting.FittingLogic import FittingLogic
40from sas.qtgui.Perspectives.Fitting import FittingUtilities
41from sas.qtgui.Perspectives.Fitting import ModelUtilities
42from sas.qtgui.Perspectives.Fitting.SmearingWidget import SmearingWidget
43from sas.qtgui.Perspectives.Fitting.OptionsWidget import OptionsWidget
44from sas.qtgui.Perspectives.Fitting.FitPage import FitPage
45from sas.qtgui.Perspectives.Fitting.ViewDelegate import ModelViewDelegate
46from sas.qtgui.Perspectives.Fitting.ViewDelegate import PolyViewDelegate
47from sas.qtgui.Perspectives.Fitting.ViewDelegate import MagnetismViewDelegate
48from sas.qtgui.Perspectives.Fitting.Constraint import Constraint
49from sas.qtgui.Perspectives.Fitting.MultiConstraint import MultiConstraint
50from sas.qtgui.Perspectives.Fitting.ReportPageLogic import ReportPageLogic
51
52TAB_MAGNETISM = 4
53TAB_POLY = 3
54CATEGORY_DEFAULT = "Choose category..."
55MODEL_DEFAULT = "Choose model..."
56CATEGORY_STRUCTURE = "Structure Factor"
57CATEGORY_CUSTOM = "Plugin Models"
58STRUCTURE_DEFAULT = "None"
59
60DEFAULT_POLYDISP_FUNCTION = 'gaussian'
61
62# CRUFT: remove when new release of sasmodels is available
63# https://github.com/SasView/sasview/pull/181#discussion_r218135162
64from sasmodels.sasview_model import SasviewModel
65if not hasattr(SasviewModel, 'get_weights'):
66    def get_weights(self, name):
67        """
68        Returns the polydispersity distribution for parameter *name* as *value* and *weight* arrays.
69        """
70        # type: (str) -> Tuple(np.ndarray, np.ndarray)
71        _, x, w = self._get_weights(self._model_info.parameters[name])
72        return x, w
73
74    SasviewModel.get_weights = get_weights
75
76logger = logging.getLogger(__name__)
77
78class ToolTippedItemModel(QtGui.QStandardItemModel):
79    """
80    Subclass from QStandardItemModel to allow displaying tooltips in
81    QTableView model.
82    """
83    def __init__(self, parent=None):
84        QtGui.QStandardItemModel.__init__(self, parent)
85
86    def headerData(self, section, orientation, role=QtCore.Qt.DisplayRole):
87        """
88        Displays tooltip for each column's header
89        :param section:
90        :param orientation:
91        :param role:
92        :return:
93        """
94        if role == QtCore.Qt.ToolTipRole:
95            if orientation == QtCore.Qt.Horizontal:
96                return str(self.header_tooltips[section])
97
98        return QtGui.QStandardItemModel.headerData(self, section, orientation, role)
99
100class FittingWidget(QtWidgets.QWidget, Ui_FittingWidgetUI):
101    """
102    Main widget for selecting form and structure factor models
103    """
104    constraintAddedSignal = QtCore.pyqtSignal(list)
105    newModelSignal = QtCore.pyqtSignal()
106    fittingFinishedSignal = QtCore.pyqtSignal(tuple)
107    batchFittingFinishedSignal = QtCore.pyqtSignal(tuple)
108    Calc1DFinishedSignal = QtCore.pyqtSignal(dict)
109    Calc2DFinishedSignal = QtCore.pyqtSignal(dict)
110
111    MAGNETIC_MODELS = ['sphere', 'core_shell_sphere', 'core_multi_shell', 'cylinder', 'parallelepiped']
112
113    def __init__(self, parent=None, data=None, tab_id=1):
114
115        super(FittingWidget, self).__init__()
116
117        # Necessary globals
118        self.parent = parent
119
120        # Which tab is this widget displayed in?
121        self.tab_id = tab_id
122
123        import sys
124        sys.excepthook = self.info
125
126        # Globals
127        self.initializeGlobals()
128
129        # data index for the batch set
130        self.data_index = 0
131        # Main Data[12]D holders
132        # Logics.data contains a single Data1D/Data2D object
133        self._logic = [FittingLogic()]
134
135        # Main GUI setup up
136        self.setupUi(self)
137        self.setWindowTitle("Fitting")
138
139        # Set up tabs widgets
140        self.initializeWidgets()
141
142        # Set up models and views
143        self.initializeModels()
144
145        # Defaults for the structure factors
146        self.setDefaultStructureCombo()
147
148        # Make structure factor and model CBs disabled
149        self.disableModelCombo()
150        self.disableStructureCombo()
151
152        # Generate the category list for display
153        self.initializeCategoryCombo()
154
155        # Initial control state
156        self.initializeControls()
157
158        QtWidgets.QApplication.processEvents()
159
160        # Connect signals to controls
161        self.initializeSignals()
162
163        if data is not None:
164            self.data = data
165
166        # New font to display angstrom symbol
167        new_font = 'font-family: -apple-system, "Helvetica Neue", "Ubuntu";'
168        self.label_17.setStyleSheet(new_font)
169        self.label_19.setStyleSheet(new_font)
170
171    def info(self, type, value, tb):
172        logger.error("SasView threw exception: " + str(value))
173        traceback.print_exception(type, value, tb)
174
175    @property
176    def logic(self):
177        # make sure the logic contains at least one element
178        assert self._logic
179        # logic connected to the currently shown data
180        return self._logic[self.data_index]
181
182    @property
183    def data(self):
184        return self.logic.data
185
186    @data.setter
187    def data(self, value):
188        """ data setter """
189        # Value is either a list of indices for batch fitting or a simple index
190        # for standard fitting. Assure we have a list, regardless.
191        if isinstance(value, list):
192            self.is_batch_fitting = True
193        else:
194            value = [value]
195
196        assert isinstance(value[0], QtGui.QStandardItem)
197
198        # Keep reference to all datasets for batch
199        self.all_data = value
200
201        # Create logics with data items
202        # Logics.data contains only a single Data1D/Data2D object
203        if len(value) == 1:
204            # single data logic is already defined, update data on it
205            self._logic[0].data = GuiUtils.dataFromItem(value[0])
206        else:
207            # batch datasets
208            self._logic = []
209            for data_item in value:
210                logic = FittingLogic(data=GuiUtils.dataFromItem(data_item))
211                self._logic.append(logic)
212
213        # Overwrite data type descriptor
214
215        self.is2D = True if isinstance(self.logic.data, Data2D) else False
216
217        # Let others know we're full of data now
218        self.data_is_loaded = True
219
220        # Enable/disable UI components
221        self.setEnablementOnDataLoad()
222
223    def initializeGlobals(self):
224        """
225        Initialize global variables used in this class
226        """
227        # SasModel is loaded
228        self.model_is_loaded = False
229        # Data[12]D passed and set
230        self.data_is_loaded = False
231        # Batch/single fitting
232        self.is_batch_fitting = False
233        self.is_chain_fitting = False
234        # Is the fit job running?
235        self.fit_started = False
236        # The current fit thread
237        self.calc_fit = None
238        # Current SasModel in view
239        self.kernel_module = None
240        # Current SasModel view dimension
241        self.is2D = False
242        # Current SasModel is multishell
243        self.model_has_shells = False
244        # Utility variable to enable unselectable option in category combobox
245        self._previous_category_index = 0
246        # Utility variables for multishell display
247        self._n_shells_row = 0
248        self._num_shell_params = 0
249        # Dictionary of {model name: model class} for the current category
250        self.models = {}
251        # Parameters to fit
252        self.main_params_to_fit = []
253        self.poly_params_to_fit = []
254        self.magnet_params_to_fit = []
255
256        # Fit options
257        self.q_range_min = 0.005
258        self.q_range_max = 0.1
259        self.npts = 25
260        self.log_points = False
261        self.weighting = 0
262        self.chi2 = None
263        # Does the control support UNDO/REDO
264        # temporarily off
265        self.undo_supported = False
266        self.page_stack = []
267        self.all_data = []
268        # custom plugin models
269        # {model.name:model}
270        self.custom_models = self.customModels()
271        # Polydisp widget table default index for function combobox
272        self.orig_poly_index = 4
273        # copy of current kernel model
274        self.kernel_module_copy = None
275
276        # dictionaries of current params
277        self.poly_params = {}
278        self.magnet_params = {}
279
280        # Page id for fitting
281        # To keep with previous SasView values, use 200 as the start offset
282        self.page_id = 200 + self.tab_id
283
284        # Data for chosen model
285        self.model_data = None
286
287        # Which shell is being currently displayed?
288        self.current_shell_displayed = 0
289        # List of all shell-unique parameters
290        self.shell_names = []
291
292        # Error column presence in parameter display
293        self.has_error_column = False
294        self.has_poly_error_column = False
295        self.has_magnet_error_column = False
296
297        # Enablement of comboboxes
298        self.enabled_cbmodel = False
299        self.enabled_sfmodel = False
300
301        # If the widget generated theory item, save it
302        self.theory_item = None
303
304        # list column widths
305        self.lstParamHeaderSizes = {}
306
307        # signal communicator
308        self.communicate = self.parent.communicate
309
310    def initializeWidgets(self):
311        """
312        Initialize widgets for tabs
313        """
314        # Options widget
315        layout = QtWidgets.QGridLayout()
316        self.options_widget = OptionsWidget(self, self.logic)
317        layout.addWidget(self.options_widget)
318        self.tabOptions.setLayout(layout)
319
320        # Smearing widget
321        layout = QtWidgets.QGridLayout()
322        self.smearing_widget = SmearingWidget(self)
323        layout.addWidget(self.smearing_widget)
324        self.tabResolution.setLayout(layout)
325
326        # Define bold font for use in various controls
327        self.boldFont = QtGui.QFont()
328        self.boldFont.setBold(True)
329
330        # Set data label
331        self.label.setFont(self.boldFont)
332        self.label.setText("No data loaded")
333        self.lblFilename.setText("")
334
335        # Magnetic angles explained in one picture
336        self.magneticAnglesWidget = QtWidgets.QWidget()
337        labl = QtWidgets.QLabel(self.magneticAnglesWidget)
338        pixmap = QtGui.QPixmap(GuiUtils.IMAGES_DIRECTORY_LOCATION + '/M_angles_pic.png')
339        labl.setPixmap(pixmap)
340        self.magneticAnglesWidget.setFixedSize(pixmap.width(), pixmap.height())
341
342    def initializeModels(self):
343        """
344        Set up models and views
345        """
346        # Set the main models
347        # We can't use a single model here, due to restrictions on flattening
348        # the model tree with subclassed QAbstractProxyModel...
349        self._model_model = ToolTippedItemModel()
350        self._poly_model = ToolTippedItemModel()
351        self._magnet_model = ToolTippedItemModel()
352
353        # Param model displayed in param list
354        self.lstParams.setModel(self._model_model)
355        self.readCategoryInfo()
356
357        self.model_parameters = None
358
359        # Delegates for custom editing and display
360        self.lstParams.setItemDelegate(ModelViewDelegate(self))
361
362        self.lstParams.setAlternatingRowColors(True)
363        stylesheet = """
364
365            QTreeView {
366                paint-alternating-row-colors-for-empty-area:0;
367            }
368
369            QTreeView::item {
370                border: 1px;
371                padding: 2px 1px;
372            }
373
374            QTreeView::item:hover {
375                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #e7effd, stop: 1 #cbdaf1);
376                border: 1px solid #bfcde4;
377            }
378
379            QTreeView::item:selected {
380                border: 1px solid #567dbc;
381            }
382
383            QTreeView::item:selected:active{
384                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #6ea1f1, stop: 1 #567dbc);
385            }
386
387            QTreeView::item:selected:!active {
388                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #6b9be8, stop: 1 #577fbf);
389            }
390           """
391        self.lstParams.setStyleSheet(stylesheet)
392        self.lstParams.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
393        self.lstParams.customContextMenuRequested.connect(self.showModelContextMenu)
394        self.lstParams.setAttribute(QtCore.Qt.WA_MacShowFocusRect, False)
395        # Column resize signals
396        self.lstParams.header().sectionResized.connect(self.onColumnWidthUpdate)
397
398        # Poly model displayed in poly list
399        self.lstPoly.setModel(self._poly_model)
400        self.setPolyModel()
401        self.setTableProperties(self.lstPoly)
402        # Delegates for custom editing and display
403        self.lstPoly.setItemDelegate(PolyViewDelegate(self))
404        # Polydispersity function combo response
405        self.lstPoly.itemDelegate().combo_updated.connect(self.onPolyComboIndexChange)
406        self.lstPoly.itemDelegate().filename_updated.connect(self.onPolyFilenameChange)
407
408        # Magnetism model displayed in magnetism list
409        self.lstMagnetic.setModel(self._magnet_model)
410        self.setMagneticModel()
411        self.setTableProperties(self.lstMagnetic)
412        # Delegates for custom editing and display
413        self.lstMagnetic.setItemDelegate(MagnetismViewDelegate(self))
414
415    def initializeCategoryCombo(self):
416        """
417        Model category combo setup
418        """
419        category_list = sorted(self.master_category_dict.keys())
420        self.cbCategory.addItem(CATEGORY_DEFAULT)
421        self.cbCategory.addItems(category_list)
422        if CATEGORY_STRUCTURE not in category_list:
423            self.cbCategory.addItem(CATEGORY_STRUCTURE)
424        self.cbCategory.setCurrentIndex(0)
425
426    def setEnablementOnDataLoad(self):
427        """
428        Enable/disable various UI elements based on data loaded
429        """
430        # Tag along functionality
431        self.label.setText("Data loaded from: ")
432        if self.logic.data.filename:
433            self.lblFilename.setText(self.logic.data.filename)
434        else:
435            self.lblFilename.setText(self.logic.data.name)
436        self.updateQRange()
437        # Switch off Data2D control
438        self.chk2DView.setEnabled(False)
439        self.chk2DView.setVisible(False)
440        self.chkMagnetism.setEnabled(False)
441        self.tabFitting.setTabEnabled(TAB_MAGNETISM, self.chkMagnetism.isChecked())
442        # Combo box or label for file name"
443        if self.is_batch_fitting:
444            self.lblFilename.setVisible(False)
445            for dataitem in self.all_data:
446                filename = GuiUtils.dataFromItem(dataitem).filename
447                self.cbFileNames.addItem(filename)
448            self.cbFileNames.setVisible(True)
449            self.chkChainFit.setEnabled(True)
450            self.chkChainFit.setVisible(True)
451            # This panel is not designed to view individual fits, so disable plotting
452            self.cmdPlot.setVisible(False)
453        # Similarly on other tabs
454        self.options_widget.setEnablementOnDataLoad()
455        self.onSelectModel()
456        # Smearing tab
457        self.smearing_widget.updateData(self.data)
458
459    def acceptsData(self):
460        """ Tells the caller this widget can accept new dataset """
461        return not self.data_is_loaded
462
463    def disableModelCombo(self):
464        """ Disable the combobox """
465        self.cbModel.setEnabled(False)
466        self.lblModel.setEnabled(False)
467        self.enabled_cbmodel = False
468
469    def enableModelCombo(self):
470        """ Enable the combobox """
471        self.cbModel.setEnabled(True)
472        self.lblModel.setEnabled(True)
473        self.enabled_cbmodel = True
474
475    def disableStructureCombo(self):
476        """ Disable the combobox """
477        self.cbStructureFactor.setEnabled(False)
478        self.lblStructure.setEnabled(False)
479        self.enabled_sfmodel = False
480
481    def enableStructureCombo(self):
482        """ Enable the combobox """
483        self.cbStructureFactor.setEnabled(True)
484        self.lblStructure.setEnabled(True)
485        self.enabled_sfmodel = True
486
487    def togglePoly(self, isChecked):
488        """ Enable/disable the polydispersity tab """
489        self.tabFitting.setTabEnabled(TAB_POLY, isChecked)
490        # Check if any parameters are ready for fitting
491        self.cmdFit.setEnabled(self.haveParamsToFit())
492
493    def toggleMagnetism(self, isChecked):
494        """ Enable/disable the magnetism tab """
495        self.tabFitting.setTabEnabled(TAB_MAGNETISM, isChecked)
496        # Check if any parameters are ready for fitting
497        self.cmdFit.setEnabled(self.haveParamsToFit())
498
499    def toggleChainFit(self, isChecked):
500        """ Enable/disable chain fitting """
501        self.is_chain_fitting = isChecked
502
503    def toggle2D(self, isChecked):
504        """ Enable/disable the controls dependent on 1D/2D data instance """
505        self.chkMagnetism.setEnabled(isChecked)
506        self.is2D = isChecked
507        # Reload the current model
508        if self.kernel_module:
509            self.onSelectModel()
510
511    @classmethod
512    def customModels(cls):
513        """ Reads in file names in the custom plugin directory """
514        return ModelUtilities._find_models()
515
516    def initializeControls(self):
517        """
518        Set initial control enablement
519        """
520        self.cbFileNames.setVisible(False)
521        self.cmdFit.setEnabled(False)
522        self.cmdPlot.setEnabled(False)
523        self.options_widget.cmdComputePoints.setVisible(False) # probably redundant
524        self.chkPolydispersity.setEnabled(True)
525        self.chkPolydispersity.setCheckState(False)
526        self.chk2DView.setEnabled(True)
527        self.chk2DView.setCheckState(False)
528        self.chkMagnetism.setEnabled(False)
529        self.chkMagnetism.setCheckState(False)
530        self.chkChainFit.setEnabled(False)
531        self.chkChainFit.setVisible(False)
532        # Tabs
533        self.tabFitting.setTabEnabled(TAB_POLY, False)
534        self.tabFitting.setTabEnabled(TAB_MAGNETISM, False)
535        self.lblChi2Value.setText("---")
536        # Smearing tab
537        self.smearing_widget.updateData(self.data)
538        # Line edits in the option tab
539        self.updateQRange()
540
541    def initializeSignals(self):
542        """
543        Connect GUI element signals
544        """
545        # Comboboxes
546        self.cbStructureFactor.currentIndexChanged.connect(self.onSelectStructureFactor)
547        self.cbCategory.currentIndexChanged.connect(self.onSelectCategory)
548        self.cbModel.currentIndexChanged.connect(self.onSelectModel)
549        self.cbFileNames.currentIndexChanged.connect(self.onSelectBatchFilename)
550        # Checkboxes
551        self.chk2DView.toggled.connect(self.toggle2D)
552        self.chkPolydispersity.toggled.connect(self.togglePoly)
553        self.chkMagnetism.toggled.connect(self.toggleMagnetism)
554        self.chkChainFit.toggled.connect(self.toggleChainFit)
555        # Buttons
556        self.cmdFit.clicked.connect(self.onFit)
557        self.cmdPlot.clicked.connect(self.onPlot)
558        self.cmdHelp.clicked.connect(self.onHelp)
559        self.cmdMagneticDisplay.clicked.connect(self.onDisplayMagneticAngles)
560
561        # Respond to change in parameters from the UI
562        self._model_model.dataChanged.connect(self.onMainParamsChange)
563        self._poly_model.dataChanged.connect(self.onPolyModelChange)
564        self._magnet_model.dataChanged.connect(self.onMagnetModelChange)
565        self.lstParams.selectionModel().selectionChanged.connect(self.onSelectionChanged)
566
567        # Local signals
568        self.batchFittingFinishedSignal.connect(self.batchFitComplete)
569        self.fittingFinishedSignal.connect(self.fitComplete)
570        self.Calc1DFinishedSignal.connect(self.complete1D)
571        self.Calc2DFinishedSignal.connect(self.complete2D)
572
573        # Signals from separate tabs asking for replot
574        self.options_widget.plot_signal.connect(self.onOptionsUpdate)
575
576        # Signals from other widgets
577        self.communicate.customModelDirectoryChanged.connect(self.onCustomModelChange)
578        self.smearing_widget.smearingChangedSignal.connect(self.onSmearingOptionsUpdate)
579
580        # Communicator signal
581        self.communicate.updateModelCategoriesSignal.connect(self.onCategoriesChanged)
582
583    def modelName(self):
584        """
585        Returns model name, by default M<tab#>, e.g. M1, M2
586        """
587        return "M%i" % self.tab_id
588
589    def nameForFittedData(self, name):
590        """
591        Generate name for the current fit
592        """
593        if self.is2D:
594            name += "2d"
595        name = "%s [%s]" % (self.modelName(), name)
596        return name
597
598    def showModelContextMenu(self, position):
599        """
600        Show context specific menu in the parameter table.
601        When clicked on parameter(s): fitting/constraints options
602        When clicked on white space: model description
603        """
604        rows = [s.row() for s in self.lstParams.selectionModel().selectedRows()
605                if self.isCheckable(s.row())]
606        menu = self.showModelDescription() if not rows else self.modelContextMenu(rows)
607        try:
608            menu.exec_(self.lstParams.viewport().mapToGlobal(position))
609        except AttributeError as ex:
610            logger.error("Error generating context menu: %s" % ex)
611        return
612
613    def modelContextMenu(self, rows):
614        """
615        Create context menu for the parameter selection
616        """
617        menu = QtWidgets.QMenu()
618        num_rows = len(rows)
619        if num_rows < 1:
620            return menu
621        # Select for fitting
622        param_string = "parameter " if num_rows == 1 else "parameters "
623        to_string = "to its current value" if num_rows == 1 else "to their current values"
624        has_constraints = any([self.rowHasConstraint(i) for i in rows])
625        has_real_constraints = any([self.rowHasActiveConstraint(i) for i in rows])
626
627        self.actionSelect = QtWidgets.QAction(self)
628        self.actionSelect.setObjectName("actionSelect")
629        self.actionSelect.setText(QtCore.QCoreApplication.translate("self", "Select "+param_string+" for fitting"))
630        # Unselect from fitting
631        self.actionDeselect = QtWidgets.QAction(self)
632        self.actionDeselect.setObjectName("actionDeselect")
633        self.actionDeselect.setText(QtCore.QCoreApplication.translate("self", "De-select "+param_string+" from fitting"))
634
635        self.actionConstrain = QtWidgets.QAction(self)
636        self.actionConstrain.setObjectName("actionConstrain")
637        self.actionConstrain.setText(QtCore.QCoreApplication.translate("self", "Constrain "+param_string + to_string))
638
639        self.actionRemoveConstraint = QtWidgets.QAction(self)
640        self.actionRemoveConstraint.setObjectName("actionRemoveConstrain")
641        self.actionRemoveConstraint.setText(QtCore.QCoreApplication.translate("self", "Remove constraint"))
642
643        self.actionEditConstraint = QtWidgets.QAction(self)
644        self.actionEditConstraint.setObjectName("actionEditConstrain")
645        self.actionEditConstraint.setText(QtCore.QCoreApplication.translate("self", "Edit constraint"))
646
647        self.actionMultiConstrain = QtWidgets.QAction(self)
648        self.actionMultiConstrain.setObjectName("actionMultiConstrain")
649        self.actionMultiConstrain.setText(QtCore.QCoreApplication.translate("self", "Constrain selected parameters to their current values"))
650
651        self.actionMutualMultiConstrain = QtWidgets.QAction(self)
652        self.actionMutualMultiConstrain.setObjectName("actionMutualMultiConstrain")
653        self.actionMutualMultiConstrain.setText(QtCore.QCoreApplication.translate("self", "Mutual constrain of selected parameters..."))
654
655        menu.addAction(self.actionSelect)
656        menu.addAction(self.actionDeselect)
657        menu.addSeparator()
658
659        if has_constraints:
660            menu.addAction(self.actionRemoveConstraint)
661            if num_rows == 1 and has_real_constraints:
662                menu.addAction(self.actionEditConstraint)
663            #if num_rows == 1:
664            #    menu.addAction(self.actionEditConstraint)
665        else:
666            menu.addAction(self.actionConstrain)
667            if num_rows == 2:
668                menu.addAction(self.actionMutualMultiConstrain)
669
670        # Define the callbacks
671        self.actionConstrain.triggered.connect(self.addSimpleConstraint)
672        self.actionRemoveConstraint.triggered.connect(self.deleteConstraint)
673        self.actionEditConstraint.triggered.connect(self.editConstraint)
674        self.actionMutualMultiConstrain.triggered.connect(self.showMultiConstraint)
675        self.actionSelect.triggered.connect(self.selectParameters)
676        self.actionDeselect.triggered.connect(self.deselectParameters)
677        return menu
678
679    def showMultiConstraint(self):
680        """
681        Show the constraint widget and receive the expression
682        """
683        selected_rows = self.lstParams.selectionModel().selectedRows()
684        # There have to be only two rows selected. The caller takes care of that
685        # but let's check the correctness.
686        assert len(selected_rows) == 2
687
688        params_list = [s.data() for s in selected_rows]
689        # Create and display the widget for param1 and param2
690        mc_widget = MultiConstraint(self, params=params_list)
691        # Check if any of the parameters are polydisperse
692        if not np.any([FittingUtilities.isParamPolydisperse(p, self.model_parameters, is2D=self.is2D) for p in params_list]):
693            # no parameters are pd - reset the text to not show the warning
694            mc_widget.lblWarning.setText("")
695        if mc_widget.exec_() != QtWidgets.QDialog.Accepted:
696            return
697
698        constraint = Constraint()
699        c_text = mc_widget.txtConstraint.text()
700
701        # widget.params[0] is the parameter we're constraining
702        constraint.param = mc_widget.params[0]
703        # parameter should have the model name preamble
704        model_name = self.kernel_module.name
705        # param_used is the parameter we're using in constraining function
706        param_used = mc_widget.params[1]
707        # Replace param_used with model_name.param_used
708        updated_param_used = model_name + "." + param_used
709        new_func = c_text.replace(param_used, updated_param_used)
710        constraint.func = new_func
711        constraint.value_ex = updated_param_used
712        # Which row is the constrained parameter in?
713        row = self.getRowFromName(constraint.param)
714
715        # what is the parameter to constraint to?
716        constraint.value = param_used
717
718        # Should the new constraint be validated?
719        constraint.validate = mc_widget.validate
720
721        # Create a new item and add the Constraint object as a child
722        self.addConstraintToRow(constraint=constraint, row=row)
723
724    def getRowFromName(self, name):
725        """
726        Given parameter name get the row number in self._model_model
727        """
728        for row in range(self._model_model.rowCount()):
729            row_name = self._model_model.item(row).text()
730            if row_name == name:
731                return row
732        return None
733
734    def getParamNames(self):
735        """
736        Return list of all parameters for the current model
737        """
738        return [self._model_model.item(row).text()
739                for row in range(self._model_model.rowCount())
740                if self.isCheckable(row)]
741
742    def modifyViewOnRow(self, row, font=None, brush=None):
743        """
744        Chage how the given row of the main model is shown
745        """
746        fields_enabled = False
747        if font is None:
748            font = QtGui.QFont()
749            fields_enabled = True
750        if brush is None:
751            brush = QtGui.QBrush()
752            fields_enabled = True
753        self._model_model.blockSignals(True)
754        # Modify font and foreground of affected rows
755        for column in range(0, self._model_model.columnCount()):
756            self._model_model.item(row, column).setForeground(brush)
757            self._model_model.item(row, column).setFont(font)
758            self._model_model.item(row, column).setEditable(fields_enabled)
759        self._model_model.blockSignals(False)
760
761    def addConstraintToRow(self, constraint=None, row=0):
762        """
763        Adds the constraint object to requested row
764        """
765        # Create a new item and add the Constraint object as a child
766        assert isinstance(constraint, Constraint)
767        assert 0 <= row <= self._model_model.rowCount()
768        assert self.isCheckable(row)
769
770        item = QtGui.QStandardItem()
771        item.setData(constraint)
772        self._model_model.item(row, 1).setChild(0, item)
773        # Set min/max to the value constrained
774        self.constraintAddedSignal.emit([row])
775        # Show visual hints for the constraint
776        font = QtGui.QFont()
777        font.setItalic(True)
778        brush = QtGui.QBrush(QtGui.QColor('blue'))
779        self.modifyViewOnRow(row, font=font, brush=brush)
780        self.communicate.statusBarUpdateSignal.emit('Constraint added')
781
782    def addSimpleConstraint(self):
783        """
784        Adds a constraint on a single parameter.
785        """
786        min_col = self.lstParams.itemDelegate().param_min
787        max_col = self.lstParams.itemDelegate().param_max
788        for row in self.selectedParameters():
789            assert(self.isCheckable(row))
790            param = self._model_model.item(row, 0).text()
791            value = self._model_model.item(row, 1).text()
792            min_t = self._model_model.item(row, min_col).text()
793            max_t = self._model_model.item(row, max_col).text()
794            # Create a Constraint object
795            constraint = Constraint(param=param, value=value, min=min_t, max=max_t)
796            # Create a new item and add the Constraint object as a child
797            item = QtGui.QStandardItem()
798            item.setData(constraint)
799            self._model_model.item(row, 1).setChild(0, item)
800            # Assumed correctness from the validator
801            value = float(value)
802            # BUMPS calculates log(max-min) without any checks, so let's assign minor range
803            min_v = value - (value/10000.0)
804            max_v = value + (value/10000.0)
805            # Set min/max to the value constrained
806            self._model_model.item(row, min_col).setText(str(min_v))
807            self._model_model.item(row, max_col).setText(str(max_v))
808            self.constraintAddedSignal.emit([row])
809            # Show visual hints for the constraint
810            font = QtGui.QFont()
811            font.setItalic(True)
812            brush = QtGui.QBrush(QtGui.QColor('blue'))
813            self.modifyViewOnRow(row, font=font, brush=brush)
814        self.communicate.statusBarUpdateSignal.emit('Constraint added')
815
816    def editConstraint(self):
817        """
818        Delete constraints from selected parameters.
819        """
820        params_list = [s.data() for s in self.lstParams.selectionModel().selectedRows()
821                   if self.isCheckable(s.row())]
822        assert len(params_list) == 1
823        row = self.lstParams.selectionModel().selectedRows()[0].row()
824        constraint = self.getConstraintForRow(row)
825        # Create and display the widget for param1 and param2
826        mc_widget = MultiConstraint(self, params=params_list, constraint=constraint)
827        # Check if any of the parameters are polydisperse
828        if not np.any([FittingUtilities.isParamPolydisperse(p, self.model_parameters, is2D=self.is2D) for p in params_list]):
829            # no parameters are pd - reset the text to not show the warning
830            mc_widget.lblWarning.setText("")
831        if mc_widget.exec_() != QtWidgets.QDialog.Accepted:
832            return
833
834        constraint = Constraint()
835        c_text = mc_widget.txtConstraint.text()
836
837        # widget.params[0] is the parameter we're constraining
838        constraint.param = mc_widget.params[0]
839        # parameter should have the model name preamble
840        model_name = self.kernel_module.name
841        # param_used is the parameter we're using in constraining function
842        param_used = mc_widget.params[1]
843        # Replace param_used with model_name.param_used
844        updated_param_used = model_name + "." + param_used
845        # Update constraint with new values
846        constraint.func = c_text
847        constraint.value_ex = updated_param_used
848        constraint.value = param_used
849        # Should the new constraint be validated?
850        constraint.validate = mc_widget.validate
851
852        # Which row is the constrained parameter in?
853        row = self.getRowFromName(constraint.param)
854
855        # Create a new item and add the Constraint object as a child
856        self.addConstraintToRow(constraint=constraint, row=row)
857
858    def deleteConstraint(self):
859        """
860        Delete constraints from selected parameters.
861        """
862        params = [s.data() for s in self.lstParams.selectionModel().selectedRows()
863                   if self.isCheckable(s.row())]
864        for param in params:
865            self.deleteConstraintOnParameter(param=param)
866
867    def deleteConstraintOnParameter(self, param=None):
868        """
869        Delete the constraint on model parameter 'param'
870        """
871        min_col = self.lstParams.itemDelegate().param_min
872        max_col = self.lstParams.itemDelegate().param_max
873        for row in range(self._model_model.rowCount()):
874            if not self.isCheckable(row):
875                continue
876            if not self.rowHasConstraint(row):
877                continue
878            # Get the Constraint object from of the model item
879            item = self._model_model.item(row, 1)
880            constraint = self.getConstraintForRow(row)
881            if constraint is None:
882                continue
883            if not isinstance(constraint, Constraint):
884                continue
885            if param and constraint.param != param:
886                continue
887            # Now we got the right row. Delete the constraint and clean up
888            # Retrieve old values and put them on the model
889            if constraint.min is not None:
890                self._model_model.item(row, min_col).setText(constraint.min)
891            if constraint.max is not None:
892                self._model_model.item(row, max_col).setText(constraint.max)
893            # Remove constraint item
894            item.removeRow(0)
895            self.constraintAddedSignal.emit([row])
896            self.modifyViewOnRow(row)
897
898        self.communicate.statusBarUpdateSignal.emit('Constraint removed')
899
900    def getConstraintForRow(self, row):
901        """
902        For the given row, return its constraint, if any (otherwise None)
903        """
904        if not self.isCheckable(row):
905            return None
906        item = self._model_model.item(row, 1)
907        try:
908            return item.child(0).data()
909        except AttributeError:
910            return None
911
912    def allParamNames(self):
913        """
914        Returns a list of all parameter names defined on the current model
915        """
916        all_params = self.kernel_module._model_info.parameters.kernel_parameters
917        all_param_names = [param.name for param in all_params]
918        # Assure scale and background are always included
919        if 'scale' not in all_param_names:
920            all_param_names.append('scale')
921        if 'background' not in all_param_names:
922            all_param_names.append('background')
923        return all_param_names
924
925    def paramHasConstraint(self, param=None):
926        """
927        Finds out if the given parameter in the main model has a constraint child
928        """
929        if param is None: return False
930        if param not in self.allParamNames(): return False
931
932        for row in range(self._model_model.rowCount()):
933            if self._model_model.item(row,0).text() != param: continue
934            return self.rowHasConstraint(row)
935
936        # nothing found
937        return False
938
939    def rowHasConstraint(self, row):
940        """
941        Finds out if row of the main model has a constraint child
942        """
943        if not self.isCheckable(row):
944            return False
945        item = self._model_model.item(row, 1)
946        if not item.hasChildren():
947            return False
948        c = item.child(0).data()
949        if isinstance(c, Constraint):
950            return True
951        return False
952
953    def rowHasActiveConstraint(self, row):
954        """
955        Finds out if row of the main model has an active constraint child
956        """
957        if not self.isCheckable(row):
958            return False
959        item = self._model_model.item(row, 1)
960        if not item.hasChildren():
961            return False
962        c = item.child(0).data()
963        if isinstance(c, Constraint) and c.active:
964            return True
965        return False
966
967    def rowHasActiveComplexConstraint(self, row):
968        """
969        Finds out if row of the main model has an active, nontrivial constraint child
970        """
971        if not self.isCheckable(row):
972            return False
973        item = self._model_model.item(row, 1)
974        if not item.hasChildren():
975            return False
976        c = item.child(0).data()
977        if isinstance(c, Constraint) and c.func and c.active:
978            return True
979        return False
980
981    def selectParameters(self):
982        """
983        Selected parameter is chosen for fitting
984        """
985        status = QtCore.Qt.Checked
986        self.setParameterSelection(status)
987
988    def deselectParameters(self):
989        """
990        Selected parameters are removed for fitting
991        """
992        status = QtCore.Qt.Unchecked
993        self.setParameterSelection(status)
994
995    def selectedParameters(self):
996        """ Returns list of selected (highlighted) parameters """
997        return [s.row() for s in self.lstParams.selectionModel().selectedRows()
998                if self.isCheckable(s.row())]
999
1000    def setParameterSelection(self, status=QtCore.Qt.Unchecked):
1001        """
1002        Selected parameters are chosen for fitting
1003        """
1004        # Convert to proper indices and set requested enablement
1005        for row in self.selectedParameters():
1006            self._model_model.item(row, 0).setCheckState(status)
1007
1008    def getConstraintsForModel(self):
1009        """
1010        Return a list of tuples. Each tuple contains constraints mapped as
1011        ('constrained parameter', 'function to constrain')
1012        e.g. [('sld','5*sld_solvent')]
1013        """
1014        param_number = self._model_model.rowCount()
1015        params = [(self._model_model.item(s, 0).text(),
1016                    self._model_model.item(s, 1).child(0).data().func)
1017                    for s in range(param_number) if self.rowHasActiveConstraint(s)]
1018        return params
1019
1020    def getComplexConstraintsForModel(self):
1021        """
1022        Return a list of tuples. Each tuple contains constraints mapped as
1023        ('constrained parameter', 'function to constrain')
1024        e.g. [('sld','5*M2.sld_solvent')].
1025        Only for constraints with defined VALUE
1026        """
1027        param_number = self._model_model.rowCount()
1028        params = [(self._model_model.item(s, 0).text(),
1029                    self._model_model.item(s, 1).child(0).data().func)
1030                    for s in range(param_number) if self.rowHasActiveComplexConstraint(s)]
1031        return params
1032
1033    def getConstraintObjectsForModel(self):
1034        """
1035        Returns Constraint objects present on the whole model
1036        """
1037        param_number = self._model_model.rowCount()
1038        constraints = [self._model_model.item(s, 1).child(0).data()
1039                       for s in range(param_number) if self.rowHasConstraint(s)]
1040
1041        return constraints
1042
1043    def getConstraintsForFitting(self):
1044        """
1045        Return a list of constraints in format ready for use in fiting
1046        """
1047        # Get constraints
1048        constraints = self.getComplexConstraintsForModel()
1049        # See if there are any constraints across models
1050        multi_constraints = [cons for cons in constraints if self.isConstraintMultimodel(cons[1])]
1051
1052        if multi_constraints:
1053            # Let users choose what to do
1054            msg = "The current fit contains constraints relying on other fit pages.\n"
1055            msg += "Parameters with those constraints are:\n" +\
1056                '\n'.join([cons[0] for cons in multi_constraints])
1057            msg += "\n\nWould you like to remove these constraints or cancel fitting?"
1058            msgbox = QtWidgets.QMessageBox(self)
1059            msgbox.setIcon(QtWidgets.QMessageBox.Warning)
1060            msgbox.setText(msg)
1061            msgbox.setWindowTitle("Existing Constraints")
1062            # custom buttons
1063            button_remove = QtWidgets.QPushButton("Remove")
1064            msgbox.addButton(button_remove, QtWidgets.QMessageBox.YesRole)
1065            button_cancel = QtWidgets.QPushButton("Cancel")
1066            msgbox.addButton(button_cancel, QtWidgets.QMessageBox.RejectRole)
1067            retval = msgbox.exec_()
1068            if retval == QtWidgets.QMessageBox.RejectRole:
1069                # cancel fit
1070                raise ValueError("Fitting cancelled")
1071            else:
1072                # remove constraint
1073                for cons in multi_constraints:
1074                    self.deleteConstraintOnParameter(param=cons[0])
1075                # re-read the constraints
1076                constraints = self.getComplexConstraintsForModel()
1077
1078        return constraints
1079
1080    def showModelDescription(self):
1081        """
1082        Creates a window with model description, when right clicked in the treeview
1083        """
1084        msg = 'Model description:\n'
1085        if self.kernel_module is not None:
1086            if str(self.kernel_module.description).rstrip().lstrip() == '':
1087                msg += "Sorry, no information is available for this model."
1088            else:
1089                msg += self.kernel_module.description + '\n'
1090        else:
1091            msg += "You must select a model to get information on this"
1092
1093        menu = QtWidgets.QMenu()
1094        label = QtWidgets.QLabel(msg)
1095        action = QtWidgets.QWidgetAction(self)
1096        action.setDefaultWidget(label)
1097        menu.addAction(action)
1098        return menu
1099
1100    def canHaveMagnetism(self):
1101        """
1102        Checks if the current model has magnetic scattering implemented
1103        """
1104        has_mag_params = False
1105        if self.kernel_module:
1106            has_mag_params = len(self.kernel_module.magnetic_params) > 0
1107        return self.is2D and has_mag_params
1108
1109    def onSelectModel(self):
1110        """
1111        Respond to select Model from list event
1112        """
1113        model = self.cbModel.currentText()
1114
1115        if model == MODEL_DEFAULT:
1116            # if the previous category was not the default, keep it.
1117            # Otherwise, just return
1118            if self._previous_model_index != 0:
1119                # We need to block signals, or else state changes on perceived unchanged conditions
1120                self.cbModel.blockSignals(True)
1121                self.cbModel.setCurrentIndex(self._previous_model_index)
1122                self.cbModel.blockSignals(False)
1123            return
1124
1125        # Assure the control is active
1126        if not self.cbModel.isEnabled():
1127            return
1128        # Empty combobox forced to be read
1129        if not model:
1130            return
1131
1132        self.chkMagnetism.setEnabled(self.canHaveMagnetism())
1133        self.chkMagnetism.setEnabled(self.canHaveMagnetism())
1134        self.tabFitting.setTabEnabled(TAB_MAGNETISM, self.chkMagnetism.isChecked() and self.canHaveMagnetism())
1135        self._previous_model_index = self.cbModel.currentIndex()
1136
1137        # Reset parameters to fit
1138        self.resetParametersToFit()
1139        self.has_error_column = False
1140        self.has_poly_error_column = False
1141
1142        structure = None
1143        if self.cbStructureFactor.isEnabled():
1144            structure = str(self.cbStructureFactor.currentText())
1145        self.respondToModelStructure(model=model, structure_factor=structure)
1146
1147    def onSelectBatchFilename(self, data_index):
1148        """
1149        Update the logic based on the selected file in batch fitting
1150        """
1151        self.data_index = data_index
1152        self.updateQRange()
1153
1154    def onSelectStructureFactor(self):
1155        """
1156        Select Structure Factor from list
1157        """
1158        model = str(self.cbModel.currentText())
1159        category = str(self.cbCategory.currentText())
1160        structure = str(self.cbStructureFactor.currentText())
1161        if category == CATEGORY_STRUCTURE:
1162            model = None
1163
1164        # Reset parameters to fit
1165        self.resetParametersToFit()
1166        self.has_error_column = False
1167        self.has_poly_error_column = False
1168
1169        self.respondToModelStructure(model=model, structure_factor=structure)
1170
1171    def resetParametersToFit(self):
1172        """
1173        Clears the list of parameters to be fitted
1174        """
1175        self.main_params_to_fit = []
1176        self.poly_params_to_fit = []
1177        self.magnet_params_to_fit = []
1178
1179    def onCustomModelChange(self):
1180        """
1181        Reload the custom model combobox
1182        """
1183        self.custom_models = self.customModels()
1184        self.readCustomCategoryInfo()
1185        self.onCategoriesChanged()
1186
1187        # See if we need to update the combo in-place
1188        if self.cbCategory.currentText() != CATEGORY_CUSTOM: return
1189
1190        current_text = self.cbModel.currentText()
1191        self.cbModel.blockSignals(True)
1192        self.cbModel.clear()
1193        self.cbModel.blockSignals(False)
1194        self.enableModelCombo()
1195        self.disableStructureCombo()
1196        # Retrieve the list of models
1197        model_list = self.master_category_dict[CATEGORY_CUSTOM]
1198        # Populate the models combobox
1199        self.cbModel.addItems(sorted([model for (model, _) in model_list]))
1200        new_index = self.cbModel.findText(current_text)
1201        if new_index != -1:
1202            self.cbModel.setCurrentIndex(self.cbModel.findText(current_text))
1203
1204    def onSelectionChanged(self):
1205        """
1206        React to parameter selection
1207        """
1208        rows = self.lstParams.selectionModel().selectedRows()
1209        # Clean previous messages
1210        self.communicate.statusBarUpdateSignal.emit("")
1211        if len(rows) == 1:
1212            # Show constraint, if present
1213            row = rows[0].row()
1214            if not self.rowHasConstraint(row):
1215                return
1216            constr = self.getConstraintForRow(row)
1217            func = self.getConstraintForRow(row).func
1218            if constr.func is not None:
1219                # inter-parameter constraint
1220                update_text = "Active constraint: "+func
1221            elif constr.param == rows[0].data():
1222                # current value constraint
1223                update_text = "Value constrained to: " + str(constr.value)
1224            else:
1225                # ill defined constraint
1226                return
1227            self.communicate.statusBarUpdateSignal.emit(update_text)
1228
1229    def replaceConstraintName(self, old_name, new_name=""):
1230        """
1231        Replace names of models in defined constraints
1232        """
1233        param_number = self._model_model.rowCount()
1234        # loop over parameters
1235        for row in range(param_number):
1236            if self.rowHasConstraint(row):
1237                func = self._model_model.item(row, 1).child(0).data().func
1238                if old_name in func:
1239                    new_func = func.replace(old_name, new_name)
1240                    self._model_model.item(row, 1).child(0).data().func = new_func
1241
1242    def isConstraintMultimodel(self, constraint):
1243        """
1244        Check if the constraint function text contains current model name
1245        """
1246        current_model_name = self.kernel_module.name
1247        if current_model_name in constraint:
1248            return False
1249        else:
1250            return True
1251
1252    def updateData(self):
1253        """
1254        Helper function for recalculation of data used in plotting
1255        """
1256        # Update the chart
1257        if self.data_is_loaded:
1258            self.cmdPlot.setText("Show Plot")
1259            self.calculateQGridForModel()
1260        else:
1261            self.cmdPlot.setText("Calculate")
1262            # Create default datasets if no data passed
1263            self.createDefaultDataset()
1264            self.theory_item = None # ensure theory is recalc. before plot, see showTheoryPlot()
1265
1266    def respondToModelStructure(self, model=None, structure_factor=None):
1267        # Set enablement on calculate/plot
1268        self.cmdPlot.setEnabled(True)
1269
1270        # kernel parameters -> model_model
1271        self.SASModelToQModel(model, structure_factor)
1272
1273        # Enable magnetism checkbox for selected models
1274        self.chkMagnetism.setEnabled(self.canHaveMagnetism())
1275        self.tabFitting.setTabEnabled(TAB_MAGNETISM, self.chkMagnetism.isChecked() and self.canHaveMagnetism())
1276
1277        # Update column widths
1278        for column, width in self.lstParamHeaderSizes.items():
1279            self.lstParams.setColumnWidth(column, width)
1280
1281        # Update plot
1282        self.updateData()
1283
1284        # Update state stack
1285        self.updateUndo()
1286
1287        # Let others know
1288        self.newModelSignal.emit()
1289
1290    def onSelectCategory(self):
1291        """
1292        Select Category from list
1293        """
1294        category = self.cbCategory.currentText()
1295        # Check if the user chose "Choose category entry"
1296        if category == CATEGORY_DEFAULT:
1297            # if the previous category was not the default, keep it.
1298            # Otherwise, just return
1299            if self._previous_category_index != 0:
1300                # We need to block signals, or else state changes on perceived unchanged conditions
1301                self.cbCategory.blockSignals(True)
1302                self.cbCategory.setCurrentIndex(self._previous_category_index)
1303                self.cbCategory.blockSignals(False)
1304            return
1305
1306        if category == CATEGORY_STRUCTURE:
1307            self.disableModelCombo()
1308            self.enableStructureCombo()
1309            # set the index to 0
1310            self.cbStructureFactor.setCurrentIndex(0)
1311            self.model_parameters = None
1312            self._model_model.clear()
1313            return
1314        # Wipe out the parameter model
1315        self._model_model.clear()
1316        # Safely clear and enable the model combo
1317        self.cbModel.blockSignals(True)
1318        self.cbModel.clear()
1319        self.cbModel.blockSignals(False)
1320        self.enableModelCombo()
1321        self.disableStructureCombo()
1322
1323        self._previous_category_index = self.cbCategory.currentIndex()
1324        # Retrieve the list of models
1325        model_list = self.master_category_dict[category]
1326        # Populate the models combobox
1327        self.cbModel.blockSignals(True)
1328        self.cbModel.addItem(MODEL_DEFAULT)
1329        self.cbModel.addItems(sorted([model for (model, _) in model_list]))
1330        self.cbModel.blockSignals(False)
1331
1332    def onPolyModelChange(self, top, bottom):
1333        """
1334        Callback method for updating the main model and sasmodel
1335        parameters with the GUI values in the polydispersity view
1336        """
1337        item = self._poly_model.itemFromIndex(top)
1338        model_column = item.column()
1339        model_row = item.row()
1340        name_index = self._poly_model.index(model_row, 0)
1341        parameter_name = str(name_index.data()) # "distribution of sld" etc.
1342        if "istribution of" in parameter_name:
1343            # just the last word
1344            parameter_name = parameter_name.rsplit()[-1]
1345
1346        delegate = self.lstPoly.itemDelegate()
1347
1348        # Extract changed value.
1349        if model_column == delegate.poly_parameter:
1350            # Is the parameter checked for fitting?
1351            value = item.checkState()
1352            parameter_name = parameter_name + '.width'
1353            if value == QtCore.Qt.Checked:
1354                self.poly_params_to_fit.append(parameter_name)
1355            else:
1356                if parameter_name in self.poly_params_to_fit:
1357                    self.poly_params_to_fit.remove(parameter_name)
1358            self.cmdFit.setEnabled(self.haveParamsToFit())
1359
1360        elif model_column in [delegate.poly_min, delegate.poly_max]:
1361            try:
1362                value = GuiUtils.toDouble(item.text())
1363            except TypeError:
1364                # Can't be converted properly, bring back the old value and exit
1365                return
1366
1367            current_details = self.kernel_module.details[parameter_name]
1368            if self.has_poly_error_column:
1369                # err column changes the indexing
1370                current_details[model_column-2] = value
1371            else:
1372                current_details[model_column-1] = value
1373
1374        elif model_column == delegate.poly_function:
1375            # name of the function - just pass
1376            pass
1377
1378        else:
1379            try:
1380                value = GuiUtils.toDouble(item.text())
1381            except TypeError:
1382                # Can't be converted properly, bring back the old value and exit
1383                return
1384
1385            # Update the sasmodel
1386            # PD[ratio] -> width, npts -> npts, nsigs -> nsigmas
1387            #self.kernel_module.setParam(parameter_name + '.' + delegate.columnDict()[model_column], value)
1388            key = parameter_name + '.' + delegate.columnDict()[model_column]
1389            self.poly_params[key] = value
1390
1391            # Update plot
1392            self.updateData()
1393
1394        # update in param model
1395        if model_column in [delegate.poly_pd, delegate.poly_error, delegate.poly_min, delegate.poly_max]:
1396            row = self.getRowFromName(parameter_name)
1397            param_item = self._model_model.item(row).child(0).child(0, model_column)
1398            if param_item is None:
1399                return
1400            self._model_model.blockSignals(True)
1401            param_item.setText(item.text())
1402            self._model_model.blockSignals(False)
1403
1404    def onMagnetModelChange(self, top, bottom):
1405        """
1406        Callback method for updating the sasmodel magnetic parameters with the GUI values
1407        """
1408        item = self._magnet_model.itemFromIndex(top)
1409        model_column = item.column()
1410        model_row = item.row()
1411        name_index = self._magnet_model.index(model_row, 0)
1412        parameter_name = str(self._magnet_model.data(name_index))
1413
1414        if model_column == 0:
1415            value = item.checkState()
1416            if value == QtCore.Qt.Checked:
1417                self.magnet_params_to_fit.append(parameter_name)
1418            else:
1419                if parameter_name in self.magnet_params_to_fit:
1420                    self.magnet_params_to_fit.remove(parameter_name)
1421            self.cmdFit.setEnabled(self.haveParamsToFit())
1422            # Update state stack
1423            self.updateUndo()
1424            return
1425
1426        # Extract changed value.
1427        try:
1428            value = GuiUtils.toDouble(item.text())
1429        except TypeError:
1430            # Unparsable field
1431            return
1432        delegate = self.lstMagnetic.itemDelegate()
1433
1434        if model_column > 1:
1435            if model_column == delegate.mag_min:
1436                pos = 1
1437            elif model_column == delegate.mag_max:
1438                pos = 2
1439            elif model_column == delegate.mag_unit:
1440                pos = 0
1441            else:
1442                raise AttributeError("Wrong column in magnetism table.")
1443            # min/max to be changed in self.kernel_module.details[parameter_name] = ['Ang', 0.0, inf]
1444            self.kernel_module.details[parameter_name][pos] = value
1445        else:
1446            self.magnet_params[parameter_name] = value
1447            #self.kernel_module.setParam(parameter_name) = value
1448            # Force the chart update when actual parameters changed
1449            self.recalculatePlotData()
1450
1451        # Update state stack
1452        self.updateUndo()
1453
1454    def onHelp(self):
1455        """
1456        Show the "Fitting" section of help
1457        """
1458        tree_location = "/user/qtgui/Perspectives/Fitting/"
1459
1460        # Actual file will depend on the current tab
1461        tab_id = self.tabFitting.currentIndex()
1462        helpfile = "fitting.html"
1463        if tab_id == 0:
1464            # Look at the model and if set, pull out its help page
1465            if self.kernel_module is not None and hasattr(self.kernel_module, 'name'):
1466                # See if the help file is there
1467                # This breaks encapsulation a bit, though.
1468                full_path = GuiUtils.HELP_DIRECTORY_LOCATION
1469                sas_path = os.path.abspath(os.path.dirname(sys.argv[0]))
1470                location = sas_path + "/" + full_path
1471                location += "/user/models/" + self.kernel_module.id + ".html"
1472                if os.path.isfile(location):
1473                    # We have HTML for this model - show it
1474                    tree_location = "/user/models/"
1475                    helpfile = self.kernel_module.id + ".html"
1476            else:
1477                helpfile = "fitting_help.html"
1478        elif tab_id == 1:
1479            helpfile = "residuals_help.html"
1480        elif tab_id == 2:
1481            helpfile = "resolution.html"
1482        elif tab_id == 3:
1483            helpfile = "pd/polydispersity.html"
1484        elif tab_id == 4:
1485            helpfile = "magnetism/magnetism.html"
1486        help_location = tree_location + helpfile
1487
1488        self.showHelp(help_location)
1489
1490    def showHelp(self, url):
1491        """
1492        Calls parent's method for opening an HTML page
1493        """
1494        self.parent.showHelp(url)
1495
1496    def onDisplayMagneticAngles(self):
1497        """
1498        Display a simple image showing direction of magnetic angles
1499        """
1500        self.magneticAnglesWidget.show()
1501
1502    def onFit(self):
1503        """
1504        Perform fitting on the current data
1505        """
1506        if self.fit_started:
1507            self.stopFit()
1508            return
1509
1510        # initialize fitter constants
1511        fit_id = 0
1512        handler = None
1513        batch_inputs = {}
1514        batch_outputs = {}
1515        #---------------------------------
1516        if LocalConfig.USING_TWISTED:
1517            handler = None
1518            updater = None
1519        else:
1520            handler = ConsoleUpdate(parent=self.parent,
1521                                    manager=self,
1522                                    improvement_delta=0.1)
1523            updater = handler.update_fit
1524
1525        # Prepare the fitter object
1526        try:
1527            fitters, _ = self.prepareFitters()
1528        except ValueError as ex:
1529            # This should not happen! GUI explicitly forbids this situation
1530            self.communicate.statusBarUpdateSignal.emit(str(ex))
1531            return
1532
1533        # keep local copy of kernel parameters, as they will change during the update
1534        self.kernel_module_copy = copy.deepcopy(self.kernel_module)
1535
1536        # Create the fitting thread, based on the fitter
1537        completefn = self.batchFittingCompleted if self.is_batch_fitting else self.fittingCompleted
1538
1539        self.calc_fit = FitThread(handler=handler,
1540                            fn=fitters,
1541                            batch_inputs=batch_inputs,
1542                            batch_outputs=batch_outputs,
1543                            page_id=[[self.page_id]],
1544                            updatefn=updater,
1545                            completefn=completefn,
1546                            reset_flag=self.is_chain_fitting)
1547
1548        if LocalConfig.USING_TWISTED:
1549            # start the trhrhread with twisted
1550            calc_thread = threads.deferToThread(self.calc_fit.compute)
1551            calc_thread.addCallback(completefn)
1552            calc_thread.addErrback(self.fitFailed)
1553        else:
1554            # Use the old python threads + Queue
1555            self.calc_fit.queue()
1556            self.calc_fit.ready(2.5)
1557
1558        self.communicate.statusBarUpdateSignal.emit('Fitting started...')
1559        self.fit_started = True
1560
1561        # Disable some elements
1562        self.disableInteractiveElements()
1563
1564    def stopFit(self):
1565        """
1566        Attempt to stop the fitting thread
1567        """
1568        if self.calc_fit is None or not self.calc_fit.isrunning():
1569            return
1570        self.calc_fit.stop()
1571        #re-enable the Fit button
1572        self.enableInteractiveElements()
1573
1574        msg = "Fitting cancelled."
1575        self.communicate.statusBarUpdateSignal.emit(msg)
1576
1577    def updateFit(self):
1578        """
1579        """
1580        print("UPDATE FIT")
1581        pass
1582
1583    def fitFailed(self, reason):
1584        """
1585        """
1586        self.enableInteractiveElements()
1587        msg = "Fitting failed with: "+ str(reason)
1588        self.communicate.statusBarUpdateSignal.emit(msg)
1589
1590    def batchFittingCompleted(self, result):
1591        """
1592        Send the finish message from calculate threads to main thread
1593        """
1594        if result is None:
1595            result = tuple()
1596        self.batchFittingFinishedSignal.emit(result)
1597
1598    def batchFitComplete(self, result):
1599        """
1600        Receive and display batch fitting results
1601        """
1602        #re-enable the Fit button
1603        self.enableInteractiveElements()
1604
1605        if len(result) == 0:
1606            msg = "Fitting failed."
1607            self.communicate.statusBarUpdateSignal.emit(msg)
1608            return
1609
1610        # Show the grid panel
1611        page_name = "BatchPage" + str(self.tab_id)
1612        results = copy.deepcopy(result[0])
1613        results.append(page_name)
1614        self.communicate.sendDataToGridSignal.emit(results)
1615
1616        elapsed = result[1]
1617        msg = "Fitting completed successfully in: %s s.\n" % GuiUtils.formatNumber(elapsed)
1618        self.communicate.statusBarUpdateSignal.emit(msg)
1619
1620        # Run over the list of results and update the items
1621        for res_index, res_list in enumerate(result[0]):
1622            # results
1623            res = res_list[0]
1624            param_dict = self.paramDictFromResults(res)
1625
1626            # create local kernel_module
1627            kernel_module = FittingUtilities.updateKernelWithResults(self.kernel_module, param_dict)
1628            # pull out current data
1629            data = self._logic[res_index].data
1630
1631            # Switch indexes
1632            self.data_index = res_index
1633            # Recompute Q ranges
1634            if self.data_is_loaded:
1635                self.q_range_min, self.q_range_max, self.npts = self.logic.computeDataRange()
1636
1637            # Recalculate theories
1638            method = self.complete1D if isinstance(self.data, Data1D) else self.complete2D
1639            self.calculateQGridForModelExt(data=data, model=kernel_module, completefn=method, use_threads=False)
1640
1641        # Restore original kernel_module, so subsequent fits on the same model don't pick up the new params
1642        if self.kernel_module is not None:
1643            self.kernel_module = copy.deepcopy(self.kernel_module_copy)
1644
1645    def paramDictFromResults(self, results):
1646        """
1647        Given the fit results structure, pull out optimized parameters and return them as nicely
1648        formatted dict
1649        """
1650        if results.fitness is None or \
1651            not np.isfinite(results.fitness) or \
1652            np.any(results.pvec is None) or \
1653            not np.all(np.isfinite(results.pvec)):
1654            msg = "Fitting did not converge!"
1655            self.communicate.statusBarUpdateSignal.emit(msg)
1656            msg += results.mesg
1657            logger.error(msg)
1658            return
1659
1660        param_list = results.param_list # ['radius', 'radius.width']
1661        param_values = results.pvec     # array([ 0.36221662,  0.0146783 ])
1662        param_stderr = results.stderr   # array([ 1.71293015,  1.71294233])
1663        params_and_errors = list(zip(param_values, param_stderr))
1664        param_dict = dict(zip(param_list, params_and_errors))
1665
1666        return param_dict
1667
1668    def fittingCompleted(self, result):
1669        """
1670        Send the finish message from calculate threads to main thread
1671        """
1672        if result is None:
1673            result = tuple()
1674        self.fittingFinishedSignal.emit(result)
1675
1676    def fitComplete(self, result):
1677        """
1678        Receive and display fitting results
1679        "result" is a tuple of actual result list and the fit time in seconds
1680        """
1681        #re-enable the Fit button
1682        self.enableInteractiveElements()
1683
1684        if len(result) == 0:
1685            msg = "Fitting failed."
1686            self.communicate.statusBarUpdateSignal.emit(msg)
1687            return
1688
1689        res_list = result[0][0]
1690        res = res_list[0]
1691        self.chi2 = res.fitness
1692        param_dict = self.paramDictFromResults(res)
1693
1694        if param_dict is None:
1695            return
1696        self.communicate.resultPlotUpdateSignal.emit(result[0])
1697
1698        elapsed = result[1]
1699        if self.calc_fit is not None and self.calc_fit._interrupting:
1700            msg = "Fitting cancelled by user after: %s s." % GuiUtils.formatNumber(elapsed)
1701            logger.warning("\n"+msg+"\n")
1702        else:
1703            msg = "Fitting completed successfully in: %s s." % GuiUtils.formatNumber(elapsed)
1704        self.communicate.statusBarUpdateSignal.emit(msg)
1705
1706        # Dictionary of fitted parameter: value, error
1707        # e.g. param_dic = {"sld":(1.703, 0.0034), "length":(33.455, -0.0983)}
1708        self.updateModelFromList(param_dict)
1709
1710        self.updatePolyModelFromList(param_dict)
1711
1712        self.updateMagnetModelFromList(param_dict)
1713
1714        # update charts
1715        self.onPlot()
1716        #self.recalculatePlotData()
1717
1718
1719        # Read only value - we can get away by just printing it here
1720        chi2_repr = GuiUtils.formatNumber(self.chi2, high=True)
1721        self.lblChi2Value.setText(chi2_repr)
1722
1723    def prepareFitters(self, fitter=None, fit_id=0):
1724        """
1725        Prepare the Fitter object for use in fitting
1726        """
1727        # fitter = None -> single/batch fitting
1728        # fitter = Fit() -> simultaneous fitting
1729
1730        # Data going in
1731        data = self.logic.data
1732        model = copy.deepcopy(self.kernel_module)
1733        qmin = self.q_range_min
1734        qmax = self.q_range_max
1735        # add polydisperse/magnet parameters if asked
1736        self.updateKernelModelWithExtraParams(model)
1737
1738        params_to_fit = copy.deepcopy(self.main_params_to_fit)
1739        if self.chkPolydispersity.isChecked():
1740            params_to_fit += self.poly_params_to_fit
1741        if self.chkMagnetism.isChecked() and self.canHaveMagnetism():
1742            params_to_fit += self.magnet_params_to_fit
1743        if not params_to_fit:
1744            raise ValueError('Fitting requires at least one parameter to optimize.')
1745
1746        # Get the constraints.
1747        constraints = self.getComplexConstraintsForModel()
1748        if fitter is None:
1749            # For single fits - check for inter-model constraints
1750            constraints = self.getConstraintsForFitting()
1751
1752        smearer = self.smearing_widget.smearer()
1753        handler = None
1754        batch_inputs = {}
1755        batch_outputs = {}
1756
1757        fitters = []
1758        for fit_index in self.all_data:
1759            fitter_single = Fit() if fitter is None else fitter
1760            data = GuiUtils.dataFromItem(fit_index)
1761            # Potential weights added directly to data
1762            weighted_data = self.addWeightingToData(data)
1763            try:
1764                fitter_single.set_model(model, fit_id, params_to_fit, data=weighted_data,
1765                             constraints=constraints)
1766            except ValueError as ex:
1767                raise ValueError("Setting model parameters failed with: %s" % ex)
1768
1769            qmin, qmax, _ = self.logic.computeRangeFromData(weighted_data)
1770            fitter_single.set_data(data=weighted_data, id=fit_id, smearer=smearer, qmin=qmin,
1771                            qmax=qmax)
1772            fitter_single.select_problem_for_fit(id=fit_id, value=1)
1773            if fitter is None:
1774                # Assign id to the new fitter only
1775                fitter_single.fitter_id = [self.page_id]
1776            fit_id += 1
1777            fitters.append(fitter_single)
1778
1779        return fitters, fit_id
1780
1781    def iterateOverModel(self, func):
1782        """
1783        Take func and throw it inside the model row loop
1784        """
1785        for row_i in range(self._model_model.rowCount()):
1786            func(row_i)
1787
1788    def updateModelFromList(self, param_dict):
1789        """
1790        Update the model with new parameters, create the errors column
1791        """
1792        assert isinstance(param_dict, dict)
1793        if not dict:
1794            return
1795
1796        def updateFittedValues(row):
1797            # Utility function for main model update
1798            # internal so can use closure for param_dict
1799            param_name = str(self._model_model.item(row, 0).text())
1800            if not self.isCheckable(row) or param_name not in list(param_dict.keys()):
1801                return
1802            # modify the param value
1803            param_repr = GuiUtils.formatNumber(param_dict[param_name][0], high=True)
1804            self._model_model.item(row, 1).setText(param_repr)
1805            self.kernel_module.setParam(param_name, param_dict[param_name][0])
1806            if self.has_error_column:
1807                error_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
1808                self._model_model.item(row, 2).setText(error_repr)
1809
1810        def updatePolyValues(row):
1811            # Utility function for updateof polydispersity part of the main model
1812            param_name = str(self._model_model.item(row, 0).text())+'.width'
1813            if not self.isCheckable(row) or param_name not in list(param_dict.keys()):
1814                return
1815            # modify the param value
1816            param_repr = GuiUtils.formatNumber(param_dict[param_name][0], high=True)
1817            self._model_model.item(row, 0).child(0).child(0,1).setText(param_repr)
1818            # modify the param error
1819            if self.has_error_column:
1820                error_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
1821                self._model_model.item(row, 0).child(0).child(0,2).setText(error_repr)
1822
1823        def createErrorColumn(row):
1824            # Utility function for error column update
1825            item = QtGui.QStandardItem()
1826            def createItem(param_name):
1827                error_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
1828                item.setText(error_repr)
1829            def curr_param():
1830                return str(self._model_model.item(row, 0).text())
1831
1832            [createItem(param_name) for param_name in list(param_dict.keys()) if curr_param() == param_name]
1833
1834            error_column.append(item)
1835
1836        def createPolyErrorColumn(row):
1837            # Utility function for error column update in the polydispersity sub-rows
1838            # NOTE: only creates empty items; updatePolyValues adds the error value
1839            item = self._model_model.item(row, 0)
1840            if not item.hasChildren():
1841                return
1842            poly_item = item.child(0)
1843            if not poly_item.hasChildren():
1844                return
1845            poly_item.insertColumn(2, [QtGui.QStandardItem("")])
1846
1847        if not self.has_error_column:
1848            # create top-level error column
1849            error_column = []
1850            self.lstParams.itemDelegate().addErrorColumn()
1851            self.iterateOverModel(createErrorColumn)
1852
1853            self._model_model.insertColumn(2, error_column)
1854
1855            FittingUtilities.addErrorHeadersToModel(self._model_model)
1856
1857            # create error column in polydispersity sub-rows
1858            self.iterateOverModel(createPolyErrorColumn)
1859
1860            self.has_error_column = True
1861
1862        # block signals temporarily, so we don't end up
1863        # updating charts with every single model change on the end of fitting
1864        self._model_model.dataChanged.disconnect()
1865        self.iterateOverModel(updateFittedValues)
1866        self.iterateOverModel(updatePolyValues)
1867        self._model_model.dataChanged.connect(self.onMainParamsChange)
1868
1869    def iterateOverPolyModel(self, func):
1870        """
1871        Take func and throw it inside the poly model row loop
1872        """
1873        for row_i in range(self._poly_model.rowCount()):
1874            func(row_i)
1875
1876    def updatePolyModelFromList(self, param_dict):
1877        """
1878        Update the polydispersity model with new parameters, create the errors column
1879        """
1880        assert isinstance(param_dict, dict)
1881        if not dict:
1882            return
1883
1884        def updateFittedValues(row_i):
1885            # Utility function for main model update
1886            # internal so can use closure for param_dict
1887            if row_i >= self._poly_model.rowCount():
1888                return
1889            param_name = str(self._poly_model.item(row_i, 0).text()).rsplit()[-1] + '.width'
1890            if param_name not in list(param_dict.keys()):
1891                return
1892            # modify the param value
1893            param_repr = GuiUtils.formatNumber(param_dict[param_name][0], high=True)
1894            self._poly_model.item(row_i, 1).setText(param_repr)
1895            self.kernel_module.setParam(param_name, param_dict[param_name][0])
1896            if self.has_poly_error_column:
1897                error_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
1898                self._poly_model.item(row_i, 2).setText(error_repr)
1899
1900        def createErrorColumn(row_i):
1901            # Utility function for error column update
1902            if row_i >= self._poly_model.rowCount():
1903                return
1904            item = QtGui.QStandardItem()
1905
1906            def createItem(param_name):
1907                error_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
1908                item.setText(error_repr)
1909
1910            def poly_param():
1911                return str(self._poly_model.item(row_i, 0).text()).rsplit()[-1] + '.width'
1912
1913            [createItem(param_name) for param_name in list(param_dict.keys()) if poly_param() == param_name]
1914
1915            error_column.append(item)
1916
1917        # block signals temporarily, so we don't end up
1918        # updating charts with every single model change on the end of fitting
1919        self._poly_model.dataChanged.disconnect()
1920        self.iterateOverPolyModel(updateFittedValues)
1921        self._poly_model.dataChanged.connect(self.onPolyModelChange)
1922
1923        if self.has_poly_error_column:
1924            return
1925
1926        self.lstPoly.itemDelegate().addErrorColumn()
1927        error_column = []
1928        self.iterateOverPolyModel(createErrorColumn)
1929
1930        # switch off reponse to model change
1931        self._poly_model.insertColumn(2, error_column)
1932        FittingUtilities.addErrorPolyHeadersToModel(self._poly_model)
1933
1934        self.has_poly_error_column = True
1935
1936    def iterateOverMagnetModel(self, func):
1937        """
1938        Take func and throw it inside the magnet model row loop
1939        """
1940        for row_i in range(self._magnet_model.rowCount()):
1941            func(row_i)
1942
1943    def updateMagnetModelFromList(self, param_dict):
1944        """
1945        Update the magnetic model with new parameters, create the errors column
1946        """
1947        assert isinstance(param_dict, dict)
1948        if not dict:
1949            return
1950        if self._magnet_model.rowCount() == 0:
1951            return
1952
1953        def updateFittedValues(row):
1954            # Utility function for main model update
1955            # internal so can use closure for param_dict
1956            if self._magnet_model.item(row, 0) is None:
1957                return
1958            param_name = str(self._magnet_model.item(row, 0).text())
1959            if param_name not in list(param_dict.keys()):
1960                return
1961            # modify the param value
1962            param_repr = GuiUtils.formatNumber(param_dict[param_name][0], high=True)
1963            self._magnet_model.item(row, 1).setText(param_repr)
1964            self.kernel_module.setParam(param_name, param_dict[param_name][0])
1965            if self.has_magnet_error_column:
1966                error_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
1967                self._magnet_model.item(row, 2).setText(error_repr)
1968
1969        def createErrorColumn(row):
1970            # Utility function for error column update
1971            item = QtGui.QStandardItem()
1972            def createItem(param_name):
1973                error_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
1974                item.setText(error_repr)
1975            def curr_param():
1976                return str(self._magnet_model.item(row, 0).text())
1977
1978            [createItem(param_name) for param_name in list(param_dict.keys()) if curr_param() == param_name]
1979
1980            error_column.append(item)
1981
1982        # block signals temporarily, so we don't end up
1983        # updating charts with every single model change on the end of fitting
1984        self._magnet_model.dataChanged.disconnect()
1985        self.iterateOverMagnetModel(updateFittedValues)
1986        self._magnet_model.dataChanged.connect(self.onMagnetModelChange)
1987
1988        if self.has_magnet_error_column:
1989            return
1990
1991        self.lstMagnetic.itemDelegate().addErrorColumn()
1992        error_column = []
1993        self.iterateOverMagnetModel(createErrorColumn)
1994
1995        # switch off reponse to model change
1996        self._magnet_model.insertColumn(2, error_column)
1997        FittingUtilities.addErrorHeadersToModel(self._magnet_model)
1998
1999        self.has_magnet_error_column = True
2000
2001    def onPlot(self):
2002        """
2003        Plot the current set of data
2004        """
2005        # Regardless of previous state, this should now be `plot show` functionality only
2006        self.cmdPlot.setText("Show Plot")
2007        # Force data recalculation so existing charts are updated
2008        if not self.data_is_loaded:
2009            self.showTheoryPlot()
2010        else:
2011            self.showPlot()
2012        # This is an important processEvent.
2013        # This allows charts to be properly updated in order
2014        # of plots being applied.
2015        QtWidgets.QApplication.processEvents()
2016        self.recalculatePlotData() # recalc+plot theory again (2nd)
2017
2018    def onSmearingOptionsUpdate(self):
2019        """
2020        React to changes in the smearing widget
2021        """
2022        self.calculateQGridForModel()
2023
2024    def recalculatePlotData(self):
2025        """
2026        Generate a new dataset for model
2027        """
2028        if not self.data_is_loaded:
2029            self.createDefaultDataset()
2030        self.calculateQGridForModel()
2031
2032    def showTheoryPlot(self):
2033        """
2034        Show the current theory plot in MPL
2035        """
2036        # Show the chart if ready
2037        if self.theory_item is None:
2038            self.recalculatePlotData()
2039        elif self.model_data:
2040            self._requestPlots(self.model_data.filename, self.theory_item.model())
2041
2042    def showPlot(self):
2043        """
2044        Show the current plot in MPL
2045        """
2046        # Show the chart if ready
2047        data_to_show = self.data
2048        # Any models for this page
2049        current_index = self.all_data[self.data_index]
2050        item = self._requestPlots(self.data.filename, current_index.model())
2051        if item:
2052            # fit+data has not been shown - show just data
2053            self.communicate.plotRequestedSignal.emit([item, data_to_show], self.tab_id)
2054
2055    def _requestPlots(self, item_name, item_model):
2056        """
2057        Emits plotRequestedSignal for all plots found in the given model under the provided item name.
2058        """
2059        fitpage_name = self.kernel_module.name
2060        plots = GuiUtils.plotsFromFilename(item_name, item_model)
2061        # Has the fitted data been shown?
2062        data_shown = False
2063        item = None
2064        for item, plot in plots.items():
2065            if fitpage_name in plot.name:
2066                data_shown = True
2067                self.communicate.plotRequestedSignal.emit([item, plot], self.tab_id)
2068        # return the last data item seen, if nothing was plotted; supposed to be just data)
2069        return None if data_shown else item
2070
2071    def onOptionsUpdate(self):
2072        """
2073        Update local option values and replot
2074        """
2075        self.q_range_min, self.q_range_max, self.npts, self.log_points, self.weighting = \
2076            self.options_widget.state()
2077        # set Q range labels on the main tab
2078        self.lblMinRangeDef.setText(GuiUtils.formatNumber(self.q_range_min, high=True))
2079        self.lblMaxRangeDef.setText(GuiUtils.formatNumber(self.q_range_max, high=True))
2080        self.recalculatePlotData()
2081
2082    def setDefaultStructureCombo(self):
2083        """
2084        Fill in the structure factors combo box with defaults
2085        """
2086        structure_factor_list = self.master_category_dict.pop(CATEGORY_STRUCTURE)
2087        factors = [factor[0] for factor in structure_factor_list]
2088        factors.insert(0, STRUCTURE_DEFAULT)
2089        self.cbStructureFactor.clear()
2090        self.cbStructureFactor.addItems(sorted(factors))
2091
2092    def createDefaultDataset(self):
2093        """
2094        Generate default Dataset 1D/2D for the given model
2095        """
2096        # Create default datasets if no data passed
2097        if self.is2D:
2098            qmax = self.q_range_max/np.sqrt(2)
2099            qstep = self.npts
2100            self.logic.createDefault2dData(qmax, qstep, self.tab_id)
2101            return
2102        elif self.log_points:
2103            qmin = -10.0 if self.q_range_min < 1.e-10 else np.log10(self.q_range_min)
2104            qmax = 10.0 if self.q_range_max > 1.e10 else np.log10(self.q_range_max)
2105            interval = np.logspace(start=qmin, stop=qmax, num=self.npts, endpoint=True, base=10.0)
2106        else:
2107            interval = np.linspace(start=self.q_range_min, stop=self.q_range_max,
2108                                   num=self.npts, endpoint=True)
2109        self.logic.createDefault1dData(interval, self.tab_id)
2110
2111    def readCategoryInfo(self):
2112        """
2113        Reads the categories in from file
2114        """
2115        self.master_category_dict = defaultdict(list)
2116        self.by_model_dict = defaultdict(list)
2117        self.model_enabled_dict = defaultdict(bool)
2118
2119        categorization_file = CategoryInstaller.get_user_file()
2120        if not os.path.isfile(categorization_file):
2121            categorization_file = CategoryInstaller.get_default_file()
2122        with open(categorization_file, 'rb') as cat_file:
2123            self.master_category_dict = json.load(cat_file)
2124            self.regenerateModelDict()
2125
2126        # Load the model dict
2127        models = load_standard_models()
2128        for model in models:
2129            self.models[model.name] = model
2130
2131        self.readCustomCategoryInfo()
2132
2133    def readCustomCategoryInfo(self):
2134        """
2135        Reads the custom model category
2136        """
2137        #Looking for plugins
2138        self.plugins = list(self.custom_models.values())
2139        plugin_list = []
2140        for name, plug in self.custom_models.items():
2141            self.models[name] = plug
2142            plugin_list.append([name, True])
2143        if plugin_list:
2144            self.master_category_dict[CATEGORY_CUSTOM] = plugin_list
2145
2146    def regenerateModelDict(self):
2147        """
2148        Regenerates self.by_model_dict which has each model name as the
2149        key and the list of categories belonging to that model
2150        along with the enabled mapping
2151        """
2152        self.by_model_dict = defaultdict(list)
2153        for category in self.master_category_dict:
2154            for (model, enabled) in self.master_category_dict[category]:
2155                self.by_model_dict[model].append(category)
2156                self.model_enabled_dict[model] = enabled
2157
2158    def addBackgroundToModel(self, model):
2159        """
2160        Adds background parameter with default values to the model
2161        """
2162        assert isinstance(model, QtGui.QStandardItemModel)
2163        checked_list = ['background', '0.001', '-inf', 'inf', '1/cm']
2164        FittingUtilities.addCheckedListToModel(model, checked_list)
2165        last_row = model.rowCount()-1
2166        model.item(last_row, 0).setEditable(False)
2167        model.item(last_row, 4).setEditable(False)
2168
2169    def addScaleToModel(self, model):
2170        """
2171        Adds scale parameter with default values to the model
2172        """
2173        assert isinstance(model, QtGui.QStandardItemModel)
2174        checked_list = ['scale', '1.0', '0.0', 'inf', '']
2175        FittingUtilities.addCheckedListToModel(model, checked_list)
2176        last_row = model.rowCount()-1
2177        model.item(last_row, 0).setEditable(False)
2178        model.item(last_row, 4).setEditable(False)
2179
2180    def addWeightingToData(self, data):
2181        """
2182        Adds weighting contribution to fitting data
2183        """
2184        new_data = copy.deepcopy(data)
2185        # Send original data for weighting
2186        weight = FittingUtilities.getWeight(data=data, is2d=self.is2D, flag=self.weighting)
2187        if self.is2D:
2188            new_data.err_data = weight
2189        else:
2190            new_data.dy = weight
2191
2192        return new_data
2193
2194    def updateQRange(self):
2195        """
2196        Updates Q Range display
2197        """
2198        if self.data_is_loaded:
2199            self.q_range_min, self.q_range_max, self.npts = self.logic.computeDataRange()
2200        # set Q range labels on the main tab
2201        self.lblMinRangeDef.setText(GuiUtils.formatNumber(self.q_range_min, high=True))
2202        self.lblMaxRangeDef.setText(GuiUtils.formatNumber(self.q_range_max, high=True))
2203        # set Q range labels on the options tab
2204        self.options_widget.updateQRange(self.q_range_min, self.q_range_max, self.npts)
2205
2206    def SASModelToQModel(self, model_name, structure_factor=None):
2207        """
2208        Setting model parameters into table based on selected category
2209        """
2210        # Crete/overwrite model items
2211        self._model_model.clear()
2212        self._poly_model.clear()
2213        self._magnet_model.clear()
2214
2215        if model_name is None:
2216            if structure_factor not in (None, "None"):
2217                # S(Q) on its own, treat the same as a form factor
2218                self.kernel_module = None
2219                self.fromStructureFactorToQModel(structure_factor)
2220            else:
2221                # No models selected
2222                return
2223        else:
2224            self.fromModelToQModel(model_name)
2225            self.addExtraShells()
2226
2227            # Allow the SF combobox visibility for the given sasmodel
2228            self.enableStructureFactorControl(structure_factor)
2229       
2230            # Add S(Q)
2231            if self.cbStructureFactor.isEnabled():
2232                structure_factor = self.cbStructureFactor.currentText()
2233                self.fromStructureFactorToQModel(structure_factor)
2234
2235            # Add polydispersity to the model
2236            self.poly_params = {}
2237            self.setPolyModel()
2238            # Add magnetic parameters to the model
2239            self.magnet_params = {}
2240            self.setMagneticModel()
2241
2242        # Now we claim the model has been loaded
2243        self.model_is_loaded = True
2244        # Change the model name to a monicker
2245        self.kernel_module.name = self.modelName()
2246        # Update the smearing tab
2247        self.smearing_widget.updateKernelModel(kernel_model=self.kernel_module)
2248
2249        # (Re)-create headers
2250        FittingUtilities.addHeadersToModel(self._model_model)
2251        self.lstParams.header().setFont(self.boldFont)
2252
2253        # Update Q Ranges
2254        self.updateQRange()
2255
2256    def fromModelToQModel(self, model_name):
2257        """
2258        Setting model parameters into QStandardItemModel based on selected _model_
2259        """
2260        name = model_name
2261        kernel_module = None
2262        if self.cbCategory.currentText() == CATEGORY_CUSTOM:
2263            # custom kernel load requires full path
2264            name = os.path.join(ModelUtilities.find_plugins_dir(), model_name+".py")
2265        try:
2266            kernel_module = generate.load_kernel_module(name)
2267        except ModuleNotFoundError as ex:
2268            pass
2269        except FileNotFoundError as ex:
2270            # can happen when name attribute not the same as actual filename
2271            pass
2272
2273        if kernel_module is None:
2274            # mismatch between "name" attribute and actual filename.
2275            curr_model = self.models[model_name]
2276            name, _ = os.path.splitext(os.path.basename(curr_model.filename))
2277            try:
2278                kernel_module = generate.load_kernel_module(name)
2279            except ModuleNotFoundError as ex:
2280                logger.error("Can't find the model "+ str(ex))
2281                return
2282
2283        if hasattr(kernel_module, 'parameters'):
2284            # built-in and custom models
2285            self.model_parameters = modelinfo.make_parameter_table(getattr(kernel_module, 'parameters', []))
2286
2287        elif hasattr(kernel_module, 'model_info'):
2288            # for sum/multiply models
2289            self.model_parameters = kernel_module.model_info.parameters
2290
2291        elif hasattr(kernel_module, 'Model') and hasattr(kernel_module.Model, "_model_info"):
2292            # this probably won't work if there's no model_info, but just in case
2293            self.model_parameters = kernel_module.Model._model_info.parameters
2294        else:
2295            # no parameters - default to blank table
2296            msg = "No parameters found in model '{}'.".format(model_name)
2297            logger.warning(msg)
2298            self.model_parameters = modelinfo.ParameterTable([])
2299
2300        # Instantiate the current sasmodel
2301        self.kernel_module = self.models[model_name]()
2302
2303        # Change the model name to a monicker
2304        self.kernel_module.name = self.modelName()
2305
2306        # Explicitly add scale and background with default values
2307        temp_undo_state = self.undo_supported
2308        self.undo_supported = False
2309        self.addScaleToModel(self._model_model)
2310        self.addBackgroundToModel(self._model_model)
2311        self.undo_supported = temp_undo_state
2312
2313        self.shell_names = self.shellNamesList()
2314
2315        # Add heading row
2316        FittingUtilities.addHeadingRowToModel(self._model_model, model_name)
2317
2318        # Update the QModel
2319        FittingUtilities.addParametersToModel(
2320                self.model_parameters,
2321                self.kernel_module,
2322                self.is2D,
2323                self._model_model,
2324                self.lstParams)
2325
2326    def fromStructureFactorToQModel(self, structure_factor):
2327        """
2328        Setting model parameters into QStandardItemModel based on selected _structure factor_
2329        """
2330        if structure_factor is None or structure_factor=="None":
2331            return
2332
2333        product_params = None
2334
2335        if self.kernel_module is None:
2336            # Structure factor is the only selected model; build it and show all its params
2337            self.kernel_module = self.models[structure_factor]()
2338            self.kernel_module.name = self.modelName()
2339            s_params = self.kernel_module._model_info.parameters
2340            s_params_orig = s_params
2341        else:
2342            s_kernel = self.models[structure_factor]()
2343            p_kernel = self.kernel_module
2344            # need to reset multiplicity to get the right product
2345            if p_kernel.is_multiplicity_model:
2346                p_kernel.multiplicity = p_kernel.multiplicity_info.number
2347
2348            p_pars_len = len(p_kernel._model_info.parameters.kernel_parameters)
2349            s_pars_len = len(s_kernel._model_info.parameters.kernel_parameters)
2350
2351            self.kernel_module = MultiplicationModel(p_kernel, s_kernel)
2352            # Modify the name to correspond to shown items
2353            self.kernel_module.name = self.modelName()
2354            all_params = self.kernel_module._model_info.parameters.kernel_parameters
2355            all_param_names = [param.name for param in all_params]
2356
2357            # S(Q) params from the product model are not necessarily the same as those from the S(Q) model; any
2358            # conflicting names with P(Q) params will cause a rename
2359
2360            if "radius_effective_mode" in all_param_names:
2361                # Show all parameters
2362                # In this case, radius_effective is NOT pruned by sasmodels.product
2363                s_params = modelinfo.ParameterTable(all_params[p_pars_len:p_pars_len+s_pars_len])
2364                s_params_orig = modelinfo.ParameterTable(s_kernel._model_info.parameters.kernel_parameters)
2365                product_params = modelinfo.ParameterTable(
2366                        self.kernel_module._model_info.parameters.kernel_parameters[p_pars_len+s_pars_len:])
2367            else:
2368                # Ensure radius_effective is not displayed
2369                s_params_orig = modelinfo.ParameterTable(s_kernel._model_info.parameters.kernel_parameters[1:])
2370                if "radius_effective" in all_param_names:
2371                    # In this case, radius_effective is NOT pruned by sasmodels.product
2372                    s_params = modelinfo.ParameterTable(all_params[p_pars_len+1:p_pars_len+s_pars_len])
2373                    product_params = modelinfo.ParameterTable(
2374                            self.kernel_module._model_info.parameters.kernel_parameters[p_pars_len+s_pars_len:])
2375                else:
2376                    # In this case, radius_effective is pruned by sasmodels.product
2377                    s_params = modelinfo.ParameterTable(all_params[p_pars_len:p_pars_len+s_pars_len-1])
2378                    product_params = modelinfo.ParameterTable(
2379                            self.kernel_module._model_info.parameters.kernel_parameters[p_pars_len+s_pars_len-1:])
2380
2381        # Add heading row
2382        FittingUtilities.addHeadingRowToModel(self._model_model, structure_factor)
2383
2384        # Get new rows for QModel
2385        # Any renamed parameters are stored as data in the relevant item, for later handling
2386        FittingUtilities.addSimpleParametersToModel(
2387                parameters=s_params,
2388                is2D=self.is2D,
2389                parameters_original=s_params_orig,
2390                model=self._model_model,
2391                view=self.lstParams)
2392
2393        # Insert product-only params into QModel
2394        if product_params:
2395            prod_rows = FittingUtilities.addSimpleParametersToModel(
2396                    parameters=product_params,
2397                    is2D=self.is2D,
2398                    parameters_original=None,
2399                    model=self._model_model,
2400                    view=self.lstParams,
2401                    row_num=2)
2402
2403            # Since this all happens after shells are dealt with and we've inserted rows, fix this counter
2404            self._n_shells_row += len(prod_rows)
2405
2406    def haveParamsToFit(self):
2407        """
2408        Finds out if there are any parameters ready to be fitted
2409        """
2410        if not self.logic.data_is_loaded:
2411            return False
2412        if self.main_params_to_fit:
2413            return True
2414        if self.chkPolydispersity.isChecked() and self.poly_params_to_fit:
2415            return True
2416        if self.chkMagnetism.isChecked() and self.canHaveMagnetism() and self.magnet_params_to_fit:
2417            return True
2418        return False
2419
2420    def onMainParamsChange(self, top, bottom):
2421        """
2422        Callback method for updating the sasmodel parameters with the GUI values
2423        """
2424        item = self._model_model.itemFromIndex(top)
2425
2426        model_column = item.column()
2427
2428        if model_column == 0:
2429            self.checkboxSelected(item)
2430            self.cmdFit.setEnabled(self.haveParamsToFit())
2431            # Update state stack
2432            self.updateUndo()
2433            return
2434
2435        model_row = item.row()
2436        name_index = self._model_model.index(model_row, 0)
2437        name_item = self._model_model.itemFromIndex(name_index)
2438
2439        # Extract changed value.
2440        try:
2441            value = GuiUtils.toDouble(item.text())
2442        except TypeError:
2443            # Unparsable field
2444            return
2445
2446        # if the item has user data, this is the actual parameter name (e.g. to handle duplicate names)
2447        if name_item.data(QtCore.Qt.UserRole):
2448            parameter_name = str(name_item.data(QtCore.Qt.UserRole))
2449        else:
2450            parameter_name = str(self._model_model.data(name_index))
2451
2452        # Update the parameter value - note: this supports +/-inf as well
2453        param_column = self.lstParams.itemDelegate().param_value
2454        min_column = self.lstParams.itemDelegate().param_min
2455        max_column = self.lstParams.itemDelegate().param_max
2456        if model_column == param_column:
2457            # don't try to update multiplicity counters if they aren't there.
2458            # Note that this will fail for proper bad update where the model
2459            # doesn't contain multiplicity parameter
2460            if parameter_name != self.kernel_module.multiplicity_info.control:
2461                self.kernel_module.setParam(parameter_name, value)
2462        elif model_column == min_column:
2463            # min/max to be changed in self.kernel_module.details[parameter_name] = ['Ang', 0.0, inf]
2464            self.kernel_module.details[parameter_name][1] = value
2465        elif model_column == max_column:
2466            self.kernel_module.details[parameter_name][2] = value
2467        else:
2468            # don't update the chart
2469            return
2470
2471        # TODO: magnetic params in self.kernel_module.details['M0:parameter_name'] = value
2472        # TODO: multishell params in self.kernel_module.details[??] = value
2473
2474        # handle display of effective radius parameter according to radius_effective_mode; pass ER into model if
2475        # necessary
2476        self.processEffectiveRadius()
2477
2478        # Force the chart update when actual parameters changed
2479        if model_column == 1:
2480            self.recalculatePlotData()
2481
2482        # Update state stack
2483        self.updateUndo()
2484
2485    def processEffectiveRadius(self):
2486        """
2487        Checks the value of radius_effective_mode, if existent, and processes radius_effective as necessary.
2488        * mode == 0: This means 'unconstrained'; ensure use can specify ER.
2489        * mode > 0: This means it is constrained to a P(Q)-computed value in sasmodels; prevent user from editing ER.
2490
2491        Note: If ER has been computed, it is passed back to SasView as an intermediate result. That value must be
2492        displayed for the user; that is not dealt with here, but in complete1D.
2493        """
2494        ER_row = self.getRowFromName("radius_effective")
2495        if ER_row is None:
2496            return
2497
2498        ER_mode_row = self.getRowFromName("radius_effective_mode")
2499        if ER_mode_row is None:
2500            return
2501
2502        try:
2503            ER_mode = int(self._model_model.item(ER_mode_row, 1).text())
2504        except ValueError:
2505            logging.error("radius_effective_mode was set to an invalid value.")
2506            return
2507
2508        if ER_mode == 0:
2509            # ensure the ER value can be modified by user
2510            self.setParamEditableByRow(ER_row, True)
2511        elif ER_mode > 0:
2512            # ensure the ER value cannot be modified by user
2513            self.setParamEditableByRow(ER_row, False)
2514        else:
2515            logging.error("radius_effective_mode was set to an invalid value.")
2516
2517    def setParamEditableByRow(self, row, editable=True):
2518        """
2519        Sets whether the user can edit a parameter in the table. If they cannot, the parameter name's font is changed,
2520        the value itself cannot be edited if clicked on, and the parameter may not be fitted.
2521        """
2522        item_name = self._model_model.item(row, 0)
2523        item_value = self._model_model.item(row, 1)
2524
2525        item_value.setEditable(editable)
2526
2527        if editable:
2528            # reset font
2529            item_name.setFont(QtGui.QFont())
2530            # reset colour
2531            item_name.setForeground(QtGui.QBrush())
2532            # make checkable
2533            item_name.setCheckable(True)
2534        else:
2535            # change font
2536            font = QtGui.QFont()
2537            font.setItalic(True)
2538            item_name.setFont(font)
2539            # change colour
2540            item_name.setForeground(QtGui.QBrush(QtGui.QColor(50, 50, 50)))
2541            # make not checkable (and uncheck)
2542            item_name.setCheckState(QtCore.Qt.Unchecked)
2543            item_name.setCheckable(False)
2544
2545    def isCheckable(self, row):
2546        return self._model_model.item(row, 0).isCheckable()
2547
2548    def selectCheckbox(self, row):
2549        """
2550        Select the checkbox in given row.
2551        """
2552        assert 0<= row <= self._model_model.rowCount()
2553        index = self._model_model.index(row, 0)
2554        item = self._model_model.itemFromIndex(index)
2555        item.setCheckState(QtCore.Qt.Checked)
2556
2557    def checkboxSelected(self, item):
2558        # Assure we're dealing with checkboxes
2559        if not item.isCheckable():
2560            return
2561        status = item.checkState()
2562
2563        # If multiple rows selected - toggle all of them, filtering uncheckable
2564        # Convert to proper indices and set requested enablement
2565        self.setParameterSelection(status)
2566
2567        # update the list of parameters to fit
2568        self.main_params_to_fit = self.checkedListFromModel(self._model_model)
2569
2570    def checkedListFromModel(self, model):
2571        """
2572        Returns list of checked parameters for given model
2573        """
2574        def isChecked(row):
2575            return model.item(row, 0).checkState() == QtCore.Qt.Checked
2576
2577        return [str(model.item(row_index, 0).text())
2578                for row_index in range(model.rowCount())
2579                if isChecked(row_index)]
2580
2581    def createNewIndex(self, fitted_data):
2582        """
2583        Create a model or theory index with passed Data1D/Data2D
2584        """
2585        if self.data_is_loaded:
2586            if not fitted_data.name:
2587                name = self.nameForFittedData(self.data.filename)
2588                fitted_data.title = name
2589                fitted_data.name = name
2590                fitted_data.filename = name
2591                fitted_data.symbol = "Line"
2592            self.updateModelIndex(fitted_data)
2593        else:
2594            if not fitted_data.name:
2595                name = self.nameForFittedData(self.kernel_module.id)
2596            else:
2597                name = fitted_data.name
2598            fitted_data.title = name
2599            fitted_data.filename = name
2600            fitted_data.symbol = "Line"
2601            self.createTheoryIndex(fitted_data)
2602            # Switch to the theory tab for user's glee
2603            self.communicate.changeDataExplorerTabSignal.emit(1)
2604
2605    def updateModelIndex(self, fitted_data):
2606        """
2607        Update a QStandardModelIndex containing model data
2608        """
2609        name = self.nameFromData(fitted_data)
2610        # Make this a line if no other defined
2611        if hasattr(fitted_data, 'symbol') and fitted_data.symbol is None:
2612            fitted_data.symbol = 'Line'
2613        # Notify the GUI manager so it can update the main model in DataExplorer
2614        GuiUtils.updateModelItemWithPlot(self.all_data[self.data_index], fitted_data, name)
2615
2616    def createTheoryIndex(self, fitted_data):
2617        """
2618        Create a QStandardModelIndex containing model data
2619        """
2620        name = self.nameFromData(fitted_data)
2621        # Notify the GUI manager so it can create the theory model in DataExplorer
2622        self.theory_item = GuiUtils.createModelItemWithPlot(fitted_data, name=name)
2623        self.communicate.updateTheoryFromPerspectiveSignal.emit(self.theory_item)
2624
2625    def nameFromData(self, fitted_data):
2626        """
2627        Return name for the dataset. Terribly impure function.
2628        """
2629        if fitted_data.name is None:
2630            name = self.nameForFittedData(self.logic.data.filename)
2631            fitted_data.title = name
2632            fitted_data.name = name
2633            fitted_data.filename = name
2634        else:
2635            name = fitted_data.name
2636        return name
2637
2638    def methodCalculateForData(self):
2639        '''return the method for data calculation'''
2640        return Calc1D if isinstance(self.data, Data1D) else Calc2D
2641
2642    def methodCompleteForData(self):
2643        '''return the method for result parsin on calc complete '''
2644        return self.completed1D if isinstance(self.data, Data1D) else self.completed2D
2645
2646    def updateKernelModelWithExtraParams(self, model=None):
2647        """
2648        Updates kernel model 'model' with extra parameters from
2649        the polydisp and magnetism tab, if the tabs are enabled
2650        """
2651        if model is None: return
2652        if not hasattr(model, 'setParam'): return
2653
2654        # add polydisperse parameters if asked
2655        if self.chkPolydispersity.isChecked() and self._poly_model.rowCount() > 0:
2656            for key, value in self.poly_params.items():
2657                model.setParam(key, value)
2658        # add magnetic params if asked
2659        if self.chkMagnetism.isChecked() and self.canHaveMagnetism() and self._magnet_model.rowCount() > 0:
2660            for key, value in self.magnet_params.items():
2661                model.setParam(key, value)
2662
2663    def calculateQGridForModelExt(self, data=None, model=None, completefn=None, use_threads=True):
2664        """
2665        Wrapper for Calc1D/2D calls
2666        """
2667        if data is None:
2668            data = self.data
2669        if model is None:
2670            model = copy.deepcopy(self.kernel_module)
2671            self.updateKernelModelWithExtraParams(model)
2672
2673        if completefn is None:
2674            completefn = self.methodCompleteForData()
2675        smearer = self.smearing_widget.smearer()
2676        weight = FittingUtilities.getWeight(data=data, is2d=self.is2D, flag=self.weighting)
2677
2678        # Disable buttons/table
2679        self.disableInteractiveElementsOnCalculate()
2680        # Awful API to a backend method.
2681        calc_thread = self.methodCalculateForData()(data=data,
2682                                               model=model,
2683                                               page_id=0,
2684                                               qmin=self.q_range_min,
2685                                               qmax=self.q_range_max,
2686                                               smearer=smearer,
2687                                               state=None,
2688                                               weight=weight,
2689                                               fid=None,
2690                                               toggle_mode_on=False,
2691                                               completefn=completefn,
2692                                               update_chisqr=True,
2693                                               exception_handler=self.calcException,
2694                                               source=None)
2695        if use_threads:
2696            if LocalConfig.USING_TWISTED:
2697                # start the thread with twisted
2698                thread = threads.deferToThread(calc_thread.compute)
2699                thread.addCallback(completefn)
2700                thread.addErrback(self.calculateDataFailed)
2701            else:
2702                # Use the old python threads + Queue
2703                calc_thread.queue()
2704                calc_thread.ready(2.5)
2705        else:
2706            results = calc_thread.compute()
2707            completefn(results)
2708
2709    def calculateQGridForModel(self):
2710        """
2711        Prepare the fitting data object, based on current ModelModel
2712        """
2713        if self.kernel_module is None:
2714            return
2715        self.calculateQGridForModelExt()
2716
2717    def calculateDataFailed(self, reason):
2718        """
2719        Thread returned error
2720        """
2721        # Bring the GUI to normal state
2722        self.enableInteractiveElements()
2723        print("Calculate Data failed with ", reason)
2724
2725    def completed1D(self, return_data):
2726        self.Calc1DFinishedSignal.emit(return_data)
2727
2728    def completed2D(self, return_data):
2729        self.Calc2DFinishedSignal.emit(return_data)
2730
2731    def complete1D(self, return_data):
2732        """
2733        Plot the current 1D data
2734        """
2735        # Bring the GUI to normal state
2736        self.enableInteractiveElements()
2737        if return_data is None:
2738            return
2739        fitted_data = self.logic.new1DPlot(return_data, self.tab_id)
2740
2741        # assure the current index is set properly for batch
2742        if len(self._logic) > 1:
2743            for i, logic in enumerate(self._logic):
2744                if logic.data.name in fitted_data.name:
2745                    self.data_index = i
2746
2747        residuals = self.calculateResiduals(fitted_data)
2748        self.model_data = fitted_data
2749        new_plots = [fitted_data]
2750        if residuals is not None:
2751            new_plots.append(residuals)
2752
2753        if self.data_is_loaded:
2754            # delete any plots associated with the data that were not updated
2755            # (e.g. to remove beta(Q), S_eff(Q))
2756            GuiUtils.deleteRedundantPlots(self.all_data[self.data_index], new_plots)
2757            pass
2758        else:
2759            # delete theory items for the model, in order to get rid of any
2760            # redundant items, e.g. beta(Q), S_eff(Q)
2761            self.communicate.deleteIntermediateTheoryPlotsSignal.emit(self.kernel_module.id)
2762
2763        # Create plots for parameters with enabled polydispersity
2764        for plot in FittingUtilities.plotPolydispersities(return_data.get('model', None)):
2765            data_id = fitted_data.id.split()
2766            plot.id = "{} [{}] {}".format(data_id[0], plot.name, " ".join(data_id[1:]))
2767            data_name = fitted_data.name.split()
2768            plot.name = " ".join([data_name[0], plot.name] + data_name[1:])
2769            self.createNewIndex(plot)
2770            new_plots.append(plot)
2771
2772        # Create plots for intermediate product data
2773        plots = self.logic.new1DProductPlots(return_data, self.tab_id)
2774        for plot in plots:
2775            plot.symbol = "Line"
2776            self.createNewIndex(plot)
2777            new_plots.append(plot)
2778
2779        for plot in new_plots:
2780            self.communicate.plotUpdateSignal.emit([plot])
2781
2782        # Update radius_effective if relevant
2783        self.updateEffectiveRadius(return_data)
2784
2785    def complete2D(self, return_data):
2786        """
2787        Plot the current 2D data
2788        """
2789        # Bring the GUI to normal state
2790        self.enableInteractiveElements()
2791
2792        if return_data is None:
2793            return
2794
2795        fitted_data = self.logic.new2DPlot(return_data)
2796        # assure the current index is set properly for batch
2797        if len(self._logic) > 1:
2798            for i, logic in enumerate(self._logic):
2799                if logic.data.name in fitted_data.name:
2800                    self.data_index = i
2801
2802        residuals = self.calculateResiduals(fitted_data)
2803        self.model_data = fitted_data
2804        new_plots = [fitted_data]
2805        if residuals is not None:
2806            new_plots.append(residuals)
2807
2808        # Update/generate plots
2809        for plot in new_plots:
2810            self.communicate.plotUpdateSignal.emit([plot])
2811
2812    def updateEffectiveRadius(self, return_data):
2813        """
2814        Given return data from sasmodels, update the effective radius parameter in the GUI table with the new
2815        calculated value as returned by sasmodels (if the value was returned).
2816        """
2817        ER_mode_row = self.getRowFromName("radius_effective_mode")
2818        if ER_mode_row is None:
2819            return
2820        try:
2821            ER_mode = int(self._model_model.item(ER_mode_row, 1).text())
2822        except ValueError:
2823            logging.error("radius_effective_mode was set to an invalid value.")
2824            return
2825        if ER_mode < 1:
2826            # does not need updating if it is not being computed
2827            return
2828
2829        ER_row = self.getRowFromName("radius_effective")
2830        if ER_row is None:
2831            return
2832
2833        scalar_results = self.logic.getScalarIntermediateResults(return_data)
2834        ER_value = scalar_results.get("effective_radius") # note name of key
2835        if ER_value is None:
2836            return
2837        # ensure the model does not recompute when updating the value
2838        self._model_model.blockSignals(True)
2839        self._model_model.item(ER_row, 1).setText(str(ER_value))
2840        self._model_model.blockSignals(False)
2841        # ensure the view is updated immediately
2842        self._model_model.layoutChanged.emit()
2843
2844    def calculateResiduals(self, fitted_data):
2845        """
2846        Calculate and print Chi2 and display chart of residuals. Returns residuals plot object.
2847        """
2848        # Create a new index for holding data
2849        fitted_data.symbol = "Line"
2850
2851        # Modify fitted_data with weighting
2852        weighted_data = self.addWeightingToData(fitted_data)
2853
2854        self.createNewIndex(weighted_data)
2855
2856        # Calculate difference between return_data and logic.data
2857        self.chi2 = FittingUtilities.calculateChi2(weighted_data, self.data)
2858        # Update the control
2859        chi2_repr = "---" if self.chi2 is None else GuiUtils.formatNumber(self.chi2, high=True)
2860        self.lblChi2Value.setText(chi2_repr)
2861
2862        # Plot residuals if actual data
2863        if not self.data_is_loaded:
2864            return
2865
2866        residuals_plot = FittingUtilities.plotResiduals(self.data, weighted_data)
2867        if residuals_plot is None:
2868            return
2869        residuals_plot.id = "Residual " + residuals_plot.id
2870        residuals_plot.plot_role = Data1D.ROLE_RESIDUAL
2871        self.createNewIndex(residuals_plot)
2872        return residuals_plot
2873
2874    def onCategoriesChanged(self):
2875            """
2876            Reload the category/model comboboxes
2877            """
2878            # Store the current combo indices
2879            current_cat = self.cbCategory.currentText()
2880            current_model = self.cbModel.currentText()
2881
2882            # reread the category file and repopulate the combo
2883            self.cbCategory.blockSignals(True)
2884            self.cbCategory.clear()
2885            self.readCategoryInfo()
2886            self.initializeCategoryCombo()
2887
2888            # Scroll back to the original index in Categories
2889            new_index = self.cbCategory.findText(current_cat)
2890            if new_index != -1:
2891                self.cbCategory.setCurrentIndex(new_index)
2892            self.cbCategory.blockSignals(False)
2893            # ...and in the Models
2894            self.cbModel.blockSignals(True)
2895            new_index = self.cbModel.findText(current_model)
2896            if new_index != -1:
2897                self.cbModel.setCurrentIndex(new_index)
2898            self.cbModel.blockSignals(False)
2899
2900            return
2901
2902    def calcException(self, etype, value, tb):
2903        """
2904        Thread threw an exception.
2905        """
2906        # Bring the GUI to normal state
2907        self.enableInteractiveElements()
2908        # TODO: remimplement thread cancellation
2909        logger.error("".join(traceback.format_exception(etype, value, tb)))
2910
2911    def setTableProperties(self, table):
2912        """
2913        Setting table properties
2914        """
2915        # Table properties
2916        table.verticalHeader().setVisible(False)
2917        table.setAlternatingRowColors(True)
2918        table.setSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding, QtWidgets.QSizePolicy.Expanding)
2919        table.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows)
2920        table.resizeColumnsToContents()
2921
2922        # Header
2923        header = table.horizontalHeader()
2924        header.setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
2925        header.ResizeMode(QtWidgets.QHeaderView.Interactive)
2926
2927        # Qt5: the following 2 lines crash - figure out why!
2928        # Resize column 0 and 7 to content
2929        #header.setSectionResizeMode(0, QtWidgets.QHeaderView.ResizeToContents)
2930        #header.setSectionResizeMode(7, QtWidgets.QHeaderView.ResizeToContents)
2931
2932    def setPolyModel(self):
2933        """
2934        Set polydispersity values
2935        """
2936        if not self.model_parameters:
2937            return
2938        self._poly_model.clear()
2939
2940        parameters = self.model_parameters.form_volume_parameters
2941        if self.is2D:
2942            parameters += self.model_parameters.orientation_parameters
2943
2944        [self.setPolyModelParameters(i, param) for i, param in \
2945            enumerate(parameters) if param.polydisperse]
2946
2947        FittingUtilities.addPolyHeadersToModel(self._poly_model)
2948
2949    def setPolyModelParameters(self, i, param):
2950        """
2951        Standard of multishell poly parameter driver
2952        """
2953        param_name = param.name
2954        # see it the parameter is multishell
2955        if '[' in param.name:
2956            # Skip empty shells
2957            if self.current_shell_displayed == 0:
2958                return
2959            else:
2960                # Create as many entries as current shells
2961                for ishell in range(1, self.current_shell_displayed+1):
2962                    # Remove [n] and add the shell numeral
2963                    name = param_name[0:param_name.index('[')] + str(ishell)
2964                    self.addNameToPolyModel(i, name)
2965        else:
2966            # Just create a simple param entry
2967            self.addNameToPolyModel(i, param_name)
2968
2969    def addNameToPolyModel(self, i, param_name):
2970        """
2971        Creates a checked row in the poly model with param_name
2972        """
2973        # Polydisp. values from the sasmodel
2974        width = self.kernel_module.getParam(param_name + '.width')
2975        npts = self.kernel_module.getParam(param_name + '.npts')
2976        nsigs = self.kernel_module.getParam(param_name + '.nsigmas')
2977        _, min, max = self.kernel_module.details[param_name]
2978
2979        # Update local param dict
2980        self.poly_params[param_name + '.width'] = width
2981        self.poly_params[param_name + '.npts'] = npts
2982        self.poly_params[param_name + '.nsigmas'] = nsigs
2983
2984        # Construct a row with polydisp. related variable.
2985        # This will get added to the polydisp. model
2986        # Note: last argument needs extra space padding for decent display of the control
2987        checked_list = ["Distribution of " + param_name, str(width),
2988                        str(min), str(max),
2989                        str(npts), str(nsigs), "gaussian      ",'']
2990        FittingUtilities.addCheckedListToModel(self._poly_model, checked_list)
2991
2992        # All possible polydisp. functions as strings in combobox
2993        func = QtWidgets.QComboBox()
2994        func.addItems([str(name_disp) for name_disp in POLYDISPERSITY_MODELS.keys()])
2995        # Set the default index
2996        func.setCurrentIndex(func.findText(DEFAULT_POLYDISP_FUNCTION))
2997        ind = self._poly_model.index(i,self.lstPoly.itemDelegate().poly_function)
2998        self.lstPoly.setIndexWidget(ind, func)
2999        func.currentIndexChanged.connect(lambda: self.onPolyComboIndexChange(str(func.currentText()), i))
3000
3001    def onPolyFilenameChange(self, row_index):
3002        """
3003        Respond to filename_updated signal from the delegate
3004        """
3005        # For the given row, invoke the "array" combo handler
3006        array_caption = 'array'
3007
3008        # Get the combo box reference
3009        ind = self._poly_model.index(row_index, self.lstPoly.itemDelegate().poly_function)
3010        widget = self.lstPoly.indexWidget(ind)
3011
3012        # Update the combo box so it displays "array"
3013        widget.blockSignals(True)
3014        widget.setCurrentIndex(self.lstPoly.itemDelegate().POLYDISPERSE_FUNCTIONS.index(array_caption))
3015        widget.blockSignals(False)
3016
3017        # Invoke the file reader
3018        self.onPolyComboIndexChange(array_caption, row_index)
3019
3020    def onPolyComboIndexChange(self, combo_string, row_index):
3021        """
3022        Modify polydisp. defaults on function choice
3023        """
3024        # Get npts/nsigs for current selection
3025        param = self.model_parameters.form_volume_parameters[row_index]
3026        file_index = self._poly_model.index(row_index, self.lstPoly.itemDelegate().poly_function)
3027        combo_box = self.lstPoly.indexWidget(file_index)
3028        try:
3029            self.disp_model = POLYDISPERSITY_MODELS[combo_string]()
3030        except IndexError:
3031            logger.error("Error in setting the dispersion model. Reverting to Gaussian.")
3032            self.disp_model = POLYDISPERSITY_MODELS['gaussian']()
3033
3034        def updateFunctionCaption(row):
3035            # Utility function for update of polydispersity function name in the main model
3036            if not self.isCheckable(row):
3037                return
3038            param_name = self._model_model.item(row, 0).text()
3039            if param_name !=  param.name:
3040                return
3041            # Modify the param value
3042            self._model_model.blockSignals(True)
3043            if self.has_error_column:
3044                # err column changes the indexing
3045                self._model_model.item(row, 0).child(0).child(0,5).setText(combo_string)
3046            else:
3047                self._model_model.item(row, 0).child(0).child(0,4).setText(combo_string)
3048            self._model_model.blockSignals(False)
3049
3050        if combo_string == 'array':
3051            try:
3052                # assure the combo is at the right index
3053                combo_box.blockSignals(True)
3054                combo_box.setCurrentIndex(combo_box.findText(combo_string))
3055                combo_box.blockSignals(False)
3056                # Load the file
3057                self.loadPolydispArray(row_index)
3058                # Update main model for display
3059                self.iterateOverModel(updateFunctionCaption)
3060                self.kernel_module.set_dispersion(param.name, self.disp_model)
3061                # uncheck the parameter
3062                self._poly_model.item(row_index, 0).setCheckState(QtCore.Qt.Unchecked)
3063                # disable the row
3064                lo = self.lstPoly.itemDelegate().poly_parameter
3065                hi = self.lstPoly.itemDelegate().poly_function
3066                self._poly_model.blockSignals(True)
3067                [self._poly_model.item(row_index, i).setEnabled(False) for i in range(lo, hi)]
3068                self._poly_model.blockSignals(False)
3069                return
3070            except IOError:
3071                combo_box.setCurrentIndex(self.orig_poly_index)
3072                # Pass for cancel/bad read
3073                pass
3074        else:
3075            self.kernel_module.set_dispersion(param.name, self.disp_model)
3076
3077        # Enable the row in case it was disabled by Array
3078        self._poly_model.blockSignals(True)
3079        max_range = self.lstPoly.itemDelegate().poly_filename
3080        [self._poly_model.item(row_index, i).setEnabled(True) for i in range(7)]
3081        file_index = self._poly_model.index(row_index, self.lstPoly.itemDelegate().poly_filename)
3082        self._poly_model.setData(file_index, "")
3083        self._poly_model.blockSignals(False)
3084
3085        npts_index = self._poly_model.index(row_index, self.lstPoly.itemDelegate().poly_npts)
3086        nsigs_index = self._poly_model.index(row_index, self.lstPoly.itemDelegate().poly_nsigs)
3087
3088        npts = POLYDISPERSITY_MODELS[str(combo_string)].default['npts']
3089        nsigs = POLYDISPERSITY_MODELS[str(combo_string)].default['nsigmas']
3090
3091        self._poly_model.setData(npts_index, npts)
3092        self._poly_model.setData(nsigs_index, nsigs)
3093
3094        self.iterateOverModel(updateFunctionCaption)
3095        self.orig_poly_index = combo_box.currentIndex()
3096
3097    def loadPolydispArray(self, row_index):
3098        """
3099        Show the load file dialog and loads requested data into state
3100        """
3101        datafile = QtWidgets.QFileDialog.getOpenFileName(
3102            self, "Choose a weight file", "", "All files (*.*)", None,
3103            QtWidgets.QFileDialog.DontUseNativeDialog)[0]
3104
3105        if not datafile:
3106            logger.info("No weight data chosen.")
3107            raise IOError
3108
3109        values = []
3110        weights = []
3111        def appendData(data_tuple):
3112            """
3113            Fish out floats from a tuple of strings
3114            """
3115            try:
3116                values.append(float(data_tuple[0]))
3117                weights.append(float(data_tuple[1]))
3118            except (ValueError, IndexError):
3119                # just pass through if line with bad data
3120                return
3121
3122        with open(datafile, 'r') as column_file:
3123            column_data = [line.rstrip().split() for line in column_file.readlines()]
3124            [appendData(line) for line in column_data]
3125
3126        # If everything went well - update the sasmodel values
3127        self.disp_model.set_weights(np.array(values), np.array(weights))
3128        # + update the cell with filename
3129        fname = os.path.basename(str(datafile))
3130        fname_index = self._poly_model.index(row_index, self.lstPoly.itemDelegate().poly_filename)
3131        self._poly_model.setData(fname_index, fname)
3132
3133    def onColumnWidthUpdate(self, index, old_size, new_size):
3134        """
3135        Simple state update of the current column widths in the  param list
3136        """
3137        self.lstParamHeaderSizes[index] = new_size
3138
3139    def setMagneticModel(self):
3140        """
3141        Set magnetism values on model
3142        """
3143        if not self.model_parameters:
3144            return
3145        self._magnet_model.clear()
3146        # default initial value
3147        m0 = 0.5
3148        for param in self.model_parameters.call_parameters:
3149            if param.type != 'magnetic': continue
3150            if "M0" in param.name:
3151                m0 += 0.5
3152                value = m0
3153            else:
3154                value = param.default
3155            self.addCheckedMagneticListToModel(param, value)
3156
3157        FittingUtilities.addHeadersToModel(self._magnet_model)
3158
3159    def shellNamesList(self):
3160        """
3161        Returns list of names of all multi-shell parameters
3162        E.g. for sld[n], radius[n], n=1..3 it will return
3163        [sld1, sld2, sld3, radius1, radius2, radius3]
3164        """
3165        multi_names = [p.name[:p.name.index('[')] for p in self.model_parameters.iq_parameters if '[' in p.name]
3166        top_index = self.kernel_module.multiplicity_info.number
3167        shell_names = []
3168        for i in range(1, top_index+1):
3169            for name in multi_names:
3170                shell_names.append(name+str(i))
3171        return shell_names
3172
3173    def addCheckedMagneticListToModel(self, param, value):
3174        """
3175        Wrapper for model update with a subset of magnetic parameters
3176        """
3177        try:
3178            basename, _ = param.name.rsplit('_', 1)
3179        except ValueError:
3180            basename = param.name
3181        if basename in self.shell_names:
3182            try:
3183                shell_index = int(basename[-2:])
3184            except ValueError:
3185                shell_index = int(basename[-1:])
3186
3187            if shell_index > self.current_shell_displayed:
3188                return
3189
3190        checked_list = [param.name,
3191                        str(value),
3192                        str(param.limits[0]),
3193                        str(param.limits[1]),
3194                        param.units]
3195
3196        self.magnet_params[param.name] = value
3197
3198        FittingUtilities.addCheckedListToModel(self._magnet_model, checked_list)
3199
3200    def enableStructureFactorControl(self, structure_factor):
3201        """
3202        Add structure factors to the list of parameters
3203        """
3204        if self.kernel_module.is_form_factor or structure_factor == 'None':
3205            self.enableStructureCombo()
3206        else:
3207            self.disableStructureCombo()
3208
3209    def addExtraShells(self):
3210        """
3211        Add a combobox for multiple shell display
3212        """
3213        param_name, param_length = FittingUtilities.getMultiplicity(self.model_parameters)
3214
3215        if param_length == 0:
3216            return
3217
3218        # cell 1: variable name
3219        item1 = QtGui.QStandardItem(param_name)
3220
3221        func = QtWidgets.QComboBox()
3222
3223        # cell 2: combobox
3224        item2 = QtGui.QStandardItem()
3225
3226        # cell 3: min value
3227        item3 = QtGui.QStandardItem()
3228        # set the cell to be non-editable
3229        item3.setFlags(item3.flags() ^ QtCore.Qt.ItemIsEditable)
3230
3231        # cell 4: max value
3232        item4 = QtGui.QStandardItem()
3233        # set the cell to be non-editable
3234        item4.setFlags(item4.flags() ^ QtCore.Qt.ItemIsEditable)
3235
3236        # cell 4: SLD button
3237        item5 = QtGui.QStandardItem()
3238        button = QtWidgets.QPushButton()
3239        button.setText("Show SLD Profile")
3240
3241        self._model_model.appendRow([item1, item2, item3, item4, item5])
3242
3243        # Beautify the row:  span columns 2-4
3244        shell_row = self._model_model.rowCount()
3245        shell_index = self._model_model.index(shell_row-1, 1)
3246        button_index = self._model_model.index(shell_row-1, 4)
3247
3248        self.lstParams.setIndexWidget(shell_index, func)
3249        self.lstParams.setIndexWidget(button_index, button)
3250        self._n_shells_row = shell_row - 1
3251
3252        # Get the default number of shells for the model
3253        kernel_pars = self.kernel_module._model_info.parameters.kernel_parameters
3254        shell_par = None
3255        for par in kernel_pars:
3256            parname = par.name
3257            if '[' in parname:
3258                 parname = parname[:parname.index('[')]
3259            if parname == param_name:
3260                shell_par = par
3261                break
3262        if shell_par is None:
3263            logger.error("Could not find %s in kernel parameters.", param_name)
3264            return
3265        default_shell_count = shell_par.default
3266        shell_min = 0
3267        shell_max = 0
3268        try:
3269            shell_min = int(shell_par.limits[0])
3270            shell_max = int(shell_par.limits[1])
3271        except IndexError as ex:
3272            # no info about limits
3273            pass
3274        except OverflowError:
3275            # Try to limit shell_par, if possible
3276            if float(shell_par.limits[1])==np.inf:
3277                shell_max = 9
3278            logging.warning("Limiting shell count to 9.")
3279        except Exception as ex:
3280            logging.error("Badly defined multiplicity: "+ str(ex))
3281            return
3282        # don't update the kernel here - this data is display only
3283        self._model_model.blockSignals(True)
3284        item3.setText(str(shell_min))
3285        item4.setText(str(shell_max))
3286        self._model_model.blockSignals(False)
3287
3288        ## Respond to index change
3289        #func.currentTextChanged.connect(self.modifyShellsInList)
3290
3291        # Respond to button press
3292        button.clicked.connect(self.onShowSLDProfile)
3293
3294        # Available range of shells displayed in the combobox
3295        func.addItems([str(i) for i in range(shell_min, shell_max+1)])
3296
3297        # Respond to index change
3298        func.currentTextChanged.connect(self.modifyShellsInList)
3299
3300        # Add default number of shells to the model
3301        func.setCurrentText(str(default_shell_count))
3302        self.modifyShellsInList(str(default_shell_count))
3303
3304    def modifyShellsInList(self, text):
3305        """
3306        Add/remove additional multishell parameters
3307        """
3308        # Find row location of the combobox
3309        first_row = self._n_shells_row + 1
3310        remove_rows = self._num_shell_params
3311        try:
3312            index = int(text)
3313        except ValueError:
3314            # bad text on the control!
3315            index = 0
3316            logger.error("Multiplicity incorrect! Setting to 0")
3317        self.kernel_module.multiplicity = index
3318        if remove_rows > 1:
3319            self._model_model.removeRows(first_row, remove_rows)
3320
3321        new_rows = FittingUtilities.addShellsToModel(
3322                self.model_parameters,
3323                self._model_model,
3324                index,
3325                first_row,
3326                self.lstParams)
3327
3328        self._num_shell_params = len(new_rows)
3329        self.current_shell_displayed = index
3330
3331        # Param values for existing shells were reset to default; force all changes into kernel module
3332        for row in new_rows:
3333            par = row[0].text()
3334            val = GuiUtils.toDouble(row[1].text())
3335            self.kernel_module.setParam(par, val)
3336
3337        # Change 'n' in the parameter model; also causes recalculation
3338        self._model_model.item(self._n_shells_row, 1).setText(str(index))
3339
3340        # Update relevant models
3341        self.setPolyModel()
3342        if self.canHaveMagnetism():
3343            self.setMagneticModel()
3344
3345    def onShowSLDProfile(self):
3346        """
3347        Show a quick plot of SLD profile
3348        """
3349        # get profile data
3350        try:
3351            x, y = self.kernel_module.getProfile()
3352        except TypeError:
3353            msg = "SLD profile calculation failed."
3354            logging.error(msg)
3355            return
3356
3357        y *= 1.0e6
3358        profile_data = Data1D(x=x, y=y)
3359        profile_data.name = "SLD"
3360        profile_data.scale = 'linear'
3361        profile_data.symbol = 'Line'
3362        profile_data.hide_error = True
3363        profile_data._xaxis = "R(\AA)"
3364        profile_data._yaxis = "SLD(10^{-6}\AA^{-2})"
3365
3366        plotter = PlotterWidget(self, quickplot=True)
3367        plotter.data = profile_data
3368        plotter.showLegend = True
3369        plotter.plot(hide_error=True, marker='-')
3370
3371        self.plot_widget = QtWidgets.QWidget()
3372        self.plot_widget.setWindowTitle("Scattering Length Density Profile")
3373        layout = QtWidgets.QVBoxLayout()
3374        layout.addWidget(plotter)
3375        self.plot_widget.setLayout(layout)
3376        self.plot_widget.show()
3377
3378    def setInteractiveElements(self, enabled=True):
3379        """
3380        Switch interactive GUI elements on/off
3381        """
3382        assert isinstance(enabled, bool)
3383
3384        self.lstParams.setEnabled(enabled)
3385        self.lstPoly.setEnabled(enabled)
3386        self.lstMagnetic.setEnabled(enabled)
3387
3388        self.cbCategory.setEnabled(enabled)
3389
3390        if enabled:
3391            # worry about original enablement of model and SF
3392            self.cbModel.setEnabled(self.enabled_cbmodel)
3393            self.cbStructureFactor.setEnabled(self.enabled_sfmodel)
3394        else:
3395            self.cbModel.setEnabled(enabled)
3396            self.cbStructureFactor.setEnabled(enabled)
3397
3398        self.cmdPlot.setEnabled(enabled)
3399
3400    def enableInteractiveElements(self):
3401        """
3402        Set buttion caption on fitting/calculate finish
3403        Enable the param table(s)
3404        """
3405        # Notify the user that fitting is available
3406        self.cmdFit.setStyleSheet('QPushButton {color: black;}')
3407        self.cmdFit.setText("Fit")
3408        self.fit_started = False
3409        self.setInteractiveElements(True)
3410
3411    def disableInteractiveElements(self):
3412        """
3413        Set buttion caption on fitting/calculate start
3414        Disable the param table(s)
3415        """
3416        # Notify the user that fitting is being run
3417        # Allow for stopping the job
3418        self.cmdFit.setStyleSheet('QPushButton {color: red;}')
3419        self.cmdFit.setText('Stop fit')
3420        self.setInteractiveElements(False)
3421
3422    def disableInteractiveElementsOnCalculate(self):
3423        """
3424        Set buttion caption on fitting/calculate start
3425        Disable the param table(s)
3426        """
3427        # Notify the user that fitting is being run
3428        # Allow for stopping the job
3429        self.cmdFit.setStyleSheet('QPushButton {color: red;}')
3430        self.cmdFit.setText('Running...')
3431        self.setInteractiveElements(False)
3432
3433    def readFitPage(self, fp):
3434        """
3435        Read in state from a fitpage object and update GUI
3436        """
3437        assert isinstance(fp, FitPage)
3438        # Main tab info
3439        self.logic.data.filename = fp.filename
3440        self.data_is_loaded = fp.data_is_loaded
3441        self.chkPolydispersity.setCheckState(fp.is_polydisperse)
3442        self.chkMagnetism.setCheckState(fp.is_magnetic)
3443        self.chk2DView.setCheckState(fp.is2D)
3444
3445        # Update the comboboxes
3446        self.cbCategory.setCurrentIndex(self.cbCategory.findText(fp.current_category))
3447        self.cbModel.setCurrentIndex(self.cbModel.findText(fp.current_model))
3448        if fp.current_factor:
3449            self.cbStructureFactor.setCurrentIndex(self.cbStructureFactor.findText(fp.current_factor))
3450
3451        self.chi2 = fp.chi2
3452
3453        # Options tab
3454        self.q_range_min = fp.fit_options[fp.MIN_RANGE]
3455        self.q_range_max = fp.fit_options[fp.MAX_RANGE]
3456        self.npts = fp.fit_options[fp.NPTS]
3457        self.log_points = fp.fit_options[fp.LOG_POINTS]
3458        self.weighting = fp.fit_options[fp.WEIGHTING]
3459
3460        # Models
3461        self._model_model = fp.model_model
3462        self._poly_model = fp.poly_model
3463        self._magnet_model = fp.magnetism_model
3464
3465        # Resolution tab
3466        smearing = fp.smearing_options[fp.SMEARING_OPTION]
3467        accuracy = fp.smearing_options[fp.SMEARING_ACCURACY]
3468        smearing_min = fp.smearing_options[fp.SMEARING_MIN]
3469        smearing_max = fp.smearing_options[fp.SMEARING_MAX]
3470        self.smearing_widget.setState(smearing, accuracy, smearing_min, smearing_max)
3471
3472        # TODO: add polidyspersity and magnetism
3473
3474    def saveToFitPage(self, fp):
3475        """
3476        Write current state to the given fitpage
3477        """
3478        assert isinstance(fp, FitPage)
3479
3480        # Main tab info
3481        fp.filename = self.logic.data.filename
3482        fp.data_is_loaded = self.data_is_loaded
3483        fp.is_polydisperse = self.chkPolydispersity.isChecked()
3484        fp.is_magnetic = self.chkMagnetism.isChecked()
3485        fp.is2D = self.chk2DView.isChecked()
3486        fp.data = self.data
3487
3488        # Use current models - they contain all the required parameters
3489        fp.model_model = self._model_model
3490        fp.poly_model = self._poly_model
3491        fp.magnetism_model = self._magnet_model
3492
3493        if self.cbCategory.currentIndex() != 0:
3494            fp.current_category = str(self.cbCategory.currentText())
3495            fp.current_model = str(self.cbModel.currentText())
3496
3497        if self.cbStructureFactor.isEnabled() and self.cbStructureFactor.currentIndex() != 0:
3498            fp.current_factor = str(self.cbStructureFactor.currentText())
3499        else:
3500            fp.current_factor = ''
3501
3502        fp.chi2 = self.chi2
3503        fp.main_params_to_fit = self.main_params_to_fit
3504        fp.poly_params_to_fit = self.poly_params_to_fit
3505        fp.magnet_params_to_fit = self.magnet_params_to_fit
3506        fp.kernel_module = self.kernel_module
3507
3508        # Algorithm options
3509        # fp.algorithm = self.parent.fit_options.selected_id
3510
3511        # Options tab
3512        fp.fit_options[fp.MIN_RANGE] = self.q_range_min
3513        fp.fit_options[fp.MAX_RANGE] = self.q_range_max
3514        fp.fit_options[fp.NPTS] = self.npts
3515        #fp.fit_options[fp.NPTS_FIT] = self.npts_fit
3516        fp.fit_options[fp.LOG_POINTS] = self.log_points
3517        fp.fit_options[fp.WEIGHTING] = self.weighting
3518
3519        # Resolution tab
3520        smearing, accuracy, smearing_min, smearing_max = self.smearing_widget.state()
3521        fp.smearing_options[fp.SMEARING_OPTION] = smearing
3522        fp.smearing_options[fp.SMEARING_ACCURACY] = accuracy
3523        fp.smearing_options[fp.SMEARING_MIN] = smearing_min
3524        fp.smearing_options[fp.SMEARING_MAX] = smearing_max
3525
3526        # TODO: add polidyspersity and magnetism
3527
3528    def updateUndo(self):
3529        """
3530        Create a new state page and add it to the stack
3531        """
3532        if self.undo_supported:
3533            self.pushFitPage(self.currentState())
3534
3535    def currentState(self):
3536        """
3537        Return fit page with current state
3538        """
3539        new_page = FitPage()
3540        self.saveToFitPage(new_page)
3541
3542        return new_page
3543
3544    def pushFitPage(self, new_page):
3545        """
3546        Add a new fit page object with current state
3547        """
3548        self.page_stack.append(new_page)
3549
3550    def popFitPage(self):
3551        """
3552        Remove top fit page from stack
3553        """
3554        if self.page_stack:
3555            self.page_stack.pop()
3556
3557    def getReport(self):
3558        """
3559        Create and return HTML report with parameters and charts
3560        """
3561        index = None
3562        if self.all_data:
3563            index = self.all_data[self.data_index]
3564        else:
3565            index = self.theory_item
3566        params = FittingUtilities.getStandardParam(self._model_model)
3567        poly_params = []
3568        magnet_params = []
3569        if self.chkPolydispersity.isChecked() and self._poly_model.rowCount() > 0:
3570            poly_params = FittingUtilities.getStandardParam(self._poly_model)
3571        if self.chkMagnetism.isChecked() and self.canHaveMagnetism() and self._magnet_model.rowCount() > 0:
3572            magnet_params = FittingUtilities.getStandardParam(self._magnet_model)
3573        report_logic = ReportPageLogic(self,
3574                                       kernel_module=self.kernel_module,
3575                                       data=self.data,
3576                                       index=index,
3577                                       params=params+poly_params+magnet_params)
3578
3579        return report_logic.reportList()
3580
3581    def loadPageStateCallback(self,state=None, datainfo=None, format=None):
3582        """
3583        This is a callback method called from the CANSAS reader.
3584        We need the instance of this reader only for writing out a file,
3585        so there's nothing here.
3586        Until Load Analysis is implemented, that is.
3587        """
3588        pass
3589
3590    def loadPageState(self, pagestate=None):
3591        """
3592        Load the PageState object and update the current widget
3593        """
3594        filepath = self.loadAnalysisFile()
3595        if filepath is None or filepath == "":
3596            return
3597
3598        with open(filepath, 'r') as statefile:
3599            #column_data = [line.rstrip().split() for line in statefile.readlines()]
3600            lines = statefile.readlines()
3601
3602        # convert into list of lists
3603        pass
3604
3605    def loadAnalysisFile(self):
3606        """
3607        Called when the "Open Project" menu item chosen.
3608        """
3609        default_name = "FitPage"+str(self.tab_id)+".fitv"
3610        wildcard = "fitv files (*.fitv)"
3611        kwargs = {
3612            'caption'   : 'Open Analysis',
3613            'directory' : default_name,
3614            'filter'    : wildcard,
3615            'parent'    : self,
3616        }
3617        filename = QtWidgets.QFileDialog.getOpenFileName(**kwargs)[0]
3618        return filename
3619
3620    def onCopyToClipboard(self, format=None):
3621        """
3622        Copy current fitting parameters into the clipboard
3623        using requested formatting:
3624        plain, excel, latex
3625        """
3626        param_list = self.getFitParameters()
3627        if format=="":
3628            param_list = self.getFitPage()
3629            param_list += self.getFitModel()
3630            formatted_output = FittingUtilities.formatParameters(param_list)
3631        elif format == "Excel":
3632            formatted_output = FittingUtilities.formatParametersExcel(param_list[1:])
3633        elif format == "Latex":
3634            formatted_output = FittingUtilities.formatParametersLatex(param_list[1:])
3635        else:
3636            raise AttributeError("Bad parameter output format specifier.")
3637
3638        # Dump formatted_output to the clipboard
3639        cb = QtWidgets.QApplication.clipboard()
3640        cb.setText(formatted_output)
3641
3642    def getFitModel(self):
3643        """
3644        serializes combobox state
3645        """
3646        param_list = []
3647        model = str(self.cbModel.currentText())
3648        category = str(self.cbCategory.currentText())
3649        structure = str(self.cbStructureFactor.currentText())
3650        param_list.append(['fitpage_category', category])
3651        param_list.append(['fitpage_model', model])
3652        param_list.append(['fitpage_structure', structure])
3653
3654        return param_list
3655
3656    def getFitPage(self):
3657        """
3658        serializes full state of this fit page
3659        """
3660        # run a loop over all parameters and pull out
3661        # first - regular params
3662        param_list = self.getFitParameters()
3663
3664        param_list.append(['is_data', str(self.data_is_loaded)])
3665        data_ids = []
3666        filenames = []
3667        if self.is_batch_fitting:
3668            for item in self.all_data:
3669                # need item->data->data_id
3670                data = GuiUtils.dataFromItem(item)
3671                data_ids.append(data.id)
3672                filenames.append(data.filename)
3673        else:
3674            if self.data_is_loaded:
3675                data_ids = [str(self.logic.data.id)]
3676                filenames = [str(self.logic.data.filename)]
3677        param_list.append(['is_batch_fitting', str(self.is_batch_fitting)])
3678        param_list.append(['data_name', filenames])
3679        param_list.append(['data_id', data_ids])
3680        param_list.append(['tab_name', self.modelName()])
3681        # option tab
3682        param_list.append(['q_range_min', str(self.q_range_min)])
3683        param_list.append(['q_range_max', str(self.q_range_max)])
3684        param_list.append(['q_weighting', str(self.weighting)])
3685        param_list.append(['weighting', str(self.options_widget.weighting)])
3686
3687        # resolution
3688        smearing, accuracy, smearing_min, smearing_max = self.smearing_widget.state()
3689        index = self.smearing_widget.cbSmearing.currentIndex()
3690        param_list.append(['smearing', str(index)])
3691        param_list.append(['smearing_min', str(smearing_min)])
3692        param_list.append(['smearing_max', str(smearing_max)])
3693
3694        # checkboxes, if required
3695        has_polydisp = self.chkPolydispersity.isChecked()
3696        has_magnetism = self.chkMagnetism.isChecked()
3697        has_chain = self.chkChainFit.isChecked()
3698        has_2D = self.chk2DView.isChecked()
3699        param_list.append(['polydisperse_params', str(has_polydisp)])
3700        param_list.append(['magnetic_params', str(has_magnetism)])
3701        param_list.append(['chainfit_params', str(has_chain)])
3702        param_list.append(['2D_params', str(has_2D)])
3703
3704        return param_list
3705
3706    def getFitParameters(self):
3707        """
3708        serializes current parameters
3709        """
3710        param_list = []
3711        if self.kernel_module is None:
3712            return param_list
3713
3714        param_list.append(['model_name', str(self.cbModel.currentText())])
3715
3716        def gatherParams(row):
3717            """
3718            Create list of main parameters based on _model_model
3719            """
3720            param_name = str(self._model_model.item(row, 0).text())
3721
3722            # Assure this is a parameter - must contain a checkbox
3723            if not self._model_model.item(row, 0).isCheckable():
3724                # maybe it is a combobox item (multiplicity)
3725                try:
3726                    index = self._model_model.index(row, 1)
3727                    widget = self.lstParams.indexWidget(index)
3728                    if widget is None:
3729                        return
3730                    if isinstance(widget, QtWidgets.QComboBox):
3731                        # find the index of the combobox
3732                        current_index = widget.currentIndex()
3733                        param_list.append([param_name, 'None', str(current_index)])
3734                except Exception as ex:
3735                    pass
3736                return
3737
3738            param_checked = str(self._model_model.item(row, 0).checkState() == QtCore.Qt.Checked)
3739            # Value of the parameter. In some cases this is the text of the combobox choice.
3740            param_value = str(self._model_model.item(row, 1).text())
3741            param_error = None
3742            param_min = None
3743            param_max = None
3744            column_offset = 0
3745            if self.has_error_column:
3746                column_offset = 1
3747                param_error = str(self._model_model.item(row, 1+column_offset).text())
3748            try:
3749                param_min = str(self._model_model.item(row, 2+column_offset).text())
3750                param_max = str(self._model_model.item(row, 3+column_offset).text())
3751            except:
3752                pass
3753            # Do we have any constraints on this parameter?
3754            constraint = self.getConstraintForRow(row)
3755            cons = ()
3756            if constraint is not None:
3757                value = constraint.value
3758                func = constraint.func
3759                value_ex = constraint.value_ex
3760                param = constraint.param
3761                validate = constraint.validate
3762
3763                cons = (value, param, value_ex, validate, func)
3764
3765            param_list.append([param_name, param_checked, param_value,param_error, param_min, param_max, cons])
3766
3767        def gatherPolyParams(row):
3768            """
3769            Create list of polydisperse parameters based on _poly_model
3770            """
3771            param_name = str(self._poly_model.item(row, 0).text()).split()[-1]
3772            param_checked = str(self._poly_model.item(row, 0).checkState() == QtCore.Qt.Checked)
3773            param_value = str(self._poly_model.item(row, 1).text())
3774            param_error = None
3775            column_offset = 0
3776            if self.has_poly_error_column:
3777                column_offset = 1
3778                param_error = str(self._poly_model.item(row, 1+column_offset).text())
3779            param_min   = str(self._poly_model.item(row, 2+column_offset).text())
3780            param_max   = str(self._poly_model.item(row, 3+column_offset).text())
3781            param_npts  = str(self._poly_model.item(row, 4+column_offset).text())
3782            param_nsigs = str(self._poly_model.item(row, 5+column_offset).text())
3783            param_fun   = str(self._poly_model.item(row, 6+column_offset).text()).rstrip()
3784            index = self._poly_model.index(row, 6+column_offset)
3785            widget = self.lstPoly.indexWidget(index)
3786            if widget is not None and isinstance(widget, QtWidgets.QComboBox):
3787                param_fun = widget.currentText()
3788            # width
3789            name = param_name+".width"
3790            param_list.append([name, param_checked, param_value, param_error,
3791                               param_min, param_max, param_npts, param_nsigs, param_fun])
3792
3793        def gatherMagnetParams(row):
3794            """
3795            Create list of magnetic parameters based on _magnet_model
3796            """
3797            param_name = str(self._magnet_model.item(row, 0).text())
3798            param_checked = str(self._magnet_model.item(row, 0).checkState() == QtCore.Qt.Checked)
3799            param_value = str(self._magnet_model.item(row, 1).text())
3800            param_error = None
3801            column_offset = 0
3802            if self.has_magnet_error_column:
3803                column_offset = 1
3804                param_error = str(self._magnet_model.item(row, 1+column_offset).text())
3805            param_min = str(self._magnet_model.item(row, 2+column_offset).text())
3806            param_max = str(self._magnet_model.item(row, 3+column_offset).text())
3807            param_list.append([param_name, param_checked, param_value,
3808                               param_error, param_min, param_max])
3809
3810        self.iterateOverModel(gatherParams)
3811        if self.chkPolydispersity.isChecked():
3812            self.iterateOverPolyModel(gatherPolyParams)
3813        if self.chkMagnetism.isChecked() and self.canHaveMagnetism():
3814            self.iterateOverMagnetModel(gatherMagnetParams)
3815
3816        if self.kernel_module.is_multiplicity_model:
3817            param_list.append(['multiplicity', str(self.kernel_module.multiplicity)])
3818
3819        return param_list
3820
3821    def onParameterPaste(self):
3822        """
3823        Use the clipboard to update fit state
3824        """
3825        # Check if the clipboard contains right stuff
3826        cb = QtWidgets.QApplication.clipboard()
3827        cb_text = cb.text()
3828
3829        lines = cb_text.split(':')
3830        if lines[0] != 'sasview_parameter_values':
3831            return False
3832
3833        # put the text into dictionary
3834        line_dict = {}
3835        for line in lines[1:]:
3836            content = line.split(',')
3837            if len(content) > 1:
3838                line_dict[content[0]] = content[1:]
3839
3840        self.updatePageWithParameters(line_dict)
3841
3842    def createPageForParameters(self, line_dict):
3843        """
3844        Sets up page with requested model/str factor
3845        and fills it up with sent parameters
3846        """
3847        if 'fitpage_category' in line_dict:
3848            self.cbCategory.setCurrentIndex(self.cbCategory.findText(line_dict['fitpage_category'][0]))
3849        if 'fitpage_model' in line_dict:
3850            self.cbModel.setCurrentIndex(self.cbModel.findText(line_dict['fitpage_model'][0]))
3851        if 'fitpage_structure' in line_dict:
3852            self.cbStructureFactor.setCurrentIndex(self.cbStructureFactor.findText(line_dict['fitpage_structure'][0]))
3853
3854        # Now that the page is ready for parameters, fill it up
3855        self.updatePageWithParameters(line_dict)
3856
3857    def updatePageWithParameters(self, line_dict):
3858        """
3859        Update FitPage with parameters in line_dict
3860        """
3861        if 'model_name' not in line_dict.keys():
3862            return
3863        model = line_dict['model_name'][0]
3864        context = {}
3865
3866        if 'multiplicity' in line_dict.keys():
3867            multip = int(line_dict['multiplicity'][0], 0)
3868            # reset the model with multiplicity, so further updates are saved
3869            if self.kernel_module.is_multiplicity_model:
3870                self.kernel_module.multiplicity=multip
3871                self.updateMultiplicityCombo(multip)
3872
3873        if 'tab_name' in line_dict.keys():
3874            self.kernel_module.name = line_dict['tab_name'][0]
3875        if 'polydisperse_params' in line_dict.keys():
3876            self.chkPolydispersity.setChecked(line_dict['polydisperse_params'][0]=='True')
3877        if 'magnetic_params' in line_dict.keys():
3878            self.chkMagnetism.setChecked(line_dict['magnetic_params'][0]=='True')
3879        if 'chainfit_params' in line_dict.keys():
3880            self.chkChainFit.setChecked(line_dict['chainfit_params'][0]=='True')
3881        if '2D_params' in line_dict.keys():
3882            self.chk2DView.setChecked(line_dict['2D_params'][0]=='True')
3883
3884        # Create the context dictionary for parameters
3885        context['model_name'] = model
3886        for key, value in line_dict.items():
3887            if len(value) > 2:
3888                context[key] = value
3889
3890        if str(self.cbModel.currentText()) != str(context['model_name']):
3891            msg = QtWidgets.QMessageBox()
3892            msg.setIcon(QtWidgets.QMessageBox.Information)
3893            msg.setText("The model in the clipboard is not the same as the currently loaded model. \
3894                         Not all parameters saved may paste correctly.")
3895            msg.setStandardButtons(QtWidgets.QMessageBox.Ok | QtWidgets.QMessageBox.Cancel)
3896            result = msg.exec_()
3897            if result == QtWidgets.QMessageBox.Ok:
3898                pass
3899            else:
3900                return
3901
3902        if 'smearing' in line_dict.keys():
3903            try:
3904                index = int(line_dict['smearing'][0])
3905                self.smearing_widget.cbSmearing.setCurrentIndex(index)
3906            except ValueError:
3907                pass
3908        if 'smearing_min' in line_dict.keys():
3909            try:
3910                self.smearing_widget.dq_l = float(line_dict['smearing_min'][0])
3911            except ValueError:
3912                pass
3913        if 'smearing_max' in line_dict.keys():
3914            try:
3915                self.smearing_widget.dq_r = float(line_dict['smearing_max'][0])
3916            except ValueError:
3917                pass
3918
3919        if 'q_range_max' in line_dict.keys():
3920            try:
3921                self.q_range_min = float(line_dict['q_range_min'][0])
3922                self.q_range_max = float(line_dict['q_range_max'][0])
3923            except ValueError:
3924                pass
3925        self.options_widget.updateQRange(self.q_range_min, self.q_range_max, self.npts)
3926        try:
3927            button_id = int(line_dict['weighting'][0])
3928            for button in self.options_widget.weightingGroup.buttons():
3929                if abs(self.options_widget.weightingGroup.id(button)) == button_id+2:
3930                    button.setChecked(True)
3931                    break
3932        except ValueError:
3933            pass
3934
3935        self.updateFullModel(context)
3936        self.updateFullPolyModel(context)
3937        self.updateFullMagnetModel(context)
3938
3939    def updateMultiplicityCombo(self, multip):
3940        """
3941        Find and update the multiplicity combobox
3942        """
3943        index = self._model_model.index(self._n_shells_row, 1)
3944        widget = self.lstParams.indexWidget(index)
3945        if widget is not None and isinstance(widget, QtWidgets.QComboBox):
3946            widget.setCurrentIndex(widget.findText(str(multip)))
3947        self.current_shell_displayed = multip
3948
3949    def updateFullModel(self, param_dict):
3950        """
3951        Update the model with new parameters
3952        """
3953        assert isinstance(param_dict, dict)
3954        if not dict:
3955            return
3956
3957        def updateFittedValues(row):
3958            # Utility function for main model update
3959            # internal so can use closure for param_dict
3960            param_name = str(self._model_model.item(row, 0).text())
3961            if param_name not in list(param_dict.keys()):
3962                return
3963            # Special case of combo box in the cell (multiplicity)
3964            param_line = param_dict[param_name]
3965            if len(param_line) == 1:
3966                # modify the shells value
3967                try:
3968                    combo_index = int(param_line[0])
3969                except ValueError:
3970                    # quietly pass
3971                    return
3972                index = self._model_model.index(row, 1)
3973                widget = self.lstParams.indexWidget(index)
3974                if widget is not None and isinstance(widget, QtWidgets.QComboBox):
3975                    #widget.setCurrentIndex(combo_index)
3976                    return
3977            # checkbox state
3978            param_checked = QtCore.Qt.Checked if param_dict[param_name][0] == "True" else QtCore.Qt.Unchecked
3979            self._model_model.item(row, 0).setCheckState(param_checked)
3980
3981            # parameter value can be either just a value or text on the combobox
3982            param_text = param_dict[param_name][1]
3983            index = self._model_model.index(row, 1)
3984            widget = self.lstParams.indexWidget(index)
3985            if widget is not None and isinstance(widget, QtWidgets.QComboBox):
3986                # Find the right index based on text
3987                combo_index = int(param_text, 0)
3988                widget.setCurrentIndex(combo_index)
3989            else:
3990                # modify the param value
3991                param_repr = GuiUtils.formatNumber(param_text, high=True)
3992                self._model_model.item(row, 1).setText(param_repr)
3993
3994            # Potentially the error column
3995            ioffset = 0
3996            joffset = 0
3997            if len(param_dict[param_name])>5:
3998                # error values are not editable - no need to update
3999                ioffset = 1
4000            if self.has_error_column:
4001                joffset = 1
4002            # min/max
4003            try:
4004                param_repr = GuiUtils.formatNumber(param_dict[param_name][2+ioffset], high=True)
4005                self._model_model.item(row, 2+joffset).setText(param_repr)
4006                param_repr = GuiUtils.formatNumber(param_dict[param_name][3+ioffset], high=True)
4007                self._model_model.item(row, 3+joffset).setText(param_repr)
4008            except:
4009                pass
4010
4011            # constraints
4012            cons = param_dict[param_name][4+ioffset]
4013            if cons is not None and len(cons)==5:
4014                value = cons[0]
4015                param = cons[1]
4016                value_ex = cons[2]
4017                validate = cons[3]
4018                function = cons[4]
4019                constraint = Constraint()
4020                constraint.value = value
4021                constraint.func = function
4022                constraint.param = param
4023                constraint.value_ex = value_ex
4024                constraint.validate = validate
4025                self.addConstraintToRow(constraint=constraint, row=row)
4026
4027            self.setFocus()
4028
4029        self.iterateOverModel(updateFittedValues)
4030
4031    def updateFullPolyModel(self, param_dict):
4032        """
4033        Update the polydispersity model with new parameters, create the errors column
4034        """
4035        assert isinstance(param_dict, dict)
4036        if not dict:
4037            return
4038
4039        def updateFittedValues(row):
4040            # Utility function for main model update
4041            # internal so can use closure for param_dict
4042            if row >= self._poly_model.rowCount():
4043                return
4044            param_name = str(self._poly_model.item(row, 0).text()).rsplit()[-1] + '.width'
4045            if param_name not in list(param_dict.keys()):
4046                return
4047            # checkbox state
4048            param_checked = QtCore.Qt.Checked if param_dict[param_name][0] == "True" else QtCore.Qt.Unchecked
4049            self._poly_model.item(row,0).setCheckState(param_checked)
4050
4051            # modify the param value
4052            param_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
4053            self._poly_model.item(row, 1).setText(param_repr)
4054
4055            # Potentially the error column
4056            ioffset = 0
4057            joffset = 0
4058            if len(param_dict[param_name])>7:
4059                ioffset = 1
4060            if self.has_poly_error_column:
4061                joffset = 1
4062            # min
4063            param_repr = GuiUtils.formatNumber(param_dict[param_name][2+ioffset], high=True)
4064            self._poly_model.item(row, 2+joffset).setText(param_repr)
4065            # max
4066            param_repr = GuiUtils.formatNumber(param_dict[param_name][3+ioffset], high=True)
4067            self._poly_model.item(row, 3+joffset).setText(param_repr)
4068            # Npts
4069            param_repr = GuiUtils.formatNumber(param_dict[param_name][4+ioffset], high=True)
4070            self._poly_model.item(row, 4+joffset).setText(param_repr)
4071            # Nsigs
4072            param_repr = GuiUtils.formatNumber(param_dict[param_name][5+ioffset], high=True)
4073            self._poly_model.item(row, 5+joffset).setText(param_repr)
4074
4075            self.setFocus()
4076
4077        self.iterateOverPolyModel(updateFittedValues)
4078
4079    def updateFullMagnetModel(self, param_dict):
4080        """
4081        Update the magnetism model with new parameters, create the errors column
4082        """
4083        assert isinstance(param_dict, dict)
4084        if not dict:
4085            return
4086
4087        def updateFittedValues(row):
4088            # Utility function for main model update
4089            # internal so can use closure for param_dict
4090            if row >= self._magnet_model.rowCount():
4091                return
4092            param_name = str(self._magnet_model.item(row, 0).text()).rsplit()[-1]
4093            if param_name not in list(param_dict.keys()):
4094                return
4095            # checkbox state
4096            param_checked = QtCore.Qt.Checked if param_dict[param_name][0] == "True" else QtCore.Qt.Unchecked
4097            self._magnet_model.item(row,0).setCheckState(param_checked)
4098
4099            # modify the param value
4100            param_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
4101            self._magnet_model.item(row, 1).setText(param_repr)
4102
4103            # Potentially the error column
4104            ioffset = 0
4105            joffset = 0
4106            if len(param_dict[param_name])>4:
4107                ioffset = 1
4108            if self.has_magnet_error_column:
4109                joffset = 1
4110            # min
4111            param_repr = GuiUtils.formatNumber(param_dict[param_name][2+ioffset], high=True)
4112            self._magnet_model.item(row, 2+joffset).setText(param_repr)
4113            # max
4114            param_repr = GuiUtils.formatNumber(param_dict[param_name][3+ioffset], high=True)
4115            self._magnet_model.item(row, 3+joffset).setText(param_repr)
4116
4117        self.iterateOverMagnetModel(updateFittedValues)
4118
4119    def getCurrentFitState(self, state=None):
4120        """
4121        Store current state for fit_page
4122        """
4123        # save model option
4124        #if self.model is not None:
4125        #    self.disp_list = self.getDispParamList()
4126        #    state.disp_list = copy.deepcopy(self.disp_list)
4127        #    #state.model = self.model.clone()
4128
4129        # Comboboxes
4130        state.categorycombobox = self.cbCategory.currentText()
4131        state.formfactorcombobox = self.cbModel.currentText()
4132        if self.cbStructureFactor.isEnabled():
4133            state.structurecombobox = self.cbStructureFactor.currentText()
4134        state.tcChi = self.chi2
4135
4136        state.enable2D = self.is2D
4137
4138        #state.weights = copy.deepcopy(self.weights)
4139        # save data
4140        state.data = copy.deepcopy(self.data)
4141
4142        # save plotting range
4143        state.qmin = self.q_range_min
4144        state.qmax = self.q_range_max
4145        state.npts = self.npts
4146
4147        #    self.state.enable_disp = self.enable_disp.GetValue()
4148        #    self.state.disable_disp = self.disable_disp.GetValue()
4149
4150        #    self.state.enable_smearer = \
4151        #                        copy.deepcopy(self.enable_smearer.GetValue())
4152        #    self.state.disable_smearer = \
4153        #                        copy.deepcopy(self.disable_smearer.GetValue())
4154
4155        #self.state.pinhole_smearer = \
4156        #                        copy.deepcopy(self.pinhole_smearer.GetValue())
4157        #self.state.slit_smearer = copy.deepcopy(self.slit_smearer.GetValue())
4158        #self.state.dI_noweight = copy.deepcopy(self.dI_noweight.GetValue())
4159        #self.state.dI_didata = copy.deepcopy(self.dI_didata.GetValue())
4160        #self.state.dI_sqrdata = copy.deepcopy(self.dI_sqrdata.GetValue())
4161        #self.state.dI_idata = copy.deepcopy(self.dI_idata.GetValue())
4162
4163        p = self.model_parameters
4164        # save checkbutton state and txtcrtl values
4165        state.parameters = FittingUtilities.getStandardParam(self._model_model)
4166        state.orientation_params_disp = FittingUtilities.getOrientationParam(self.kernel_module)
4167
4168        #self._copy_parameters_state(self.orientation_params_disp, self.state.orientation_params_disp)
4169        #self._copy_parameters_state(self.parameters, self.state.parameters)
4170        #self._copy_parameters_state(self.fittable_param, self.state.fittable_param)
4171        #self._copy_parameters_state(self.fixed_param, self.state.fixed_param)
4172
Note: See TracBrowser for help on using the repository browser.