FittingWidget.py @ 63319b0

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalc

Last change on this file since 63319b0 was 63319b0, checked in by Piotr Rozyczko <rozyczko@…>, 6 years ago
unit tests for constraints: FittingWidget?, FittingPerspective?
Property mode set to `100644`
File size: 88.0 KB

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

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

SasView

source: sasview/src/sas/qtgui/Perspectives/Fitting/FittingWidget.py @ 63319b0

Download in other formats: