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

ESS_GUIESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalc
Last change on this file since 6fbb859 was 6fbb859, checked in by Torin Cooper-Bennun <torin.cooper-bennun@…>, 6 years ago

Merge branch 'ESS_GUI' into ESS_GUI_iss1052

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