ResolutionCalculatorPanel.py @ 7fd20fc

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 7fd20fc was e90988c, checked in by Piotr Rozyczko <rozyczko@…>, 7 years ago
Show help pages in default browser. Fixed some help links and modified unit tests. SASVIEW-800
Property mode set to `100644`
File size: 30.7 KB

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

Download in other formats: