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

ESS_GUIESS_GUI_batch_fittingESS_GUI_orderingESS_GUI_sync_sascalc
Last change on this file since 1b03c0a was 1b03c0a, checked in by Piotr Rozyczko <piotr.rozyczko@…>, 4 months ago

Update the kernel with array dispersion parameters. SASVIEW-1089

  • Property mode set to 100644
File size: 161.0 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.onSelectBatchFilename(res_index)
1633
1634            method = self.complete1D if isinstance(self.data, Data1D) else self.complete2D
1635            self.calculateQGridForModelExt(data=data, model=kernel_module, completefn=method, use_threads=False)
1636
1637        # Restore original kernel_module, so subsequent fits on the same model don't pick up the new params
1638        if self.kernel_module is not None:
1639            self.kernel_module = copy.deepcopy(self.kernel_module_copy)
1640
1641    def paramDictFromResults(self, results):
1642        """
1643        Given the fit results structure, pull out optimized parameters and return them as nicely
1644        formatted dict
1645        """
1646        if results.fitness is None or \
1647            not np.isfinite(results.fitness) or \
1648            np.any(results.pvec is None) or \
1649            not np.all(np.isfinite(results.pvec)):
1650            msg = "Fitting did not converge!"
1651            self.communicate.statusBarUpdateSignal.emit(msg)
1652            msg += results.mesg
1653            logger.error(msg)
1654            return
1655
1656        param_list = results.param_list # ['radius', 'radius.width']
1657        param_values = results.pvec     # array([ 0.36221662,  0.0146783 ])
1658        param_stderr = results.stderr   # array([ 1.71293015,  1.71294233])
1659        params_and_errors = list(zip(param_values, param_stderr))
1660        param_dict = dict(zip(param_list, params_and_errors))
1661
1662        return param_dict
1663
1664    def fittingCompleted(self, result):
1665        """
1666        Send the finish message from calculate threads to main thread
1667        """
1668        if result is None:
1669            result = tuple()
1670        self.fittingFinishedSignal.emit(result)
1671
1672    def fitComplete(self, result):
1673        """
1674        Receive and display fitting results
1675        "result" is a tuple of actual result list and the fit time in seconds
1676        """
1677        #re-enable the Fit button
1678        self.enableInteractiveElements()
1679
1680        if len(result) == 0:
1681            msg = "Fitting failed."
1682            self.communicate.statusBarUpdateSignal.emit(msg)
1683            return
1684
1685        res_list = result[0][0]
1686        res = res_list[0]
1687        self.chi2 = res.fitness
1688        param_dict = self.paramDictFromResults(res)
1689
1690        if param_dict is None:
1691            return
1692        self.communicate.resultPlotUpdateSignal.emit(result[0])
1693
1694        elapsed = result[1]
1695        if self.calc_fit is not None and self.calc_fit._interrupting:
1696            msg = "Fitting cancelled by user after: %s s." % GuiUtils.formatNumber(elapsed)
1697            logger.warning("\n"+msg+"\n")
1698        else:
1699            msg = "Fitting completed successfully in: %s s." % GuiUtils.formatNumber(elapsed)
1700        self.communicate.statusBarUpdateSignal.emit(msg)
1701
1702        # Dictionary of fitted parameter: value, error
1703        # e.g. param_dic = {"sld":(1.703, 0.0034), "length":(33.455, -0.0983)}
1704        self.updateModelFromList(param_dict)
1705
1706        self.updatePolyModelFromList(param_dict)
1707
1708        self.updateMagnetModelFromList(param_dict)
1709
1710        # update charts
1711        self.onPlot()
1712        #self.recalculatePlotData()
1713
1714
1715        # Read only value - we can get away by just printing it here
1716        chi2_repr = GuiUtils.formatNumber(self.chi2, high=True)
1717        self.lblChi2Value.setText(chi2_repr)
1718
1719    def prepareFitters(self, fitter=None, fit_id=0):
1720        """
1721        Prepare the Fitter object for use in fitting
1722        """
1723        # fitter = None -> single/batch fitting
1724        # fitter = Fit() -> simultaneous fitting
1725
1726        # Data going in
1727        data = self.logic.data
1728        model = copy.deepcopy(self.kernel_module)
1729        qmin = self.q_range_min
1730        qmax = self.q_range_max
1731        # add polydisperse/magnet parameters if asked
1732        self.updateKernelModelWithExtraParams(model)
1733
1734        params_to_fit = copy.deepcopy(self.main_params_to_fit)
1735        if self.chkPolydispersity.isChecked():
1736            params_to_fit += self.poly_params_to_fit
1737        if self.chkMagnetism.isChecked() and self.canHaveMagnetism():
1738            params_to_fit += self.magnet_params_to_fit
1739        if not params_to_fit:
1740            raise ValueError('Fitting requires at least one parameter to optimize.')
1741
1742        # Get the constraints.
1743        constraints = self.getComplexConstraintsForModel()
1744        if fitter is None:
1745            # For single fits - check for inter-model constraints
1746            constraints = self.getConstraintsForFitting()
1747
1748        smearer = self.smearing_widget.smearer()
1749        handler = None
1750        batch_inputs = {}
1751        batch_outputs = {}
1752
1753        fitters = []
1754        for fit_index in self.all_data:
1755            fitter_single = Fit() if fitter is None else fitter
1756            data = GuiUtils.dataFromItem(fit_index)
1757            # Potential weights added directly to data
1758            weighted_data = self.addWeightingToData(data)
1759            try:
1760                fitter_single.set_model(model, fit_id, params_to_fit, data=weighted_data,
1761                             constraints=constraints)
1762            except ValueError as ex:
1763                raise ValueError("Setting model parameters failed with: %s" % ex)
1764
1765            qmin, qmax, _ = self.logic.computeRangeFromData(weighted_data)
1766            fitter_single.set_data(data=weighted_data, id=fit_id, smearer=smearer, qmin=qmin,
1767                            qmax=qmax)
1768            fitter_single.select_problem_for_fit(id=fit_id, value=1)
1769            if fitter is None:
1770                # Assign id to the new fitter only
1771                fitter_single.fitter_id = [self.page_id]
1772            fit_id += 1
1773            fitters.append(fitter_single)
1774
1775        return fitters, fit_id
1776
1777    def iterateOverModel(self, func):
1778        """
1779        Take func and throw it inside the model row loop
1780        """
1781        for row_i in range(self._model_model.rowCount()):
1782            func(row_i)
1783
1784    def updateModelFromList(self, param_dict):
1785        """
1786        Update the model with new parameters, create the errors column
1787        """
1788        assert isinstance(param_dict, dict)
1789        if not dict:
1790            return
1791
1792        def updateFittedValues(row):
1793            # Utility function for main model update
1794            # internal so can use closure for param_dict
1795            param_name = str(self._model_model.item(row, 0).text())
1796            if not self.isCheckable(row) or param_name not in list(param_dict.keys()):
1797                return
1798            # modify the param value
1799            param_repr = GuiUtils.formatNumber(param_dict[param_name][0], high=True)
1800            self._model_model.item(row, 1).setText(param_repr)
1801            self.kernel_module.setParam(param_name, param_dict[param_name][0])
1802            if self.has_error_column:
1803                error_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
1804                self._model_model.item(row, 2).setText(error_repr)
1805
1806        def updatePolyValues(row):
1807            # Utility function for updateof polydispersity part of the main model
1808            param_name = str(self._model_model.item(row, 0).text())+'.width'
1809            if not self.isCheckable(row) or param_name not in list(param_dict.keys()):
1810                return
1811            # modify the param value
1812            param_repr = GuiUtils.formatNumber(param_dict[param_name][0], high=True)
1813            self._model_model.item(row, 0).child(0).child(0,1).setText(param_repr)
1814            # modify the param error
1815            if self.has_error_column:
1816                error_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
1817                self._model_model.item(row, 0).child(0).child(0,2).setText(error_repr)
1818
1819        def createErrorColumn(row):
1820            # Utility function for error column update
1821            item = QtGui.QStandardItem()
1822            def createItem(param_name):
1823                error_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
1824                item.setText(error_repr)
1825            def curr_param():
1826                return str(self._model_model.item(row, 0).text())
1827
1828            [createItem(param_name) for param_name in list(param_dict.keys()) if curr_param() == param_name]
1829
1830            error_column.append(item)
1831
1832        def createPolyErrorColumn(row):
1833            # Utility function for error column update in the polydispersity sub-rows
1834            # NOTE: only creates empty items; updatePolyValues adds the error value
1835            item = self._model_model.item(row, 0)
1836            if not item.hasChildren():
1837                return
1838            poly_item = item.child(0)
1839            if not poly_item.hasChildren():
1840                return
1841            poly_item.insertColumn(2, [QtGui.QStandardItem("")])
1842
1843        if not self.has_error_column:
1844            # create top-level error column
1845            error_column = []
1846            self.lstParams.itemDelegate().addErrorColumn()
1847            self.iterateOverModel(createErrorColumn)
1848
1849            self._model_model.insertColumn(2, error_column)
1850
1851            FittingUtilities.addErrorHeadersToModel(self._model_model)
1852
1853            # create error column in polydispersity sub-rows
1854            self.iterateOverModel(createPolyErrorColumn)
1855
1856            self.has_error_column = True
1857
1858        # block signals temporarily, so we don't end up
1859        # updating charts with every single model change on the end of fitting
1860        self._model_model.dataChanged.disconnect()
1861        self.iterateOverModel(updateFittedValues)
1862        self.iterateOverModel(updatePolyValues)
1863        self._model_model.dataChanged.connect(self.onMainParamsChange)
1864
1865    def iterateOverPolyModel(self, func):
1866        """
1867        Take func and throw it inside the poly model row loop
1868        """
1869        for row_i in range(self._poly_model.rowCount()):
1870            func(row_i)
1871
1872    def updatePolyModelFromList(self, param_dict):
1873        """
1874        Update the polydispersity model with new parameters, create the errors column
1875        """
1876        assert isinstance(param_dict, dict)
1877        if not dict:
1878            return
1879
1880        def updateFittedValues(row_i):
1881            # Utility function for main model update
1882            # internal so can use closure for param_dict
1883            if row_i >= self._poly_model.rowCount():
1884                return
1885            param_name = str(self._poly_model.item(row_i, 0).text()).rsplit()[-1] + '.width'
1886            if param_name not in list(param_dict.keys()):
1887                return
1888            # modify the param value
1889            param_repr = GuiUtils.formatNumber(param_dict[param_name][0], high=True)
1890            self._poly_model.item(row_i, 1).setText(param_repr)
1891            self.kernel_module.setParam(param_name, param_dict[param_name][0])
1892            if self.has_poly_error_column:
1893                error_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
1894                self._poly_model.item(row_i, 2).setText(error_repr)
1895
1896        def createErrorColumn(row_i):
1897            # Utility function for error column update
1898            if row_i >= self._poly_model.rowCount():
1899                return
1900            item = QtGui.QStandardItem()
1901
1902            def createItem(param_name):
1903                error_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
1904                item.setText(error_repr)
1905
1906            def poly_param():
1907                return str(self._poly_model.item(row_i, 0).text()).rsplit()[-1] + '.width'
1908
1909            [createItem(param_name) for param_name in list(param_dict.keys()) if poly_param() == param_name]
1910
1911            error_column.append(item)
1912
1913        # block signals temporarily, so we don't end up
1914        # updating charts with every single model change on the end of fitting
1915        self._poly_model.dataChanged.disconnect()
1916        self.iterateOverPolyModel(updateFittedValues)
1917        self._poly_model.dataChanged.connect(self.onPolyModelChange)
1918
1919        if self.has_poly_error_column:
1920            return
1921
1922        self.lstPoly.itemDelegate().addErrorColumn()
1923        error_column = []
1924        self.iterateOverPolyModel(createErrorColumn)
1925
1926        # switch off reponse to model change
1927        self._poly_model.insertColumn(2, error_column)
1928        FittingUtilities.addErrorPolyHeadersToModel(self._poly_model)
1929
1930        self.has_poly_error_column = True
1931
1932    def iterateOverMagnetModel(self, func):
1933        """
1934        Take func and throw it inside the magnet model row loop
1935        """
1936        for row_i in range(self._magnet_model.rowCount()):
1937            func(row_i)
1938
1939    def updateMagnetModelFromList(self, param_dict):
1940        """
1941        Update the magnetic model with new parameters, create the errors column
1942        """
1943        assert isinstance(param_dict, dict)
1944        if not dict:
1945            return
1946        if self._magnet_model.rowCount() == 0:
1947            return
1948
1949        def updateFittedValues(row):
1950            # Utility function for main model update
1951            # internal so can use closure for param_dict
1952            if self._magnet_model.item(row, 0) is None:
1953                return
1954            param_name = str(self._magnet_model.item(row, 0).text())
1955            if param_name not in list(param_dict.keys()):
1956                return
1957            # modify the param value
1958            param_repr = GuiUtils.formatNumber(param_dict[param_name][0], high=True)
1959            self._magnet_model.item(row, 1).setText(param_repr)
1960            self.kernel_module.setParam(param_name, param_dict[param_name][0])
1961            if self.has_magnet_error_column:
1962                error_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
1963                self._magnet_model.item(row, 2).setText(error_repr)
1964
1965        def createErrorColumn(row):
1966            # Utility function for error column update
1967            item = QtGui.QStandardItem()
1968            def createItem(param_name):
1969                error_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
1970                item.setText(error_repr)
1971            def curr_param():
1972                return str(self._magnet_model.item(row, 0).text())
1973
1974            [createItem(param_name) for param_name in list(param_dict.keys()) if curr_param() == param_name]
1975
1976            error_column.append(item)
1977
1978        # block signals temporarily, so we don't end up
1979        # updating charts with every single model change on the end of fitting
1980        self._magnet_model.dataChanged.disconnect()
1981        self.iterateOverMagnetModel(updateFittedValues)
1982        self._magnet_model.dataChanged.connect(self.onMagnetModelChange)
1983
1984        if self.has_magnet_error_column:
1985            return
1986
1987        self.lstMagnetic.itemDelegate().addErrorColumn()
1988        error_column = []
1989        self.iterateOverMagnetModel(createErrorColumn)
1990
1991        # switch off reponse to model change
1992        self._magnet_model.insertColumn(2, error_column)
1993        FittingUtilities.addErrorHeadersToModel(self._magnet_model)
1994
1995        self.has_magnet_error_column = True
1996
1997    def onPlot(self):
1998        """
1999        Plot the current set of data
2000        """
2001        # Regardless of previous state, this should now be `plot show` functionality only
2002        self.cmdPlot.setText("Show Plot")
2003        # Force data recalculation so existing charts are updated
2004        if not self.data_is_loaded:
2005            self.showTheoryPlot()
2006        else:
2007            self.showPlot()
2008        # This is an important processEvent.
2009        # This allows charts to be properly updated in order
2010        # of plots being applied.
2011        QtWidgets.QApplication.processEvents()
2012        self.recalculatePlotData() # recalc+plot theory again (2nd)
2013
2014    def onSmearingOptionsUpdate(self):
2015        """
2016        React to changes in the smearing widget
2017        """
2018        self.calculateQGridForModel()
2019
2020    def recalculatePlotData(self):
2021        """
2022        Generate a new dataset for model
2023        """
2024        if not self.data_is_loaded:
2025            self.createDefaultDataset()
2026        self.calculateQGridForModel()
2027
2028    def showTheoryPlot(self):
2029        """
2030        Show the current theory plot in MPL
2031        """
2032        # Show the chart if ready
2033        if self.theory_item is None:
2034            self.recalculatePlotData()
2035        elif self.model_data:
2036            self._requestPlots(self.model_data.filename, self.theory_item.model())
2037
2038    def showPlot(self):
2039        """
2040        Show the current plot in MPL
2041        """
2042        # Show the chart if ready
2043        data_to_show = self.data
2044        # Any models for this page
2045        current_index = self.all_data[self.data_index]
2046        item = self._requestPlots(self.data.filename, current_index.model())
2047        if item:
2048            # fit+data has not been shown - show just data
2049            self.communicate.plotRequestedSignal.emit([item, data_to_show], self.tab_id)
2050
2051    def _requestPlots(self, item_name, item_model):
2052        """
2053        Emits plotRequestedSignal for all plots found in the given model under the provided item name.
2054        """
2055        fitpage_name = self.kernel_module.name
2056        plots = GuiUtils.plotsFromFilename(item_name, item_model)
2057        # Has the fitted data been shown?
2058        data_shown = False
2059        item = None
2060        for item, plot in plots.items():
2061            if fitpage_name in plot.name:
2062                data_shown = True
2063                self.communicate.plotRequestedSignal.emit([item, plot], self.tab_id)
2064        # return the last data item seen, if nothing was plotted; supposed to be just data)
2065        return None if data_shown else item
2066
2067    def onOptionsUpdate(self):
2068        """
2069        Update local option values and replot
2070        """
2071        self.q_range_min, self.q_range_max, self.npts, self.log_points, self.weighting = \
2072            self.options_widget.state()
2073        # set Q range labels on the main tab
2074        self.lblMinRangeDef.setText(GuiUtils.formatNumber(self.q_range_min, high=True))
2075        self.lblMaxRangeDef.setText(GuiUtils.formatNumber(self.q_range_max, high=True))
2076        self.recalculatePlotData()
2077
2078    def setDefaultStructureCombo(self):
2079        """
2080        Fill in the structure factors combo box with defaults
2081        """
2082        structure_factor_list = self.master_category_dict.pop(CATEGORY_STRUCTURE)
2083        factors = [factor[0] for factor in structure_factor_list]
2084        factors.insert(0, STRUCTURE_DEFAULT)
2085        self.cbStructureFactor.clear()
2086        self.cbStructureFactor.addItems(sorted(factors))
2087
2088    def createDefaultDataset(self):
2089        """
2090        Generate default Dataset 1D/2D for the given model
2091        """
2092        # Create default datasets if no data passed
2093        if self.is2D:
2094            qmax = self.q_range_max/np.sqrt(2)
2095            qstep = self.npts
2096            self.logic.createDefault2dData(qmax, qstep, self.tab_id)
2097            return
2098        elif self.log_points:
2099            qmin = -10.0 if self.q_range_min < 1.e-10 else np.log10(self.q_range_min)
2100            qmax = 10.0 if self.q_range_max > 1.e10 else np.log10(self.q_range_max)
2101            interval = np.logspace(start=qmin, stop=qmax, num=self.npts, endpoint=True, base=10.0)
2102        else:
2103            interval = np.linspace(start=self.q_range_min, stop=self.q_range_max,
2104                                   num=self.npts, endpoint=True)
2105        self.logic.createDefault1dData(interval, self.tab_id)
2106
2107    def readCategoryInfo(self):
2108        """
2109        Reads the categories in from file
2110        """
2111        self.master_category_dict = defaultdict(list)
2112        self.by_model_dict = defaultdict(list)
2113        self.model_enabled_dict = defaultdict(bool)
2114
2115        categorization_file = CategoryInstaller.get_user_file()
2116        if not os.path.isfile(categorization_file):
2117            categorization_file = CategoryInstaller.get_default_file()
2118        with open(categorization_file, 'rb') as cat_file:
2119            self.master_category_dict = json.load(cat_file)
2120            self.regenerateModelDict()
2121
2122        # Load the model dict
2123        models = load_standard_models()
2124        for model in models:
2125            self.models[model.name] = model
2126
2127        self.readCustomCategoryInfo()
2128
2129    def readCustomCategoryInfo(self):
2130        """
2131        Reads the custom model category
2132        """
2133        #Looking for plugins
2134        self.plugins = list(self.custom_models.values())
2135        plugin_list = []
2136        for name, plug in self.custom_models.items():
2137            self.models[name] = plug
2138            plugin_list.append([name, True])
2139        if plugin_list:
2140            self.master_category_dict[CATEGORY_CUSTOM] = plugin_list
2141
2142    def regenerateModelDict(self):
2143        """
2144        Regenerates self.by_model_dict which has each model name as the
2145        key and the list of categories belonging to that model
2146        along with the enabled mapping
2147        """
2148        self.by_model_dict = defaultdict(list)
2149        for category in self.master_category_dict:
2150            for (model, enabled) in self.master_category_dict[category]:
2151                self.by_model_dict[model].append(category)
2152                self.model_enabled_dict[model] = enabled
2153
2154    def addBackgroundToModel(self, model):
2155        """
2156        Adds background parameter with default values to the model
2157        """
2158        assert isinstance(model, QtGui.QStandardItemModel)
2159        checked_list = ['background', '0.001', '-inf', 'inf', '1/cm']
2160        FittingUtilities.addCheckedListToModel(model, checked_list)
2161        last_row = model.rowCount()-1
2162        model.item(last_row, 0).setEditable(False)
2163        model.item(last_row, 4).setEditable(False)
2164
2165    def addScaleToModel(self, model):
2166        """
2167        Adds scale parameter with default values to the model
2168        """
2169        assert isinstance(model, QtGui.QStandardItemModel)
2170        checked_list = ['scale', '1.0', '0.0', 'inf', '']
2171        FittingUtilities.addCheckedListToModel(model, checked_list)
2172        last_row = model.rowCount()-1
2173        model.item(last_row, 0).setEditable(False)
2174        model.item(last_row, 4).setEditable(False)
2175
2176    def addWeightingToData(self, data):
2177        """
2178        Adds weighting contribution to fitting data
2179        """
2180        new_data = copy.deepcopy(data)
2181        # Send original data for weighting
2182        weight = FittingUtilities.getWeight(data=data, is2d=self.is2D, flag=self.weighting)
2183        if self.is2D:
2184            new_data.err_data = weight
2185        else:
2186            new_data.dy = weight
2187
2188        return new_data
2189
2190    def updateQRange(self):
2191        """
2192        Updates Q Range display
2193        """
2194        if self.data_is_loaded:
2195            self.q_range_min, self.q_range_max, self.npts = self.logic.computeDataRange()
2196        # set Q range labels on the main tab
2197        self.lblMinRangeDef.setText(GuiUtils.formatNumber(self.q_range_min, high=True))
2198        self.lblMaxRangeDef.setText(GuiUtils.formatNumber(self.q_range_max, high=True))
2199        # set Q range labels on the options tab
2200        self.options_widget.updateQRange(self.q_range_min, self.q_range_max, self.npts)
2201
2202    def SASModelToQModel(self, model_name, structure_factor=None):
2203        """
2204        Setting model parameters into table based on selected category
2205        """
2206        # Crete/overwrite model items
2207        self._model_model.clear()
2208        self._poly_model.clear()
2209        self._magnet_model.clear()
2210
2211        if model_name is None:
2212            if structure_factor not in (None, "None"):
2213                # S(Q) on its own, treat the same as a form factor
2214                self.kernel_module = None
2215                self.fromStructureFactorToQModel(structure_factor)
2216            else:
2217                # No models selected
2218                return
2219        else:
2220            self.fromModelToQModel(model_name)
2221            self.addExtraShells()
2222
2223            # Allow the SF combobox visibility for the given sasmodel
2224            self.enableStructureFactorControl(structure_factor)
2225       
2226            # Add S(Q)
2227            if self.cbStructureFactor.isEnabled():
2228                structure_factor = self.cbStructureFactor.currentText()
2229                self.fromStructureFactorToQModel(structure_factor)
2230
2231            # Add polydispersity to the model
2232            self.poly_params = {}
2233            self.setPolyModel()
2234            # Add magnetic parameters to the model
2235            self.magnet_params = {}
2236            self.setMagneticModel()
2237
2238        # Now we claim the model has been loaded
2239        self.model_is_loaded = True
2240        # Change the model name to a monicker
2241        self.kernel_module.name = self.modelName()
2242        # Update the smearing tab
2243        self.smearing_widget.updateKernelModel(kernel_model=self.kernel_module)
2244
2245        # (Re)-create headers
2246        FittingUtilities.addHeadersToModel(self._model_model)
2247        self.lstParams.header().setFont(self.boldFont)
2248
2249        # Update Q Ranges
2250        self.updateQRange()
2251
2252    def fromModelToQModel(self, model_name):
2253        """
2254        Setting model parameters into QStandardItemModel based on selected _model_
2255        """
2256        name = model_name
2257        kernel_module = None
2258        if self.cbCategory.currentText() == CATEGORY_CUSTOM:
2259            # custom kernel load requires full path
2260            name = os.path.join(ModelUtilities.find_plugins_dir(), model_name+".py")
2261        try:
2262            kernel_module = generate.load_kernel_module(name)
2263        except ModuleNotFoundError as ex:
2264            pass
2265        except FileNotFoundError as ex:
2266            # can happen when name attribute not the same as actual filename
2267            pass
2268
2269        if kernel_module is None:
2270            # mismatch between "name" attribute and actual filename.
2271            curr_model = self.models[model_name]
2272            name, _ = os.path.splitext(os.path.basename(curr_model.filename))
2273            try:
2274                kernel_module = generate.load_kernel_module(name)
2275            except ModuleNotFoundError as ex:
2276                logger.error("Can't find the model "+ str(ex))
2277                return
2278
2279        if hasattr(kernel_module, 'parameters'):
2280            # built-in and custom models
2281            self.model_parameters = modelinfo.make_parameter_table(getattr(kernel_module, 'parameters', []))
2282
2283        elif hasattr(kernel_module, 'model_info'):
2284            # for sum/multiply models
2285            self.model_parameters = kernel_module.model_info.parameters
2286
2287        elif hasattr(kernel_module, 'Model') and hasattr(kernel_module.Model, "_model_info"):
2288            # this probably won't work if there's no model_info, but just in case
2289            self.model_parameters = kernel_module.Model._model_info.parameters
2290        else:
2291            # no parameters - default to blank table
2292            msg = "No parameters found in model '{}'.".format(model_name)
2293            logger.warning(msg)
2294            self.model_parameters = modelinfo.ParameterTable([])
2295
2296        # Instantiate the current sasmodel
2297        self.kernel_module = self.models[model_name]()
2298
2299        # Change the model name to a monicker
2300        self.kernel_module.name = self.modelName()
2301
2302        # Explicitly add scale and background with default values
2303        temp_undo_state = self.undo_supported
2304        self.undo_supported = False
2305        self.addScaleToModel(self._model_model)
2306        self.addBackgroundToModel(self._model_model)
2307        self.undo_supported = temp_undo_state
2308
2309        self.shell_names = self.shellNamesList()
2310
2311        # Add heading row
2312        FittingUtilities.addHeadingRowToModel(self._model_model, model_name)
2313
2314        # Update the QModel
2315        FittingUtilities.addParametersToModel(
2316                self.model_parameters,
2317                self.kernel_module,
2318                self.is2D,
2319                self._model_model,
2320                self.lstParams)
2321
2322    def fromStructureFactorToQModel(self, structure_factor):
2323        """
2324        Setting model parameters into QStandardItemModel based on selected _structure factor_
2325        """
2326        if structure_factor is None or structure_factor=="None":
2327            return
2328
2329        product_params = None
2330
2331        if self.kernel_module is None:
2332            # Structure factor is the only selected model; build it and show all its params
2333            self.kernel_module = self.models[structure_factor]()
2334            self.kernel_module.name = self.modelName()
2335            s_params = self.kernel_module._model_info.parameters
2336            s_params_orig = s_params
2337        else:
2338            s_kernel = self.models[structure_factor]()
2339            p_kernel = self.kernel_module
2340            # need to reset multiplicity to get the right product
2341            if p_kernel.is_multiplicity_model:
2342                p_kernel.multiplicity = p_kernel.multiplicity_info.number
2343
2344            p_pars_len = len(p_kernel._model_info.parameters.kernel_parameters)
2345            s_pars_len = len(s_kernel._model_info.parameters.kernel_parameters)
2346
2347            self.kernel_module = MultiplicationModel(p_kernel, s_kernel)
2348            # Modify the name to correspond to shown items
2349            self.kernel_module.name = self.modelName()
2350            all_params = self.kernel_module._model_info.parameters.kernel_parameters
2351            all_param_names = [param.name for param in all_params]
2352
2353            # S(Q) params from the product model are not necessarily the same as those from the S(Q) model; any
2354            # conflicting names with P(Q) params will cause a rename
2355
2356            if "radius_effective_mode" in all_param_names:
2357                # Show all parameters
2358                # In this case, radius_effective is NOT pruned by sasmodels.product
2359                s_params = modelinfo.ParameterTable(all_params[p_pars_len:p_pars_len+s_pars_len])
2360                s_params_orig = modelinfo.ParameterTable(s_kernel._model_info.parameters.kernel_parameters)
2361                product_params = modelinfo.ParameterTable(
2362                        self.kernel_module._model_info.parameters.kernel_parameters[p_pars_len+s_pars_len:])
2363            else:
2364                # Ensure radius_effective is not displayed
2365                s_params_orig = modelinfo.ParameterTable(s_kernel._model_info.parameters.kernel_parameters[1:])
2366                if "radius_effective" in all_param_names:
2367                    # In this case, radius_effective is NOT pruned by sasmodels.product
2368                    s_params = modelinfo.ParameterTable(all_params[p_pars_len+1:p_pars_len+s_pars_len])
2369                    product_params = modelinfo.ParameterTable(
2370                            self.kernel_module._model_info.parameters.kernel_parameters[p_pars_len+s_pars_len:])
2371                else:
2372                    # In this case, radius_effective is pruned by sasmodels.product
2373                    s_params = modelinfo.ParameterTable(all_params[p_pars_len:p_pars_len+s_pars_len-1])
2374                    product_params = modelinfo.ParameterTable(
2375                            self.kernel_module._model_info.parameters.kernel_parameters[p_pars_len+s_pars_len-1:])
2376
2377        # Add heading row
2378        FittingUtilities.addHeadingRowToModel(self._model_model, structure_factor)
2379
2380        # Get new rows for QModel
2381        # Any renamed parameters are stored as data in the relevant item, for later handling
2382        FittingUtilities.addSimpleParametersToModel(
2383                parameters=s_params,
2384                is2D=self.is2D,
2385                parameters_original=s_params_orig,
2386                model=self._model_model,
2387                view=self.lstParams)
2388
2389        # Insert product-only params into QModel
2390        if product_params:
2391            prod_rows = FittingUtilities.addSimpleParametersToModel(
2392                    parameters=product_params,
2393                    is2D=self.is2D,
2394                    parameters_original=None,
2395                    model=self._model_model,
2396                    view=self.lstParams,
2397                    row_num=2)
2398
2399            # Since this all happens after shells are dealt with and we've inserted rows, fix this counter
2400            self._n_shells_row += len(prod_rows)
2401
2402    def haveParamsToFit(self):
2403        """
2404        Finds out if there are any parameters ready to be fitted
2405        """
2406        if not self.logic.data_is_loaded:
2407            return False
2408        if self.main_params_to_fit:
2409            return True
2410        if self.chkPolydispersity.isChecked() and self.poly_params_to_fit:
2411            return True
2412        if self.chkMagnetism.isChecked() and self.canHaveMagnetism() and self.magnet_params_to_fit:
2413            return True
2414        return False
2415
2416    def onMainParamsChange(self, top, bottom):
2417        """
2418        Callback method for updating the sasmodel parameters with the GUI values
2419        """
2420        item = self._model_model.itemFromIndex(top)
2421
2422        model_column = item.column()
2423
2424        if model_column == 0:
2425            self.checkboxSelected(item)
2426            self.cmdFit.setEnabled(self.haveParamsToFit())
2427            # Update state stack
2428            self.updateUndo()
2429            return
2430
2431        model_row = item.row()
2432        name_index = self._model_model.index(model_row, 0)
2433        name_item = self._model_model.itemFromIndex(name_index)
2434
2435        # Extract changed value.
2436        try:
2437            value = GuiUtils.toDouble(item.text())
2438        except TypeError:
2439            # Unparsable field
2440            return
2441
2442        # if the item has user data, this is the actual parameter name (e.g. to handle duplicate names)
2443        if name_item.data(QtCore.Qt.UserRole):
2444            parameter_name = str(name_item.data(QtCore.Qt.UserRole))
2445        else:
2446            parameter_name = str(self._model_model.data(name_index))
2447
2448        # Update the parameter value - note: this supports +/-inf as well
2449        param_column = self.lstParams.itemDelegate().param_value
2450        min_column = self.lstParams.itemDelegate().param_min
2451        max_column = self.lstParams.itemDelegate().param_max
2452        if model_column == param_column:
2453            # don't try to update multiplicity counters if they aren't there.
2454            # Note that this will fail for proper bad update where the model
2455            # doesn't contain multiplicity parameter
2456            if parameter_name != self.kernel_module.multiplicity_info.control:
2457                self.kernel_module.setParam(parameter_name, value)
2458        elif model_column == min_column:
2459            # min/max to be changed in self.kernel_module.details[parameter_name] = ['Ang', 0.0, inf]
2460            self.kernel_module.details[parameter_name][1] = value
2461        elif model_column == max_column:
2462            self.kernel_module.details[parameter_name][2] = value
2463        else:
2464            # don't update the chart
2465            return
2466
2467        # TODO: magnetic params in self.kernel_module.details['M0:parameter_name'] = value
2468        # TODO: multishell params in self.kernel_module.details[??] = value
2469
2470        # handle display of effective radius parameter according to radius_effective_mode; pass ER into model if
2471        # necessary
2472        self.processEffectiveRadius()
2473
2474        # Force the chart update when actual parameters changed
2475        if model_column == 1:
2476            self.recalculatePlotData()
2477
2478        # Update state stack
2479        self.updateUndo()
2480
2481    def processEffectiveRadius(self):
2482        """
2483        Checks the value of radius_effective_mode, if existent, and processes radius_effective as necessary.
2484        * mode == 0: This means 'unconstrained'; ensure use can specify ER.
2485        * mode > 0: This means it is constrained to a P(Q)-computed value in sasmodels; prevent user from editing ER.
2486
2487        Note: If ER has been computed, it is passed back to SasView as an intermediate result. That value must be
2488        displayed for the user; that is not dealt with here, but in complete1D.
2489        """
2490        ER_row = self.getRowFromName("radius_effective")
2491        if ER_row is None:
2492            return
2493
2494        ER_mode_row = self.getRowFromName("radius_effective_mode")
2495        if ER_mode_row is None:
2496            return
2497
2498        try:
2499            ER_mode = int(self._model_model.item(ER_mode_row, 1).text())
2500        except ValueError:
2501            logging.error("radius_effective_mode was set to an invalid value.")
2502            return
2503
2504        if ER_mode == 0:
2505            # ensure the ER value can be modified by user
2506            self.setParamEditableByRow(ER_row, True)
2507        elif ER_mode > 0:
2508            # ensure the ER value cannot be modified by user
2509            self.setParamEditableByRow(ER_row, False)
2510        else:
2511            logging.error("radius_effective_mode was set to an invalid value.")
2512
2513    def setParamEditableByRow(self, row, editable=True):
2514        """
2515        Sets whether the user can edit a parameter in the table. If they cannot, the parameter name's font is changed,
2516        the value itself cannot be edited if clicked on, and the parameter may not be fitted.
2517        """
2518        item_name = self._model_model.item(row, 0)
2519        item_value = self._model_model.item(row, 1)
2520
2521        item_value.setEditable(editable)
2522
2523        if editable:
2524            # reset font
2525            item_name.setFont(QtGui.QFont())
2526            # reset colour
2527            item_name.setForeground(QtGui.QBrush())
2528            # make checkable
2529            item_name.setCheckable(True)
2530        else:
2531            # change font
2532            font = QtGui.QFont()
2533            font.setItalic(True)
2534            item_name.setFont(font)
2535            # change colour
2536            item_name.setForeground(QtGui.QBrush(QtGui.QColor(50, 50, 50)))
2537            # make not checkable (and uncheck)
2538            item_name.setCheckState(QtCore.Qt.Unchecked)
2539            item_name.setCheckable(False)
2540
2541    def isCheckable(self, row):
2542        return self._model_model.item(row, 0).isCheckable()
2543
2544    def selectCheckbox(self, row):
2545        """
2546        Select the checkbox in given row.
2547        """
2548        assert 0<= row <= self._model_model.rowCount()
2549        index = self._model_model.index(row, 0)
2550        item = self._model_model.itemFromIndex(index)
2551        item.setCheckState(QtCore.Qt.Checked)
2552
2553    def checkboxSelected(self, item):
2554        # Assure we're dealing with checkboxes
2555        if not item.isCheckable():
2556            return
2557        status = item.checkState()
2558
2559        # If multiple rows selected - toggle all of them, filtering uncheckable
2560        # Convert to proper indices and set requested enablement
2561        self.setParameterSelection(status)
2562
2563        # update the list of parameters to fit
2564        self.main_params_to_fit = self.checkedListFromModel(self._model_model)
2565
2566    def checkedListFromModel(self, model):
2567        """
2568        Returns list of checked parameters for given model
2569        """
2570        def isChecked(row):
2571            return model.item(row, 0).checkState() == QtCore.Qt.Checked
2572
2573        return [str(model.item(row_index, 0).text())
2574                for row_index in range(model.rowCount())
2575                if isChecked(row_index)]
2576
2577    def createNewIndex(self, fitted_data):
2578        """
2579        Create a model or theory index with passed Data1D/Data2D
2580        """
2581        if self.data_is_loaded:
2582            if not fitted_data.name:
2583                name = self.nameForFittedData(self.data.filename)
2584                fitted_data.title = name
2585                fitted_data.name = name
2586                fitted_data.filename = name
2587                fitted_data.symbol = "Line"
2588            self.updateModelIndex(fitted_data)
2589        else:
2590            if not fitted_data.name:
2591                name = self.nameForFittedData(self.kernel_module.id)
2592            else:
2593                name = fitted_data.name
2594            fitted_data.title = name
2595            fitted_data.filename = name
2596            fitted_data.symbol = "Line"
2597            self.createTheoryIndex(fitted_data)
2598            # Switch to the theory tab for user's glee
2599            self.communicate.changeDataExplorerTabSignal.emit(1)
2600
2601    def updateModelIndex(self, fitted_data):
2602        """
2603        Update a QStandardModelIndex containing model data
2604        """
2605        name = self.nameFromData(fitted_data)
2606        # Make this a line if no other defined
2607        if hasattr(fitted_data, 'symbol') and fitted_data.symbol is None:
2608            fitted_data.symbol = 'Line'
2609        # Notify the GUI manager so it can update the main model in DataExplorer
2610        GuiUtils.updateModelItemWithPlot(self.all_data[self.data_index], fitted_data, name)
2611
2612    def createTheoryIndex(self, fitted_data):
2613        """
2614        Create a QStandardModelIndex containing model data
2615        """
2616        name = self.nameFromData(fitted_data)
2617        # Notify the GUI manager so it can create the theory model in DataExplorer
2618        self.theory_item = GuiUtils.createModelItemWithPlot(fitted_data, name=name)
2619        self.communicate.updateTheoryFromPerspectiveSignal.emit(self.theory_item)
2620
2621    def nameFromData(self, fitted_data):
2622        """
2623        Return name for the dataset. Terribly impure function.
2624        """
2625        if fitted_data.name is None:
2626            name = self.nameForFittedData(self.logic.data.filename)
2627            fitted_data.title = name
2628            fitted_data.name = name
2629            fitted_data.filename = name
2630        else:
2631            name = fitted_data.name
2632        return name
2633
2634    def methodCalculateForData(self):
2635        '''return the method for data calculation'''
2636        return Calc1D if isinstance(self.data, Data1D) else Calc2D
2637
2638    def methodCompleteForData(self):
2639        '''return the method for result parsin on calc complete '''
2640        return self.completed1D if isinstance(self.data, Data1D) else self.completed2D
2641
2642    def updateKernelModelWithExtraParams(self, model=None):
2643        """
2644        Updates kernel model 'model' with extra parameters from
2645        the polydisp and magnetism tab, if the tabs are enabled
2646        """
2647        if model is None: return
2648        if not hasattr(model, 'setParam'): return
2649
2650        # add polydisperse parameters if asked
2651        if self.chkPolydispersity.isChecked() and self._poly_model.rowCount() > 0:
2652            for key, value in self.poly_params.items():
2653                model.setParam(key, value)
2654        # add magnetic params if asked
2655        if self.chkMagnetism.isChecked() and self.canHaveMagnetism() and self._magnet_model.rowCount() > 0:
2656            for key, value in self.magnet_params.items():
2657                model.setParam(key, value)
2658
2659    def calculateQGridForModelExt(self, data=None, model=None, completefn=None, use_threads=True):
2660        """
2661        Wrapper for Calc1D/2D calls
2662        """
2663        if data is None:
2664            data = self.data
2665        if model is None:
2666            model = copy.deepcopy(self.kernel_module)
2667            self.updateKernelModelWithExtraParams(model)
2668
2669        if completefn is None:
2670            completefn = self.methodCompleteForData()
2671        smearer = self.smearing_widget.smearer()
2672        weight = FittingUtilities.getWeight(data=data, is2d=self.is2D, flag=self.weighting)
2673
2674        # Disable buttons/table
2675        self.disableInteractiveElementsOnCalculate()
2676        # Awful API to a backend method.
2677        calc_thread = self.methodCalculateForData()(data=data,
2678                                               model=model,
2679                                               page_id=0,
2680                                               qmin=self.q_range_min,
2681                                               qmax=self.q_range_max,
2682                                               smearer=smearer,
2683                                               state=None,
2684                                               weight=weight,
2685                                               fid=None,
2686                                               toggle_mode_on=False,
2687                                               completefn=completefn,
2688                                               update_chisqr=True,
2689                                               exception_handler=self.calcException,
2690                                               source=None)
2691        if use_threads:
2692            if LocalConfig.USING_TWISTED:
2693                # start the thread with twisted
2694                thread = threads.deferToThread(calc_thread.compute)
2695                thread.addCallback(completefn)
2696                thread.addErrback(self.calculateDataFailed)
2697            else:
2698                # Use the old python threads + Queue
2699                calc_thread.queue()
2700                calc_thread.ready(2.5)
2701        else:
2702            results = calc_thread.compute()
2703            completefn(results)
2704
2705    def calculateQGridForModel(self):
2706        """
2707        Prepare the fitting data object, based on current ModelModel
2708        """
2709        if self.kernel_module is None:
2710            return
2711        self.calculateQGridForModelExt()
2712
2713    def calculateDataFailed(self, reason):
2714        """
2715        Thread returned error
2716        """
2717        # Bring the GUI to normal state
2718        self.enableInteractiveElements()
2719        print("Calculate Data failed with ", reason)
2720
2721    def completed1D(self, return_data):
2722        self.Calc1DFinishedSignal.emit(return_data)
2723
2724    def completed2D(self, return_data):
2725        self.Calc2DFinishedSignal.emit(return_data)
2726
2727    def complete1D(self, return_data):
2728        """
2729        Plot the current 1D data
2730        """
2731        # Bring the GUI to normal state
2732        self.enableInteractiveElements()
2733        if return_data is None:
2734            return
2735        fitted_data = self.logic.new1DPlot(return_data, self.tab_id)
2736
2737        # assure the current index is set properly for batch
2738        if len(self._logic) > 1:
2739            for i, logic in enumerate(self._logic):
2740                if logic.data.name in fitted_data.name:
2741                    self.data_index = i
2742
2743        residuals = self.calculateResiduals(fitted_data)
2744        self.model_data = fitted_data
2745        new_plots = [fitted_data]
2746        if residuals is not None:
2747            new_plots.append(residuals)
2748
2749        if self.data_is_loaded:
2750            # delete any plots associated with the data that were not updated
2751            # (e.g. to remove beta(Q), S_eff(Q))
2752            GuiUtils.deleteRedundantPlots(self.all_data[self.data_index], new_plots)
2753            pass
2754        else:
2755            # delete theory items for the model, in order to get rid of any
2756            # redundant items, e.g. beta(Q), S_eff(Q)
2757            self.communicate.deleteIntermediateTheoryPlotsSignal.emit(self.kernel_module.id)
2758
2759        # Create plots for parameters with enabled polydispersity
2760        for plot in FittingUtilities.plotPolydispersities(return_data.get('model', None)):
2761            data_id = fitted_data.id.split()
2762            plot.id = "{} [{}] {}".format(data_id[0], plot.name, " ".join(data_id[1:]))
2763            data_name = fitted_data.name.split()
2764            plot.name = " ".join([data_name[0], plot.name] + data_name[1:])
2765            self.createNewIndex(plot)
2766            new_plots.append(plot)
2767
2768        # Create plots for intermediate product data
2769        plots = self.logic.new1DProductPlots(return_data, self.tab_id)
2770        for plot in plots:
2771            plot.symbol = "Line"
2772            self.createNewIndex(plot)
2773            new_plots.append(plot)
2774
2775        for plot in new_plots:
2776            self.communicate.plotUpdateSignal.emit([plot])
2777
2778        # Update radius_effective if relevant
2779        self.updateEffectiveRadius(return_data)
2780
2781    def complete2D(self, return_data):
2782        """
2783        Plot the current 2D data
2784        """
2785        # Bring the GUI to normal state
2786        self.enableInteractiveElements()
2787
2788        if return_data is None:
2789            return
2790
2791        fitted_data = self.logic.new2DPlot(return_data)
2792        # assure the current index is set properly for batch
2793        if len(self._logic) > 1:
2794            for i, logic in enumerate(self._logic):
2795                if logic.data.name in fitted_data.name:
2796                    self.data_index = i
2797
2798        residuals = self.calculateResiduals(fitted_data)
2799        self.model_data = fitted_data
2800        new_plots = [fitted_data]
2801        if residuals is not None:
2802            new_plots.append(residuals)
2803
2804        # Update/generate plots
2805        for plot in new_plots:
2806            self.communicate.plotUpdateSignal.emit([plot])
2807
2808    def updateEffectiveRadius(self, return_data):
2809        """
2810        Given return data from sasmodels, update the effective radius parameter in the GUI table with the new
2811        calculated value as returned by sasmodels (if the value was returned).
2812        """
2813        ER_mode_row = self.getRowFromName("radius_effective_mode")
2814        if ER_mode_row is None:
2815            return
2816        try:
2817            ER_mode = int(self._model_model.item(ER_mode_row, 1).text())
2818        except ValueError:
2819            logging.error("radius_effective_mode was set to an invalid value.")
2820            return
2821        if ER_mode < 1:
2822            # does not need updating if it is not being computed
2823            return
2824
2825        ER_row = self.getRowFromName("radius_effective")
2826        if ER_row is None:
2827            return
2828
2829        scalar_results = self.logic.getScalarIntermediateResults(return_data)
2830        ER_value = scalar_results.get("effective_radius") # note name of key
2831        if ER_value is None:
2832            return
2833        # ensure the model does not recompute when updating the value
2834        self._model_model.blockSignals(True)
2835        self._model_model.item(ER_row, 1).setText(str(ER_value))
2836        self._model_model.blockSignals(False)
2837        # ensure the view is updated immediately
2838        self._model_model.layoutChanged.emit()
2839
2840    def calculateResiduals(self, fitted_data):
2841        """
2842        Calculate and print Chi2 and display chart of residuals. Returns residuals plot object.
2843        """
2844        # Create a new index for holding data
2845        fitted_data.symbol = "Line"
2846
2847        # Modify fitted_data with weighting
2848        weighted_data = self.addWeightingToData(fitted_data)
2849
2850        self.createNewIndex(weighted_data)
2851
2852        # Calculate difference between return_data and logic.data
2853        self.chi2 = FittingUtilities.calculateChi2(weighted_data, self.data)
2854        # Update the control
2855        chi2_repr = "---" if self.chi2 is None else GuiUtils.formatNumber(self.chi2, high=True)
2856        self.lblChi2Value.setText(chi2_repr)
2857
2858        # Plot residuals if actual data
2859        if not self.data_is_loaded:
2860            return
2861
2862        residuals_plot = FittingUtilities.plotResiduals(self.data, weighted_data)
2863        if residuals_plot is None:
2864            return
2865        residuals_plot.id = "Residual " + residuals_plot.id
2866        residuals_plot.plot_role = Data1D.ROLE_RESIDUAL
2867        self.createNewIndex(residuals_plot)
2868        return residuals_plot
2869
2870    def onCategoriesChanged(self):
2871            """
2872            Reload the category/model comboboxes
2873            """
2874            # Store the current combo indices
2875            current_cat = self.cbCategory.currentText()
2876            current_model = self.cbModel.currentText()
2877
2878            # reread the category file and repopulate the combo
2879            self.cbCategory.blockSignals(True)
2880            self.cbCategory.clear()
2881            self.readCategoryInfo()
2882            self.initializeCategoryCombo()
2883
2884            # Scroll back to the original index in Categories
2885            new_index = self.cbCategory.findText(current_cat)
2886            if new_index != -1:
2887                self.cbCategory.setCurrentIndex(new_index)
2888            self.cbCategory.blockSignals(False)
2889            # ...and in the Models
2890            self.cbModel.blockSignals(True)
2891            new_index = self.cbModel.findText(current_model)
2892            if new_index != -1:
2893                self.cbModel.setCurrentIndex(new_index)
2894            self.cbModel.blockSignals(False)
2895
2896            return
2897
2898    def calcException(self, etype, value, tb):
2899        """
2900        Thread threw an exception.
2901        """
2902        # Bring the GUI to normal state
2903        self.enableInteractiveElements()
2904        # TODO: remimplement thread cancellation
2905        logger.error("".join(traceback.format_exception(etype, value, tb)))
2906
2907    def setTableProperties(self, table):
2908        """
2909        Setting table properties
2910        """
2911        # Table properties
2912        table.verticalHeader().setVisible(False)
2913        table.setAlternatingRowColors(True)
2914        table.setSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding, QtWidgets.QSizePolicy.Expanding)
2915        table.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows)
2916        table.resizeColumnsToContents()
2917
2918        # Header
2919        header = table.horizontalHeader()
2920        header.setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
2921        header.ResizeMode(QtWidgets.QHeaderView.Interactive)
2922
2923        # Qt5: the following 2 lines crash - figure out why!
2924        # Resize column 0 and 7 to content
2925        #header.setSectionResizeMode(0, QtWidgets.QHeaderView.ResizeToContents)
2926        #header.setSectionResizeMode(7, QtWidgets.QHeaderView.ResizeToContents)
2927
2928    def setPolyModel(self):
2929        """
2930        Set polydispersity values
2931        """
2932        if not self.model_parameters:
2933            return
2934        self._poly_model.clear()
2935
2936        parameters = self.model_parameters.form_volume_parameters
2937        if self.is2D:
2938            parameters += self.model_parameters.orientation_parameters
2939
2940        [self.setPolyModelParameters(i, param) for i, param in \
2941            enumerate(parameters) if param.polydisperse]
2942
2943        FittingUtilities.addPolyHeadersToModel(self._poly_model)
2944
2945    def setPolyModelParameters(self, i, param):
2946        """
2947        Standard of multishell poly parameter driver
2948        """
2949        param_name = param.name
2950        # see it the parameter is multishell
2951        if '[' in param.name:
2952            # Skip empty shells
2953            if self.current_shell_displayed == 0:
2954                return
2955            else:
2956                # Create as many entries as current shells
2957                for ishell in range(1, self.current_shell_displayed+1):
2958                    # Remove [n] and add the shell numeral
2959                    name = param_name[0:param_name.index('[')] + str(ishell)
2960                    self.addNameToPolyModel(i, name)
2961        else:
2962            # Just create a simple param entry
2963            self.addNameToPolyModel(i, param_name)
2964
2965    def addNameToPolyModel(self, i, param_name):
2966        """
2967        Creates a checked row in the poly model with param_name
2968        """
2969        # Polydisp. values from the sasmodel
2970        width = self.kernel_module.getParam(param_name + '.width')
2971        npts = self.kernel_module.getParam(param_name + '.npts')
2972        nsigs = self.kernel_module.getParam(param_name + '.nsigmas')
2973        _, min, max = self.kernel_module.details[param_name]
2974
2975        # Update local param dict
2976        self.poly_params[param_name + '.width'] = width
2977        self.poly_params[param_name + '.npts'] = npts
2978        self.poly_params[param_name + '.nsigmas'] = nsigs
2979
2980        # Construct a row with polydisp. related variable.
2981        # This will get added to the polydisp. model
2982        # Note: last argument needs extra space padding for decent display of the control
2983        checked_list = ["Distribution of " + param_name, str(width),
2984                        str(min), str(max),
2985                        str(npts), str(nsigs), "gaussian      ",'']
2986        FittingUtilities.addCheckedListToModel(self._poly_model, checked_list)
2987
2988        # All possible polydisp. functions as strings in combobox
2989        func = QtWidgets.QComboBox()
2990        func.addItems([str(name_disp) for name_disp in POLYDISPERSITY_MODELS.keys()])
2991        # Set the default index
2992        func.setCurrentIndex(func.findText(DEFAULT_POLYDISP_FUNCTION))
2993        ind = self._poly_model.index(i,self.lstPoly.itemDelegate().poly_function)
2994        self.lstPoly.setIndexWidget(ind, func)
2995        func.currentIndexChanged.connect(lambda: self.onPolyComboIndexChange(str(func.currentText()), i))
2996
2997    def onPolyFilenameChange(self, row_index):
2998        """
2999        Respond to filename_updated signal from the delegate
3000        """
3001        # For the given row, invoke the "array" combo handler
3002        array_caption = 'array'
3003
3004        # Get the combo box reference
3005        ind = self._poly_model.index(row_index, self.lstPoly.itemDelegate().poly_function)
3006        widget = self.lstPoly.indexWidget(ind)
3007
3008        # Update the combo box so it displays "array"
3009        widget.blockSignals(True)
3010        widget.setCurrentIndex(self.lstPoly.itemDelegate().POLYDISPERSE_FUNCTIONS.index(array_caption))
3011        widget.blockSignals(False)
3012
3013        # Invoke the file reader
3014        self.onPolyComboIndexChange(array_caption, row_index)
3015
3016    def onPolyComboIndexChange(self, combo_string, row_index):
3017        """
3018        Modify polydisp. defaults on function choice
3019        """
3020        # Get npts/nsigs for current selection
3021        param = self.model_parameters.form_volume_parameters[row_index]
3022        file_index = self._poly_model.index(row_index, self.lstPoly.itemDelegate().poly_function)
3023        combo_box = self.lstPoly.indexWidget(file_index)
3024        try:
3025            self.disp_model = POLYDISPERSITY_MODELS[combo_string]()
3026        except IndexError:
3027            logger.error("Error in setting the dispersion model. Reverting to Gaussian.")
3028            self.disp_model = POLYDISPERSITY_MODELS['gaussian']()
3029
3030        def updateFunctionCaption(row):
3031            # Utility function for update of polydispersity function name in the main model
3032            if not self.isCheckable(row):
3033                return
3034            param_name = self._model_model.item(row, 0).text()
3035            if param_name !=  param.name:
3036                return
3037            # Modify the param value
3038            self._model_model.blockSignals(True)
3039            if self.has_error_column:
3040                # err column changes the indexing
3041                self._model_model.item(row, 0).child(0).child(0,5).setText(combo_string)
3042            else:
3043                self._model_model.item(row, 0).child(0).child(0,4).setText(combo_string)
3044            self._model_model.blockSignals(False)
3045
3046        if combo_string == 'array':
3047            try:
3048                # assure the combo is at the right index
3049                combo_box.blockSignals(True)
3050                combo_box.setCurrentIndex(combo_box.findText(combo_string))
3051                combo_box.blockSignals(False)
3052                # Load the file
3053                self.loadPolydispArray(row_index)
3054                # Update main model for display
3055                self.iterateOverModel(updateFunctionCaption)
3056                self.kernel_module.set_dispersion(param.name, self.disp_model)
3057                # disable the row
3058                lo = self.lstPoly.itemDelegate().poly_pd
3059                hi = self.lstPoly.itemDelegate().poly_function
3060                self._poly_model.blockSignals(True)
3061                [self._poly_model.item(row_index, i).setEnabled(False) for i in range(lo, hi)]
3062                self._poly_model.blockSignals(False)
3063                return
3064            except IOError:
3065                combo_box.setCurrentIndex(self.orig_poly_index)
3066                # Pass for cancel/bad read
3067                pass
3068        else:
3069            self.kernel_module.set_dispersion(param.name, self.disp_model)
3070
3071        # Enable the row in case it was disabled by Array
3072        self._poly_model.blockSignals(True)
3073        max_range = self.lstPoly.itemDelegate().poly_filename
3074        [self._poly_model.item(row_index, i).setEnabled(True) for i in range(7)]
3075        file_index = self._poly_model.index(row_index, self.lstPoly.itemDelegate().poly_filename)
3076        self._poly_model.setData(file_index, "")
3077        self._poly_model.blockSignals(False)
3078
3079        npts_index = self._poly_model.index(row_index, self.lstPoly.itemDelegate().poly_npts)
3080        nsigs_index = self._poly_model.index(row_index, self.lstPoly.itemDelegate().poly_nsigs)
3081
3082        npts = POLYDISPERSITY_MODELS[str(combo_string)].default['npts']
3083        nsigs = POLYDISPERSITY_MODELS[str(combo_string)].default['nsigmas']
3084
3085        self._poly_model.setData(npts_index, npts)
3086        self._poly_model.setData(nsigs_index, nsigs)
3087
3088        self.iterateOverModel(updateFunctionCaption)
3089        self.orig_poly_index = combo_box.currentIndex()
3090
3091    def loadPolydispArray(self, row_index):
3092        """
3093        Show the load file dialog and loads requested data into state
3094        """
3095        datafile = QtWidgets.QFileDialog.getOpenFileName(
3096            self, "Choose a weight file", "", "All files (*.*)", None,
3097            QtWidgets.QFileDialog.DontUseNativeDialog)[0]
3098
3099        if not datafile:
3100            logger.info("No weight data chosen.")
3101            raise IOError
3102
3103        values = []
3104        weights = []
3105        def appendData(data_tuple):
3106            """
3107            Fish out floats from a tuple of strings
3108            """
3109            try:
3110                values.append(float(data_tuple[0]))
3111                weights.append(float(data_tuple[1]))
3112            except (ValueError, IndexError):
3113                # just pass through if line with bad data
3114                return
3115
3116        with open(datafile, 'r') as column_file:
3117            column_data = [line.rstrip().split() for line in column_file.readlines()]
3118            [appendData(line) for line in column_data]
3119
3120        # If everything went well - update the sasmodel values
3121        self.disp_model.set_weights(np.array(values), np.array(weights))
3122        # + update the cell with filename
3123        fname = os.path.basename(str(datafile))
3124        fname_index = self._poly_model.index(row_index, self.lstPoly.itemDelegate().poly_filename)
3125        self._poly_model.setData(fname_index, fname)
3126
3127    def onColumnWidthUpdate(self, index, old_size, new_size):
3128        """
3129        Simple state update of the current column widths in the  param list
3130        """
3131        self.lstParamHeaderSizes[index] = new_size
3132
3133    def setMagneticModel(self):
3134        """
3135        Set magnetism values on model
3136        """
3137        if not self.model_parameters:
3138            return
3139        self._magnet_model.clear()
3140        # default initial value
3141        m0 = 0.5
3142        for param in self.model_parameters.call_parameters:
3143            if param.type != 'magnetic': continue
3144            if "M0" in param.name:
3145                m0 += 0.5
3146                value = m0
3147            else:
3148                value = param.default
3149            self.addCheckedMagneticListToModel(param, value)
3150
3151        FittingUtilities.addHeadersToModel(self._magnet_model)
3152
3153    def shellNamesList(self):
3154        """
3155        Returns list of names of all multi-shell parameters
3156        E.g. for sld[n], radius[n], n=1..3 it will return
3157        [sld1, sld2, sld3, radius1, radius2, radius3]
3158        """
3159        multi_names = [p.name[:p.name.index('[')] for p in self.model_parameters.iq_parameters if '[' in p.name]
3160        top_index = self.kernel_module.multiplicity_info.number
3161        shell_names = []
3162        for i in range(1, top_index+1):
3163            for name in multi_names:
3164                shell_names.append(name+str(i))
3165        return shell_names
3166
3167    def addCheckedMagneticListToModel(self, param, value):
3168        """
3169        Wrapper for model update with a subset of magnetic parameters
3170        """
3171        try:
3172            basename, _ = param.name.rsplit('_', 1)
3173        except ValueError:
3174            basename = param.name
3175        if basename in self.shell_names:
3176            try:
3177                shell_index = int(basename[-2:])
3178            except ValueError:
3179                shell_index = int(basename[-1:])
3180
3181            if shell_index > self.current_shell_displayed:
3182                return
3183
3184        checked_list = [param.name,
3185                        str(value),
3186                        str(param.limits[0]),
3187                        str(param.limits[1]),
3188                        param.units]
3189
3190        self.magnet_params[param.name] = value
3191
3192        FittingUtilities.addCheckedListToModel(self._magnet_model, checked_list)
3193
3194    def enableStructureFactorControl(self, structure_factor):
3195        """
3196        Add structure factors to the list of parameters
3197        """
3198        if self.kernel_module.is_form_factor or structure_factor == 'None':
3199            self.enableStructureCombo()
3200        else:
3201            self.disableStructureCombo()
3202
3203    def addExtraShells(self):
3204        """
3205        Add a combobox for multiple shell display
3206        """
3207        param_name, param_length = FittingUtilities.getMultiplicity(self.model_parameters)
3208
3209        if param_length == 0:
3210            return
3211
3212        # cell 1: variable name
3213        item1 = QtGui.QStandardItem(param_name)
3214
3215        func = QtWidgets.QComboBox()
3216
3217        # cell 2: combobox
3218        item2 = QtGui.QStandardItem()
3219
3220        # cell 3: min value
3221        item3 = QtGui.QStandardItem()
3222        # set the cell to be non-editable
3223        item3.setFlags(item3.flags() ^ QtCore.Qt.ItemIsEditable)
3224
3225        # cell 4: max value
3226        item4 = QtGui.QStandardItem()
3227        # set the cell to be non-editable
3228        item4.setFlags(item4.flags() ^ QtCore.Qt.ItemIsEditable)
3229
3230        # cell 4: SLD button
3231        item5 = QtGui.QStandardItem()
3232        button = QtWidgets.QPushButton()
3233        button.setText("Show SLD Profile")
3234
3235        self._model_model.appendRow([item1, item2, item3, item4, item5])
3236
3237        # Beautify the row:  span columns 2-4
3238        shell_row = self._model_model.rowCount()
3239        shell_index = self._model_model.index(shell_row-1, 1)
3240        button_index = self._model_model.index(shell_row-1, 4)
3241
3242        self.lstParams.setIndexWidget(shell_index, func)
3243        self.lstParams.setIndexWidget(button_index, button)
3244        self._n_shells_row = shell_row - 1
3245
3246        # Get the default number of shells for the model
3247        kernel_pars = self.kernel_module._model_info.parameters.kernel_parameters
3248        shell_par = None
3249        for par in kernel_pars:
3250            parname = par.name
3251            if '[' in parname:
3252                 parname = parname[:parname.index('[')]
3253            if parname == param_name:
3254                shell_par = par
3255                break
3256        if shell_par is None:
3257            logger.error("Could not find %s in kernel parameters.", param_name)
3258            return
3259        default_shell_count = shell_par.default
3260        shell_min = 0
3261        shell_max = 0
3262        try:
3263            shell_min = int(shell_par.limits[0])
3264            shell_max = int(shell_par.limits[1])
3265        except IndexError as ex:
3266            # no info about limits
3267            pass
3268        except OverflowError:
3269            # Try to limit shell_par, if possible
3270            if float(shell_par.limits[1])==np.inf:
3271                shell_max = 9
3272            logging.warning("Limiting shell count to 9.")
3273        except Exception as ex:
3274            logging.error("Badly defined multiplicity: "+ str(ex))
3275            return
3276        # don't update the kernel here - this data is display only
3277        self._model_model.blockSignals(True)
3278        item3.setText(str(shell_min))
3279        item4.setText(str(shell_max))
3280        self._model_model.blockSignals(False)
3281
3282        ## Respond to index change
3283        #func.currentTextChanged.connect(self.modifyShellsInList)
3284
3285        # Respond to button press
3286        button.clicked.connect(self.onShowSLDProfile)
3287
3288        # Available range of shells displayed in the combobox
3289        func.addItems([str(i) for i in range(shell_min, shell_max+1)])
3290
3291        # Respond to index change
3292        func.currentTextChanged.connect(self.modifyShellsInList)
3293
3294        # Add default number of shells to the model
3295        func.setCurrentText(str(default_shell_count))
3296        self.modifyShellsInList(str(default_shell_count))
3297
3298    def modifyShellsInList(self, text):
3299        """
3300        Add/remove additional multishell parameters
3301        """
3302        # Find row location of the combobox
3303        first_row = self._n_shells_row + 1
3304        remove_rows = self._num_shell_params
3305        try:
3306            index = int(text)
3307        except ValueError:
3308            # bad text on the control!
3309            index = 0
3310            logger.error("Multiplicity incorrect! Setting to 0")
3311        self.kernel_module.multiplicity = index
3312        if remove_rows > 1:
3313            self._model_model.removeRows(first_row, remove_rows)
3314
3315        new_rows = FittingUtilities.addShellsToModel(
3316                self.model_parameters,
3317                self._model_model,
3318                index,
3319                first_row,
3320                self.lstParams)
3321
3322        self._num_shell_params = len(new_rows)
3323        self.current_shell_displayed = index
3324
3325        # Param values for existing shells were reset to default; force all changes into kernel module
3326        for row in new_rows:
3327            par = row[0].text()
3328            val = GuiUtils.toDouble(row[1].text())
3329            self.kernel_module.setParam(par, val)
3330
3331        # Change 'n' in the parameter model; also causes recalculation
3332        self._model_model.item(self._n_shells_row, 1).setText(str(index))
3333
3334        # Update relevant models
3335        self.setPolyModel()
3336        if self.canHaveMagnetism():
3337            self.setMagneticModel()
3338
3339    def onShowSLDProfile(self):
3340        """
3341        Show a quick plot of SLD profile
3342        """
3343        # get profile data
3344        try:
3345            x, y = self.kernel_module.getProfile()
3346        except TypeError:
3347            msg = "SLD profile calculation failed."
3348            logging.error(msg)
3349            return
3350
3351        y *= 1.0e6
3352        profile_data = Data1D(x=x, y=y)
3353        profile_data.name = "SLD"
3354        profile_data.scale = 'linear'
3355        profile_data.symbol = 'Line'
3356        profile_data.hide_error = True
3357        profile_data._xaxis = "R(\AA)"
3358        profile_data._yaxis = "SLD(10^{-6}\AA^{-2})"
3359
3360        plotter = PlotterWidget(self, quickplot=True)
3361        plotter.data = profile_data
3362        plotter.showLegend = True
3363        plotter.plot(hide_error=True, marker='-')
3364
3365        self.plot_widget = QtWidgets.QWidget()
3366        self.plot_widget.setWindowTitle("Scattering Length Density Profile")
3367        layout = QtWidgets.QVBoxLayout()
3368        layout.addWidget(plotter)
3369        self.plot_widget.setLayout(layout)
3370        self.plot_widget.show()
3371
3372    def setInteractiveElements(self, enabled=True):
3373        """
3374        Switch interactive GUI elements on/off
3375        """
3376        assert isinstance(enabled, bool)
3377
3378        self.lstParams.setEnabled(enabled)
3379        self.lstPoly.setEnabled(enabled)
3380        self.lstMagnetic.setEnabled(enabled)
3381
3382        self.cbCategory.setEnabled(enabled)
3383
3384        if enabled:
3385            # worry about original enablement of model and SF
3386            self.cbModel.setEnabled(self.enabled_cbmodel)
3387            self.cbStructureFactor.setEnabled(self.enabled_sfmodel)
3388        else:
3389            self.cbModel.setEnabled(enabled)
3390            self.cbStructureFactor.setEnabled(enabled)
3391
3392        self.cmdPlot.setEnabled(enabled)
3393
3394    def enableInteractiveElements(self):
3395        """
3396        Set buttion caption on fitting/calculate finish
3397        Enable the param table(s)
3398        """
3399        # Notify the user that fitting is available
3400        self.cmdFit.setStyleSheet('QPushButton {color: black;}')
3401        self.cmdFit.setText("Fit")
3402        self.fit_started = False
3403        self.setInteractiveElements(True)
3404
3405    def disableInteractiveElements(self):
3406        """
3407        Set buttion caption on fitting/calculate start
3408        Disable the param table(s)
3409        """
3410        # Notify the user that fitting is being run
3411        # Allow for stopping the job
3412        self.cmdFit.setStyleSheet('QPushButton {color: red;}')
3413        self.cmdFit.setText('Stop fit')
3414        self.setInteractiveElements(False)
3415
3416    def disableInteractiveElementsOnCalculate(self):
3417        """
3418        Set buttion caption on fitting/calculate start
3419        Disable the param table(s)
3420        """
3421        # Notify the user that fitting is being run
3422        # Allow for stopping the job
3423        self.cmdFit.setStyleSheet('QPushButton {color: red;}')
3424        self.cmdFit.setText('Running...')
3425        self.setInteractiveElements(False)
3426
3427    def readFitPage(self, fp):
3428        """
3429        Read in state from a fitpage object and update GUI
3430        """
3431        assert isinstance(fp, FitPage)
3432        # Main tab info
3433        self.logic.data.filename = fp.filename
3434        self.data_is_loaded = fp.data_is_loaded
3435        self.chkPolydispersity.setCheckState(fp.is_polydisperse)
3436        self.chkMagnetism.setCheckState(fp.is_magnetic)
3437        self.chk2DView.setCheckState(fp.is2D)
3438
3439        # Update the comboboxes
3440        self.cbCategory.setCurrentIndex(self.cbCategory.findText(fp.current_category))
3441        self.cbModel.setCurrentIndex(self.cbModel.findText(fp.current_model))
3442        if fp.current_factor:
3443            self.cbStructureFactor.setCurrentIndex(self.cbStructureFactor.findText(fp.current_factor))
3444
3445        self.chi2 = fp.chi2
3446
3447        # Options tab
3448        self.q_range_min = fp.fit_options[fp.MIN_RANGE]
3449        self.q_range_max = fp.fit_options[fp.MAX_RANGE]
3450        self.npts = fp.fit_options[fp.NPTS]
3451        self.log_points = fp.fit_options[fp.LOG_POINTS]
3452        self.weighting = fp.fit_options[fp.WEIGHTING]
3453
3454        # Models
3455        self._model_model = fp.model_model
3456        self._poly_model = fp.poly_model
3457        self._magnet_model = fp.magnetism_model
3458
3459        # Resolution tab
3460        smearing = fp.smearing_options[fp.SMEARING_OPTION]
3461        accuracy = fp.smearing_options[fp.SMEARING_ACCURACY]
3462        smearing_min = fp.smearing_options[fp.SMEARING_MIN]
3463        smearing_max = fp.smearing_options[fp.SMEARING_MAX]
3464        self.smearing_widget.setState(smearing, accuracy, smearing_min, smearing_max)
3465
3466        # TODO: add polidyspersity and magnetism
3467
3468    def saveToFitPage(self, fp):
3469        """
3470        Write current state to the given fitpage
3471        """
3472        assert isinstance(fp, FitPage)
3473
3474        # Main tab info
3475        fp.filename = self.logic.data.filename
3476        fp.data_is_loaded = self.data_is_loaded
3477        fp.is_polydisperse = self.chkPolydispersity.isChecked()
3478        fp.is_magnetic = self.chkMagnetism.isChecked()
3479        fp.is2D = self.chk2DView.isChecked()
3480        fp.data = self.data
3481
3482        # Use current models - they contain all the required parameters
3483        fp.model_model = self._model_model
3484        fp.poly_model = self._poly_model
3485        fp.magnetism_model = self._magnet_model
3486
3487        if self.cbCategory.currentIndex() != 0:
3488            fp.current_category = str(self.cbCategory.currentText())
3489            fp.current_model = str(self.cbModel.currentText())
3490
3491        if self.cbStructureFactor.isEnabled() and self.cbStructureFactor.currentIndex() != 0:
3492            fp.current_factor = str(self.cbStructureFactor.currentText())
3493        else:
3494            fp.current_factor = ''
3495
3496        fp.chi2 = self.chi2
3497        fp.main_params_to_fit = self.main_params_to_fit
3498        fp.poly_params_to_fit = self.poly_params_to_fit
3499        fp.magnet_params_to_fit = self.magnet_params_to_fit
3500        fp.kernel_module = self.kernel_module
3501
3502        # Algorithm options
3503        # fp.algorithm = self.parent.fit_options.selected_id
3504
3505        # Options tab
3506        fp.fit_options[fp.MIN_RANGE] = self.q_range_min
3507        fp.fit_options[fp.MAX_RANGE] = self.q_range_max
3508        fp.fit_options[fp.NPTS] = self.npts
3509        #fp.fit_options[fp.NPTS_FIT] = self.npts_fit
3510        fp.fit_options[fp.LOG_POINTS] = self.log_points
3511        fp.fit_options[fp.WEIGHTING] = self.weighting
3512
3513        # Resolution tab
3514        smearing, accuracy, smearing_min, smearing_max = self.smearing_widget.state()
3515        fp.smearing_options[fp.SMEARING_OPTION] = smearing
3516        fp.smearing_options[fp.SMEARING_ACCURACY] = accuracy
3517        fp.smearing_options[fp.SMEARING_MIN] = smearing_min
3518        fp.smearing_options[fp.SMEARING_MAX] = smearing_max
3519
3520        # TODO: add polidyspersity and magnetism
3521
3522    def updateUndo(self):
3523        """
3524        Create a new state page and add it to the stack
3525        """
3526        if self.undo_supported:
3527            self.pushFitPage(self.currentState())
3528
3529    def currentState(self):
3530        """
3531        Return fit page with current state
3532        """
3533        new_page = FitPage()
3534        self.saveToFitPage(new_page)
3535
3536        return new_page
3537
3538    def pushFitPage(self, new_page):
3539        """
3540        Add a new fit page object with current state
3541        """
3542        self.page_stack.append(new_page)
3543
3544    def popFitPage(self):
3545        """
3546        Remove top fit page from stack
3547        """
3548        if self.page_stack:
3549            self.page_stack.pop()
3550
3551    def getReport(self):
3552        """
3553        Create and return HTML report with parameters and charts
3554        """
3555        index = None
3556        if self.all_data:
3557            index = self.all_data[self.data_index]
3558        else:
3559            index = self.theory_item
3560        params = FittingUtilities.getStandardParam(self._model_model)
3561        poly_params = []
3562        magnet_params = []
3563        if self.chkPolydispersity.isChecked() and self._poly_model.rowCount() > 0:
3564            poly_params = FittingUtilities.getStandardParam(self._poly_model)
3565        if self.chkMagnetism.isChecked() and self.canHaveMagnetism() and self._magnet_model.rowCount() > 0:
3566            magnet_params = FittingUtilities.getStandardParam(self._magnet_model)
3567        report_logic = ReportPageLogic(self,
3568                                       kernel_module=self.kernel_module,
3569                                       data=self.data,
3570                                       index=index,
3571                                       params=params+poly_params+magnet_params)
3572
3573        return report_logic.reportList()
3574
3575    def loadPageStateCallback(self,state=None, datainfo=None, format=None):
3576        """
3577        This is a callback method called from the CANSAS reader.
3578        We need the instance of this reader only for writing out a file,
3579        so there's nothing here.
3580        Until Load Analysis is implemented, that is.
3581        """
3582        pass
3583
3584    def loadPageState(self, pagestate=None):
3585        """
3586        Load the PageState object and update the current widget
3587        """
3588        filepath = self.loadAnalysisFile()
3589        if filepath is None or filepath == "":
3590            return
3591
3592        with open(filepath, 'r') as statefile:
3593            #column_data = [line.rstrip().split() for line in statefile.readlines()]
3594            lines = statefile.readlines()
3595
3596        # convert into list of lists
3597        pass
3598
3599    def loadAnalysisFile(self):
3600        """
3601        Called when the "Open Project" menu item chosen.
3602        """
3603        default_name = "FitPage"+str(self.tab_id)+".fitv"
3604        wildcard = "fitv files (*.fitv)"
3605        kwargs = {
3606            'caption'   : 'Open Analysis',
3607            'directory' : default_name,
3608            'filter'    : wildcard,
3609            'parent'    : self,
3610        }
3611        filename = QtWidgets.QFileDialog.getOpenFileName(**kwargs)[0]
3612        return filename
3613
3614    def onCopyToClipboard(self, format=None):
3615        """
3616        Copy current fitting parameters into the clipboard
3617        using requested formatting:
3618        plain, excel, latex
3619        """
3620        param_list = self.getFitParameters()
3621        if format=="":
3622            param_list = self.getFitPage()
3623            param_list += self.getFitModel()
3624            formatted_output = FittingUtilities.formatParameters(param_list)
3625        elif format == "Excel":
3626            formatted_output = FittingUtilities.formatParametersExcel(param_list[1:])
3627        elif format == "Latex":
3628            formatted_output = FittingUtilities.formatParametersLatex(param_list[1:])
3629        else:
3630            raise AttributeError("Bad parameter output format specifier.")
3631
3632        # Dump formatted_output to the clipboard
3633        cb = QtWidgets.QApplication.clipboard()
3634        cb.setText(formatted_output)
3635
3636    def getFitModel(self):
3637        """
3638        serializes combobox state
3639        """
3640        param_list = []
3641        model = str(self.cbModel.currentText())
3642        category = str(self.cbCategory.currentText())
3643        structure = str(self.cbStructureFactor.currentText())
3644        param_list.append(['fitpage_category', category])
3645        param_list.append(['fitpage_model', model])
3646        param_list.append(['fitpage_structure', structure])
3647
3648        return param_list
3649
3650    def getFitPage(self):
3651        """
3652        serializes full state of this fit page
3653        """
3654        # run a loop over all parameters and pull out
3655        # first - regular params
3656        param_list = self.getFitParameters()
3657
3658        param_list.append(['is_data', str(self.data_is_loaded)])
3659        data_ids = []
3660        filenames = []
3661        if self.is_batch_fitting:
3662            for item in self.all_data:
3663                # need item->data->data_id
3664                data = GuiUtils.dataFromItem(item)
3665                data_ids.append(data.id)
3666                filenames.append(data.filename)
3667        else:
3668            if self.data_is_loaded:
3669                data_ids = [str(self.logic.data.id)]
3670                filenames = [str(self.logic.data.filename)]
3671        param_list.append(['is_batch_fitting', str(self.is_batch_fitting)])
3672        param_list.append(['data_name', filenames])
3673        param_list.append(['data_id', data_ids])
3674        param_list.append(['tab_name', self.modelName()])
3675        # option tab
3676        param_list.append(['q_range_min', str(self.q_range_min)])
3677        param_list.append(['q_range_max', str(self.q_range_max)])
3678        param_list.append(['q_weighting', str(self.weighting)])
3679        param_list.append(['weighting', str(self.options_widget.weighting)])
3680
3681        # resolution
3682        smearing, accuracy, smearing_min, smearing_max = self.smearing_widget.state()
3683        index = self.smearing_widget.cbSmearing.currentIndex()
3684        param_list.append(['smearing', str(index)])
3685        param_list.append(['smearing_min', str(smearing_min)])
3686        param_list.append(['smearing_max', str(smearing_max)])
3687
3688        # checkboxes, if required
3689        has_polydisp = self.chkPolydispersity.isChecked()
3690        has_magnetism = self.chkMagnetism.isChecked()
3691        has_chain = self.chkChainFit.isChecked()
3692        has_2D = self.chk2DView.isChecked()
3693        param_list.append(['polydisperse_params', str(has_polydisp)])
3694        param_list.append(['magnetic_params', str(has_magnetism)])
3695        param_list.append(['chainfit_params', str(has_chain)])
3696        param_list.append(['2D_params', str(has_2D)])
3697
3698        return param_list
3699
3700    def getFitParameters(self):
3701        """
3702        serializes current parameters
3703        """
3704        param_list = []
3705        if self.kernel_module is None:
3706            return param_list
3707
3708        param_list.append(['model_name', str(self.cbModel.currentText())])
3709
3710        def gatherParams(row):
3711            """
3712            Create list of main parameters based on _model_model
3713            """
3714            param_name = str(self._model_model.item(row, 0).text())
3715
3716            # Assure this is a parameter - must contain a checkbox
3717            if not self._model_model.item(row, 0).isCheckable():
3718                # maybe it is a combobox item (multiplicity)
3719                try:
3720                    index = self._model_model.index(row, 1)
3721                    widget = self.lstParams.indexWidget(index)
3722                    if widget is None:
3723                        return
3724                    if isinstance(widget, QtWidgets.QComboBox):
3725                        # find the index of the combobox
3726                        current_index = widget.currentIndex()
3727                        param_list.append([param_name, 'None', str(current_index)])
3728                except Exception as ex:
3729                    pass
3730                return
3731
3732            param_checked = str(self._model_model.item(row, 0).checkState() == QtCore.Qt.Checked)
3733            # Value of the parameter. In some cases this is the text of the combobox choice.
3734            param_value = str(self._model_model.item(row, 1).text())
3735            param_error = None
3736            param_min = None
3737            param_max = None
3738            column_offset = 0
3739            if self.has_error_column:
3740                column_offset = 1
3741                param_error = str(self._model_model.item(row, 1+column_offset).text())
3742            try:
3743                param_min = str(self._model_model.item(row, 2+column_offset).text())
3744                param_max = str(self._model_model.item(row, 3+column_offset).text())
3745            except:
3746                pass
3747            # Do we have any constraints on this parameter?
3748            constraint = self.getConstraintForRow(row)
3749            cons = ()
3750            if constraint is not None:
3751                value = constraint.value
3752                func = constraint.func
3753                value_ex = constraint.value_ex
3754                param = constraint.param
3755                validate = constraint.validate
3756
3757                cons = (value, param, value_ex, validate, func)
3758
3759            param_list.append([param_name, param_checked, param_value,param_error, param_min, param_max, cons])
3760
3761        def gatherPolyParams(row):
3762            """
3763            Create list of polydisperse parameters based on _poly_model
3764            """
3765            param_name = str(self._poly_model.item(row, 0).text()).split()[-1]
3766            param_checked = str(self._poly_model.item(row, 0).checkState() == QtCore.Qt.Checked)
3767            param_value = str(self._poly_model.item(row, 1).text())
3768            param_error = None
3769            column_offset = 0
3770            if self.has_poly_error_column:
3771                column_offset = 1
3772                param_error = str(self._poly_model.item(row, 1+column_offset).text())
3773            param_min   = str(self._poly_model.item(row, 2+column_offset).text())
3774            param_max   = str(self._poly_model.item(row, 3+column_offset).text())
3775            param_npts  = str(self._poly_model.item(row, 4+column_offset).text())
3776            param_nsigs = str(self._poly_model.item(row, 5+column_offset).text())
3777            param_fun   = str(self._poly_model.item(row, 6+column_offset).text()).rstrip()
3778            index = self._poly_model.index(row, 6+column_offset)
3779            widget = self.lstPoly.indexWidget(index)
3780            if widget is not None and isinstance(widget, QtWidgets.QComboBox):
3781                param_fun = widget.currentText()
3782            # width
3783            name = param_name+".width"
3784            param_list.append([name, param_checked, param_value, param_error,
3785                               param_min, param_max, param_npts, param_nsigs, param_fun])
3786
3787        def gatherMagnetParams(row):
3788            """
3789            Create list of magnetic parameters based on _magnet_model
3790            """
3791            param_name = str(self._magnet_model.item(row, 0).text())
3792            param_checked = str(self._magnet_model.item(row, 0).checkState() == QtCore.Qt.Checked)
3793            param_value = str(self._magnet_model.item(row, 1).text())
3794            param_error = None
3795            column_offset = 0
3796            if self.has_magnet_error_column:
3797                column_offset = 1
3798                param_error = str(self._magnet_model.item(row, 1+column_offset).text())
3799            param_min = str(self._magnet_model.item(row, 2+column_offset).text())
3800            param_max = str(self._magnet_model.item(row, 3+column_offset).text())
3801            param_list.append([param_name, param_checked, param_value,
3802                               param_error, param_min, param_max])
3803
3804        self.iterateOverModel(gatherParams)
3805        if self.chkPolydispersity.isChecked():
3806            self.iterateOverPolyModel(gatherPolyParams)
3807        if self.chkMagnetism.isChecked() and self.canHaveMagnetism():
3808            self.iterateOverMagnetModel(gatherMagnetParams)
3809
3810        if self.kernel_module.is_multiplicity_model:
3811            param_list.append(['multiplicity', str(self.kernel_module.multiplicity)])
3812
3813        return param_list
3814
3815    def onParameterPaste(self):
3816        """
3817        Use the clipboard to update fit state
3818        """
3819        # Check if the clipboard contains right stuff
3820        cb = QtWidgets.QApplication.clipboard()
3821        cb_text = cb.text()
3822
3823        lines = cb_text.split(':')
3824        if lines[0] != 'sasview_parameter_values':
3825            return False
3826
3827        # put the text into dictionary
3828        line_dict = {}
3829        for line in lines[1:]:
3830            content = line.split(',')
3831            if len(content) > 1:
3832                line_dict[content[0]] = content[1:]
3833
3834        self.updatePageWithParameters(line_dict)
3835
3836    def createPageForParameters(self, line_dict):
3837        """
3838        Sets up page with requested model/str factor
3839        and fills it up with sent parameters
3840        """
3841        if 'fitpage_category' in line_dict:
3842            self.cbCategory.setCurrentIndex(self.cbCategory.findText(line_dict['fitpage_category'][0]))
3843        if 'fitpage_model' in line_dict:
3844            self.cbModel.setCurrentIndex(self.cbModel.findText(line_dict['fitpage_model'][0]))
3845        if 'fitpage_structure' in line_dict:
3846            self.cbStructureFactor.setCurrentIndex(self.cbStructureFactor.findText(line_dict['fitpage_structure'][0]))
3847
3848        # Now that the page is ready for parameters, fill it up
3849        self.updatePageWithParameters(line_dict)
3850
3851    def updatePageWithParameters(self, line_dict):
3852        """
3853        Update FitPage with parameters in line_dict
3854        """
3855        if 'model_name' not in line_dict.keys():
3856            return
3857        model = line_dict['model_name'][0]
3858        context = {}
3859
3860        if 'multiplicity' in line_dict.keys():
3861            multip = int(line_dict['multiplicity'][0], 0)
3862            # reset the model with multiplicity, so further updates are saved
3863            if self.kernel_module.is_multiplicity_model:
3864                self.kernel_module.multiplicity=multip
3865                self.updateMultiplicityCombo(multip)
3866
3867        if 'tab_name' in line_dict.keys():
3868            self.kernel_module.name = line_dict['tab_name'][0]
3869        if 'polydisperse_params' in line_dict.keys():
3870            self.chkPolydispersity.setChecked(line_dict['polydisperse_params'][0]=='True')
3871        if 'magnetic_params' in line_dict.keys():
3872            self.chkMagnetism.setChecked(line_dict['magnetic_params'][0]=='True')
3873        if 'chainfit_params' in line_dict.keys():
3874            self.chkChainFit.setChecked(line_dict['chainfit_params'][0]=='True')
3875        if '2D_params' in line_dict.keys():
3876            self.chk2DView.setChecked(line_dict['2D_params'][0]=='True')
3877
3878        # Create the context dictionary for parameters
3879        context['model_name'] = model
3880        for key, value in line_dict.items():
3881            if len(value) > 2:
3882                context[key] = value
3883
3884        if str(self.cbModel.currentText()) != str(context['model_name']):
3885            msg = QtWidgets.QMessageBox()
3886            msg.setIcon(QtWidgets.QMessageBox.Information)
3887            msg.setText("The model in the clipboard is not the same as the currently loaded model. \
3888                         Not all parameters saved may paste correctly.")
3889            msg.setStandardButtons(QtWidgets.QMessageBox.Ok | QtWidgets.QMessageBox.Cancel)
3890            result = msg.exec_()
3891            if result == QtWidgets.QMessageBox.Ok:
3892                pass
3893            else:
3894                return
3895
3896        if 'smearing' in line_dict.keys():
3897            try:
3898                index = int(line_dict['smearing'][0])
3899                self.smearing_widget.cbSmearing.setCurrentIndex(index)
3900            except ValueError:
3901                pass
3902        if 'smearing_min' in line_dict.keys():
3903            try:
3904                self.smearing_widget.dq_l = float(line_dict['smearing_min'][0])
3905            except ValueError:
3906                pass
3907        if 'smearing_max' in line_dict.keys():
3908            try:
3909                self.smearing_widget.dq_r = float(line_dict['smearing_max'][0])
3910            except ValueError:
3911                pass
3912
3913        if 'q_range_max' in line_dict.keys():
3914            try:
3915                self.q_range_min = float(line_dict['q_range_min'][0])
3916                self.q_range_max = float(line_dict['q_range_max'][0])
3917            except ValueError:
3918                pass
3919        self.options_widget.updateQRange(self.q_range_min, self.q_range_max, self.npts)
3920        try:
3921            button_id = int(line_dict['weighting'][0])
3922            for button in self.options_widget.weightingGroup.buttons():
3923                if abs(self.options_widget.weightingGroup.id(button)) == button_id+2:
3924                    button.setChecked(True)
3925                    break
3926        except ValueError:
3927            pass
3928
3929        self.updateFullModel(context)
3930        self.updateFullPolyModel(context)
3931        self.updateFullMagnetModel(context)
3932
3933    def updateMultiplicityCombo(self, multip):
3934        """
3935        Find and update the multiplicity combobox
3936        """
3937        index = self._model_model.index(self._n_shells_row, 1)
3938        widget = self.lstParams.indexWidget(index)
3939        if widget is not None and isinstance(widget, QtWidgets.QComboBox):
3940            widget.setCurrentIndex(widget.findText(str(multip)))
3941        self.current_shell_displayed = multip
3942
3943    def updateFullModel(self, param_dict):
3944        """
3945        Update the model with new parameters
3946        """
3947        assert isinstance(param_dict, dict)
3948        if not dict:
3949            return
3950
3951        def updateFittedValues(row):
3952            # Utility function for main model update
3953            # internal so can use closure for param_dict
3954            param_name = str(self._model_model.item(row, 0).text())
3955            if param_name not in list(param_dict.keys()):
3956                return
3957            # Special case of combo box in the cell (multiplicity)
3958            param_line = param_dict[param_name]
3959            if len(param_line) == 1:
3960                # modify the shells value
3961                try:
3962                    combo_index = int(param_line[0])
3963                except ValueError:
3964                    # quietly pass
3965                    return
3966                index = self._model_model.index(row, 1)
3967                widget = self.lstParams.indexWidget(index)
3968                if widget is not None and isinstance(widget, QtWidgets.QComboBox):
3969                    #widget.setCurrentIndex(combo_index)
3970                    return
3971            # checkbox state
3972            param_checked = QtCore.Qt.Checked if param_dict[param_name][0] == "True" else QtCore.Qt.Unchecked
3973            self._model_model.item(row, 0).setCheckState(param_checked)
3974
3975            # parameter value can be either just a value or text on the combobox
3976            param_text = param_dict[param_name][1]
3977            index = self._model_model.index(row, 1)
3978            widget = self.lstParams.indexWidget(index)
3979            if widget is not None and isinstance(widget, QtWidgets.QComboBox):
3980                # Find the right index based on text
3981                combo_index = int(param_text, 0)
3982                widget.setCurrentIndex(combo_index)
3983            else:
3984                # modify the param value
3985                param_repr = GuiUtils.formatNumber(param_text, high=True)
3986                self._model_model.item(row, 1).setText(param_repr)
3987
3988            # Potentially the error column
3989            ioffset = 0
3990            joffset = 0
3991            if len(param_dict[param_name])>5:
3992                # error values are not editable - no need to update
3993                ioffset = 1
3994            if self.has_error_column:
3995                joffset = 1
3996            # min/max
3997            try:
3998                param_repr = GuiUtils.formatNumber(param_dict[param_name][2+ioffset], high=True)
3999                self._model_model.item(row, 2+joffset).setText(param_repr)
4000                param_repr = GuiUtils.formatNumber(param_dict[param_name][3+ioffset], high=True)
4001                self._model_model.item(row, 3+joffset).setText(param_repr)
4002            except:
4003                pass
4004
4005            # constraints
4006            cons = param_dict[param_name][4+ioffset]
4007            if cons is not None and len(cons)==5:
4008                value = cons[0]
4009                param = cons[1]
4010                value_ex = cons[2]
4011                validate = cons[3]
4012                function = cons[4]
4013                constraint = Constraint()
4014                constraint.value = value
4015                constraint.func = function
4016                constraint.param = param
4017                constraint.value_ex = value_ex
4018                constraint.validate = validate
4019                self.addConstraintToRow(constraint=constraint, row=row)
4020
4021            self.setFocus()
4022
4023        self.iterateOverModel(updateFittedValues)
4024
4025    def updateFullPolyModel(self, param_dict):
4026        """
4027        Update the polydispersity model with new parameters, create the errors column
4028        """
4029        assert isinstance(param_dict, dict)
4030        if not dict:
4031            return
4032
4033        def updateFittedValues(row):
4034            # Utility function for main model update
4035            # internal so can use closure for param_dict
4036            if row >= self._poly_model.rowCount():
4037                return
4038            param_name = str(self._poly_model.item(row, 0).text()).rsplit()[-1] + '.width'
4039            if param_name not in list(param_dict.keys()):
4040                return
4041            # checkbox state
4042            param_checked = QtCore.Qt.Checked if param_dict[param_name][0] == "True" else QtCore.Qt.Unchecked
4043            self._poly_model.item(row,0).setCheckState(param_checked)
4044
4045            # modify the param value
4046            param_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
4047            self._poly_model.item(row, 1).setText(param_repr)
4048
4049            # Potentially the error column
4050            ioffset = 0
4051            joffset = 0
4052            if len(param_dict[param_name])>7:
4053                ioffset = 1
4054            if self.has_poly_error_column:
4055                joffset = 1
4056            # min
4057            param_repr = GuiUtils.formatNumber(param_dict[param_name][2+ioffset], high=True)
4058            self._poly_model.item(row, 2+joffset).setText(param_repr)
4059            # max
4060            param_repr = GuiUtils.formatNumber(param_dict[param_name][3+ioffset], high=True)
4061            self._poly_model.item(row, 3+joffset).setText(param_repr)
4062            # Npts
4063            param_repr = GuiUtils.formatNumber(param_dict[param_name][4+ioffset], high=True)
4064            self._poly_model.item(row, 4+joffset).setText(param_repr)
4065            # Nsigs
4066            param_repr = GuiUtils.formatNumber(param_dict[param_name][5+ioffset], high=True)
4067            self._poly_model.item(row, 5+joffset).setText(param_repr)
4068
4069            self.setFocus()
4070
4071        self.iterateOverPolyModel(updateFittedValues)
4072
4073    def updateFullMagnetModel(self, param_dict):
4074        """
4075        Update the magnetism model with new parameters, create the errors column
4076        """
4077        assert isinstance(param_dict, dict)
4078        if not dict:
4079            return
4080
4081        def updateFittedValues(row):
4082            # Utility function for main model update
4083            # internal so can use closure for param_dict
4084            if row >= self._magnet_model.rowCount():
4085                return
4086            param_name = str(self._magnet_model.item(row, 0).text()).rsplit()[-1]
4087            if param_name not in list(param_dict.keys()):
4088                return
4089            # checkbox state
4090            param_checked = QtCore.Qt.Checked if param_dict[param_name][0] == "True" else QtCore.Qt.Unchecked
4091            self._magnet_model.item(row,0).setCheckState(param_checked)
4092
4093            # modify the param value
4094            param_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
4095            self._magnet_model.item(row, 1).setText(param_repr)
4096
4097            # Potentially the error column
4098            ioffset = 0
4099            joffset = 0
4100            if len(param_dict[param_name])>4:
4101                ioffset = 1
4102            if self.has_magnet_error_column:
4103                joffset = 1
4104            # min
4105            param_repr = GuiUtils.formatNumber(param_dict[param_name][2+ioffset], high=True)
4106            self._magnet_model.item(row, 2+joffset).setText(param_repr)
4107            # max
4108            param_repr = GuiUtils.formatNumber(param_dict[param_name][3+ioffset], high=True)
4109            self._magnet_model.item(row, 3+joffset).setText(param_repr)
4110
4111        self.iterateOverMagnetModel(updateFittedValues)
4112
4113    def getCurrentFitState(self, state=None):
4114        """
4115        Store current state for fit_page
4116        """
4117        # save model option
4118        #if self.model is not None:
4119        #    self.disp_list = self.getDispParamList()
4120        #    state.disp_list = copy.deepcopy(self.disp_list)
4121        #    #state.model = self.model.clone()
4122
4123        # Comboboxes
4124        state.categorycombobox = self.cbCategory.currentText()
4125        state.formfactorcombobox = self.cbModel.currentText()
4126        if self.cbStructureFactor.isEnabled():
4127            state.structurecombobox = self.cbStructureFactor.currentText()
4128        state.tcChi = self.chi2
4129
4130        state.enable2D = self.is2D
4131
4132        #state.weights = copy.deepcopy(self.weights)
4133        # save data
4134        state.data = copy.deepcopy(self.data)
4135
4136        # save plotting range
4137        state.qmin = self.q_range_min
4138        state.qmax = self.q_range_max
4139        state.npts = self.npts
4140
4141        #    self.state.enable_disp = self.enable_disp.GetValue()
4142        #    self.state.disable_disp = self.disable_disp.GetValue()
4143
4144        #    self.state.enable_smearer = \
4145        #                        copy.deepcopy(self.enable_smearer.GetValue())
4146        #    self.state.disable_smearer = \
4147        #                        copy.deepcopy(self.disable_smearer.GetValue())
4148
4149        #self.state.pinhole_smearer = \
4150        #                        copy.deepcopy(self.pinhole_smearer.GetValue())
4151        #self.state.slit_smearer = copy.deepcopy(self.slit_smearer.GetValue())
4152        #self.state.dI_noweight = copy.deepcopy(self.dI_noweight.GetValue())
4153        #self.state.dI_didata = copy.deepcopy(self.dI_didata.GetValue())
4154        #self.state.dI_sqrdata = copy.deepcopy(self.dI_sqrdata.GetValue())
4155        #self.state.dI_idata = copy.deepcopy(self.dI_idata.GetValue())
4156
4157        p = self.model_parameters
4158        # save checkbutton state and txtcrtl values
4159        state.parameters = FittingUtilities.getStandardParam(self._model_model)
4160        state.orientation_params_disp = FittingUtilities.getOrientationParam(self.kernel_module)
4161
4162        #self._copy_parameters_state(self.orientation_params_disp, self.state.orientation_params_disp)
4163        #self._copy_parameters_state(self.parameters, self.state.parameters)
4164        #self._copy_parameters_state(self.fittable_param, self.state.fittable_param)
4165        #self._copy_parameters_state(self.fixed_param, self.state.fixed_param)
4166
Note: See TracBrowser for help on using the repository browser.