InvariantPerspective.py

ESS_GUI

Last change on this file was 4cdfa17, checked in by wojciech, 6 years ago
Moving qt parts to main thread in Invariant perspective
Property mode set to `100644`
File size: 31.2 KB

Line
1	# global
2	import sys
3	import os
4	import logging
5	import copy
6	import webbrowser
7
8	from PyQt5 import QtCore
9	from PyQt5 import QtGui, QtWidgets
10
11	from twisted.internet import threads
12	from twisted.internet import reactor
13
14	# sas-global
15	from sas.sascalc.invariant import invariant
16	from sas.qtgui.Plotting.PlotterData import Data1D
17	import sas.qtgui.Utilities.GuiUtils as GuiUtils
18
19	# import sas.qtgui.Plotting.PlotHelper as PlotHelper
20
21	# local
22	from .UI.TabbedInvariantUI import Ui_tabbedInvariantUI
23	from .InvariantDetails import DetailsDialog
24	from .InvariantUtils import WIDGETS
25
26	# The minimum q-value to be used when extrapolating
27	Q_MINIMUM = 1e-5
28	# The maximum q-value to be used when extrapolating
29	Q_MAXIMUM = 10
30	# the ratio of maximum q value/(qmax of data) to plot the theory data
31	Q_MAXIMUM_PLOT = 3
32	# Default number of points of interpolation: high and low range
33	NPOINTS_Q_INTERP = 10
34	# Default power law for interpolation
35	DEFAULT_POWER_LOW = 4
36
37	# Background of line edits if settings OK or wrong
38	BG_WHITE = "background-color: rgb(255, 255, 255);"
39	BG_RED = "background-color: rgb(244, 170, 164);"
40
41	class InvariantWindow(QtWidgets.QDialog, Ui_tabbedInvariantUI):
42	# The controller which is responsible for managing signal slots connections
43	# for the gui and providing an interface to the data model.
44	name = "Invariant" # For displaying in the combo box in DataExplorer
45
46	def __init__(self, parent=None):
47	super(InvariantWindow, self).__init__()
48	self.setupUi(self)
49
50	self.setWindowTitle("Invariant Perspective")
51
52	# initial input params
53	self._background = 0.0
54	self._scale = 1.0
55	self._contrast = 1.0
56	self._porod = None
57
58	self.parent = parent
59
60	self._manager = parent
61	self._reactor = reactor
62	self._model_item = QtGui.QStandardItem()
63
64	self.detailsDialog = DetailsDialog(self)
65	self.detailsDialog.cmdOK.clicked.connect(self.enabling)
66
67	self._low_extrapolate = False
68	self._low_guinier = True
69	self._low_fit = False
70	self._low_power_value = False
71	self._low_points = NPOINTS_Q_INTERP
72	self._low_power_value = DEFAULT_POWER_LOW
73
74	self._high_extrapolate = False
75	self._high_power_value = False
76	self._high_fit = False
77	self._high_points = NPOINTS_Q_INTERP
78	self._high_power_value = DEFAULT_POWER_LOW
79
80	# no reason to have this widget resizable
81	self.resize(self.minimumSizeHint())
82
83	self.communicate = self._manager.communicator()
84
85	self._data = None
86	self._path = ""
87
88	self._allow_close = False
89
90	# Modify font in order to display Angstrom symbol correctly
91	new_font = 'font-family: -apple-system, "Helvetica Neue", "Ubuntu";'
92	self.lblTotalQUnits.setStyleSheet(new_font)
93	self.lblSpecificSurfaceUnits.setStyleSheet(new_font)
94	self.lblInvariantTotalQUnits.setStyleSheet(new_font)
95	self.lblContrastUnits.setStyleSheet(new_font)
96	self.lblPorodCstUnits.setStyleSheet(new_font)
97	self.lblExtrapolQUnits.setStyleSheet(new_font)
98
99	# To remove blue square around line edits
100	self.txtBackgd.setAttribute(QtCore.Qt.WA_MacShowFocusRect, False)
101	self.txtContrast.setAttribute(QtCore.Qt.WA_MacShowFocusRect, False)
102	self.txtScale.setAttribute(QtCore.Qt.WA_MacShowFocusRect, False)
103	self.txtPorodCst.setAttribute(QtCore.Qt.WA_MacShowFocusRect, False)
104	self.txtNptsHighQ.setAttribute(QtCore.Qt.WA_MacShowFocusRect, False)
105	self.txtNptsLowQ.setAttribute(QtCore.Qt.WA_MacShowFocusRect, False)
106	self.txtPowerLowQ.setAttribute(QtCore.Qt.WA_MacShowFocusRect, False)
107	self.txtPowerHighQ.setAttribute(QtCore.Qt.WA_MacShowFocusRect, False)
108
109	self.txtExtrapolQMin.setText(str(Q_MINIMUM))
110	self.txtExtrapolQMax.setText(str(Q_MAXIMUM))
111
112	# Let's choose the Standard Item Model.
113	self.model = QtGui.QStandardItemModel(self)
114
115	# Connect buttons to slots.
116	# Needs to be done early so default values propagate properly.
117	self.setupSlots()
118
119	# Set up the model.
120	self.setupModel()
121
122	# Set up the mapper
123	self.setupMapper()
124
125	# Default enablement
126	self.cmdCalculate.setEnabled(False)
127
128	# validator: double
129	self.txtBackgd.setValidator(GuiUtils.DoubleValidator())
130	self.txtContrast.setValidator(GuiUtils.DoubleValidator())
131	self.txtScale.setValidator(GuiUtils.DoubleValidator())
132	self.txtPorodCst.setValidator(GuiUtils.DoubleValidator())
133
134	# validator: integer number
135	self.txtNptsLowQ.setValidator(QtGui.QIntValidator())
136	self.txtNptsHighQ.setValidator(QtGui.QIntValidator())
137	self.txtPowerLowQ.setValidator(GuiUtils.DoubleValidator())
138	self.txtPowerHighQ.setValidator(GuiUtils.DoubleValidator())
139
140	def enabling(self):
141	""" """
142	self.cmdStatus.setEnabled(True)
143
144	def setClosable(self, value=True):
145	""" Allow outsiders close this widget """
146	assert isinstance(value, bool)
147
148	self._allow_close = value
149
150	def closeEvent(self, event):
151	"""
152	Overwrite QDialog close method to allow for custom widget close
153	"""
154	if self._allow_close:
155	# reset the closability flag
156	self.setClosable(value=False)
157	# Tell the MdiArea to close the container
158	self.parentWidget().close()
159	event.accept()
160	else:
161	event.ignore()
162	# Maybe we should just minimize
163	self.setWindowState(QtCore.Qt.WindowMinimized)
164
165	def updateFromModel(self):
166	""" Update the globals based on the data in the model """
167	self._background = float(self.model.item(WIDGETS.W_BACKGROUND).text())
168	self._contrast = float(self.model.item(WIDGETS.W_CONTRAST).text())
169	self._scale = float(self.model.item(WIDGETS.W_SCALE).text())
170	if self.model.item(WIDGETS.W_POROD_CST).text() != 'None' \
171	and self.model.item(WIDGETS.W_POROD_CST).text() != '':
172	self._porod = float(self.model.item(WIDGETS.W_POROD_CST).text())
173
174	# Low extrapolating
175	self._low_extrapolate = str(self.model.item(WIDGETS.W_ENABLE_LOWQ).text()) == 'true'
176	self._low_points = float(self.model.item(WIDGETS.W_NPTS_LOWQ).text())
177	self._low_guinier = str(self.model.item(WIDGETS.W_LOWQ_GUINIER).text()) == 'true'
178	self._low_fit = str(self.model.item(WIDGETS.W_LOWQ_FIT).text()) == 'true'
179	self._low_power_value = float(self.model.item(WIDGETS.W_LOWQ_POWER_VALUE).text())
180
181	# High extrapolating
182	self._high_extrapolate = str(self.model.item(WIDGETS.W_ENABLE_HIGHQ).text()) == 'true'
183	self._high_points = float(self.model.item(WIDGETS.W_NPTS_HIGHQ).text())
184	self._high_fit = str(self.model.item(WIDGETS.W_HIGHQ_FIT).text()) == 'true'
185	self._high_power_value = float(self.model.item(WIDGETS.W_HIGHQ_POWER_VALUE).text())
186
187	def calculateInvariant(self):
188	""" Use twisted to thread the calculations away """
189	# Find out if extrapolation needs to be used.
190	extrapolation = None
191	if self._low_extrapolate and not self._high_extrapolate:
192	extrapolation = "low"
193	elif not self._low_extrapolate and self._high_extrapolate:
194	extrapolation = "high"
195	elif self._low_extrapolate and self._high_extrapolate:
196	extrapolation = "both"
197
198	# modify the Calculate button to indicate background process
199	self.cmdCalculate.setText("Calculating...")
200	self.cmdCalculate.setEnabled(False)
201
202	# Send the calculations to separate thread.
203	d = threads.deferToThread(self.calculateThread, extrapolation)
204
205	# Add deferred callback for call return
206	d.addCallback(self.deferredPlot)
207	d.addErrback(self.calculationFailed)
208
209	def calculationFailed(self, reason):
210	print("calculation failed: ", reason)
211	pass
212
213	def deferredPlot(self, model):
214	"""
215	Run the GUI/model update in the main thread
216	"""
217	reactor.callFromThread(lambda: self.plotResult(model))
218
219	def plotResult(self, model):
220	""" Plot result of calculation """
221	# Set the button back to available
222	self.cmdCalculate.setEnabled(True)
223	self.cmdCalculate.setText("Calculate")
224	self.cmdStatus.setEnabled(True)
225
226	self.model = model
227	self.mapper.toFirst()
228	self._data = GuiUtils.dataFromItem(self._model_item)
229
230	# Send the modified model item to DE for keeping in the model
231	# Currently -unused
232	# self.communicate.updateModelFromPerspectiveSignal.emit(self._model_item)
233
234	plot_data = GuiUtils.plotsFromCheckedItems(self._manager.filesWidget.model)
235	#self.communicate.plotRequestedSignal.emit([item, plot], self.tab_id)
236
237	self._manager.filesWidget.plotData(plot_data)
238
239	# Update the details dialog in case it is open
240	self.updateDetailsWidget(model)
241
242	def updateDetailsWidget(self, model):
243	"""
244	On demand update of the details widget
245	"""
246	if self.detailsDialog.isVisible():
247	self.onStatus()
248
249	def calculateThread(self, extrapolation):
250	"""
251	Perform Invariant calculations.
252	TODO: Create a dictionary of results to be sent to DE on completion.
253	"""
254	self.updateFromModel()
255	msg = ''
256
257	qstar_low = 0.0
258	qstar_low_err = 0.0
259	qstar_high = 0.0
260	qstar_high_err = 0.0
261	qstar_total = 0.0
262	qstar_total_error = 0.0
263
264	temp_data = copy.deepcopy(self._data)
265
266	# Prepare the invariant object
267	inv = invariant.InvariantCalculator(data=temp_data,
268	background=self._background,
269	scale=self._scale)
270	if self._low_extrapolate:
271
272	function_low = "power_law"
273	if self._low_guinier:
274	function_low = "guinier"
275	if self._low_fit:
276	self._low_power_value = None
277
278	inv.set_extrapolation(range="low",
279	npts=int(self._low_points),
280	function=function_low,
281	power=self._low_power_value)
282
283	if self._high_extrapolate:
284	function_low = "power_law"
285	inv.set_extrapolation(range="high",
286	npts=int(self._high_points),
287	function=function_low,
288	power=self._high_power_value)
289	# Compute invariant
290	calculation_failed = False
291
292	try:
293	qstar_total, qstar_total_error = inv.get_qstar_with_error()
294	except Exception as ex:
295	msg += str(ex)
296	calculation_failed = True
297	# Display relevant information
298	item = QtGui.QStandardItem("ERROR")
299	self.model.setItem(WIDGETS.W_INVARIANT, item)
300	item = QtGui.QStandardItem("ERROR")
301	self.model.setItem(WIDGETS.W_INVARIANT_ERR, item)
302
303	try:
304	volume_fraction, volume_fraction_error = \
305	inv.get_volume_fraction_with_error(self._contrast)
306
307	except Exception as ex:
308	calculation_failed = True
309	msg += str(ex)
310	# Display relevant information
311	item = QtGui.QStandardItem("ERROR")
312	self.model.setItem(WIDGETS.W_VOLUME_FRACTION, item)
313	item = QtGui.QStandardItem("ERROR")
314	self.model.setItem(WIDGETS.W_VOLUME_FRACTION_ERR, item)
315
316	if self._porod:
317	try:
318	surface, surface_error = \
319	inv.get_surface_with_error(self._contrast, self._porod)
320	except Exception as ex:
321	calculation_failed = True
322	msg += str(ex)
323	# Display relevant information
324	item = QtGui.QStandardItem("ERROR")
325	self.model.setItem(WIDGETS.W_SPECIFIC_SURFACE, item)
326	item = QtGui.QStandardItem("ERROR")
327	self.model.setItem(WIDGETS.W_SPECIFIC_SURFACE_ERR, item)
328	else:
329	surface = None
330
331	if (calculation_failed):
332	logging.warning('Calculation failed: {}'.format(msg))
333	return self.model
334
335	low_calculation_pass = True
336	high_calculation_pass = True
337	if self._low_extrapolate:
338	try:
339	qstar_low, qstar_low_err = inv.get_qstar_low()
340	except Exception as ex:
341	low_calculation_pass = False
342	msg += str(ex)
343	logging.warning('Low-q calculation failed: {}'.format(msg))
344	if self._high_extrapolate:
345	try:
346	qstar_high, qstar_high_err = inv.get_qstar_high()
347	except Exception as ex:
348	high_calculation_pass = False
349	msg += str(ex)
350	logging.warning('High-q calculation failed: {}'.format(msg))
351
352
353	if self._low_extrapolate and low_calculation_pass:
354	extrapolated_data = inv.get_extra_data_low(self._low_points)
355	power_low = inv.get_extrapolation_power(range='low')
356
357	# Plot the chart
358	title = "Low-Q extrapolation"
359
360	# Convert the data into plottable
361	extrapolated_data = self._manager.createGuiData(extrapolated_data)
362
363	extrapolated_data.name = title
364	extrapolated_data.title = title
365	extrapolated_data.symbol = "Line"
366	extrapolated_data.has_errors = False
367
368	# copy labels and units of axes for plotting
369	extrapolated_data._xaxis = temp_data._xaxis
370	extrapolated_data._xunit = temp_data._xunit
371	extrapolated_data._yaxis = temp_data._yaxis
372	extrapolated_data._yunit = temp_data._yunit
373
374	# Add the plot to the model item
375	# This needs to run in the main thread
376	reactor.callFromThread(GuiUtils.updateModelItemWithPlot,
377	self._model_item,
378	extrapolated_data,
379	title)
380
381	if self._high_extrapolate and high_calculation_pass:
382	# for presentation in InvariantDetails
383	qmax_plot = Q_MAXIMUM_PLOT * max(temp_data.x)
384
385	if qmax_plot > Q_MAXIMUM:
386	qmax_plot = Q_MAXIMUM
387	power_high = inv.get_extrapolation_power(range='high')
388	high_out_data = inv.get_extra_data_high(q_end=qmax_plot, npts=500)
389
390	# Plot the chart
391	title = "High-Q extrapolation"
392
393	# Convert the data into plottable
394	high_out_data = self._manager.createGuiData(high_out_data)
395	high_out_data.name = title
396	high_out_data.title = title
397	high_out_data.symbol = "Line"
398	high_out_data.has_errors = False
399
400	# copy labels and units of axes for plotting
401	high_out_data._xaxis = temp_data._xaxis
402	high_out_data._xunit = temp_data._xunit
403	high_out_data._yaxis = temp_data._yaxis
404	high_out_data._yunit = temp_data._yunit
405
406	# Add the plot to the model item
407	# This needs to run in the main thread
408	reactor.callFromThread(GuiUtils.updateModelItemWithPlot,
409	self._model_item, high_out_data, title)
410
411	reactor.callFromThread(self.updateModelFromThread, WIDGETS.W_VOLUME_FRACTION, volume_fraction)
412	reactor.callFromThread(self.updateModelFromThread, WIDGETS.W_VOLUME_FRACTION_ERR, volume_fraction_error)
413	if surface:
414	reactor.callFromThread(self.updateModelFromThread, WIDGETS.W_SPECIFIC_SURFACE, surface)
415	reactor.callFromThread(self.updateModelFromThread, WIDGETS.W_SPECIFIC_SURFACE_ERR,
416	surface_error)
417
418	reactor.callFromThread(self.updateModelFromThread, WIDGETS.W_INVARIANT, qstar_total)
419	reactor.callFromThread(self.updateModelFromThread, WIDGETS.W_INVARIANT_ERR, qstar_total_error)
420	reactor.callFromThread(self.updateModelFromThread, WIDGETS.D_LOW_QSTAR, qstar_low)
421	reactor.callFromThread(self.updateModelFromThread, WIDGETS.D_LOW_QSTAR_ERR, qstar_low_err)
422	reactor.callFromThread(self.updateModelFromThread, WIDGETS.D_HIGH_QSTAR, qstar_high)
423	reactor.callFromThread(self.updateModelFromThread, WIDGETS.D_HIGH_QSTAR_ERR, qstar_high_err)
424	return self.model
425
426
427	def updateModelFromThread(self, widget, value):
428	"""
429	Update the model in the main thread
430	"""
431	item = QtGui.QStandardItem(str(float('%.3g' % value)))
432	self.model.setItem(widget, item)
433
434	def title(self):
435	""" Perspective name """
436	return "Invariant panel"
437
438	def onStatus(self):
439	"""
440	Display Invariant Details panel when clicking on Status button
441	"""
442	self.detailsDialog.setModel(self.model)
443	self.detailsDialog.showDialog()
444	self.cmdStatus.setEnabled(False)
445
446	def onHelp(self):
447	""" Display help when clicking on Help button """
448	treeLocation = "/user/qtgui/Perspectives/Invariant/invariant_help.html"
449	self.parent.showHelp(treeLocation)
450
451	def setupSlots(self):
452	""" """
453	self.cmdCalculate.clicked.connect(self.calculateInvariant)
454	self.cmdStatus.clicked.connect(self.onStatus)
455	self.cmdHelp.clicked.connect(self.onHelp)
456
457	self.chkLowQ.stateChanged.connect(self.stateChanged)
458	self.chkLowQ.stateChanged.connect(self.checkQExtrapolatedData)
459
460	self.chkHighQ.stateChanged.connect(self.stateChanged)
461	self.chkHighQ.stateChanged.connect(self.checkQExtrapolatedData)
462
463	# slots for the Guinier and PowerLaw radio buttons at low Q
464	# since they are not auto-exclusive
465	self.rbGuinier.toggled.connect(self.lowGuinierAndPowerToggle)
466
467	self.rbPowerLawLowQ.toggled.connect(self.lowGuinierAndPowerToggle)
468
469	self.rbFitHighQ.toggled.connect(self.hiFitAndFixToggle)
470
471	self.rbFitLowQ.toggled.connect(self.lowFitAndFixToggle)
472
473	self.model.itemChanged.connect(self.modelChanged)
474
475	# update model from gui editing by users
476	self.txtBackgd.textChanged.connect(self.updateFromGui)
477
478	self.txtScale.textChanged.connect(self.updateFromGui)
479
480	self.txtContrast.textChanged.connect(self.updateFromGui)
481
482	self.txtPorodCst.textChanged.connect(self.updateFromGui)
483
484	self.txtPowerLowQ.textChanged.connect(self.updateFromGui)
485
486	self.txtPowerHighQ.textChanged.connect(self.updateFromGui)
487
488	self.txtNptsLowQ.textChanged.connect(self.updateFromGui)
489
490	self.txtNptsHighQ.textChanged.connect(self.updateFromGui)
491
492	# check values of n_points compared to distribution length
493	if self.txtNptsLowQ.isEnabled():
494	self.txtNptsLowQ.textChanged.connect(self.checkLength)
495
496	if self.txtNptsHighQ.isEnabled():
497	self.txtNptsHighQ.textChanged.connect(self.checkLength)
498
499	def stateChanged(self):
500	"""
501	Catch modifications from low- and high-Q extrapolation check boxes
502	"""
503	sender = self.sender()
504
505	itemf = QtGui.QStandardItem(str(sender.isChecked()).lower())
506	if sender.text() == 'Enable Low-Q extrapolation':
507	self.model.setItem(WIDGETS.W_ENABLE_LOWQ, itemf)
508
509	if sender.text() == 'Enable High-Q extrapolation':
510	self.model.setItem(WIDGETS.W_ENABLE_HIGHQ, itemf)
511
512	def checkLength(self):
513	"""
514	Validators of number of points for extrapolation.
515	Error if it is larger than the distribution length
516	"""
517	try:
518	int_value = int(self.sender().text())
519	except ValueError:
520	self.sender().setStyleSheet(BG_RED)
521	self.cmdCalculate.setEnabled(False)
522	return
523
524	if self._data:
525	if len(self._data.x) < int_value:
526	self.sender().setStyleSheet(BG_RED)
527	logging.warning('The number of points must be smaller than {}'.format(len(self._data.x)))
528	self.cmdCalculate.setEnabled(False)
529	else:
530	self.sender().setStyleSheet(BG_WHITE)
531	self.cmdCalculate.setEnabled(True)
532	else:
533	# logging.info('no data is loaded')
534	self.cmdCalculate.setEnabled(False)
535
536	def modelChanged(self, item):
537	""" Update when model changed """
538	if item.row() == WIDGETS.W_ENABLE_LOWQ:
539	toggle = (str(item.text()) == 'true')
540	self._low_extrapolate = toggle
541	self.lowQToggle(toggle)
542	elif item.row() == WIDGETS.W_ENABLE_HIGHQ:
543	toggle = (str(item.text()) == 'true')
544	self._high_extrapolate = toggle
545	self.highQToggle(toggle)
546
547	def checkQExtrapolatedData(self):
548	"""
549	Match status of low or high-Q extrapolated data checkbox in
550	DataExplorer with low or high-Q extrapolation checkbox in invariant
551	panel
552	"""
553	# name to search in DataExplorer
554	if 'Low' in str(self.sender().text()):
555	name = "Low-Q extrapolation"
556	if 'High' in str(self.sender().text()):
557	name = "High-Q extrapolation"
558
559	GuiUtils.updateModelItemStatus(self._manager.filesWidget.model,
560	self._path, name,
561	self.sender().checkState())
562
563	def updateFromGui(self):
564	""" Update model when new user inputs """
565	possible_senders = ['txtBackgd', 'txtContrast', 'txtPorodCst',
566	'txtScale', 'txtPowerLowQ', 'txtPowerHighQ',
567	'txtNptsLowQ', 'txtNptsHighQ']
568
569	related_widgets = [WIDGETS.W_BACKGROUND, WIDGETS.W_CONTRAST,
570	WIDGETS.W_POROD_CST, WIDGETS.W_SCALE,
571	WIDGETS.W_LOWQ_POWER_VALUE, WIDGETS.W_HIGHQ_POWER_VALUE,
572	WIDGETS.W_NPTS_LOWQ, WIDGETS.W_NPTS_HIGHQ]
573
574	related_internal_values = [self._background, self._contrast,
575	self._porod, self._scale,
576	self._low_power_value,
577	self._high_power_value,
578	self._low_points, self._high_points]
579
580	item = QtGui.QStandardItem(self.sender().text())
581
582	index_elt = possible_senders.index(self.sender().objectName())
583
584	self.model.setItem(related_widgets[index_elt], item)
585	try:
586	related_internal_values[index_elt] = float(self.sender().text())
587	self.sender().setStyleSheet(BG_WHITE)
588	self.cmdCalculate.setEnabled(True)
589	except ValueError:
590	# empty field, just skip
591	self.sender().setStyleSheet(BG_RED)
592	self.cmdCalculate.setEnabled(False)
593
594	def lowGuinierAndPowerToggle(self, toggle):
595	"""
596	Guinier and Power radio buttons cannot be selected at the same time
597	If Power is selected, Fit and Fix radio buttons are visible and
598	Power line edit can be edited if Fix is selected
599	"""
600	if self.sender().text() == 'Guinier':
601	self._low_guinier = toggle
602
603	toggle = not toggle
604	self.rbPowerLawLowQ.setChecked(toggle)
605
606	self.rbFitLowQ.toggled.connect(self.lowFitAndFixToggle)
607	self.rbFitLowQ.setVisible(toggle)
608	self.rbFixLowQ.setVisible(toggle)
609
610	self.txtPowerLowQ.setEnabled(toggle and (not self._low_fit))
611
612	else:
613	self._low_guinier = not toggle
614
615	self.rbGuinier.setChecked(not toggle)
616
617	self.rbFitLowQ.toggled.connect(self.lowFitAndFixToggle)
618	self.rbFitLowQ.setVisible(toggle)
619	self.rbFixLowQ.setVisible(toggle)
620
621	self.txtPowerLowQ.setEnabled(toggle and (not self._low_fit))
622
623	def lowFitAndFixToggle(self, toggle):
624	""" Fit and Fix radiobuttons cannot be selected at the same time """
625	self._low_fit = toggle
626
627	toggle = not toggle
628	self.txtPowerLowQ.setEnabled(toggle)
629
630	def hiFitAndFixToggle(self, toggle):
631	"""
632	Enable editing of power exponent if Fix for high Q is checked
633	Disable otherwise
634	"""
635	self.txtPowerHighQ.setEnabled(not toggle)
636
637	def highQToggle(self, clicked):
638	""" Disable/enable High Q extrapolation """
639	self.rbFitHighQ.setEnabled(clicked)
640	self.rbFixHighQ.setEnabled(clicked)
641	self.txtNptsHighQ.setEnabled(clicked)
642	self.txtPowerHighQ.setEnabled(clicked)
643
644	def lowQToggle(self, clicked):
645	""" Disable / enable Low Q extrapolation """
646	self.rbGuinier.setEnabled(clicked)
647	self.rbPowerLawLowQ.setEnabled(clicked)
648	self.txtNptsLowQ.setEnabled(clicked)
649	# Enable subelements
650	self.rbFitLowQ.setVisible(self.rbPowerLawLowQ.isChecked())
651	self.rbFixLowQ.setVisible(self.rbPowerLawLowQ.isChecked())
652	self.rbFitLowQ.setEnabled(clicked) # and not self._low_guinier)
653	self.rbFixLowQ.setEnabled(clicked) # and not self._low_guinier)
654
655	self.txtPowerLowQ.setEnabled(clicked
656	and not self._low_guinier
657	and not self._low_fit)
658
659	def setupModel(self):
660	""" """
661	# filename
662	item = QtGui.QStandardItem(self._path)
663	self.model.setItem(WIDGETS.W_FILENAME, item)
664
665	# add Q parameters to the model
666	qmin = 0.0
667	item = QtGui.QStandardItem(str(qmin))
668	self.model.setItem(WIDGETS.W_QMIN, item)
669	qmax = 0.0
670	item = QtGui.QStandardItem(str(qmax))
671	self.model.setItem(WIDGETS.W_QMAX, item)
672
673	# add custom input params
674	item = QtGui.QStandardItem(str(self._background))
675	self.model.setItem(WIDGETS.W_BACKGROUND, item)
676	item = QtGui.QStandardItem(str(self._contrast))
677	self.model.setItem(WIDGETS.W_CONTRAST, item)
678	item = QtGui.QStandardItem(str(self._scale))
679	self.model.setItem(WIDGETS.W_SCALE, item)
680	# leave line edit empty if Porod constant not defined
681	if self._porod != None:
682	item = QtGui.QStandardItem(str(self._porod))
683	else:
684	item = QtGui.QStandardItem(str(''))
685	self.model.setItem(WIDGETS.W_POROD_CST, item)
686
687	# Dialog elements
688	itemf = QtGui.QStandardItem("false")
689	self.model.setItem(WIDGETS.W_ENABLE_HIGHQ, itemf)
690	itemf = QtGui.QStandardItem("false")
691	self.model.setItem(WIDGETS.W_ENABLE_LOWQ, itemf)
692
693	item = QtGui.QStandardItem(str(NPOINTS_Q_INTERP))
694	self.model.setItem(WIDGETS.W_NPTS_LOWQ, item)
695	item = QtGui.QStandardItem(str(NPOINTS_Q_INTERP))
696	self.model.setItem(WIDGETS.W_NPTS_HIGHQ, item)
697
698	itemt = QtGui.QStandardItem("true")
699	self.model.setItem(WIDGETS.W_LOWQ_GUINIER, itemt)
700
701	itemt = QtGui.QStandardItem("true")
702	self.model.setItem(WIDGETS.W_LOWQ_FIT, itemt)
703	item = QtGui.QStandardItem(str(DEFAULT_POWER_LOW))
704	self.model.setItem(WIDGETS.W_LOWQ_POWER_VALUE, item)
705
706	itemt = QtGui.QStandardItem("true")
707	self.model.setItem(WIDGETS.W_HIGHQ_FIT, itemt)
708	item = QtGui.QStandardItem(str(DEFAULT_POWER_LOW))
709	self.model.setItem(WIDGETS.W_HIGHQ_POWER_VALUE, item)
710
711	def setupMapper(self):
712	# Set up the mapper.
713	self.mapper = QtWidgets.QDataWidgetMapper(self)
714	self.mapper.setOrientation(QtCore.Qt.Vertical)
715	self.mapper.setModel(self.model)
716
717	# Filename
718	self.mapper.addMapping(self.txtName, WIDGETS.W_FILENAME)
719
720	# Qmin/Qmax
721	self.mapper.addMapping(self.txtTotalQMin, WIDGETS.W_QMIN)
722	self.mapper.addMapping(self.txtTotalQMax, WIDGETS.W_QMAX)
723
724	# Background
725	self.mapper.addMapping(self.txtBackgd, WIDGETS.W_BACKGROUND)
726
727	# Scale
728	self.mapper.addMapping(self.txtScale, WIDGETS.W_SCALE)
729
730	# Contrast
731	self.mapper.addMapping(self.txtContrast, WIDGETS.W_CONTRAST)
732
733	# Porod constant
734	self.mapper.addMapping(self.txtPorodCst, WIDGETS.W_POROD_CST)
735
736	# Lowq/Highq items
737	self.mapper.addMapping(self.chkLowQ, WIDGETS.W_ENABLE_LOWQ)
738	self.mapper.addMapping(self.chkHighQ, WIDGETS.W_ENABLE_HIGHQ)
739
740	self.mapper.addMapping(self.txtNptsLowQ, WIDGETS.W_NPTS_LOWQ)
741	self.mapper.addMapping(self.rbGuinier, WIDGETS.W_LOWQ_GUINIER)
742	self.mapper.addMapping(self.rbFitLowQ, WIDGETS.W_LOWQ_FIT)
743	self.mapper.addMapping(self.txtPowerLowQ, WIDGETS.W_LOWQ_POWER_VALUE)
744
745	self.mapper.addMapping(self.txtNptsHighQ, WIDGETS.W_NPTS_HIGHQ)
746	self.mapper.addMapping(self.rbFitHighQ, WIDGETS.W_HIGHQ_FIT)
747	self.mapper.addMapping(self.txtPowerHighQ, WIDGETS.W_HIGHQ_POWER_VALUE)
748
749	# Output
750	self.mapper.addMapping(self.txtVolFract, WIDGETS.W_VOLUME_FRACTION)
751	self.mapper.addMapping(self.txtVolFractErr, WIDGETS.W_VOLUME_FRACTION_ERR)
752	self.mapper.addMapping(self.txtSpecSurf, WIDGETS.W_SPECIFIC_SURFACE)
753	self.mapper.addMapping(self.txtSpecSurfErr, WIDGETS.W_SPECIFIC_SURFACE_ERR)
754	self.mapper.addMapping(self.txtInvariantTot, WIDGETS.W_INVARIANT)
755	self.mapper.addMapping(self.txtInvariantTotErr, WIDGETS.W_INVARIANT_ERR)
756
757	self.mapper.toFirst()
758
759	def setData(self, data_item=None, is_batch=False):
760	"""
761	Obtain a QStandardItem object and dissect it to get Data1D/2D
762	Pass it over to the calculator
763	"""
764	assert data_item is not None
765
766	if self.txtName.text() == data_item[0].text():
767	logging.info('This file is already loaded in Invariant panel.')
768	return
769
770	if not isinstance(data_item, list):
771	msg = "Incorrect type passed to the Invariant Perspective"
772	raise AttributeError(msg)
773
774	if not isinstance(data_item[0], QtGui.QStandardItem):
775	msg = "Incorrect type passed to the Invariant Perspective"
776	raise AttributeError(msg)
777
778	# only 1 file can be loaded
779	self._model_item = data_item[0]
780
781	# Extract data on 1st child - this is the Data1D/2D component
782	data = GuiUtils.dataFromItem(self._model_item)
783	self.model.item(WIDGETS.W_FILENAME).setData(self._model_item.text())
784	# update GUI and model with info from loaded data
785	self.updateGuiFromFile(data=data)
786
787	def updateGuiFromFile(self, data=None):
788	"""
789	update display in GUI and plot
790	"""
791	self._data = data
792
793	# plot loaded file
794	if not isinstance(self._data, Data1D):
795	msg = "Invariant cannot be computed with 2D data."
796	raise ValueError(msg)
797
798	try:
799	filename = data.filename
800	except:
801	msg = 'No filename chosen.'
802	raise ValueError(msg)
803	try:
804	qmin = min(self._data.x)
805	qmax = max(self._data.x)
806	except:
807	msg = "Unable to find q min/max of \n data named %s" % \
808	data.filename
809	raise ValueError(msg)
810
811	# update model with input form files: filename, qmin, qmax
812	self.model.item(WIDGETS.W_FILENAME).setText(filename)
813	self.model.item(WIDGETS.W_QMIN).setText(str(qmin))
814	self.model.item(WIDGETS.W_QMAX).setText(str(qmax))
815	self._path = filename
816
817	# Calculate and add to GUI: volume fraction, invariant total,
818	# and specific surface if porod checked
819	self.calculateInvariant()
820
821	def allowBatch(self):
822	"""
823	Tell the caller that we don't accept multiple data instances
824	"""
825	return False

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

SasView

source: sasview/src/sas/qtgui/Perspectives/Invariant/InvariantPerspective.py

Download in other formats: