ResolutionCalculatorPanel.py @ fc4fec8

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 fc4fec8 was fc4fec8, checked in by celinedurniak <celine.durniak@…>, 7 years ago
Implemented corrections from review of Resolution Calculator Panel
Property mode set to `100644`
File size: 31.1 KB

Line
1	"""
2	This object is a small tool to allow user to quickly
3	determine the variance in q from the
4	instrumental parameters.
5	"""
6	from PyQt4 import QtGui
7	from PyQt4 import QtCore
8
9	from twisted.internet import threads
10	import sas.qtgui.Utilities.GuiUtils as GuiUtils
11	from sas.qtgui.Plotting.PlotterData import Data2D
12	from sas.qtgui.Plotting.Plotter2D import Plotter2DWidget
13	from sas.sascalc.calculator.resolution_calculator import ResolutionCalculator
14	import matplotlib.patches as patches
15
16	import numpy
17	import sys
18	import logging
19	import os
20	import re
21
22	from UI.ResolutionCalculatorPanelUI import Ui_ResolutionCalculatorPanel
23
24	_SOURCE_MASS = {'Alpha': 6.64465620E-24,
25	'Deuteron': 3.34358320E-24,
26	'Neutron': 1.67492729E-24,
27	'Photon': 0.0,
28	'Proton': 1.67262137E-24,
29	'Triton': 5.00826667E-24}
30
31	BG_WHITE = "background-color: rgb(255, 255, 255);"
32	BG_RED = "background-color: rgb(244, 170, 164);"
33
34
35	class ResolutionCalculatorPanel(QtGui.QDialog, Ui_ResolutionCalculatorPanel):
36	"""
37	compute resolution in 2D
38	"""
39	def __init__(self, parent=None):
40	super(ResolutionCalculatorPanel, self).__init__()
41	self.setupUi(self)
42	self.manager = parent
43
44	# New font to display angstrom symbol
45	new_font = 'font-family: -apple-system, "Helvetica Neue", "Ubuntu";'
46	self.lblUnitWavelength.setStyleSheet(new_font)
47	self.lblUnitQx.setStyleSheet(new_font)
48	self.lblUnitQy.setStyleSheet(new_font)
49	self.lblUnitSigmax.setStyleSheet(new_font)
50	self.lblUnitSigmay.setStyleSheet(new_font)
51	self.lblUnitSigmalamd.setStyleSheet(new_font)
52	self.lblUnit1DSigma.setStyleSheet(new_font)
53
54	# by default Spectrum label and cbCustomSpectrum are not visible
55	self.cbCustomSpectrum.setVisible(False)
56	self.lblSpectrum.setVisible(False)
57	# self.onReset()
58
59	# change index of comboboxes
60	self.cbWaveColor.currentIndexChanged.connect(self.onSelectWaveColor)
61	self.cbCustomSpectrum.currentIndexChanged.connect(self.onSelectCustomSpectrum)
62
63	# push buttons
64	self.cmdClose.clicked.connect(self.accept)
65	self.cmdHelp.clicked.connect(self.onHelp)
66	self.cmdCompute.clicked.connect(self.onCompute)
67	self.cmdReset.clicked.connect(self.onReset)
68
69	# input defaults
70	self.qx = []
71	self.qy = []
72	# dQ defaults
73	self.sigma_r = None
74	self.sigma_phi = None
75	self.sigma_1d = None
76
77	# number of bins for wavelength and wavelength spread
78	self.num_wave = 10
79	self.spectrum_dic = {}
80
81	# dQ 2d image
82	self.image = None
83	# Source selection dic
84	self.source_mass = _SOURCE_MASS
85	# detector coordinate of estimation of sigmas
86	self.det_coordinate = 'cartesian'
87
88	self.resolution = ResolutionCalculator()
89	self.spectrum_dic['Add new'] = ''
90	self.spectrum_dic['Flat'] = self.resolution.get_default_spectrum()
91	self.resolution.set_spectrum(self.spectrum_dic['Flat'])
92
93	# validators
94	self.txtWavelength.editingFinished.connect(self.checkWavelength)
95	self.txtWavelengthSpread.editingFinished.connect(self.checkWavelengthSpread)
96
97	self.txtDetectorPixSize.editingFinished.connect(self.checkPixels)
98	self.txtDetectorSize.editingFinished.connect(self.checkPixels)
99
100	self.txtSourceApertureSize.editingFinished.connect(self.checkAperture)
101	self.txtSampleApertureSize.editingFinished.connect(self.checkAperture)
102
103	self.txtQx.editingFinished.connect(self.checkQx_y)
104	self.txtQy.editingFinished.connect(self.checkQx_y)
105
106	# double validator
107	self.txtSource2SampleDistance.setValidator(QtGui.QDoubleValidator())
108	self.txtSample2DetectorDistance.setValidator(QtGui.QDoubleValidator())
109	self.txtSampleOffset.setValidator(QtGui.QDoubleValidator())
110
111	# call compute to calculate with default values
112	self.createTemplate2DPlot()
113	self.onCompute()
114
115	# #################################
116	# Validators: red background in line edits when wrong input
117	# and display of info logging message
118	# #################################
119
120	def checkWavelength(self):
121	""" Validator for Wavelength
122	if TOF, wavelength = min - max else only one number """
123	text_edit = self.txtWavelength # self.sender()
124	if text_edit.isModified():
125	text_edit.setStyleSheet(QtCore.QString(BG_WHITE))
126	input_string = str(text_edit.text())
127	if self.cbWaveColor.currentText() != 'TOF':
128	input_wavelength = re.match('\d+\.?\d*', input_string)
129	if input_wavelength is None:
130	text_edit.setStyleSheet(QtCore.QString(BG_RED))
131	self.cmdCompute.setEnabled(False)
132	logging.info('Wavelength has to be a number.')
133	else:
134	text_edit.setStyleSheet(QtCore.QString(BG_WHITE))
135	self.cmdCompute.setEnabled(True)
136	else:
137	interval_wavelength = re.match('^\d+\.?\d\s-\s\d+\.?\d$',
138	input_string)
139
140	if interval_wavelength is None:
141	text_edit.setStyleSheet(QtCore.QString(BG_RED))
142	self.cmdCompute.setEnabled(False)
143	logging.info("Wavelength's input has to be an interval: "
144	"min - max.")
145	else:
146	# check on min < max
147	[wavelength_min, wavelength_max] = \
148	re.findall('\d+\.?\d*', interval_wavelength.group())
149
150	if float(wavelength_min) >= float(wavelength_max):
151	text_edit.setStyleSheet(QtCore.QString(BG_RED))
152	self.cmdCompute.setEnabled(False)
153	logging.info("Wavelength: min must be smaller than max.")
154
155	else:
156	text_edit.setStyleSheet(QtCore.QString(BG_WHITE))
157	self.cmdCompute.setEnabled(True)
158
159	def checkWavelengthSpread(self):
160	""" Validator for WavelengthSpread
161	Input can be a 'number or min - max (; Number of bins)' """
162	text_edit = self.sender()
163
164	if text_edit.isModified():
165	text_edit.setStyleSheet(QtCore.QString(BG_WHITE))
166	if self.cbWaveColor.currentText() != 'TOF':
167	pattern = '^\d+\.?\d(\|;\s\d+)$'
168	input_string = str(text_edit.text())
169	wavelength_spread_input = re.match(pattern, input_string)
170
171	if wavelength_spread_input is None:
172	text_edit.setStyleSheet(QtCore.QString(BG_RED))
173	self.cmdCompute.setEnabled(False)
174	logging.info('Wavelength spread has to be specified: '
175	'single value or value; integer number of bins.')
176
177	else:
178	split_input = wavelength_spread_input.group().split(';')
179	self.num_wave = split_input[1] if len(split_input) > 1 else 10
180	text_edit.setStyleSheet(QtCore.QString(BG_WHITE))
181	self.cmdCompute.setEnabled(True)
182	else:
183	pattern = '^\d+\.?\d\s-\s\d+\.?\d(\|;\s*\d+)$'
184	input_string = str(text_edit.text())
185	wavelength_spread_input = re.match(pattern, input_string)
186
187	if wavelength_spread_input is None:
188	text_edit.setStyleSheet(QtCore.QString(BG_RED))
189	self.cmdCompute.setEnabled(False)
190	logging.info("Wavelength spread has to be specified: "
191	"doublet separated by '-' with optional "
192	"number of bins (given after ';'). "
193	"For example, 0.1 - 0.1 (; 20).")
194
195	else:
196	split_input = wavelength_spread_input.group().split(';')
197	self.num_wave = split_input[1] if len(
198	split_input) > 1 else 10
199	text_edit.setStyleSheet(QtCore.QString(BG_WHITE))
200	self.cmdCompute.setEnabled(True)
201
202	def checkPixels(self):
203	""" Validator for detector pixel size and number """
204	text_edit = self.sender()
205
206	if text_edit.isModified():
207	text_edit.setStyleSheet(QtCore.QString(BG_WHITE))
208	pattern = '^\d+\.?\d,\s\d+\.?\d*$'
209	input_string = str(text_edit.text())
210	pixels_input = re.match(pattern, input_string)
211
212	if pixels_input is None:
213	text_edit.setStyleSheet(QtCore.QString(BG_RED))
214	self.cmdCompute.setEnabled(False)
215	logging.info('The input for the detector should contain 2 '
216	'values separated by a comma.')
217
218	else:
219	text_edit.setStyleSheet(QtCore.QString(BG_WHITE))
220	self.cmdCompute.setEnabled(True)
221
222	def checkQx_y(self):
223	""" Validator for qx and qy inputs """
224	Q_modified = [self.txtQx.isModified(), self.txtQy.isModified()]
225	if any(Q_modified):
226	pattern = '^-?\d+\.?\d(,\s-?\d+\.?\d)$'
227	text_edit = self.txtQx if Q_modified[0] else self.txtQy
228	input_string = str(text_edit.text())
229	q_input = re.match(pattern, input_string)
230	if q_input is None:
231	text_edit.setStyleSheet(QtCore.QString(BG_RED))
232	self.cmdCompute.setEnabled(False)
233	logging.info('Qx and Qy should contain one or more comma-separated numbers.')
234	else:
235	text_edit.setStyleSheet(QtCore.QString(BG_WHITE))
236	self.cmdCompute.setEnabled(True)
237	qx = str(self.txtQx.text()).split(',')
238	qy = str(self.txtQy.text()).split(',')
239
240	if len(qx) == 1 and len(qy) > 1:
241	fill_qx = ', '.join([qx[0]] * len(qy))
242	self.txtQx.setText(fill_qx)
243
244	elif len(qy) == 1 and len(qx) > 1:
245	fill_qy = ', '.join([qy[0]] * len(qx))
246	self.txtQy.setText(fill_qy)
247
248	elif len(qx) != len(qy):
249	text_edit.setStyleSheet(QtCore.QString(BG_RED))
250	self.cmdCompute.setEnabled(False)
251	logging.info(
252	'Qx and Qy should have the same number of elements.')
253
254	else:
255	text_edit.setStyleSheet(QtCore.QString(BG_WHITE))
256	self.cmdCompute.setEnabled(True)
257
258	def checkAperture(self):
259	""" Validator for Sample and Source apertures"""
260	text_edit = self.sender()
261
262	if text_edit.isModified():
263	text_edit.setStyleSheet(QtCore.QString(BG_WHITE))
264	input_string = str(text_edit.text())
265	pattern = '^\d+\.?\d(\|,\s\d+)$'
266	aperture_input = re.match(pattern, input_string)
267
268	if aperture_input is None:
269	text_edit.setStyleSheet(QtCore.QString(BG_RED))
270	self.cmdCompute.setEnabled(False)
271	logging.info('A circular aperture is defined by a single '
272	'value (diameter). A rectangular aperture is '
273	'defined by 2 values separated by a comma.')
274
275	else:
276	text_edit.setStyleSheet(QtCore.QString(BG_WHITE))
277	self.cmdCompute.setEnabled(True)
278
279	# #################################
280	# Slots associated with signals from comboboxes
281	# #################################
282
283	def onSelectWaveColor(self):
284	""" Modify layout of GUI when TOF selected: add elements
285	and modify default entry of Wavelength """
286	list_wdata = self.resolution.get_wave_list()
287	min_lambda = min(list_wdata[0])
288
289	min_wspread = min(list_wdata[1])
290	max_wspread = max(list_wdata[1])
291
292	if self.cbWaveColor.currentText() == 'TOF':
293	self.cbCustomSpectrum.setVisible(True)
294	self.lblSpectrum.setVisible(True)
295	# Get information about wavelength and spread
296
297	if len(list_wdata[0]) < 2:
298	max_lambda = 2 * min_lambda
299	else:
300	max_lambda = max(list_wdata[0])
301	self.txtWavelength.setText('{} - {}'.format(min_lambda, max_lambda))
302	self.txtWavelengthSpread.setText('{} - {}'.format(min_wspread,
303	max_wspread))
304
305	else:
306	self.cbCustomSpectrum.setVisible(False)
307	self.lblSpectrum.setVisible(False)
308	# modify Wavelength line edit only if set for TOF (2 elements)
309
310	if len(self.txtWavelength.text().split('-')) >= 2:
311	self.txtWavelength.setText(str(min_lambda))
312	self.txtWavelengthSpread.setText(str(min_wspread))
313
314	def onSelectCustomSpectrum(self):
315	""" On Spectrum Combobox event"""
316	if self.cbCustomSpectrum.currentText() == 'Add New':
317	datafile = QtGui.QFileDialog.getOpenFileName(
318	self, "Choose a spectral distribution file", "",
319	"All files (.)",
320	None, QtGui.QFileDialog.DontUseNativeDialog)
321
322	if datafile is None or str(datafile) == '':
323	logging.info("No spectral distribution data chosen.")
324	self.cbCustomSpectrum.setCurrentIndex(0)
325	self.resolution.set_spectrum(self.spectrum_dic['Flat'])
326	return
327
328	try:
329	basename = os.path.basename(datafile)
330	if basename not in self.spectrum_dic.keys():
331	self.cbCustomSpectrum.addItem(basename)
332
333	input_f = open(datafile, 'r')
334	buff = input_f.read()
335	lines = buff.split('\n')
336
337	wavelength = []
338	intensity = []
339
340	for line in lines:
341	toks = line.split()
342	try:
343	wave = float(toks[0])
344	intens = float(toks[1])
345	wavelength.append(wave)
346	intensity.append(intens)
347	except:
348	logging.info('Could not extract values from file')
349	except:
350	raise
351
352	self.spectrum_dic[basename] = [wavelength, intensity]
353	self.resolution.set_spectrum(self.spectrum_dic[basename])
354	return
355
356	# #################################
357	# Slots associated with signals from push buttons
358	# #################################
359
360	def onHelp(self):
361	"""
362	Bring up the Resolution Calculator Documentation whenever
363	the HELP button is clicked.
364	Calls Documentation Window with the path of the location within the
365	documentation tree (after /doc/ ....".
366	"""
367	try:
368	location = GuiUtils.HELP_DIRECTORY_LOCATION + \
369	"/user/sasgui/perspectives/calculator/resolution_calculator_help.html"
370	self.manager._helpView.load(QtCore.QUrl(location))
371	self.manager._helpView.show()
372
373	except AttributeError:
374	# No manager defined - testing and standalone runs
375	pass
376
377	def onReset(self):
378	# by default Spectrum label and cbCustomSpectrum are not visible
379	self.cbCustomSpectrum.setVisible(False)
380	self.lblSpectrum.setVisible(False)
381	# Comboboxes
382	self.cbCustomSpectrum.setCurrentIndex([self.cbCustomSpectrum.itemText(i)
383	for i in range(self.cbCustomSpectrum.count())].index('Flat'))
384	self.cbSource.setCurrentIndex([self.cbSource.itemText(i) for i in
385	range(self.cbSource.count())].index('Neutron'))
386	self.cbWaveColor.setCurrentIndex([self.cbWaveColor.itemText(i) for i
387	in range(self.cbWaveColor.count())].index('Monochromatic'))
388	# LineEdits
389	self.txtDetectorPixSize.setText('0.5, 0.5')
390	self.txtDetectorSize.setText('128, 128')
391	self.txtSample2DetectorDistance.setText('1000')
392	self.txtSampleApertureSize.setText('1.27')
393	self.txtSampleOffset.setText('0')
394	self.txtSource2SampleDistance.setText('1627')
395	self.txtSourceApertureSize.setText('3.81')
396	self.txtWavelength.setText('6.0')
397	self.txtWavelengthSpread.setText('0.125')
398	self.txtQx.setText('0.0')
399	self.txtQy.setText('0.0')
400	self.txt1DSigma.setText('0.0008289')
401	self.txtSigma_x.setText('0.0008288')
402	self.txtSigma_y.setText('0.0008288')
403	self.txtSigma_lamd.setText('3.168e-05')
404
405	self.image = None
406	self.source_mass = _SOURCE_MASS
407	self.det_coordinate = 'cartesian'
408	self.num_wave = 10
409	self.spectrum_dic = {}
410	self.spectrum_dic['Add new'] = ''
411	self.spectrum_dic['Flat'] = self.resolution.get_default_spectrum()
412	self.resolution.set_spectrum(self.spectrum_dic['Flat'])
413	# Reset plot
414	self.onCompute()
415
416	# TODO Keep legacy validators??
417	def onCompute(self):
418	"""
419	Execute the computation of resolution
420	"""
421	# Q min max list default
422	qx_min = []
423	qx_max = []
424	qy_min = []
425	qy_max = []
426	# possible max qrange
427	self.resolution.qxmin_limit = 0
428	self.resolution.qxmax_limit = 0
429	self.resolution.qymin_limit = 0
430	self.resolution.qymax_limit = 0
431
432	try:
433	# Get all the values to compute
434	wavelength = self._str2longlist(self.txtWavelength.text())
435
436	source = self.cbSource.currentText()
437	mass = self.source_mass[str(source)]
438	self.resolution.set_neutron_mass(float(mass))
439
440	wavelength_spread = self._str2longlist(\
441	self.txtWavelengthSpread.text().split(';')[0])
442	# Validate the wave inputs
443	wave_input = self._validate_q_input(wavelength, wavelength_spread)
444	if wave_input is not None:
445	wavelength, wavelength_spread = wave_input
446
447	self.resolution.set_wave(wavelength)
448	self.resolution.set_wave_spread(wavelength_spread)
449
450	# use legacy validator for correct input assignment
451
452	source_aperture_size = self.txtSourceApertureSize.text()
453	source_aperture_size = self._str2longlist(source_aperture_size)
454	self.resolution.set_source_aperture_size(source_aperture_size)
455
456	sample_aperture_size = self.txtSampleApertureSize.text()
457	sample_aperture_size = self._string2list(sample_aperture_size)
458	self.resolution.set_sample_aperture_size(sample_aperture_size)
459
460	source2sample_distance = self.txtSource2SampleDistance.text()
461	source2sample_distance = self._string2list(source2sample_distance)
462	self.resolution.set_source2sample_distance(source2sample_distance)
463
464	sample2sample_distance = self.txtSampleOffset.text()
465	sample2sample_distance = self._string2list(sample2sample_distance)
466	self.resolution.set_sample2sample_distance(sample2sample_distance)
467
468	sample2detector_distance = self.txtSample2DetectorDistance.text()
469	sample2detector_distance = self._string2list(
470	sample2detector_distance)
471	self.resolution.set_sample2detector_distance(
472	sample2detector_distance)
473
474	detector_size = self.txtDetectorSize.text()
475	detector_size = self._string2list(detector_size)
476	self.resolution.set_detector_size(detector_size)
477
478	detector_pix_size = self.txtDetectorPixSize.text()
479	detector_pix_size = self._string2list(detector_pix_size)
480	self.resolution.set_detector_pix_size(detector_pix_size)
481
482	self.qx = self._string2inputlist(self.txtQx.text())
483	self.qy = self._string2inputlist(self.txtQy.text())
484
485	# Find min max of qs
486	xmin = min(self.qx)
487	xmax = max(self.qx)
488	ymin = min(self.qy)
489	ymax = max(self.qy)
490	if not self._validate_q_input(self.qx, self.qy):
491	raise ValueError("Invalid Q input")
492	except:
493	msg = "An error occurred during the resolution computation."
494	msg += "Please check your inputs..."
495	logging.warning(msg)
496	return
497
498	# Validate the q inputs
499	q_input = self._validate_q_input(self.qx, self.qy)
500	if q_input is not None:
501	self.qx, self.qy = q_input
502
503	# Make list of q min max for mapping
504	for i in range(len(self.qx)):
505	qx_min.append(xmin)
506	qx_max.append(xmax)
507	for i in range(len(self.qy)):
508	qy_min.append(ymin)
509	qy_max.append(ymax)
510
511	# Compute the resolution
512	if self.image is not None:
513	self.resolution.reset_image()
514
515	# Compute and get the image plot
516	try:
517	cal_res = threads.deferToThread(self.map_wrapper,
518	self.calc_func,
519	self.qx,
520	self.qy,
521	qx_min,
522	qx_max,
523	qy_min, qy_max)
524
525	cal_res.addCallback(self.complete)
526
527	# logging.info("Computation is in progress...")
528	self.cmdCompute.setText('Wait...')
529	self.cmdCompute.setEnabled(False)
530	except:
531	raise
532
533	def complete(self, image):
534	"""
535	Complete computation
536	"""
537	self.image = image
538
539	# Get and format the sigmas
540	sigma_r = self.formatNumber(self.resolution.sigma_1)
541	sigma_phi = self.formatNumber(self.resolution.sigma_2)
542	sigma_lamd = self.formatNumber(self.resolution.sigma_lamd)
543	sigma_1d = self.formatNumber(self.resolution.sigma_1d)
544
545	# Set output values
546	self.txtSigma_x.setText(str(sigma_r))
547	self.txtSigma_y.setText(str(sigma_phi))
548	self.txtSigma_lamd.setText(str(sigma_lamd))
549	self.txt1DSigma.setText(str(sigma_1d))
550
551	self.cmdCompute.setText('Compute')
552	self.cmdCompute.setEnabled(True)
553
554	self.new2DPlot()
555
556	return
557
558	def map_wrapper(self, func, qx, qy, qx_min, qx_max, qy_min, qy_max):
559	"""
560	Prepare the Mapping for the computation
561	: params qx, qy, qx_min, qx_max, qy_min, qy_max:
562	: return: image (numpy array)
563	"""
564	image = map(func, qx, qy,
565	qx_min, qx_max,
566	qy_min, qy_max)[0]
567	return image
568
569	def calc_func(self, qx, qy, qx_min, qx_max, qy_min, qy_max):
570	"""
571	Perform the calculation for a given set of Q values.
572	: return: image (numpy array)
573	"""
574	try:
575	qx_value = float(qx)
576	qy_value = float(qy)
577	except :
578	raise ValueError
579
580	# calculate 2D resolution distribution image
581	image = self.resolution.compute_and_plot(qx_value, qy_value,
582	qx_min, qx_max, qy_min,
583	qy_max,
584	self.det_coordinate)
585	return image
586
587	# #################################
588	# Legacy validators
589	# #################################
590	def _string2list(self, input_string):
591	"""
592	Change NNN, NNN to list,ie. [NNN, NNN] where NNN is a number
593	"""
594	new_numbers_list = []
595	# check the number of floats
596	try:
597	strg = float(input_string)
598	new_numbers_list.append(strg)
599	except:
600	string_split = input_string.split(',')
601	if len(string_split) == 2:
602	str_1 = string_split[0]
603	str_2 = string_split[1]
604	new_numbers_list.append(float(str_1))
605	new_numbers_list.append(float(str_2))
606	elif len(string_split) == 1:
607	str_1 = string_split[0]
608	new_numbers_list.append(float(str_1))
609	else:
610	msg = "The numbers must be one or two (separated by ',')"
611	logging.info(msg)
612	raise RuntimeError, msg
613
614	return new_numbers_list
615
616	def _string2inputlist(self, input_string):
617	"""
618	Change NNN, NNN,... to list,ie. [NNN, NNN,...] where NNN is a number
619	: return new_list: string like list
620	"""
621	new_list = []
622	string_split = input_string.split(',')
623	try:
624	new_list = [float(t) for t in string_split]
625	except:
626	logging.error(sys.exc_value)
627	return new_list
628
629	def _str2longlist(self, input_string):
630	"""
631	Change NNN, NNN,... to list, NNN - NNN ; NNN to list, or float to list
632	: return new_string: string like list
633	"""
634	try:
635	# is float
636	out = [float(input_string)]
637	return out
638	except:
639	if self.cbWaveColor.currentText() == 'Monochromatic':
640	logging.warning("Wrong format of inputs.")
641	else:
642	try:
643	# has a '-'
644	if input_string.count('-') > 0:
645	value = input_string.split('-')
646	if value[1].count(';') > 0:
647	# has a ';'
648	last_list = value[1].split(';')
649	num = numpy.ceil(float(last_list[1]))
650	max_value = float(last_list[0])
651	self.num_wave = num
652	else:
653	# default num
654	num = self.num_wave
655	max_value = float(value[1])
656	min_value = float(value[0])
657	# make a list
658	bin_size = numpy.fabs(max_value - min_value) / (num - 1)
659	out = [min_value + bin_size * bnum for bnum in
660	range(num)]
661	return out
662	if input_string.count(',') > 0:
663	out = self._string2inputlist(input_string)
664	return out
665	except:
666	logging.error(sys.exc_value)
667
668	def _validate_q_input(self, qx, qy):
669	"""
670	Check if q inputs are valid
671	: params qx: qx as a list
672	: params qy: qy as a list
673	: return: True/False
674	"""
675	# check qualifications
676	if qx.__class__.__name__ != 'list':
677	return None
678	if qy.__class__.__name__ != 'list':
679	return None
680	if len(qx) < 1:
681	return None
682	if len(qy) < 1:
683	return None
684	# allow one input
685	if len(qx) == 1 and len(qy) > 1:
686	qx = [qx[0] for ind in range(len(qy))]
687
688	if len(qy) == 1 and len(qx) > 1:
689	qy = [qy[0] for ind in range(len(qx))]
690	# check length
691	if len(qx) != len(qy):
692	return None
693	if qx is None or qy is None:
694	return None
695	return qx, qy
696
697	def formatNumber(self, value=None):
698	"""
699	Return a float in a standardized, human-readable formatted string
700	"""
701	try:
702	value = float(value)
703	except:
704	output = None
705	return output
706
707	output = "%-7.4g" % value
708	return output.lstrip().rstrip()
709
710	# #################################
711	# Plot
712	# #################################
713
714	def createTemplate2DPlot(self):
715	"""
716	Create a template for 2D data
717	"""
718	self.plotter = Plotter2DWidget(self, quickplot=True)
719	self.plotter.scale = 'linear'
720	self.plotter.cmap = None
721	layout = QtGui.QHBoxLayout()
722	layout.setContentsMargins(0, 0, 0, 0)
723	self.graphicsView.setLayout(layout)
724	layout.addWidget(self.plotter)
725
726	def new2DPlot(self):
727	"""
728	Create a new 2D data instance based on computing results
729	"""
730	qx_min, qx_max, qy_min, qy_max = self.resolution.get_detector_qrange()
731
732	dx_size = (qx_max - qx_min) / (1000 - 1)
733	dy_size = (qy_max - qy_min) / (1000 - 1)
734	x_val = numpy.arange(qx_min, qx_max, dx_size)
735	y_val = numpy.arange(qy_max, qy_min, -dy_size)
736
737	self.drawLines()
738
739	self.plotter.data = Data2D(image=self.image,
740	qx_data=x_val,
741	qy_data=y_val,
742	xmin=qx_min, xmax=qx_max,
743	ymin=qy_min, ymax=qy_max)
744
745	self.plotter.plot()
746	self.plotter.show()
747
748	def drawLines(self):
749	"""
750	Draw lines in image if applicable
751	"""
752	wave_list, _ = self.resolution.get_wave_list()
753	if len(wave_list) > 1 and wave_list[-1] == max(wave_list):
754	color = 'g'
755	# draw a green rectangle(limit for the longest wavelength
756	# to be involved) for tof inputs
757	# Get the params from resolution
758	# plotting range for largest wavelength
759	qx_min = self.resolution.qx_min
760	qx_max = self.resolution.qx_max
761	qy_min = self.resolution.qy_min
762	qy_max = self.resolution.qy_max
763	# detector range
764	detector_qx_min = self.resolution.detector_qx_min
765	detector_qx_max = self.resolution.detector_qx_max
766	detector_qy_min = self.resolution.detector_qy_min
767	detector_qy_max = self.resolution.detector_qy_max
768
769	rect = patches.Rectangle((detector_qx_min + 0.0002,
770	detector_qy_min + 0.0002),
771	detector_qx_max - detector_qx_min,
772	detector_qy_max - detector_qy_min,
773	linewidth=2,
774	edgecolor=color, facecolor='none')
775	self.plotter.ax.add_patch(rect)
776	else:
777	qx_min, qx_max, qy_min, qy_max = self.resolution.get_detector_qrange()
778	# detector range
779	detector_qx_min = self.resolution.qxmin_limit
780	detector_qx_max = self.resolution.qxmax_limit
781	detector_qy_min = self.resolution.qymin_limit
782	detector_qy_max = self.resolution.qymax_limit
783
784	xmin = min(self.qx)
785	xmax = max(self.qx)
786	ymin = min(self.qy)
787	ymax = max(self.qy)
788
789	if xmin < detector_qx_min or xmax > detector_qx_max or \
790	ymin < detector_qy_min or ymax > detector_qy_max:
791	# message
792	msg = 'At least one q value located out side of\n'
793	msg += " the detector range (%s < qx < %s, %s < qy < %s),\n" % \
794	(self.formatNumber(detector_qx_min),
795	self.formatNumber(detector_qx_max),
796	self.formatNumber(detector_qy_min),
797	self.formatNumber(detector_qy_max))
798	msg += " is ignored in computation.\n"
799
800	logging.warning(msg)
801
802	# Draw zero axis lines.
803	if qy_min < 0 <= qy_max:
804	self.plotter.ax.axhline(linewidth=1)
805
806	if qx_min < 0 <= qx_max:
807	self.plotter.ax.axvline(linewidth=1)

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

SasView

source: sasview/src/sas/qtgui/Calculators/ResolutionCalculatorPanel.py @ fc4fec8

Download in other formats: