FittingWidget.py @ 516ee4b

ESS_GUIESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalc

Last change on this file since 516ee4b was b87dc1a, checked in by Torin Cooper-Bennun <torin.cooper-bennun@…>, 6 years ago
keep non-fittable rows selectable, to not break layout
Property mode set to `100644`
File size: 105.4 KB

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

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

SasView

source: sasview/src/sas/qtgui/Perspectives/Fitting/FittingWidget.py @ 516ee4b

Download in other formats: