FittingWidget.py @ 5d14851a

ESS_GUIESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_opencl

Last change on this file since 5d14851a was d4c9242, checked in by Piotr Rozyczko <piotr.rozyczko@…>, 6 years ago
Calculate chi2 only when having actual data. SASVIEW-1276
Property mode set to `100644`
File size: 161.5 KB

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

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

SasView

source: sasview/src/sas/qtgui/Perspectives/Fitting/FittingWidget.py @ 5d14851a

Download in other formats: