InversionPerspective.py @ 477c473

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 477c473 was 477c473, checked in by krzywon, 6 years ago
Fix DMax window updates.
Property mode set to `100644`
File size: 22.8 KB

Line
1	import sys
2	import logging
3	import pylab
4	import numpy as np
5
6	from PyQt4 import QtGui, QtCore, QtWebKit
7	from twisted.internet import reactor
8
9	# sas-global
10	import sas.qtgui.Utilities.GuiUtils as GuiUtils
11
12	# pr inversion GUI elements
13	from InversionUtils import WIDGETS
14	import UI.TabbedInversionUI
15	from UI.TabbedInversionUI import Ui_PrInversion
16	from InversionLogic import InversionLogic
17
18	# pr inversion calculation elements
19	from sas.sascalc.dataloader.data_info import Data1D
20	from sas.sascalc.pr.invertor import Invertor
21
22	def is_float(value):
23	"""Converts text input values to floats. Empty strings throw ValueError"""
24	try:
25	return float(value)
26	except ValueError:
27	return 0.0
28
29
30	# TODO: Modify plot references, don't just send new
31	# TODO: Update help with batch capabilities
32	# TODO: Method to export results in some meaningful way
33	class InversionWindow(QtGui.QTabWidget, Ui_PrInversion):
34	"""
35	The main window for the P(r) Inversion perspective.
36	"""
37
38	name = "Inversion"
39
40	def __init__(self, parent=None, data=None):
41	super(InversionWindow, self).__init__()
42	self.setupUi(self)
43
44	self.setWindowTitle("P(r) Inversion Perspective")
45
46	self._manager = parent
47	self._model_item = QtGui.QStandardItem()
48	self._helpView = QtWebKit.QWebView()
49
50	self.communicate = GuiUtils.Communicate()
51
52	self.logic = InversionLogic()
53
54	self.dmaxWindow = None
55
56	# The window should not close
57	self._allow_close = False
58
59	# current QStandardItem showing on the panel
60	self._data = None
61	# current Data1D as referenced by self._data
62	self._data_set = None
63
64	# p(r) calculator
65	self._calculator = Invertor()
66	self._last_calculator = None
67	self.calc_thread = None
68	self.estimation_thread = None
69
70	# Current data object in view
71	self._data_index = 0
72	# list mapping data to p(r) calculation
73	self._data_list = {}
74	if not isinstance(data, list):
75	data_list = [data]
76	if data is not None:
77	for datum in data_list:
78	self._data_list[datum] = self._calculator.clone()
79
80	# plots for current data
81	self.pr_plot = None
82	self.data_plot = None
83	# plot references for all data in perspective
84	self.pr_plot_list = {}
85	self.data_plot_list = {}
86
87	self.model = QtGui.QStandardItemModel(self)
88	self.mapper = QtGui.QDataWidgetMapper(self)
89	# Link user interactions with methods
90	self.setupLinks()
91	# Set values
92	self.setupModel()
93	# Set up the Widget Map
94	self.setupMapper()
95	# Set base window state
96	self.setupWindow()
97
98	######################################################################
99	# Base Perspective Class Definitions
100
101	def communicator(self):
102	return self.communicate
103
104	def allowBatch(self):
105	return True
106
107	def setClosable(self, value=True):
108	"""
109	Allow outsiders close this widget
110	"""
111	assert isinstance(value, bool)
112	self._allow_close = value
113
114	def closeEvent(self, event):
115	"""
116	Overwrite QDialog close method to allow for custom widget close
117	"""
118	if self._allow_close:
119	# reset the closability flag
120	self.setClosable(value=False)
121	event.accept()
122	else:
123	event.ignore()
124	# Maybe we should just minimize
125	self.setWindowState(QtCore.Qt.WindowMinimized)
126
127	######################################################################
128	# Initialization routines
129
130	def setupLinks(self):
131	"""Connect the use controls to their appropriate methods"""
132	self.dataList.currentIndexChanged.connect(self.displayChange)
133	self.calculateAllButton.clicked.connect(self.startThreadAll)
134	self.calculateThisButton.clicked.connect(self.startThread)
135	self.removeButton.clicked.connect(self.removeData)
136	self.helpButton.clicked.connect(self.help)
137	self.estimateBgd.toggled.connect(self.toggleBgd)
138	self.manualBgd.toggled.connect(self.toggleBgd)
139	self.regConstantSuggestionButton.clicked.connect(self.acceptAlpha)
140	self.noOfTermsSuggestionButton.clicked.connect(self.acceptNoTerms)
141	self.explorerButton.clicked.connect(self.openExplorerWindow)
142	self.backgroundInput.textChanged.connect(
143	lambda: self._calculator.set_est_bck(int(is_float(
144	str(self.backgroundInput.text())))))
145	self.minQInput.textChanged.connect(
146	lambda: self._calculator.set_qmin(is_float(
147	str(self.minQInput.text()))))
148	self.regularizationConstantInput.textChanged.connect(
149	lambda: self._calculator.set_alpha(is_float(
150	str(self.regularizationConstantInput.text()))))
151	self.maxDistanceInput.textChanged.connect(
152	lambda: self._calculator.set_dmax(is_float(
153	str(self.maxDistanceInput.text()))))
154	self.maxQInput.textChanged.connect(
155	lambda: self._calculator.set_qmax(is_float(
156	str(self.maxQInput.text()))))
157	self.slitHeightInput.textChanged.connect(
158	lambda: self._calculator.set_slit_height(is_float(
159	str(self.slitHeightInput.text()))))
160	self.slitWidthInput.textChanged.connect(
161	lambda: self._calculator.set_slit_width(is_float(
162	str(self.slitHeightInput.text()))))
163	self.model.itemChanged.connect(self.model_changed)
164
165	def setupMapper(self):
166	# Set up the mapper.
167	self.mapper.setOrientation(QtCore.Qt.Vertical)
168	self.mapper.setModel(self.model)
169
170	# Filename
171	self.mapper.addMapping(self.dataList, WIDGETS.W_FILENAME)
172	# Background
173	self.mapper.addMapping(self.backgroundInput, WIDGETS.W_BACKGROUND_INPUT)
174	self.mapper.addMapping(self.estimateBgd, WIDGETS.W_ESTIMATE)
175	self.mapper.addMapping(self.manualBgd, WIDGETS.W_MANUAL_INPUT)
176
177	# Qmin/Qmax
178	self.mapper.addMapping(self.minQInput, WIDGETS.W_QMIN)
179	self.mapper.addMapping(self.maxQInput, WIDGETS.W_QMAX)
180
181	# Slit Parameter items
182	self.mapper.addMapping(self.slitWidthInput, WIDGETS.W_SLIT_WIDTH)
183	self.mapper.addMapping(self.slitHeightInput, WIDGETS.W_SLIT_HEIGHT)
184
185	# Parameter Items
186	self.mapper.addMapping(self.regularizationConstantInput,
187	WIDGETS.W_REGULARIZATION)
188	self.mapper.addMapping(self.regConstantSuggestionButton,
189	WIDGETS.W_REGULARIZATION_SUGGEST)
190	self.mapper.addMapping(self.explorerButton, WIDGETS.W_EXPLORE)
191	self.mapper.addMapping(self.maxDistanceInput, WIDGETS.W_MAX_DIST)
192	self.mapper.addMapping(self.noOfTermsInput, WIDGETS.W_NO_TERMS)
193	self.mapper.addMapping(self.noOfTermsSuggestionButton,
194	WIDGETS.W_NO_TERMS_SUGGEST)
195
196	# Output
197	self.mapper.addMapping(self.rgValue, WIDGETS.W_RG)
198	self.mapper.addMapping(self.iQ0Value, WIDGETS.W_I_ZERO)
199	self.mapper.addMapping(self.backgroundValue, WIDGETS.W_BACKGROUND_OUTPUT)
200	self.mapper.addMapping(self.computationTimeValue, WIDGETS.W_COMP_TIME)
201	self.mapper.addMapping(self.chiDofValue, WIDGETS.W_CHI_SQUARED)
202	self.mapper.addMapping(self.oscillationValue, WIDGETS.W_OSCILLATION)
203	self.mapper.addMapping(self.posFractionValue, WIDGETS.W_POS_FRACTION)
204	self.mapper.addMapping(self.sigmaPosFractionValue,
205	WIDGETS.W_SIGMA_POS_FRACTION)
206
207	# Main Buttons
208	self.mapper.addMapping(self.removeButton, WIDGETS.W_REMOVE)
209	self.mapper.addMapping(self.calculateAllButton, WIDGETS.W_CALCULATE_ALL)
210	self.mapper.addMapping(self.calculateThisButton,
211	WIDGETS.W_CALCULATE_VISIBLE)
212	self.mapper.addMapping(self.helpButton, WIDGETS.W_HELP)
213
214	self.mapper.toFirst()
215
216	def setupModel(self):
217	"""
218	Update boxes with initial values
219	"""
220	item = QtGui.QStandardItem("")
221	self.model.setItem(WIDGETS.W_FILENAME, item)
222	item = QtGui.QStandardItem('0.0')
223	self.model.setItem(WIDGETS.W_BACKGROUND_INPUT, item)
224	item = QtGui.QStandardItem("")
225	self.model.setItem(WIDGETS.W_QMIN, item)
226	item = QtGui.QStandardItem("")
227	self.model.setItem(WIDGETS.W_QMAX, item)
228	item = QtGui.QStandardItem("")
229	self.model.setItem(WIDGETS.W_SLIT_WIDTH, item)
230	item = QtGui.QStandardItem("")
231	self.model.setItem(WIDGETS.W_SLIT_HEIGHT, item)
232	item = QtGui.QStandardItem("10")
233	self.model.setItem(WIDGETS.W_NO_TERMS, item)
234	item = QtGui.QStandardItem("0.0001")
235	self.model.setItem(WIDGETS.W_REGULARIZATION, item)
236	item = QtGui.QStandardItem("140.0")
237	self.model.setItem(WIDGETS.W_MAX_DIST, item)
238	item = QtGui.QStandardItem("")
239	self.model.setItem(WIDGETS.W_RG, item)
240	item = QtGui.QStandardItem("")
241	self.model.setItem(WIDGETS.W_I_ZERO, item)
242	item = QtGui.QStandardItem("")
243	self.model.setItem(WIDGETS.W_BACKGROUND_OUTPUT, item)
244	item = QtGui.QStandardItem("")
245	self.model.setItem(WIDGETS.W_COMP_TIME, item)
246	item = QtGui.QStandardItem("")
247	self.model.setItem(WIDGETS.W_CHI_SQUARED, item)
248	item = QtGui.QStandardItem("")
249	self.model.setItem(WIDGETS.W_OSCILLATION, item)
250	item = QtGui.QStandardItem("")
251	self.model.setItem(WIDGETS.W_POS_FRACTION, item)
252	item = QtGui.QStandardItem("")
253	self.model.setItem(WIDGETS.W_SIGMA_POS_FRACTION, item)
254
255	def setupWindow(self):
256	"""Initialize base window state on init"""
257	self.setTabPosition(0)
258	self.enableButtons()
259	self.estimateBgd.setChecked(True)
260
261	######################################################################
262	# Methods for updating GUI
263
264	def enableButtons(self):
265	"""
266	Enable buttons when data is present, else disable them
267	"""
268	self.removeButton.setEnabled(self.logic.data_is_loaded)
269	self.explorerButton.setEnabled(self.logic.data_is_loaded)
270	self.calculateAllButton.setEnabled(self.logic.data_is_loaded)
271	self.calculateThisButton.setEnabled(self.logic.data_is_loaded)
272
273	def populateDataComboBox(self, filename, data_ref):
274	"""
275	Append a new file name to the data combobox
276	:param filename: data filename
277	:param data_ref: QStandardItem reference for data set to be added
278	"""
279	qt_item = QtCore.QString.fromUtf8(filename)
280	ref = QtCore.QVariant(data_ref)
281	self.dataList.addItem(qt_item, ref)
282
283	def acceptNoTerms(self):
284	"""Send estimated no of terms to input"""
285	self.model.setItem(WIDGETS.W_NO_TERMS, QtGui.QStandardItem(
286	self.noOfTermsSuggestionButton.text()))
287
288	def acceptAlpha(self):
289	"""Send estimated alpha to input"""
290	self.model.setItem(WIDGETS.W_REGULARIZATION, QtGui.QStandardItem(
291	self.regConstantSuggestionButton.text()))
292
293	def displayChange(self):
294	variant_ref = self.dataList.itemData(self.dataList.currentIndex())
295	self.setCurrentData(variant_ref.toPyObject())
296
297	def removeData(self):
298	"""Remove the existing data reference from the P(r) Persepective"""
299	self._data_list.pop(self._data)
300	self.pr_plot_list.pop(self._data)
301	self.data_plot_list.pop(self._data)
302	if self.dmaxWindow is not None:
303	self.dmaxWindow = None
304	self.dataList.removeItem(self.dataList.currentIndex())
305	self.dataList.setCurrentIndex(0)
306
307	######################################################################
308	# GUI Interaction Events
309
310	def update_calculator(self):
311	"""Update all p(r) params"""
312	self._calculator.set_x(self._data_set.x)
313	self._calculator.set_y(self._data_set.y)
314	self._calculator.set_err(self._data_set.dy)
315
316	def model_changed(self):
317	"""Update the values when user makes changes"""
318	if not self.mapper:
319	msg = "Unable to update P{r}. The connection between the main GUI "
320	msg += "and P(r) was severed. Attempting to restart P(r)."
321	logging.warning(msg)
322	self.setClosable(True)
323	self.close()
324	InversionWindow.__init__(self.parent(), self._data_list.keys())
325	exit(0)
326	# TODO: Only send plot first time - otherwise, update in complete
327	if self.pr_plot is not None:
328	title = self.pr_plot.name
329	GuiUtils.updateModelItemWithPlot(
330	self._data, QtCore.QVariant(self.pr_plot), title)
331	if self.data_plot is not None:
332	title = self.data_plot.name
333	GuiUtils.updateModelItemWithPlot(
334	self._data, QtCore.QVariant(self.data_plot), title)
335	if self.dmaxWindow is not None:
336	self.dmaxWindow.pr_state = self._calculator
337	self.dmaxWindow.nfunc = self.getNFunc()
338
339	self.mapper.toFirst()
340
341	def help(self):
342	"""
343	Open the P(r) Inversion help browser
344	"""
345	tree_location = (GuiUtils.HELP_DIRECTORY_LOCATION +
346	"user/sasgui/perspectives/pr/pr_help.html")
347
348	# Actual file anchor will depend on the combo box index
349	# Note that we can be clusmy here, since bad current_fitter_id
350	# will just make the page displayed from the top
351	self._helpView.load(QtCore.QUrl(tree_location))
352	self._helpView.show()
353
354	def toggleBgd(self):
355	"""
356	Toggle the background between manual and estimated
357	"""
358	sender = self.sender()
359	if sender is self.estimateBgd:
360	self.backgroundInput.setEnabled(False)
361	else:
362	self.backgroundInput.setEnabled(True)
363
364	def openExplorerWindow(self):
365	"""
366	Open the Explorer window to see correlations between params and results
367	"""
368	from dmax import DmaxWindow
369	self.dmaxWindow = DmaxWindow(self._calculator, self.getNFunc(), self)
370	self.dmaxWindow.show()
371
372	######################################################################
373	# Response Actions
374
375	def setData(self, data_item=None, is_batch=False):
376	"""
377	Assign new data set(s) to the P(r) perspective
378	Obtain a QStandardItem object and parse it to get Data1D/2D
379	Pass it over to the calculator
380	"""
381	assert data_item is not None
382
383	if not isinstance(data_item, list):
384	msg = "Incorrect type passed to the P(r) Perspective"
385	raise AttributeError, msg
386
387	for data in data_item:
388	# Create initial internal mappings
389	self._data_list[data] = self._calculator.clone()
390	self._data_set = GuiUtils.dataFromItem(data)
391	self.data_plot_list[data] = self.data_plot
392	self.pr_plot_list[data] = self.pr_plot
393	ref_var = QtCore.QVariant(data)
394	self.populateDataComboBox(self._data_set.filename, ref_var)
395	self.setCurrentData(data)
396
397	# Estimate initial values from data
398	self.performEstimate()
399	self.logic = InversionLogic(self._data_set)
400
401	# Estimate q range
402	qmin, qmax = self.logic.computeDataRange()
403	self.model.setItem(WIDGETS.W_QMIN, QtGui.QStandardItem(
404	"{:.4g}".format(qmin)))
405	self.model.setItem(WIDGETS.W_QMAX, QtGui.QStandardItem(
406	"{:.4g}".format(qmax)))
407
408	self.enableButtons()
409
410	def getNFunc(self):
411	"""Get the n_func value from the GUI object"""
412	return int(UI.TabbedInversionUI._fromUtf8(self.noOfTermsInput.text()))
413
414	def setCurrentData(self, data_ref):
415	"""Get the current data and display as necessary"""
416
417	if not isinstance(data_ref, QtGui.QStandardItem):
418	msg = "Incorrect type passed to the P(r) Perspective"
419	raise AttributeError, msg
420
421	# Data references
422	self._data = data_ref
423	self._data_set = GuiUtils.dataFromItem(data_ref)
424	self._calculator = self._data_list[data_ref]
425	self.pr_plot = self.pr_plot_list[data_ref]
426	self.data_plot = self.data_plot_list[data_ref]
427
428	######################################################################
429	# Thread Creators
430
431	def startThreadAll(self):
432	for data_ref, pr in self._data_list.items():
433	self._data_set = GuiUtils.dataFromItem(data_ref)
434	self._calculator = pr
435	self.startThread()
436
437	def startThread(self):
438	"""
439	Start a calculation thread
440	"""
441	from Thread import CalcPr
442
443	# Set data before running the calculations
444	self.update_calculator()
445
446	# If a thread is already started, stop it
447	if self.calc_thread is not None and self.calc_thread.isrunning():
448	self.calc_thread.stop()
449	pr = self._calculator.clone()
450	nfunc = self.getNFunc()
451	self.calc_thread = CalcPr(pr, nfunc,
452	error_func=self._threadError,
453	completefn=self._completed, updatefn=None)
454	self.calc_thread.queue()
455	self.calc_thread.ready(2.5)
456
457	def performEstimateNT(self):
458	"""
459	Perform parameter estimation
460	"""
461	from Thread import EstimateNT
462
463	# If a thread is already started, stop it
464	if (self.estimation_thread is not None and
465	self.estimation_thread.isrunning()):
466	self.estimation_thread.stop()
467	pr = self._calculator.clone()
468	# Skip the slit settings for the estimation
469	# It slows down the application and it doesn't change the estimates
470	pr.slit_height = 0.0
471	pr.slit_width = 0.0
472	nfunc = self.getNFunc()
473	self.estimation_thread = EstimateNT(pr, nfunc,
474	error_func=self._threadError,
475	completefn=self._estimateNTCompleted,
476	updatefn=None)
477	self.estimation_thread.queue()
478	self.estimation_thread.ready(2.5)
479
480	def performEstimate(self):
481	"""
482	Perform parameter estimation
483	"""
484	from Thread import EstimatePr
485
486	self.startThread()
487
488	# If a thread is already started, stop it
489	if (self.estimation_thread is not None and
490	self.estimation_thread.isrunning()):
491	self.estimation_thread.stop()
492	pr = self._calculator.clone()
493	nfunc = self.getNFunc()
494	self.estimation_thread = EstimatePr(pr, nfunc,
495	error_func=self._threadError,
496	completefn=self._estimateCompleted,
497	updatefn=None)
498	self.estimation_thread.queue()
499	self.estimation_thread.ready(2.5)
500
501	######################################################################
502	# Thread Complete
503
504	def _estimateCompleted(self, alpha, message, elapsed):
505	"""
506	Parameter estimation completed,
507	display the results to the user
508
509	:param alpha: estimated best alpha
510	:param elapsed: computation time
511	"""
512	# Save useful info
513	self.model.setItem(WIDGETS.W_COMP_TIME,
514	QtGui.QStandardItem(str(elapsed)))
515	self.regConstantSuggestionButton.setText(QtCore.QString(str(alpha)))
516	self.regConstantSuggestionButton.setEnabled(True)
517	if message:
518	logging.info(message)
519	self.performEstimateNT()
520
521	def _estimateNTCompleted(self, nterms, alpha, message, elapsed):
522	"""
523	Parameter estimation completed,
524	display the results to the user
525
526	:param alpha: estimated best alpha
527	:param nterms: estimated number of terms
528	:param elapsed: computation time
529
530	"""
531	# Save useful info
532	self.noOfTermsSuggestionButton.setText(QtCore.QString(
533	"{:n}".format(nterms)))
534	self.noOfTermsSuggestionButton.setEnabled(True)
535	self.regConstantSuggestionButton.setText(QtCore.QString(
536	"{:.3g}".format(alpha)))
537	self.regConstantSuggestionButton.setEnabled(True)
538	self.model.setItem(WIDGETS.W_COMP_TIME,
539	QtGui.QStandardItem(str(elapsed)))
540	if message:
541	logging.info(message)
542
543	def _completed(self, out, cov, pr, elapsed):
544	"""
545	Method called with the results when the inversion is done
546
547	:param out: output coefficient for the base functions
548	:param cov: covariance matrix
549	:param pr: Invertor instance
550	:param elapsed: time spent computing
551
552	"""
553	# Save useful info
554	cov = np.ascontiguousarray(cov)
555	pr.cov = cov
556	pr.out = out
557	pr.elapsed = elapsed
558
559	# Show result on control panel
560
561	self.model.setItem(WIDGETS.W_RG, QtGui.QStandardItem(str(pr.rg(out))))
562	self.model.setItem(WIDGETS.W_I_ZERO,
563	QtGui.QStandardItem(str(pr.iq0(out))))
564	self.model.setItem(WIDGETS.W_BACKGROUND_INPUT,
565	QtGui.QStandardItem("{:.3f}".format(pr.est_bck)))
566	self.model.setItem(WIDGETS.W_BACKGROUND_OUTPUT, QtGui.QStandardItem(
567	str("{:.3g}".format(pr.background))))
568	self.model.setItem(WIDGETS.W_CHI_SQUARED,
569	QtGui.QStandardItem(str(pr.chi2[0])))
570	self.model.setItem(WIDGETS.W_COMP_TIME,
571	QtGui.QStandardItem(str(elapsed)))
572	self.model.setItem(WIDGETS.W_OSCILLATION,
573	QtGui.QStandardItem(str(pr.oscillations(out))))
574	self.model.setItem(WIDGETS.W_POS_FRACTION,
575	QtGui.QStandardItem(str(pr.get_positive(out))))
576	self.model.setItem(WIDGETS.W_SIGMA_POS_FRACTION,
577	QtGui.QStandardItem(str(pr.get_pos_err(out, cov))))
578
579	# Save Pr invertor
580	self._calculator = pr
581	# Append data to data list
582	self._data_list[self._data] = self._calculator.clone()
583
584	# Create new P(r) and fit plots
585	if self.pr_plot is None:
586	self.pr_plot = self.logic.newPRPlot(out, self._calculator, cov)
587	self.pr_plot_list[self._data] = self.pr_plot
588	else:
589	# FIXME: this should update the existing plot, not create a new one
590	self.pr_plot = self.logic.newPRPlot(out, self._calculator, cov)
591	self.pr_plot_list[self._data] = self.pr_plot
592	if self.data_plot is None:
593	self.data_plot = self.logic.new1DPlot(out, self._calculator)
594	self.data_plot_list[self._data] = self.data_plot
595	else:
596	# FIXME: this should update the existing plot, not create a new one
597	self.data_plot = self.logic.new1DPlot(out, self._calculator)
598	self.data_plot_list[self._data] = self.data_plot
599
600	def _threadError(self, error):
601	"""
602	Call-back method for calculation errors
603	"""
604	logging.warning(error)

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

SasView

source: sasview/src/sas/qtgui/Perspectives/Inversion/InversionPerspective.py @ 477c473

Download in other formats: