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

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

Allow model-specific help be shown when a model is defined.

  • Property mode set to 100644
File size: 160.4 KB
Line 
1import json
2import os
3import sys
4from collections import defaultdict
5
6import copy
7import logging
8import traceback
9from twisted.internet import threads
10import numpy as np
11import webbrowser
12
13from PyQt5 import QtCore
14from PyQt5 import QtGui
15from PyQt5 import QtWidgets
16
17from sasmodels import generate
18from sasmodels import modelinfo
19from sasmodels.sasview_model import load_standard_models
20from sasmodels.sasview_model import MultiplicationModel
21from sasmodels.weights import MODELS as POLYDISPERSITY_MODELS
22
23from sas.sascalc.fit.BumpsFitting import BumpsFit as Fit
24from sas.sascalc.fit.pagestate import PageState
25
26import sas.qtgui.Utilities.GuiUtils as GuiUtils
27import sas.qtgui.Utilities.LocalConfig as LocalConfig
28from sas.qtgui.Utilities.CategoryInstaller import CategoryInstaller
29from sas.qtgui.Plotting.PlotterData import Data1D
30from sas.qtgui.Plotting.PlotterData import Data2D
31from sas.qtgui.Plotting.Plotter import PlotterWidget
32
33from sas.qtgui.Perspectives.Fitting.UI.FittingWidgetUI import Ui_FittingWidgetUI
34from sas.qtgui.Perspectives.Fitting.FitThread import FitThread
35from sas.qtgui.Perspectives.Fitting.ConsoleUpdate import ConsoleUpdate
36
37from sas.qtgui.Perspectives.Fitting.ModelThread import Calc1D
38from sas.qtgui.Perspectives.Fitting.ModelThread import Calc2D
39from sas.qtgui.Perspectives.Fitting.FittingLogic import FittingLogic
40from sas.qtgui.Perspectives.Fitting import FittingUtilities
41from sas.qtgui.Perspectives.Fitting import ModelUtilities
42from sas.qtgui.Perspectives.Fitting.SmearingWidget import SmearingWidget
43from sas.qtgui.Perspectives.Fitting.OptionsWidget import OptionsWidget
44from sas.qtgui.Perspectives.Fitting.FitPage import FitPage
45from sas.qtgui.Perspectives.Fitting.ViewDelegate import ModelViewDelegate
46from sas.qtgui.Perspectives.Fitting.ViewDelegate import PolyViewDelegate
47from sas.qtgui.Perspectives.Fitting.ViewDelegate import MagnetismViewDelegate
48from sas.qtgui.Perspectives.Fitting.Constraint import Constraint
49from sas.qtgui.Perspectives.Fitting.MultiConstraint import MultiConstraint
50from sas.qtgui.Perspectives.Fitting.ReportPageLogic import ReportPageLogic
51
52TAB_MAGNETISM = 4
53TAB_POLY = 3
54CATEGORY_DEFAULT = "Choose category..."
55MODEL_DEFAULT = "Choose model..."
56CATEGORY_STRUCTURE = "Structure Factor"
57CATEGORY_CUSTOM = "Plugin Models"
58STRUCTURE_DEFAULT = "None"
59
60DEFAULT_POLYDISP_FUNCTION = 'gaussian'
61
62# CRUFT: remove when new release of sasmodels is available
63# https://github.com/SasView/sasview/pull/181#discussion_r218135162
64from sasmodels.sasview_model import SasviewModel
65if not hasattr(SasviewModel, 'get_weights'):
66    def get_weights(self, name):
67        """
68        Returns the polydispersity distribution for parameter *name* as *value* and *weight* arrays.
69        """
70        # type: (str) -> Tuple(np.ndarray, np.ndarray)
71        _, x, w = self._get_weights(self._model_info.parameters[name])
72        return x, w
73
74    SasviewModel.get_weights = get_weights
75
76logger = logging.getLogger(__name__)
77
78class ToolTippedItemModel(QtGui.QStandardItemModel):
79    """
80    Subclass from QStandardItemModel to allow displaying tooltips in
81    QTableView model.
82    """
83    def __init__(self, parent=None):
84        QtGui.QStandardItemModel.__init__(self, parent)
85
86    def headerData(self, section, orientation, role=QtCore.Qt.DisplayRole):
87        """
88        Displays tooltip for each column's header
89        :param section:
90        :param orientation:
91        :param role:
92        :return:
93        """
94        if role == QtCore.Qt.ToolTipRole:
95            if orientation == QtCore.Qt.Horizontal:
96                return str(self.header_tooltips[section])
97
98        return QtGui.QStandardItemModel.headerData(self, section, orientation, role)
99
100class FittingWidget(QtWidgets.QWidget, Ui_FittingWidgetUI):
101    """
102    Main widget for selecting form and structure factor models
103    """
104    constraintAddedSignal = QtCore.pyqtSignal(list)
105    newModelSignal = QtCore.pyqtSignal()
106    fittingFinishedSignal = QtCore.pyqtSignal(tuple)
107    batchFittingFinishedSignal = QtCore.pyqtSignal(tuple)
108    Calc1DFinishedSignal = QtCore.pyqtSignal(dict)
109    Calc2DFinishedSignal = QtCore.pyqtSignal(dict)
110
111    MAGNETIC_MODELS = ['sphere', 'core_shell_sphere', 'core_multi_shell', 'cylinder', 'parallelepiped']
112
113    def __init__(self, parent=None, data=None, tab_id=1):
114
115        super(FittingWidget, self).__init__()
116
117        # Necessary globals
118        self.parent = parent
119
120        # Which tab is this widget displayed in?
121        self.tab_id = tab_id
122
123        import sys
124        sys.excepthook = self.info
125
126        # Globals
127        self.initializeGlobals()
128
129        # data index for the batch set
130        self.data_index = 0
131        # Main Data[12]D holders
132        # Logics.data contains a single Data1D/Data2D object
133        self._logic = [FittingLogic()]
134
135        # Main GUI setup up
136        self.setupUi(self)
137        self.setWindowTitle("Fitting")
138
139        # Set up tabs widgets
140        self.initializeWidgets()
141
142        # Set up models and views
143        self.initializeModels()
144
145        # Defaults for the structure factors
146        self.setDefaultStructureCombo()
147
148        # Make structure factor and model CBs disabled
149        self.disableModelCombo()
150        self.disableStructureCombo()
151
152        # Generate the category list for display
153        self.initializeCategoryCombo()
154
155        # Initial control state
156        self.initializeControls()
157
158        QtWidgets.QApplication.processEvents()
159
160        # Connect signals to controls
161        self.initializeSignals()
162
163        if data is not None:
164            self.data = data
165
166        # New font to display angstrom symbol
167        new_font = 'font-family: -apple-system, "Helvetica Neue", "Ubuntu";'
168        self.label_17.setStyleSheet(new_font)
169        self.label_19.setStyleSheet(new_font)
170
171    def info(self, type, value, tb):
172        logger.error("SasView threw exception: " + str(value))
173        traceback.print_exception(type, value, tb)
174
175    @property
176    def logic(self):
177        # make sure the logic contains at least one element
178        assert self._logic
179        # logic connected to the currently shown data
180        return self._logic[self.data_index]
181
182    @property
183    def data(self):
184        return self.logic.data
185
186    @data.setter
187    def data(self, value):
188        """ data setter """
189        # Value is either a list of indices for batch fitting or a simple index
190        # for standard fitting. Assure we have a list, regardless.
191        if isinstance(value, list):
192            self.is_batch_fitting = True
193        else:
194            value = [value]
195
196        assert isinstance(value[0], QtGui.QStandardItem)
197
198        # Keep reference to all datasets for batch
199        self.all_data = value
200
201        # Create logics with data items
202        # Logics.data contains only a single Data1D/Data2D object
203        if len(value) == 1:
204            # single data logic is already defined, update data on it
205            self._logic[0].data = GuiUtils.dataFromItem(value[0])
206        else:
207            # batch datasets
208            self._logic = []
209            for data_item in value:
210                logic = FittingLogic(data=GuiUtils.dataFromItem(data_item))
211                self._logic.append(logic)
212
213        # Overwrite data type descriptor
214
215        self.is2D = True if isinstance(self.logic.data, Data2D) else False
216
217        # Let others know we're full of data now
218        self.data_is_loaded = True
219
220        # Enable/disable UI components
221        self.setEnablementOnDataLoad()
222
223    def initializeGlobals(self):
224        """
225        Initialize global variables used in this class
226        """
227        # SasModel is loaded
228        self.model_is_loaded = False
229        # Data[12]D passed and set
230        self.data_is_loaded = False
231        # Batch/single fitting
232        self.is_batch_fitting = False
233        self.is_chain_fitting = False
234        # Is the fit job running?
235        self.fit_started = False
236        # The current fit thread
237        self.calc_fit = None
238        # Current SasModel in view
239        self.kernel_module = None
240        # Current SasModel view dimension
241        self.is2D = False
242        # Current SasModel is multishell
243        self.model_has_shells = False
244        # Utility variable to enable unselectable option in category combobox
245        self._previous_category_index = 0
246        # Utility variables for multishell display
247        self._n_shells_row = 0
248        self._num_shell_params = 0
249        # Dictionary of {model name: model class} for the current category
250        self.models = {}
251        # Parameters to fit
252        self.main_params_to_fit = []
253        self.poly_params_to_fit = []
254        self.magnet_params_to_fit = []
255
256        # Fit options
257        self.q_range_min = 0.005
258        self.q_range_max = 0.1
259        self.npts = 25
260        self.log_points = False
261        self.weighting = 0
262        self.chi2 = None
263        # Does the control support UNDO/REDO
264        # temporarily off
265        self.undo_supported = False
266        self.page_stack = []
267        self.all_data = []
268        # custom plugin models
269        # {model.name:model}
270        self.custom_models = self.customModels()
271        # Polydisp widget table default index for function combobox
272        self.orig_poly_index = 3
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
3025        def updateFunctionCaption(row):
3026            # Utility function for update of polydispersity function name in the main model
3027            if not self.isCheckable(row):
3028                return
3029            self._model_model.blockSignals(True)
3030            param_name = str(self._model_model.item(row, 0).text())
3031            self._model_model.blockSignals(False)
3032            if param_name !=  param.name:
3033                return
3034            # Modify the param value
3035            self._model_model.blockSignals(True)
3036            if self.has_error_column:
3037                # err column changes the indexing
3038                self._model_model.item(row, 0).child(0).child(0,5).setText(combo_string)
3039            else:
3040                self._model_model.item(row, 0).child(0).child(0,4).setText(combo_string)
3041            self._model_model.blockSignals(False)
3042
3043        if combo_string == 'array':
3044            try:
3045                self.loadPolydispArray(row_index)
3046                # Update main model for display
3047                self.iterateOverModel(updateFunctionCaption)
3048                # disable the row
3049                lo = self.lstPoly.itemDelegate().poly_pd
3050                hi = self.lstPoly.itemDelegate().poly_function
3051                [self._poly_model.item(row_index, i).setEnabled(False) for i in range(lo, hi)]
3052                return
3053            except IOError:
3054                combo_box.setCurrentIndex(self.orig_poly_index)
3055                # Pass for cancel/bad read
3056                pass
3057
3058        # Enable the row in case it was disabled by Array
3059        self._poly_model.blockSignals(True)
3060        max_range = self.lstPoly.itemDelegate().poly_filename
3061        [self._poly_model.item(row_index, i).setEnabled(True) for i in range(7)]
3062        file_index = self._poly_model.index(row_index, self.lstPoly.itemDelegate().poly_filename)
3063        self._poly_model.setData(file_index, "")
3064        self._poly_model.blockSignals(False)
3065
3066        npts_index = self._poly_model.index(row_index, self.lstPoly.itemDelegate().poly_npts)
3067        nsigs_index = self._poly_model.index(row_index, self.lstPoly.itemDelegate().poly_nsigs)
3068
3069        npts = POLYDISPERSITY_MODELS[str(combo_string)].default['npts']
3070        nsigs = POLYDISPERSITY_MODELS[str(combo_string)].default['nsigmas']
3071
3072        self._poly_model.setData(npts_index, npts)
3073        self._poly_model.setData(nsigs_index, nsigs)
3074
3075        self.iterateOverModel(updateFunctionCaption)
3076        self.orig_poly_index = combo_box.currentIndex()
3077
3078    def loadPolydispArray(self, row_index):
3079        """
3080        Show the load file dialog and loads requested data into state
3081        """
3082        datafile = QtWidgets.QFileDialog.getOpenFileName(
3083            self, "Choose a weight file", "", "All files (*.*)", None,
3084            QtWidgets.QFileDialog.DontUseNativeDialog)[0]
3085
3086        if not datafile:
3087            logger.info("No weight data chosen.")
3088            raise IOError
3089
3090        values = []
3091        weights = []
3092        def appendData(data_tuple):
3093            """
3094            Fish out floats from a tuple of strings
3095            """
3096            try:
3097                values.append(float(data_tuple[0]))
3098                weights.append(float(data_tuple[1]))
3099            except (ValueError, IndexError):
3100                # just pass through if line with bad data
3101                return
3102
3103        with open(datafile, 'r') as column_file:
3104            column_data = [line.rstrip().split() for line in column_file.readlines()]
3105            [appendData(line) for line in column_data]
3106
3107        # If everything went well - update the sasmodel values
3108        self.disp_model = POLYDISPERSITY_MODELS['array']()
3109        self.disp_model.set_weights(np.array(values), np.array(weights))
3110        # + update the cell with filename
3111        fname = os.path.basename(str(datafile))
3112        fname_index = self._poly_model.index(row_index, self.lstPoly.itemDelegate().poly_filename)
3113        self._poly_model.setData(fname_index, fname)
3114
3115    def onColumnWidthUpdate(self, index, old_size, new_size):
3116        """
3117        Simple state update of the current column widths in the  param list
3118        """
3119        self.lstParamHeaderSizes[index] = new_size
3120
3121    def setMagneticModel(self):
3122        """
3123        Set magnetism values on model
3124        """
3125        if not self.model_parameters:
3126            return
3127        self._magnet_model.clear()
3128        # default initial value
3129        m0 = 0.5
3130        for param in self.model_parameters.call_parameters:
3131            if param.type != 'magnetic': continue
3132            if "M0" in param.name:
3133                m0 += 0.5
3134                value = m0
3135            else:
3136                value = param.default
3137            self.addCheckedMagneticListToModel(param, value)
3138
3139        FittingUtilities.addHeadersToModel(self._magnet_model)
3140
3141    def shellNamesList(self):
3142        """
3143        Returns list of names of all multi-shell parameters
3144        E.g. for sld[n], radius[n], n=1..3 it will return
3145        [sld1, sld2, sld3, radius1, radius2, radius3]
3146        """
3147        multi_names = [p.name[:p.name.index('[')] for p in self.model_parameters.iq_parameters if '[' in p.name]
3148        top_index = self.kernel_module.multiplicity_info.number
3149        shell_names = []
3150        for i in range(1, top_index+1):
3151            for name in multi_names:
3152                shell_names.append(name+str(i))
3153        return shell_names
3154
3155    def addCheckedMagneticListToModel(self, param, value):
3156        """
3157        Wrapper for model update with a subset of magnetic parameters
3158        """
3159        try:
3160            basename, _ = param.name.rsplit('_', 1)
3161        except ValueError:
3162            basename = param.name
3163        if basename in self.shell_names:
3164            try:
3165                shell_index = int(basename[-2:])
3166            except ValueError:
3167                shell_index = int(basename[-1:])
3168
3169            if shell_index > self.current_shell_displayed:
3170                return
3171
3172        checked_list = [param.name,
3173                        str(value),
3174                        str(param.limits[0]),
3175                        str(param.limits[1]),
3176                        param.units]
3177
3178        self.magnet_params[param.name] = value
3179
3180        FittingUtilities.addCheckedListToModel(self._magnet_model, checked_list)
3181
3182    def enableStructureFactorControl(self, structure_factor):
3183        """
3184        Add structure factors to the list of parameters
3185        """
3186        if self.kernel_module.is_form_factor or structure_factor == 'None':
3187            self.enableStructureCombo()
3188        else:
3189            self.disableStructureCombo()
3190
3191    def addExtraShells(self):
3192        """
3193        Add a combobox for multiple shell display
3194        """
3195        param_name, param_length = FittingUtilities.getMultiplicity(self.model_parameters)
3196
3197        if param_length == 0:
3198            return
3199
3200        # cell 1: variable name
3201        item1 = QtGui.QStandardItem(param_name)
3202
3203        func = QtWidgets.QComboBox()
3204
3205        # cell 2: combobox
3206        item2 = QtGui.QStandardItem()
3207
3208        # cell 3: min value
3209        item3 = QtGui.QStandardItem()
3210        # set the cell to be non-editable
3211        item3.setFlags(item3.flags() ^ QtCore.Qt.ItemIsEditable)
3212
3213        # cell 4: max value
3214        item4 = QtGui.QStandardItem()
3215        # set the cell to be non-editable
3216        item4.setFlags(item4.flags() ^ QtCore.Qt.ItemIsEditable)
3217
3218        # cell 4: SLD button
3219        item5 = QtGui.QStandardItem()
3220        button = QtWidgets.QPushButton()
3221        button.setText("Show SLD Profile")
3222
3223        self._model_model.appendRow([item1, item2, item3, item4, item5])
3224
3225        # Beautify the row:  span columns 2-4
3226        shell_row = self._model_model.rowCount()
3227        shell_index = self._model_model.index(shell_row-1, 1)
3228        button_index = self._model_model.index(shell_row-1, 4)
3229
3230        self.lstParams.setIndexWidget(shell_index, func)
3231        self.lstParams.setIndexWidget(button_index, button)
3232        self._n_shells_row = shell_row - 1
3233
3234        # Get the default number of shells for the model
3235        kernel_pars = self.kernel_module._model_info.parameters.kernel_parameters
3236        shell_par = None
3237        for par in kernel_pars:
3238            parname = par.name
3239            if '[' in parname:
3240                 parname = parname[:parname.index('[')]
3241            if parname == param_name:
3242                shell_par = par
3243                break
3244        if shell_par is None:
3245            logger.error("Could not find %s in kernel parameters.", param_name)
3246            return
3247        default_shell_count = shell_par.default
3248        shell_min = 0
3249        shell_max = 0
3250        try:
3251            shell_min = int(shell_par.limits[0])
3252            shell_max = int(shell_par.limits[1])
3253        except IndexError as ex:
3254            # no info about limits
3255            pass
3256        except OverflowError:
3257            # Try to limit shell_par, if possible
3258            if float(shell_par.limits[1])==np.inf:
3259                shell_max = 9
3260            logging.warning("Limiting shell count to 9.")
3261        except Exception as ex:
3262            logging.error("Badly defined multiplicity: "+ str(ex))
3263            return
3264        # don't update the kernel here - this data is display only
3265        self._model_model.blockSignals(True)
3266        item3.setText(str(shell_min))
3267        item4.setText(str(shell_max))
3268        self._model_model.blockSignals(False)
3269
3270        ## Respond to index change
3271        #func.currentTextChanged.connect(self.modifyShellsInList)
3272
3273        # Respond to button press
3274        button.clicked.connect(self.onShowSLDProfile)
3275
3276        # Available range of shells displayed in the combobox
3277        func.addItems([str(i) for i in range(shell_min, shell_max+1)])
3278
3279        # Respond to index change
3280        func.currentTextChanged.connect(self.modifyShellsInList)
3281
3282        # Add default number of shells to the model
3283        func.setCurrentText(str(default_shell_count))
3284        self.modifyShellsInList(str(default_shell_count))
3285
3286    def modifyShellsInList(self, text):
3287        """
3288        Add/remove additional multishell parameters
3289        """
3290        # Find row location of the combobox
3291        first_row = self._n_shells_row + 1
3292        remove_rows = self._num_shell_params
3293        try:
3294            index = int(text)
3295        except ValueError:
3296            # bad text on the control!
3297            index = 0
3298            logger.error("Multiplicity incorrect! Setting to 0")
3299        self.kernel_module.multiplicity = index
3300        if remove_rows > 1:
3301            self._model_model.removeRows(first_row, remove_rows)
3302
3303        new_rows = FittingUtilities.addShellsToModel(
3304                self.model_parameters,
3305                self._model_model,
3306                index,
3307                first_row,
3308                self.lstParams)
3309
3310        self._num_shell_params = len(new_rows)
3311        self.current_shell_displayed = index
3312
3313        # Param values for existing shells were reset to default; force all changes into kernel module
3314        for row in new_rows:
3315            par = row[0].text()
3316            val = GuiUtils.toDouble(row[1].text())
3317            self.kernel_module.setParam(par, val)
3318
3319        # Change 'n' in the parameter model; also causes recalculation
3320        self._model_model.item(self._n_shells_row, 1).setText(str(index))
3321
3322        # Update relevant models
3323        self.setPolyModel()
3324        if self.canHaveMagnetism():
3325            self.setMagneticModel()
3326
3327    def onShowSLDProfile(self):
3328        """
3329        Show a quick plot of SLD profile
3330        """
3331        # get profile data
3332        try:
3333            x, y = self.kernel_module.getProfile()
3334        except TypeError:
3335            msg = "SLD profile calculation failed."
3336            logging.error(msg)
3337            return
3338
3339        y *= 1.0e6
3340        profile_data = Data1D(x=x, y=y)
3341        profile_data.name = "SLD"
3342        profile_data.scale = 'linear'
3343        profile_data.symbol = 'Line'
3344        profile_data.hide_error = True
3345        profile_data._xaxis = "R(\AA)"
3346        profile_data._yaxis = "SLD(10^{-6}\AA^{-2})"
3347
3348        plotter = PlotterWidget(self, quickplot=True)
3349        plotter.data = profile_data
3350        plotter.showLegend = True
3351        plotter.plot(hide_error=True, marker='-')
3352
3353        self.plot_widget = QtWidgets.QWidget()
3354        self.plot_widget.setWindowTitle("Scattering Length Density Profile")
3355        layout = QtWidgets.QVBoxLayout()
3356        layout.addWidget(plotter)
3357        self.plot_widget.setLayout(layout)
3358        self.plot_widget.show()
3359
3360    def setInteractiveElements(self, enabled=True):
3361        """
3362        Switch interactive GUI elements on/off
3363        """
3364        assert isinstance(enabled, bool)
3365
3366        self.lstParams.setEnabled(enabled)
3367        self.lstPoly.setEnabled(enabled)
3368        self.lstMagnetic.setEnabled(enabled)
3369
3370        self.cbCategory.setEnabled(enabled)
3371
3372        if enabled:
3373            # worry about original enablement of model and SF
3374            self.cbModel.setEnabled(self.enabled_cbmodel)
3375            self.cbStructureFactor.setEnabled(self.enabled_sfmodel)
3376        else:
3377            self.cbModel.setEnabled(enabled)
3378            self.cbStructureFactor.setEnabled(enabled)
3379
3380        self.cmdPlot.setEnabled(enabled)
3381
3382    def enableInteractiveElements(self):
3383        """
3384        Set buttion caption on fitting/calculate finish
3385        Enable the param table(s)
3386        """
3387        # Notify the user that fitting is available
3388        self.cmdFit.setStyleSheet('QPushButton {color: black;}')
3389        self.cmdFit.setText("Fit")
3390        self.fit_started = False
3391        self.setInteractiveElements(True)
3392
3393    def disableInteractiveElements(self):
3394        """
3395        Set buttion caption on fitting/calculate start
3396        Disable the param table(s)
3397        """
3398        # Notify the user that fitting is being run
3399        # Allow for stopping the job
3400        self.cmdFit.setStyleSheet('QPushButton {color: red;}')
3401        self.cmdFit.setText('Stop fit')
3402        self.setInteractiveElements(False)
3403
3404    def disableInteractiveElementsOnCalculate(self):
3405        """
3406        Set buttion caption on fitting/calculate start
3407        Disable the param table(s)
3408        """
3409        # Notify the user that fitting is being run
3410        # Allow for stopping the job
3411        self.cmdFit.setStyleSheet('QPushButton {color: red;}')
3412        self.cmdFit.setText('Running...')
3413        self.setInteractiveElements(False)
3414
3415    def readFitPage(self, fp):
3416        """
3417        Read in state from a fitpage object and update GUI
3418        """
3419        assert isinstance(fp, FitPage)
3420        # Main tab info
3421        self.logic.data.filename = fp.filename
3422        self.data_is_loaded = fp.data_is_loaded
3423        self.chkPolydispersity.setCheckState(fp.is_polydisperse)
3424        self.chkMagnetism.setCheckState(fp.is_magnetic)
3425        self.chk2DView.setCheckState(fp.is2D)
3426
3427        # Update the comboboxes
3428        self.cbCategory.setCurrentIndex(self.cbCategory.findText(fp.current_category))
3429        self.cbModel.setCurrentIndex(self.cbModel.findText(fp.current_model))
3430        if fp.current_factor:
3431            self.cbStructureFactor.setCurrentIndex(self.cbStructureFactor.findText(fp.current_factor))
3432
3433        self.chi2 = fp.chi2
3434
3435        # Options tab
3436        self.q_range_min = fp.fit_options[fp.MIN_RANGE]
3437        self.q_range_max = fp.fit_options[fp.MAX_RANGE]
3438        self.npts = fp.fit_options[fp.NPTS]
3439        self.log_points = fp.fit_options[fp.LOG_POINTS]
3440        self.weighting = fp.fit_options[fp.WEIGHTING]
3441
3442        # Models
3443        self._model_model = fp.model_model
3444        self._poly_model = fp.poly_model
3445        self._magnet_model = fp.magnetism_model
3446
3447        # Resolution tab
3448        smearing = fp.smearing_options[fp.SMEARING_OPTION]
3449        accuracy = fp.smearing_options[fp.SMEARING_ACCURACY]
3450        smearing_min = fp.smearing_options[fp.SMEARING_MIN]
3451        smearing_max = fp.smearing_options[fp.SMEARING_MAX]
3452        self.smearing_widget.setState(smearing, accuracy, smearing_min, smearing_max)
3453
3454        # TODO: add polidyspersity and magnetism
3455
3456    def saveToFitPage(self, fp):
3457        """
3458        Write current state to the given fitpage
3459        """
3460        assert isinstance(fp, FitPage)
3461
3462        # Main tab info
3463        fp.filename = self.logic.data.filename
3464        fp.data_is_loaded = self.data_is_loaded
3465        fp.is_polydisperse = self.chkPolydispersity.isChecked()
3466        fp.is_magnetic = self.chkMagnetism.isChecked()
3467        fp.is2D = self.chk2DView.isChecked()
3468        fp.data = self.data
3469
3470        # Use current models - they contain all the required parameters
3471        fp.model_model = self._model_model
3472        fp.poly_model = self._poly_model
3473        fp.magnetism_model = self._magnet_model
3474
3475        if self.cbCategory.currentIndex() != 0:
3476            fp.current_category = str(self.cbCategory.currentText())
3477            fp.current_model = str(self.cbModel.currentText())
3478
3479        if self.cbStructureFactor.isEnabled() and self.cbStructureFactor.currentIndex() != 0:
3480            fp.current_factor = str(self.cbStructureFactor.currentText())
3481        else:
3482            fp.current_factor = ''
3483
3484        fp.chi2 = self.chi2
3485        fp.main_params_to_fit = self.main_params_to_fit
3486        fp.poly_params_to_fit = self.poly_params_to_fit
3487        fp.magnet_params_to_fit = self.magnet_params_to_fit
3488        fp.kernel_module = self.kernel_module
3489
3490        # Algorithm options
3491        # fp.algorithm = self.parent.fit_options.selected_id
3492
3493        # Options tab
3494        fp.fit_options[fp.MIN_RANGE] = self.q_range_min
3495        fp.fit_options[fp.MAX_RANGE] = self.q_range_max
3496        fp.fit_options[fp.NPTS] = self.npts
3497        #fp.fit_options[fp.NPTS_FIT] = self.npts_fit
3498        fp.fit_options[fp.LOG_POINTS] = self.log_points
3499        fp.fit_options[fp.WEIGHTING] = self.weighting
3500
3501        # Resolution tab
3502        smearing, accuracy, smearing_min, smearing_max = self.smearing_widget.state()
3503        fp.smearing_options[fp.SMEARING_OPTION] = smearing
3504        fp.smearing_options[fp.SMEARING_ACCURACY] = accuracy
3505        fp.smearing_options[fp.SMEARING_MIN] = smearing_min
3506        fp.smearing_options[fp.SMEARING_MAX] = smearing_max
3507
3508        # TODO: add polidyspersity and magnetism
3509
3510    def updateUndo(self):
3511        """
3512        Create a new state page and add it to the stack
3513        """
3514        if self.undo_supported:
3515            self.pushFitPage(self.currentState())
3516
3517    def currentState(self):
3518        """
3519        Return fit page with current state
3520        """
3521        new_page = FitPage()
3522        self.saveToFitPage(new_page)
3523
3524        return new_page
3525
3526    def pushFitPage(self, new_page):
3527        """
3528        Add a new fit page object with current state
3529        """
3530        self.page_stack.append(new_page)
3531
3532    def popFitPage(self):
3533        """
3534        Remove top fit page from stack
3535        """
3536        if self.page_stack:
3537            self.page_stack.pop()
3538
3539    def getReport(self):
3540        """
3541        Create and return HTML report with parameters and charts
3542        """
3543        index = None
3544        if self.all_data:
3545            index = self.all_data[self.data_index]
3546        else:
3547            index = self.theory_item
3548        params = FittingUtilities.getStandardParam(self._model_model)
3549        poly_params = []
3550        magnet_params = []
3551        if self.chkPolydispersity.isChecked() and self._poly_model.rowCount() > 0:
3552            poly_params = FittingUtilities.getStandardParam(self._poly_model)
3553        if self.chkMagnetism.isChecked() and self.canHaveMagnetism() and self._magnet_model.rowCount() > 0:
3554            magnet_params = FittingUtilities.getStandardParam(self._magnet_model)
3555        report_logic = ReportPageLogic(self,
3556                                       kernel_module=self.kernel_module,
3557                                       data=self.data,
3558                                       index=index,
3559                                       params=params+poly_params+magnet_params)
3560
3561        return report_logic.reportList()
3562
3563    def loadPageStateCallback(self,state=None, datainfo=None, format=None):
3564        """
3565        This is a callback method called from the CANSAS reader.
3566        We need the instance of this reader only for writing out a file,
3567        so there's nothing here.
3568        Until Load Analysis is implemented, that is.
3569        """
3570        pass
3571
3572    def loadPageState(self, pagestate=None):
3573        """
3574        Load the PageState object and update the current widget
3575        """
3576        filepath = self.loadAnalysisFile()
3577        if filepath is None or filepath == "":
3578            return
3579
3580        with open(filepath, 'r') as statefile:
3581            #column_data = [line.rstrip().split() for line in statefile.readlines()]
3582            lines = statefile.readlines()
3583
3584        # convert into list of lists
3585        pass
3586
3587    def loadAnalysisFile(self):
3588        """
3589        Called when the "Open Project" menu item chosen.
3590        """
3591        default_name = "FitPage"+str(self.tab_id)+".fitv"
3592        wildcard = "fitv files (*.fitv)"
3593        kwargs = {
3594            'caption'   : 'Open Analysis',
3595            'directory' : default_name,
3596            'filter'    : wildcard,
3597            'parent'    : self,
3598        }
3599        filename = QtWidgets.QFileDialog.getOpenFileName(**kwargs)[0]
3600        return filename
3601
3602    def onCopyToClipboard(self, format=None):
3603        """
3604        Copy current fitting parameters into the clipboard
3605        using requested formatting:
3606        plain, excel, latex
3607        """
3608        param_list = self.getFitParameters()
3609        if format=="":
3610            param_list = self.getFitPage()
3611            param_list += self.getFitModel()
3612            formatted_output = FittingUtilities.formatParameters(param_list)
3613        elif format == "Excel":
3614            formatted_output = FittingUtilities.formatParametersExcel(param_list[1:])
3615        elif format == "Latex":
3616            formatted_output = FittingUtilities.formatParametersLatex(param_list[1:])
3617        else:
3618            raise AttributeError("Bad parameter output format specifier.")
3619
3620        # Dump formatted_output to the clipboard
3621        cb = QtWidgets.QApplication.clipboard()
3622        cb.setText(formatted_output)
3623
3624    def getFitModel(self):
3625        """
3626        serializes combobox state
3627        """
3628        param_list = []
3629        model = str(self.cbModel.currentText())
3630        category = str(self.cbCategory.currentText())
3631        structure = str(self.cbStructureFactor.currentText())
3632        param_list.append(['fitpage_category', category])
3633        param_list.append(['fitpage_model', model])
3634        param_list.append(['fitpage_structure', structure])
3635
3636        return param_list
3637
3638    def getFitPage(self):
3639        """
3640        serializes full state of this fit page
3641        """
3642        # run a loop over all parameters and pull out
3643        # first - regular params
3644        param_list = self.getFitParameters()
3645
3646        param_list.append(['is_data', str(self.data_is_loaded)])
3647        data_ids = []
3648        filenames = []
3649        if self.is_batch_fitting:
3650            for item in self.all_data:
3651                # need item->data->data_id
3652                data = GuiUtils.dataFromItem(item)
3653                data_ids.append(data.id)
3654                filenames.append(data.filename)
3655        else:
3656            if self.data_is_loaded:
3657                data_ids = [str(self.logic.data.id)]
3658                filenames = [str(self.logic.data.filename)]
3659        param_list.append(['is_batch_fitting', str(self.is_batch_fitting)])
3660        param_list.append(['data_name', filenames])
3661        param_list.append(['data_id', data_ids])
3662        param_list.append(['tab_name', self.modelName()])
3663        # option tab
3664        param_list.append(['q_range_min', str(self.q_range_min)])
3665        param_list.append(['q_range_max', str(self.q_range_max)])
3666        param_list.append(['q_weighting', str(self.weighting)])
3667        param_list.append(['weighting', str(self.options_widget.weighting)])
3668
3669        # resolution
3670        smearing, accuracy, smearing_min, smearing_max = self.smearing_widget.state()
3671        index = self.smearing_widget.cbSmearing.currentIndex()
3672        param_list.append(['smearing', str(index)])
3673        param_list.append(['smearing_min', str(smearing_min)])
3674        param_list.append(['smearing_max', str(smearing_max)])
3675
3676        # checkboxes, if required
3677        has_polydisp = self.chkPolydispersity.isChecked()
3678        has_magnetism = self.chkMagnetism.isChecked()
3679        has_chain = self.chkChainFit.isChecked()
3680        has_2D = self.chk2DView.isChecked()
3681        param_list.append(['polydisperse_params', str(has_polydisp)])
3682        param_list.append(['magnetic_params', str(has_magnetism)])
3683        param_list.append(['chainfit_params', str(has_chain)])
3684        param_list.append(['2D_params', str(has_2D)])
3685
3686        return param_list
3687
3688    def getFitParameters(self):
3689        """
3690        serializes current parameters
3691        """
3692        param_list = []
3693        if self.kernel_module is None:
3694            return param_list
3695
3696        param_list.append(['model_name', str(self.cbModel.currentText())])
3697
3698        def gatherParams(row):
3699            """
3700            Create list of main parameters based on _model_model
3701            """
3702            param_name = str(self._model_model.item(row, 0).text())
3703
3704            # Assure this is a parameter - must contain a checkbox
3705            if not self._model_model.item(row, 0).isCheckable():
3706                # maybe it is a combobox item (multiplicity)
3707                try:
3708                    index = self._model_model.index(row, 1)
3709                    widget = self.lstParams.indexWidget(index)
3710                    if widget is None:
3711                        return
3712                    if isinstance(widget, QtWidgets.QComboBox):
3713                        # find the index of the combobox
3714                        current_index = widget.currentIndex()
3715                        param_list.append([param_name, 'None', str(current_index)])
3716                except Exception as ex:
3717                    pass
3718                return
3719
3720            param_checked = str(self._model_model.item(row, 0).checkState() == QtCore.Qt.Checked)
3721            # Value of the parameter. In some cases this is the text of the combobox choice.
3722            param_value = str(self._model_model.item(row, 1).text())
3723            param_error = None
3724            param_min = None
3725            param_max = None
3726            column_offset = 0
3727            if self.has_error_column:
3728                column_offset = 1
3729                param_error = str(self._model_model.item(row, 1+column_offset).text())
3730            try:
3731                param_min = str(self._model_model.item(row, 2+column_offset).text())
3732                param_max = str(self._model_model.item(row, 3+column_offset).text())
3733            except:
3734                pass
3735            # Do we have any constraints on this parameter?
3736            constraint = self.getConstraintForRow(row)
3737            cons = ()
3738            if constraint is not None:
3739                value = constraint.value
3740                func = constraint.func
3741                value_ex = constraint.value_ex
3742                param = constraint.param
3743                validate = constraint.validate
3744
3745                cons = (value, param, value_ex, validate, func)
3746
3747            param_list.append([param_name, param_checked, param_value,param_error, param_min, param_max, cons])
3748
3749        def gatherPolyParams(row):
3750            """
3751            Create list of polydisperse parameters based on _poly_model
3752            """
3753            param_name = str(self._poly_model.item(row, 0).text()).split()[-1]
3754            param_checked = str(self._poly_model.item(row, 0).checkState() == QtCore.Qt.Checked)
3755            param_value = str(self._poly_model.item(row, 1).text())
3756            param_error = None
3757            column_offset = 0
3758            if self.has_poly_error_column:
3759                column_offset = 1
3760                param_error = str(self._poly_model.item(row, 1+column_offset).text())
3761            param_min   = str(self._poly_model.item(row, 2+column_offset).text())
3762            param_max   = str(self._poly_model.item(row, 3+column_offset).text())
3763            param_npts  = str(self._poly_model.item(row, 4+column_offset).text())
3764            param_nsigs = str(self._poly_model.item(row, 5+column_offset).text())
3765            param_fun   = str(self._poly_model.item(row, 6+column_offset).text()).rstrip()
3766            index = self._poly_model.index(row, 6+column_offset)
3767            widget = self.lstPoly.indexWidget(index)
3768            if widget is not None and isinstance(widget, QtWidgets.QComboBox):
3769                param_fun = widget.currentText()
3770            # width
3771            name = param_name+".width"
3772            param_list.append([name, param_checked, param_value, param_error,
3773                               param_min, param_max, param_npts, param_nsigs, param_fun])
3774
3775        def gatherMagnetParams(row):
3776            """
3777            Create list of magnetic parameters based on _magnet_model
3778            """
3779            param_name = str(self._magnet_model.item(row, 0).text())
3780            param_checked = str(self._magnet_model.item(row, 0).checkState() == QtCore.Qt.Checked)
3781            param_value = str(self._magnet_model.item(row, 1).text())
3782            param_error = None
3783            column_offset = 0
3784            if self.has_magnet_error_column:
3785                column_offset = 1
3786                param_error = str(self._magnet_model.item(row, 1+column_offset).text())
3787            param_min = str(self._magnet_model.item(row, 2+column_offset).text())
3788            param_max = str(self._magnet_model.item(row, 3+column_offset).text())
3789            param_list.append([param_name, param_checked, param_value,
3790                               param_error, param_min, param_max])
3791
3792        self.iterateOverModel(gatherParams)
3793        if self.chkPolydispersity.isChecked():
3794            self.iterateOverPolyModel(gatherPolyParams)
3795        if self.chkMagnetism.isChecked() and self.canHaveMagnetism():
3796            self.iterateOverMagnetModel(gatherMagnetParams)
3797
3798        if self.kernel_module.is_multiplicity_model:
3799            param_list.append(['multiplicity', str(self.kernel_module.multiplicity)])
3800
3801        return param_list
3802
3803    def onParameterPaste(self):
3804        """
3805        Use the clipboard to update fit state
3806        """
3807        # Check if the clipboard contains right stuff
3808        cb = QtWidgets.QApplication.clipboard()
3809        cb_text = cb.text()
3810
3811        lines = cb_text.split(':')
3812        if lines[0] != 'sasview_parameter_values':
3813            return False
3814
3815        # put the text into dictionary
3816        line_dict = {}
3817        for line in lines[1:]:
3818            content = line.split(',')
3819            if len(content) > 1:
3820                line_dict[content[0]] = content[1:]
3821
3822        self.updatePageWithParameters(line_dict)
3823
3824    def createPageForParameters(self, line_dict):
3825        """
3826        Sets up page with requested model/str factor
3827        and fills it up with sent parameters
3828        """
3829        if 'fitpage_category' in line_dict:
3830            self.cbCategory.setCurrentIndex(self.cbCategory.findText(line_dict['fitpage_category'][0]))
3831        if 'fitpage_model' in line_dict:
3832            self.cbModel.setCurrentIndex(self.cbModel.findText(line_dict['fitpage_model'][0]))
3833        if 'fitpage_structure' in line_dict:
3834            self.cbStructureFactor.setCurrentIndex(self.cbStructureFactor.findText(line_dict['fitpage_structure'][0]))
3835
3836        # Now that the page is ready for parameters, fill it up
3837        self.updatePageWithParameters(line_dict)
3838
3839    def updatePageWithParameters(self, line_dict):
3840        """
3841        Update FitPage with parameters in line_dict
3842        """
3843        if 'model_name' not in line_dict.keys():
3844            return
3845        model = line_dict['model_name'][0]
3846        context = {}
3847
3848        if 'multiplicity' in line_dict.keys():
3849            multip = int(line_dict['multiplicity'][0], 0)
3850            # reset the model with multiplicity, so further updates are saved
3851            if self.kernel_module.is_multiplicity_model:
3852                self.kernel_module.multiplicity=multip
3853                self.updateMultiplicityCombo(multip)
3854
3855        if 'tab_name' in line_dict.keys():
3856            self.kernel_module.name = line_dict['tab_name'][0]
3857        if 'polydisperse_params' in line_dict.keys():
3858            self.chkPolydispersity.setChecked(line_dict['polydisperse_params'][0]=='True')
3859        if 'magnetic_params' in line_dict.keys():
3860            self.chkMagnetism.setChecked(line_dict['magnetic_params'][0]=='True')
3861        if 'chainfit_params' in line_dict.keys():
3862            self.chkChainFit.setChecked(line_dict['chainfit_params'][0]=='True')
3863        if '2D_params' in line_dict.keys():
3864            self.chk2DView.setChecked(line_dict['2D_params'][0]=='True')
3865
3866        # Create the context dictionary for parameters
3867        context['model_name'] = model
3868        for key, value in line_dict.items():
3869            if len(value) > 2:
3870                context[key] = value
3871
3872        if str(self.cbModel.currentText()) != str(context['model_name']):
3873            msg = QtWidgets.QMessageBox()
3874            msg.setIcon(QtWidgets.QMessageBox.Information)
3875            msg.setText("The model in the clipboard is not the same as the currently loaded model. \
3876                         Not all parameters saved may paste correctly.")
3877            msg.setStandardButtons(QtWidgets.QMessageBox.Ok | QtWidgets.QMessageBox.Cancel)
3878            result = msg.exec_()
3879            if result == QtWidgets.QMessageBox.Ok:
3880                pass
3881            else:
3882                return
3883
3884        if 'smearing' in line_dict.keys():
3885            try:
3886                index = int(line_dict['smearing'][0])
3887                self.smearing_widget.cbSmearing.setCurrentIndex(index)
3888            except ValueError:
3889                pass
3890        if 'smearing_min' in line_dict.keys():
3891            try:
3892                self.smearing_widget.dq_l = float(line_dict['smearing_min'][0])
3893            except ValueError:
3894                pass
3895        if 'smearing_max' in line_dict.keys():
3896            try:
3897                self.smearing_widget.dq_r = float(line_dict['smearing_max'][0])
3898            except ValueError:
3899                pass
3900
3901        if 'q_range_max' in line_dict.keys():
3902            try:
3903                self.q_range_min = float(line_dict['q_range_min'][0])
3904                self.q_range_max = float(line_dict['q_range_max'][0])
3905            except ValueError:
3906                pass
3907        self.options_widget.updateQRange(self.q_range_min, self.q_range_max, self.npts)
3908        try:
3909            button_id = int(line_dict['weighting'][0])
3910            for button in self.options_widget.weightingGroup.buttons():
3911                if abs(self.options_widget.weightingGroup.id(button)) == button_id+2:
3912                    button.setChecked(True)
3913                    break
3914        except ValueError:
3915            pass
3916
3917        self.updateFullModel(context)
3918        self.updateFullPolyModel(context)
3919        self.updateFullMagnetModel(context)
3920
3921    def updateMultiplicityCombo(self, multip):
3922        """
3923        Find and update the multiplicity combobox
3924        """
3925        index = self._model_model.index(self._n_shells_row, 1)
3926        widget = self.lstParams.indexWidget(index)
3927        if widget is not None and isinstance(widget, QtWidgets.QComboBox):
3928            widget.setCurrentIndex(widget.findText(str(multip)))
3929        self.current_shell_displayed = multip
3930
3931    def updateFullModel(self, param_dict):
3932        """
3933        Update the model with new parameters
3934        """
3935        assert isinstance(param_dict, dict)
3936        if not dict:
3937            return
3938
3939        def updateFittedValues(row):
3940            # Utility function for main model update
3941            # internal so can use closure for param_dict
3942            param_name = str(self._model_model.item(row, 0).text())
3943            if param_name not in list(param_dict.keys()):
3944                return
3945            # Special case of combo box in the cell (multiplicity)
3946            param_line = param_dict[param_name]
3947            if len(param_line) == 1:
3948                # modify the shells value
3949                try:
3950                    combo_index = int(param_line[0])
3951                except ValueError:
3952                    # quietly pass
3953                    return
3954                index = self._model_model.index(row, 1)
3955                widget = self.lstParams.indexWidget(index)
3956                if widget is not None and isinstance(widget, QtWidgets.QComboBox):
3957                    #widget.setCurrentIndex(combo_index)
3958                    return
3959            # checkbox state
3960            param_checked = QtCore.Qt.Checked if param_dict[param_name][0] == "True" else QtCore.Qt.Unchecked
3961            self._model_model.item(row, 0).setCheckState(param_checked)
3962
3963            # parameter value can be either just a value or text on the combobox
3964            param_text = param_dict[param_name][1]
3965            index = self._model_model.index(row, 1)
3966            widget = self.lstParams.indexWidget(index)
3967            if widget is not None and isinstance(widget, QtWidgets.QComboBox):
3968                # Find the right index based on text
3969                combo_index = int(param_text, 0)
3970                widget.setCurrentIndex(combo_index)
3971            else:
3972                # modify the param value
3973                param_repr = GuiUtils.formatNumber(param_text, high=True)
3974                self._model_model.item(row, 1).setText(param_repr)
3975
3976            # Potentially the error column
3977            ioffset = 0
3978            joffset = 0
3979            if len(param_dict[param_name])>5:
3980                # error values are not editable - no need to update
3981                ioffset = 1
3982            if self.has_error_column:
3983                joffset = 1
3984            # min/max
3985            try:
3986                param_repr = GuiUtils.formatNumber(param_dict[param_name][2+ioffset], high=True)
3987                self._model_model.item(row, 2+joffset).setText(param_repr)
3988                param_repr = GuiUtils.formatNumber(param_dict[param_name][3+ioffset], high=True)
3989                self._model_model.item(row, 3+joffset).setText(param_repr)
3990            except:
3991                pass
3992
3993            # constraints
3994            cons = param_dict[param_name][4+ioffset]
3995            if cons is not None and len(cons)==5:
3996                value = cons[0]
3997                param = cons[1]
3998                value_ex = cons[2]
3999                validate = cons[3]
4000                function = cons[4]
4001                constraint = Constraint()
4002                constraint.value = value
4003                constraint.func = function
4004                constraint.param = param
4005                constraint.value_ex = value_ex
4006                constraint.validate = validate
4007                self.addConstraintToRow(constraint=constraint, row=row)
4008
4009            self.setFocus()
4010
4011        self.iterateOverModel(updateFittedValues)
4012
4013    def updateFullPolyModel(self, param_dict):
4014        """
4015        Update the polydispersity model with new parameters, create the errors column
4016        """
4017        assert isinstance(param_dict, dict)
4018        if not dict:
4019            return
4020
4021        def updateFittedValues(row):
4022            # Utility function for main model update
4023            # internal so can use closure for param_dict
4024            if row >= self._poly_model.rowCount():
4025                return
4026            param_name = str(self._poly_model.item(row, 0).text()).rsplit()[-1] + '.width'
4027            if param_name not in list(param_dict.keys()):
4028                return
4029            # checkbox state
4030            param_checked = QtCore.Qt.Checked if param_dict[param_name][0] == "True" else QtCore.Qt.Unchecked
4031            self._poly_model.item(row,0).setCheckState(param_checked)
4032
4033            # modify the param value
4034            param_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
4035            self._poly_model.item(row, 1).setText(param_repr)
4036
4037            # Potentially the error column
4038            ioffset = 0
4039            joffset = 0
4040            if len(param_dict[param_name])>7:
4041                ioffset = 1
4042            if self.has_poly_error_column:
4043                joffset = 1
4044            # min
4045            param_repr = GuiUtils.formatNumber(param_dict[param_name][2+ioffset], high=True)
4046            self._poly_model.item(row, 2+joffset).setText(param_repr)
4047            # max
4048            param_repr = GuiUtils.formatNumber(param_dict[param_name][3+ioffset], high=True)
4049            self._poly_model.item(row, 3+joffset).setText(param_repr)
4050            # Npts
4051            param_repr = GuiUtils.formatNumber(param_dict[param_name][4+ioffset], high=True)
4052            self._poly_model.item(row, 4+joffset).setText(param_repr)
4053            # Nsigs
4054            param_repr = GuiUtils.formatNumber(param_dict[param_name][5+ioffset], high=True)
4055            self._poly_model.item(row, 5+joffset).setText(param_repr)
4056
4057            self.setFocus()
4058
4059        self.iterateOverPolyModel(updateFittedValues)
4060
4061    def updateFullMagnetModel(self, param_dict):
4062        """
4063        Update the magnetism model with new parameters, create the errors column
4064        """
4065        assert isinstance(param_dict, dict)
4066        if not dict:
4067            return
4068
4069        def updateFittedValues(row):
4070            # Utility function for main model update
4071            # internal so can use closure for param_dict
4072            if row >= self._magnet_model.rowCount():
4073                return
4074            param_name = str(self._magnet_model.item(row, 0).text()).rsplit()[-1]
4075            if param_name not in list(param_dict.keys()):
4076                return
4077            # checkbox state
4078            param_checked = QtCore.Qt.Checked if param_dict[param_name][0] == "True" else QtCore.Qt.Unchecked
4079            self._magnet_model.item(row,0).setCheckState(param_checked)
4080
4081            # modify the param value
4082            param_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True)
4083            self._magnet_model.item(row, 1).setText(param_repr)
4084
4085            # Potentially the error column
4086            ioffset = 0
4087            joffset = 0
4088            if len(param_dict[param_name])>4:
4089                ioffset = 1
4090            if self.has_magnet_error_column:
4091                joffset = 1
4092            # min
4093            param_repr = GuiUtils.formatNumber(param_dict[param_name][2+ioffset], high=True)
4094            self._magnet_model.item(row, 2+joffset).setText(param_repr)
4095            # max
4096            param_repr = GuiUtils.formatNumber(param_dict[param_name][3+ioffset], high=True)
4097            self._magnet_model.item(row, 3+joffset).setText(param_repr)
4098
4099        self.iterateOverMagnetModel(updateFittedValues)
4100
4101    def getCurrentFitState(self, state=None):
4102        """
4103        Store current state for fit_page
4104        """
4105        # save model option
4106        #if self.model is not None:
4107        #    self.disp_list = self.getDispParamList()
4108        #    state.disp_list = copy.deepcopy(self.disp_list)
4109        #    #state.model = self.model.clone()
4110
4111        # Comboboxes
4112        state.categorycombobox = self.cbCategory.currentText()
4113        state.formfactorcombobox = self.cbModel.currentText()
4114        if self.cbStructureFactor.isEnabled():
4115            state.structurecombobox = self.cbStructureFactor.currentText()
4116        state.tcChi = self.chi2
4117
4118        state.enable2D = self.is2D
4119
4120        #state.weights = copy.deepcopy(self.weights)
4121        # save data
4122        state.data = copy.deepcopy(self.data)
4123
4124        # save plotting range
4125        state.qmin = self.q_range_min
4126        state.qmax = self.q_range_max
4127        state.npts = self.npts
4128
4129        #    self.state.enable_disp = self.enable_disp.GetValue()
4130        #    self.state.disable_disp = self.disable_disp.GetValue()
4131
4132        #    self.state.enable_smearer = \
4133        #                        copy.deepcopy(self.enable_smearer.GetValue())
4134        #    self.state.disable_smearer = \
4135        #                        copy.deepcopy(self.disable_smearer.GetValue())
4136
4137        #self.state.pinhole_smearer = \
4138        #                        copy.deepcopy(self.pinhole_smearer.GetValue())
4139        #self.state.slit_smearer = copy.deepcopy(self.slit_smearer.GetValue())
4140        #self.state.dI_noweight = copy.deepcopy(self.dI_noweight.GetValue())
4141        #self.state.dI_didata = copy.deepcopy(self.dI_didata.GetValue())
4142        #self.state.dI_sqrdata = copy.deepcopy(self.dI_sqrdata.GetValue())
4143        #self.state.dI_idata = copy.deepcopy(self.dI_idata.GetValue())
4144
4145        p = self.model_parameters
4146        # save checkbutton state and txtcrtl values
4147        state.parameters = FittingUtilities.getStandardParam(self._model_model)
4148        state.orientation_params_disp = FittingUtilities.getOrientationParam(self.kernel_module)
4149
4150        #self._copy_parameters_state(self.orientation_params_disp, self.state.orientation_params_disp)
4151        #self._copy_parameters_state(self.parameters, self.state.parameters)
4152        #self._copy_parameters_state(self.fittable_param, self.state.fittable_param)
4153        #self._copy_parameters_state(self.fixed_param, self.state.fixed_param)
4154
Note: See TracBrowser for help on using the repository browser.