FittingWidget.py @ 712db9e

ESS_GUIESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalc

Last change on this file since 712db9e was 712db9e, checked in by rozyczko <piotr.rozyczko@…>, 6 years ago
Set pointer to the correct set of data in batch fitting.
Property mode set to `100644`
File size: 136.1 KB

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

Note: See TracBrowser for help on using the repository browser.

SasView

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

Download in other formats: