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

ESS_GUIESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalc
Last change on this file since 6dbff18 was 6dbff18, checked in by Piotr Rozyczko <rozyczko@…>, 14 months ago

Restructure parameters to fit into three separate lists to enable proper processing. SASVIEW-1008

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