GenericScatteringCalculator.py @ 62c6dc0

ESS_GUIESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalc

Last change on this file since 62c6dc0 was 30e0be0, checked in by Piotr Rozyczko <piotr.rozyczko@…>, 6 years ago
Updates to the scattering calculator SASVIEW-1147
Property mode set to `100644`
File size: 33.8 KB

Rev	Line
[dc5ef15]	1	import sys
	2	import os
	3	import numpy
	4	import logging
	5	import time
	6
[4992ff2]	7	from PyQt5 import QtCore
	8	from PyQt5 import QtGui
	9	from PyQt5 import QtWidgets
	10
[dc5ef15]	11	from twisted.internet import threads
	12
	13	import sas.qtgui.Utilities.GuiUtils as GuiUtils
	14	from sas.qtgui.Utilities.GenericReader import GenReader
	15	from sas.sascalc.dataloader.data_info import Detector
	16	from sas.sascalc.dataloader.data_info import Source
	17	from sas.sascalc.calculator import sas_gen
	18	from sas.qtgui.Plotting.PlotterBase import PlotterBase
	19	from sas.qtgui.Plotting.Plotter2D import Plotter2D
	20	from sas.qtgui.Plotting.Plotter import Plotter
[fef38e8]	21
[dc5ef15]	22	from sas.qtgui.Plotting.PlotterData import Data1D
	23	from sas.qtgui.Plotting.PlotterData import Data2D
	24
	25	# Local UI
[b3e8629]	26	from .UI.GenericScatteringCalculator import Ui_GenericScatteringCalculator
[dc5ef15]	27
	28	_Q1D_MIN = 0.001
	29
	30
[4992ff2]	31	class GenericScatteringCalculator(QtWidgets.QDialog, Ui_GenericScatteringCalculator):
[dc5ef15]	32
	33	trigger_plot_3d = QtCore.pyqtSignal()
[30e0be0]	34	calculationFinishedSignal = QtCore.pyqtSignal()
[dc5ef15]	35
	36	def __init__(self, parent=None):
	37	super(GenericScatteringCalculator, self).__init__()
	38	self.setupUi(self)
	39	self.manager = parent
	40	self.communicator = self.manager.communicator()
	41	self.model = sas_gen.GenSAS()
	42	self.omf_reader = sas_gen.OMFReader()
	43	self.sld_reader = sas_gen.SLDReader()
	44	self.pdb_reader = sas_gen.PDBReader()
	45	self.reader = None
	46	self.sld_data = None
	47
	48	self.parameters = []
	49	self.data = None
	50	self.datafile = None
	51	self.file_name = ''
	52	self.ext = None
	53	self.default_shape = str(self.cbShape.currentText())
	54	self.is_avg = False
	55	self.data_to_plot = None
[4d1eff2]	56	self.graph_num = 1 # index for name of graph
[dc5ef15]	57
	58	# combox box
	59	self.cbOptionsCalc.setVisible(False)
	60
	61	# push buttons
	62	self.cmdClose.clicked.connect(self.accept)
	63	self.cmdHelp.clicked.connect(self.onHelp)
	64
	65	self.cmdLoad.clicked.connect(self.loadFile)
	66	self.cmdCompute.clicked.connect(self.onCompute)
	67	self.cmdReset.clicked.connect(self.onReset)
	68	self.cmdSave.clicked.connect(self.onSaveFile)
	69
	70	self.cmdDraw.clicked.connect(lambda: self.plot3d(has_arrow=True))
	71	self.cmdDrawpoints.clicked.connect(lambda: self.plot3d(has_arrow=False))
	72
	73	# validators
	74	# scale, volume and background must be positive
	75	validat_regex_pos = QtCore.QRegExp('^[+]?([.]\d+\|\d+([.]\d+)?)$')
	76	self.txtScale.setValidator(QtGui.QRegExpValidator(validat_regex_pos,
	77	self.txtScale))
	78	self.txtBackground.setValidator(QtGui.QRegExpValidator(
	79	validat_regex_pos, self.txtBackground))
	80	self.txtTotalVolume.setValidator(QtGui.QRegExpValidator(
	81	validat_regex_pos, self.txtTotalVolume))
	82
	83	# fraction of spin up between 0 and 1
	84	validat_regexbetween0_1 = QtCore.QRegExp('^(0(\.\d)\|1(\.0+)?)$')
	85	self.txtUpFracIn.setValidator(
	86	QtGui.QRegExpValidator(validat_regexbetween0_1, self.txtUpFracIn))
	87	self.txtUpFracOut.setValidator(
	88	QtGui.QRegExpValidator(validat_regexbetween0_1, self.txtUpFracOut))
	89
	90	# 0 < Qmax <= 1000
	91	validat_regex_q = QtCore.QRegExp('^1000$\|^[+]?(\d{1,3}([.]\d+)?)$')
	92	self.txtQxMax.setValidator(QtGui.QRegExpValidator(validat_regex_q,
	93	self.txtQxMax))
	94	self.txtQxMax.textChanged.connect(self.check_value)
	95
	96	# 2 <= Qbin <= 1000
	97	self.txtNoQBins.setValidator(QtGui.QRegExpValidator(validat_regex_q,
	98	self.txtNoQBins))
	99	self.txtNoQBins.textChanged.connect(self.check_value)
	100
	101	# plots - 3D in real space
[4d1eff2]	102	self.trigger_plot_3d.connect(lambda: self.plot3d(has_arrow=False))
[dc5ef15]	103
[30e0be0]	104	# plots - 3D in real space
	105	self.calculationFinishedSignal.connect(self.plot_1_2d)
	106
[dc5ef15]	107	# TODO the option Ellipsoid has not been implemented
	108	self.cbShape.currentIndexChanged.connect(self.selectedshapechange)
	109
[457d961]	110	# New font to display angstrom symbol
	111	new_font = 'font-family: -apple-system, "Helvetica Neue", "Ubuntu";'
	112	self.lblUnitSolventSLD.setStyleSheet(new_font)
	113	self.lblUnitVolume.setStyleSheet(new_font)
	114	self.lbl5.setStyleSheet(new_font)
	115	self.lblUnitMx.setStyleSheet(new_font)
	116	self.lblUnitMy.setStyleSheet(new_font)
	117	self.lblUnitMz.setStyleSheet(new_font)
	118	self.lblUnitNucl.setStyleSheet(new_font)
	119	self.lblUnitx.setStyleSheet(new_font)
	120	self.lblUnity.setStyleSheet(new_font)
	121	self.lblUnitz.setStyleSheet(new_font)
	122
[dc5ef15]	123	def selectedshapechange(self):
	124	"""
	125	TODO Temporary solution to display information about option 'Ellipsoid'
	126	"""
[b3e8629]	127	print("The option Ellipsoid has not been implemented yet.")
[dc5ef15]	128	self.communicator.statusBarUpdateSignal.emit(
	129	"The option Ellipsoid has not been implemented yet.")
	130
	131	def loadFile(self):
	132	"""
	133	Open menu to choose the datafile to load
	134	Only extensions .SLD, .PDB, .OMF, .sld, .pdb, .omf
	135	"""
	136	try:
[4992ff2]	137	self.datafile = QtWidgets.QFileDialog.getOpenFileName(
[dc5ef15]	138	self, "Choose a file", "", "All Gen files (.OMF .omf) ;;"
	139	"SLD files (.SLD .sld);;PDB files (.pdb .PDB);; "
	140	"OMF files (.OMF .omf);; "
[fbfc488]	141	"All files (.)")[0]
[dc5ef15]	142	if self.datafile:
	143	self.default_shape = str(self.cbShape.currentText())
	144	self.file_name = os.path.basename(str(self.datafile))
	145	self.ext = os.path.splitext(str(self.datafile))[1]
	146	if self.ext in self.omf_reader.ext:
	147	loader = self.omf_reader
	148	elif self.ext in self.sld_reader.ext:
	149	loader = self.sld_reader
	150	elif self.ext in self.pdb_reader.ext:
	151	loader = self.pdb_reader
	152	else:
	153	loader = None
	154	# disable some entries depending on type of loaded file
	155	# (according to documentation)
	156	if self.ext.lower() in ['.sld', '.omf', '.pdb']:
	157	self.txtUpFracIn.setEnabled(False)
	158	self.txtUpFracOut.setEnabled(False)
	159	self.txtUpTheta.setEnabled(False)
	160
	161	if self.reader is not None and self.reader.isrunning():
	162	self.reader.stop()
	163	self.cmdLoad.setEnabled(False)
	164	self.cmdLoad.setText('Loading...')
	165	self.communicator.statusBarUpdateSignal.emit(
	166	"Loading File {}".format(os.path.basename(
	167	str(self.datafile))))
	168	self.reader = GenReader(path=str(self.datafile), loader=loader,
	169	completefn=self.complete_loading,
	170	updatefn=self.load_update)
	171	self.reader.queue()
	172	except (RuntimeError, IOError):
[b3e8629]	173	log_msg = "Generic SAS Calculator: %s" % sys.exc_info()[1]
[dc5ef15]	174	logging.info(log_msg)
	175	raise
	176	return
	177
	178	def load_update(self):
	179	""" Legacy function used in GenRead """
	180	if self.reader.isrunning():
	181	status_type = "progress"
	182	else:
	183	status_type = "stop"
	184	logging.info(status_type)
	185
	186	def complete_loading(self, data=None):
	187	""" Function used in GenRead"""
	188	self.cbShape.setEnabled(False)
	189	try:
	190	is_pdbdata = False
	191	self.txtData.setText(os.path.basename(str(self.datafile)))
	192	self.is_avg = False
	193	if self.ext in self.omf_reader.ext:
	194	gen = sas_gen.OMF2SLD()
	195	gen.set_data(data)
	196	self.sld_data = gen.get_magsld()
	197	self.check_units()
	198	elif self.ext in self.sld_reader.ext:
	199	self.sld_data = data
	200	elif self.ext in self.pdb_reader.ext:
	201	self.sld_data = data
	202	is_pdbdata = True
	203	# Display combobox of orientation only for pdb data
	204	self.cbOptionsCalc.setVisible(is_pdbdata)
	205	self.update_gui()
	206	except IOError:
	207	log_msg = "Loading Error: " \
	208	"This file format is not supported for GenSAS."
	209	logging.info(log_msg)
	210	raise
	211	except ValueError:
	212	log_msg = "Could not find any data"
	213	logging.info(log_msg)
	214	raise
	215	logging.info("Load Complete")
	216	self.cmdLoad.setEnabled(True)
	217	self.cmdLoad.setText('Load')
	218	self.trigger_plot_3d.emit()
	219
	220	def check_units(self):
	221	"""
	222	Check if the units from the OMF file correspond to the default ones
	223	displayed on the interface.
	224	If not, modify the GUI with the correct unit
	225	"""
	226	# TODO: adopt the convention of font and symbol for the updated values
	227	if sas_gen.OMFData().valueunit != 'A^(-2)':
	228	value_unit = sas_gen.OMFData().valueunit
	229	self.lbl_unitMx.setText(value_unit)
	230	self.lbl_unitMy.setText(value_unit)
	231	self.lbl_unitMz.setText(value_unit)
	232	self.lbl_unitNucl.setText(value_unit)
	233	if sas_gen.OMFData().meshunit != 'A':
	234	mesh_unit = sas_gen.OMFData().meshunit
	235	self.lbl_unitx.setText(mesh_unit)
	236	self.lbl_unity.setText(mesh_unit)
	237	self.lbl_unitz.setText(mesh_unit)
	238	self.lbl_unitVolume.setText(mesh_unit+"^3")
	239
	240	def check_value(self):
	241	"""Check range of text edits for QMax and Number of Qbins """
	242	text_edit = self.sender()
[7fb471d]	243	text_edit.setStyleSheet('background-color: rgb(255, 255, 255);')
[dc5ef15]	244	if text_edit.text():
	245	value = float(str(text_edit.text()))
	246	if text_edit == self.txtQxMax:
	247	if value <= 0 or value > 1000:
[7fb471d]	248	text_edit.setStyleSheet('background-color: rgb(255, 182, 193);')
[dc5ef15]	249	else:
[7fb471d]	250	text_edit.setStyleSheet('background-color: rgb(255, 255, 255);')
[dc5ef15]	251	elif text_edit == self.txtNoQBins:
	252	if value < 2 or value > 1000:
[7fb471d]	253	self.txtNoQBins.setStyleSheet('background-color: rgb(255, 182, 193);')
[dc5ef15]	254	else:
[7fb471d]	255	self.txtNoQBins.setStyleSheet('background-color: rgb(255, 255, 255);')
[dc5ef15]	256
	257	def update_gui(self):
	258	""" Update the interface with values from loaded data """
	259	self.model.set_is_avg(self.is_avg)
	260	self.model.set_sld_data(self.sld_data)
	261	self.model.params['total_volume'] = len(self.sld_data.sld_n)*self.sld_data.vol_pix[0]
	262
	263	# add condition for activation of save button
	264	self.cmdSave.setEnabled(True)
	265
	266	# activation of 3D plots' buttons (with and without arrows)
	267	self.cmdDraw.setEnabled(self.sld_data is not None)
	268	self.cmdDrawpoints.setEnabled(self.sld_data is not None)
	269
	270	self.txtScale.setText(str(self.model.params['scale']))
	271	self.txtBackground.setText(str(self.model.params['background']))
	272	self.txtSolventSLD.setText(str(self.model.params['solvent_SLD']))
	273
	274	# Volume to write to interface: npts x volume of first pixel
	275	self.txtTotalVolume.setText(str(len(self.sld_data.sld_n)*self.sld_data.vol_pix[0]))
	276
	277	self.txtUpFracIn.setText(str(self.model.params['Up_frac_in']))
	278	self.txtUpFracOut.setText(str(self.model.params['Up_frac_out']))
	279	self.txtUpTheta.setText(str(self.model.params['Up_theta']))
	280
	281	self.txtNoPixels.setText(str(len(self.sld_data.sld_n)))
	282	self.txtNoPixels.setEnabled(False)
	283
	284	list_parameters = ['sld_mx', 'sld_my', 'sld_mz', 'sld_n', 'xnodes',
	285	'ynodes', 'znodes', 'xstepsize', 'ystepsize',
	286	'zstepsize']
	287	list_gui_button = [self.txtMx, self.txtMy, self.txtMz, self.txtNucl,
	288	self.txtXnodes, self.txtYnodes, self.txtZnodes,
	289	self.txtXstepsize, self.txtYstepsize,
	290	self.txtZstepsize]
	291
	292	# Fill right hand side of GUI
	293	for indx, item in enumerate(list_parameters):
	294	if getattr(self.sld_data, item) is None:
	295	list_gui_button[indx].setText('NaN')
	296	else:
	297	value = getattr(self.sld_data, item)
	298	if isinstance(value, numpy.ndarray):
	299	item_for_gui = str(GuiUtils.formatNumber(numpy.average(value), True))
	300	else:
	301	item_for_gui = str(GuiUtils.formatNumber(value, True))
	302	list_gui_button[indx].setText(item_for_gui)
	303
	304	# Enable / disable editing of right hand side of GUI
	305	for indx, item in enumerate(list_parameters):
	306	if indx < 4:
	307	# this condition only applies to Mx,y,z and Nucl
	308	value = getattr(self.sld_data, item)
	309	enable = self.sld_data.pix_type == 'pixel' \
	310	and numpy.min(value) == numpy.max(value)
	311	else:
	312	enable = not self.sld_data.is_data
	313	list_gui_button[indx].setEnabled(enable)
	314
	315	def write_new_values_from_gui(self):
	316	"""
	317	update parameters using modified inputs from GUI
	318	used before computing
	319	"""
	320	if self.txtScale.isModified():
	321	self.model.params['scale'] = float(self.txtScale.text())
	322
	323	if self.txtBackground.isModified():
	324	self.model.params['background'] = float(self.txtBackground.text())
	325
	326	if self.txtSolventSLD.isModified():
	327	self.model.params['solvent_SLD'] = float(self.txtSolventSLD.text())
	328
	329	# Different condition for total volume to get correct volume after
	330	# applying set_sld_data in compute
	331	if self.txtTotalVolume.isModified() \
	332	or self.model.params['total_volume'] != float(self.txtTotalVolume.text()):
	333	self.model.params['total_volume'] = float(self.txtTotalVolume.text())
	334
	335	if self.txtUpFracIn.isModified():
	336	self.model.params['Up_frac_in'] = float(self.txtUpFracIn.text())
	337
	338	if self.txtUpFracOut.isModified():
	339	self.model.params['Up_frac_out'] = float(self.txtUpFracOut.text())
	340
	341	if self.txtUpTheta.isModified():
	342	self.model.params['Up_theta'] = float(self.txtUpTheta.text())
	343
	344	if self.txtMx.isModified():
	345	self.sld_data.sld_mx = float(self.txtMx.text())*\
	346	numpy.ones(len(self.sld_data.sld_mx))
	347
	348	if self.txtMy.isModified():
	349	self.sld_data.sld_my = float(self.txtMy.text())*\
	350	numpy.ones(len(self.sld_data.sld_my))
	351
	352	if self.txtMz.isModified():
	353	self.sld_data.sld_mz = float(self.txtMz.text())*\
	354	numpy.ones(len(self.sld_data.sld_mz))
	355
	356	if self.txtNucl.isModified():
	357	self.sld_data.sld_n = float(self.txtNucl.text())*\
	358	numpy.ones(len(self.sld_data.sld_n))
	359
	360	if self.txtXnodes.isModified():
	361	self.sld_data.xnodes = int(self.txtXnodes.text())
	362
	363	if self.txtYnodes.isModified():
	364	self.sld_data.ynodes = int(self.txtYnodes.text())
	365
	366	if self.txtZnodes.isModified():
	367	self.sld_data.znodes = int(self.txtZnodes.text())
	368
	369	if self.txtXstepsize.isModified():
	370	self.sld_data.xstepsize = float(self.txtXstepsize.text())
	371
	372	if self.txtYstepsize.isModified():
	373	self.sld_data.ystepsize = float(self.txtYstepsize.text())
	374
	375	if self.txtZstepsize.isModified():
	376	self.sld_data.zstepsize = float(self.txtZstepsize.text())
	377
	378	if self.cbOptionsCalc.isVisible():
	379	self.is_avg = (self.cbOptionsCalc.currentIndex() == 1)
	380
	381	def onHelp(self):
	382	"""
	383	Bring up the Generic Scattering calculator Documentation whenever
	384	the HELP button is clicked.
	385	Calls Documentation Window with the path of the location within the
	386	documentation tree (after /doc/ ....".
	387	"""
[aed0532]	388	location = "/user/qtgui/Calculators/sas_calculator_help.html"
[e90988c]	389	self.manager.showHelp(location)
[dc5ef15]	390
	391	def onReset(self):
	392	""" Reset the inputs of textEdit to default values """
	393	try:
	394	# reset values in textedits
	395	self.txtUpFracIn.setText("1.0")
	396	self.txtUpFracOut.setText("1.0")
	397	self.txtUpTheta.setText("0.0")
	398	self.txtBackground.setText("0.0")
	399	self.txtScale.setText("1.0")
	400	self.txtSolventSLD.setText("0.0")
	401	self.txtTotalVolume.setText("216000.0")
	402	self.txtNoQBins.setText("50")
	403	self.txtQxMax.setText("0.3")
	404	self.txtNoPixels.setText("1000")
	405	self.txtMx.setText("0")
	406	self.txtMy.setText("0")
	407	self.txtMz.setText("0")
	408	self.txtNucl.setText("6.97e-06")
	409	self.txtXnodes.setText("10")
	410	self.txtYnodes.setText("10")
	411	self.txtZnodes.setText("10")
	412	self.txtXstepsize.setText("6")
	413	self.txtYstepsize.setText("6")
	414	self.txtZstepsize.setText("6")
	415	# reset Load button and textedit
	416	self.txtData.setText('Default SLD Profile')
	417	self.cmdLoad.setEnabled(True)
	418	self.cmdLoad.setText('Load')
	419	# reset option for calculation
	420	self.cbOptionsCalc.setCurrentIndex(0)
	421	self.cbOptionsCalc.setVisible(False)
	422	# reset shape button
	423	self.cbShape.setCurrentIndex(0)
	424	self.cbShape.setEnabled(True)
	425	# reset compute button
	426	self.cmdCompute.setText('Compute')
	427	self.cmdCompute.setEnabled(True)
	428	# TODO reload default data set
	429	self._create_default_sld_data()
	430
	431	finally:
	432	pass
	433
	434	def _create_default_2d_data(self):
	435	"""
	436	Copied from previous version
	437	Create 2D data by default
	438	:warning: This data is never plotted.
	439	"""
	440	self.qmax_x = float(self.txtQxMax.text())
	441	self.npts_x = int(self.txtNoQBins.text())
	442	self.data = Data2D()
	443	self.data.is_data = False
	444	# # Default values
	445	self.data.detector.append(Detector())
	446	index = len(self.data.detector) - 1
	447	self.data.detector[index].distance = 8000 # mm
	448	self.data.source.wavelength = 6 # A
	449	self.data.detector[index].pixel_size.x = 5 # mm
	450	self.data.detector[index].pixel_size.y = 5 # mm
	451	self.data.detector[index].beam_center.x = self.qmax_x
	452	self.data.detector[index].beam_center.y = self.qmax_x
	453	xmax = self.qmax_x
	454	xmin = -xmax
	455	ymax = self.qmax_x
	456	ymin = -ymax
	457	qstep = self.npts_x
	458
	459	x = numpy.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True)
	460	y = numpy.linspace(start=ymin, stop=ymax, num=qstep, endpoint=True)
	461	# use data info instead
	462	new_x = numpy.tile(x, (len(y), 1))
	463	new_y = numpy.tile(y, (len(x), 1))
	464	new_y = new_y.swapaxes(0, 1)
	465	# all data require now in 1d array
	466	qx_data = new_x.flatten()
	467	qy_data = new_y.flatten()
	468	q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data)
	469	# set all True (standing for unmasked) as default
	470	mask = numpy.ones(len(qx_data), dtype=bool)
	471	self.data.source = Source()
	472	self.data.data = numpy.ones(len(mask))
	473	self.data.err_data = numpy.ones(len(mask))
	474	self.data.qx_data = qx_data
	475	self.data.qy_data = qy_data
	476	self.data.q_data = q_data
	477	self.data.mask = mask
	478	# store x and y bin centers in q space
	479	self.data.x_bins = x
	480	self.data.y_bins = y
	481	# max and min taking account of the bin sizes
	482	self.data.xmin = xmin
	483	self.data.xmax = xmax
	484	self.data.ymin = ymin
	485	self.data.ymax = ymax
	486
	487	def _create_default_sld_data(self):
	488	"""
	489	Copied from previous version
	490	Making default sld-data
	491	"""
	492	sld_n_default = 6.97e-06 # what is this number??
	493	omfdata = sas_gen.OMFData()
	494	omf2sld = sas_gen.OMF2SLD()
	495	omf2sld.set_data(omfdata, self.default_shape)
	496	self.sld_data = omf2sld.output
	497	self.sld_data.is_data = False
	498	self.sld_data.filename = "Default SLD Profile"
	499	self.sld_data.set_sldn(sld_n_default)
	500
	501	def _create_default_1d_data(self):
	502	"""
	503	Copied from previous version
	504	Create 1D data by default
	505	:warning: This data is never plotted.
	506	residuals.x = data_copy.x[index]
	507	residuals.dy = numpy.ones(len(residuals.y))
	508	residuals.dx = None
	509	residuals.dxl = None
	510	residuals.dxw = None
	511	"""
	512	self.qmax_x = float(self.txtQxMax.text())
	513	self.npts_x = int(self.txtNoQBins.text())
	514	# Default values
	515	xmax = self.qmax_x
	516	xmin = self.qmax_x * _Q1D_MIN
	517	qstep = self.npts_x
	518	x = numpy.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True)
	519	# store x and y bin centers in q space
	520	y = numpy.ones(len(x))
	521	dy = numpy.zeros(len(x))
	522	dx = numpy.zeros(len(x))
	523	self.data = Data1D(x=x, y=y)
	524	self.data.dx = dx
	525	self.data.dy = dy
	526
	527	def onCompute(self):
	528	"""
	529	Copied from previous version
	530	Execute the computation of I(qx, qy)
	531	"""
	532	# Set default data when nothing loaded yet
	533	if self.sld_data is None:
	534	self._create_default_sld_data()
	535	try:
	536	self.model.set_sld_data(self.sld_data)
	537	self.write_new_values_from_gui()
	538	if self.is_avg or self.is_avg is None:
	539	self._create_default_1d_data()
	540	i_out = numpy.zeros(len(self.data.y))
	541	inputs = [self.data.x, [], i_out]
	542	else:
	543	self._create_default_2d_data()
	544	i_out = numpy.zeros(len(self.data.data))
	545	inputs = [self.data.qx_data, self.data.qy_data, i_out]
	546	logging.info("Computation is in progress...")
	547	self.cmdCompute.setText('Wait...')
	548	self.cmdCompute.setEnabled(False)
	549	d = threads.deferToThread(self.complete, inputs, self._update)
	550	# Add deferred callback for call return
[30e0be0]	551	#d.addCallback(self.plot_1_2d)
	552	d.addCallback(self.calculateComplete)
[7fb471d]	553	d.addErrback(self.calculateFailed)
[dc5ef15]	554	except:
[b3e8629]	555	log_msg = "{}. stop".format(sys.exc_info()[1])
[dc5ef15]	556	logging.info(log_msg)
	557	return
	558
	559	def _update(self, value):
	560	"""
	561	Copied from previous version
	562	"""
	563	pass
	564
[7fb471d]	565	def calculateFailed(self, reason):
	566	"""
	567	"""
	568	print("Calculate Failed with:\n", reason)
	569	pass
	570
[30e0be0]	571	def calculateComplete(self, d):
	572	"""
	573	Notify the main thread
	574	"""
	575	self.calculationFinishedSignal.emit()
	576
[dc5ef15]	577	def complete(self, input, update=None):
	578	"""
	579	Gen compute complete function
	580	:Param input: input list [qx_data, qy_data, i_out]
	581	"""
	582	out = numpy.empty(0)
	583	for ind in range(len(input[0])):
	584	if self.is_avg:
	585	if ind % 1 == 0 and update is not None:
	586	# update()
	587	percentage = int(100.0 * float(ind) / len(input[0]))
	588	update(percentage)
	589	time.sleep(0.001) # 0.1
	590	inputi = [input[0][ind:ind + 1], [], input[2][ind:ind + 1]]
	591	outi = self.model.run(inputi)
	592	out = numpy.append(out, outi)
	593	else:
	594	if ind % 50 == 0 and update is not None:
	595	percentage = int(100.0 * float(ind) / len(input[0]))
	596	update(percentage)
	597	time.sleep(0.001)
	598	inputi = [input[0][ind:ind + 1], input[1][ind:ind + 1],
	599	input[2][ind:ind + 1]]
	600	outi = self.model.runXY(inputi)
	601	out = numpy.append(out, outi)
	602	self.data_to_plot = out
	603	logging.info('Gen computation completed.')
	604	self.cmdCompute.setText('Compute')
	605	self.cmdCompute.setEnabled(True)
	606	return
	607
	608	def onSaveFile(self):
	609	"""Save data as .sld file"""
	610	path = os.path.dirname(str(self.datafile))
	611	default_name = os.path.join(path, 'sld_file')
	612	kwargs = {
	613	'parent': self,
	614	'directory': default_name,
	615	'filter': 'SLD file (*.sld)',
[4992ff2]	616	'options': QtWidgets.QFileDialog.DontUseNativeDialog}
[dc5ef15]	617	# Query user for filename.
[d6b8a1d]	618	filename_tuple = QtWidgets.QFileDialog.getSaveFileName(**kwargs)
[53c771e]	619	filename = filename_tuple[0]
[dc5ef15]	620	if filename:
	621	try:
[d6b8a1d]	622	_, extension = os.path.splitext(filename)
	623	if not extension:
	624	filename = '.'.join((filename, 'sld'))
	625	sas_gen.SLDReader().write(filename, self.sld_data)
[dc5ef15]	626	except:
	627	raise
	628
	629	def plot3d(self, has_arrow=False):
	630	""" Generate 3D plot in real space with or without arrows """
	631	self.write_new_values_from_gui()
	632	graph_title = " Graph {}: {} 3D SLD Profile".format(self.graph_num,
	633	self.file_name)
	634	if has_arrow:
	635	graph_title += ' - Magnetic Vector as Arrow'
	636
	637	plot3D = Plotter3D(self, graph_title)
	638	plot3D.plot(self.sld_data, has_arrow=has_arrow)
	639	plot3D.show()
	640	self.graph_num += 1
	641
[30e0be0]	642	def plot_1_2d(self):
[dc5ef15]	643	""" Generate 1D or 2D plot, called in Compute"""
	644	if self.is_avg or self.is_avg is None:
	645	data = Data1D(x=self.data.x, y=self.data_to_plot)
	646	data.title = "GenSAS {} #{} 1D".format(self.file_name,
	647	int(self.graph_num))
	648	data.xaxis('\\rm{Q_{x}}', '\AA^{-1}')
	649	data.yaxis('\\rm{Intensity}', 'cm^{-1}')
[30e0be0]	650	plot1D = Plotter(self, quickplot=True)
[dc5ef15]	651	plot1D.plot(data)
	652	plot1D.show()
	653	self.graph_num += 1
	654	# TODO
[b3e8629]	655	print('TRANSFER OF DATA TO MAIN PANEL TO BE IMPLEMENTED')
[dc5ef15]	656	return plot1D
	657	else:
	658	numpy.nan_to_num(self.data_to_plot)
	659	data = Data2D(image=self.data_to_plot,
	660	qx_data=self.data.qx_data,
	661	qy_data=self.data.qy_data,
	662	q_data=self.data.q_data,
	663	xmin=self.data.xmin, xmax=self.data.ymax,
	664	ymin=self.data.ymin, ymax=self.data.ymax,
	665	err_image=self.data.err_data)
	666	data.title = "GenSAS {} #{} 2D".format(self.file_name,
	667	int(self.graph_num))
[30e0be0]	668	plot2D = Plotter2D(self, quickplot=True)
[dc5ef15]	669	plot2D.plot(data)
	670	plot2D.show()
	671	self.graph_num += 1
	672	# TODO
[b3e8629]	673	print('TRANSFER OF DATA TO MAIN PANEL TO BE IMPLEMENTED')
[dc5ef15]	674	return plot2D
	675
	676
	677	class Plotter3DWidget(PlotterBase):
	678	"""
	679	3D Plot widget for use with a QDialog
	680	"""
	681	def __init__(self, parent=None, manager=None):
	682	super(Plotter3DWidget, self).__init__(parent, manager=manager)
	683
	684	@property
	685	def data(self):
	686	return self._data
	687
	688	@data.setter
	689	def data(self, data=None):
	690	""" data setter """
	691	self._data = data
	692
	693	def plot(self, data=None, has_arrow=False):
	694	"""
	695	Plot 3D self._data
	696	"""
[4d1eff2]	697	if not data:
	698	return
[dc5ef15]	699	self.data = data
[4d1eff2]	700	#assert(self._data)
[dc5ef15]	701	# Prepare and show the plot
	702	self.showPlot(data=self.data, has_arrow=has_arrow)
	703
	704	def showPlot(self, data, has_arrow=False):
	705	"""
	706	Render and show the current data
	707	"""
	708	# If we don't have any data, skip.
	709	if data is None:
	710	return
[fef38e8]	711	# This import takes forever - place it here so the main UI starts faster
	712	from mpl_toolkits.mplot3d import Axes3D
[dc5ef15]	713	color_dic = {'H': 'blue', 'D': 'purple', 'N': 'orange',
	714	'O': 'red', 'C': 'green', 'P': 'cyan', 'Other': 'k'}
	715	marker = ','
	716	m_size = 2
	717
	718	pos_x = data.pos_x
	719	pos_y = data.pos_y
	720	pos_z = data.pos_z
	721	sld_mx = data.sld_mx
	722	sld_my = data.sld_my
	723	sld_mz = data.sld_mz
	724	pix_symbol = data.pix_symbol
	725	sld_tot = numpy.fabs(sld_mx) + numpy.fabs(sld_my) + \
	726	numpy.fabs(sld_mz) + numpy.fabs(data.sld_n)
	727	is_nonzero = sld_tot > 0.0
	728	is_zero = sld_tot == 0.0
	729
	730	if data.pix_type == 'atom':
	731	marker = 'o'
	732	m_size = 3.5
	733
	734	self.figure.clear()
	735	self.figure.subplots_adjust(left=0.1, right=.8, bottom=.1)
	736	ax = Axes3D(self.figure)
	737	ax.set_xlabel('x ($\A{}$)'.format(data.pos_unit))
	738	ax.set_ylabel('z ($\A{}$)'.format(data.pos_unit))
	739	ax.set_zlabel('y ($\A{}$)'.format(data.pos_unit))
	740
	741	# I. Plot null points
	742	if is_zero.any():
	743	im = ax.plot(pos_x[is_zero], pos_z[is_zero], pos_y[is_zero],
	744	marker, c="y", alpha=0.5, markeredgecolor='y',
	745	markersize=m_size)
	746	pos_x = pos_x[is_nonzero]
	747	pos_y = pos_y[is_nonzero]
	748	pos_z = pos_z[is_nonzero]
	749	sld_mx = sld_mx[is_nonzero]
	750	sld_my = sld_my[is_nonzero]
	751	sld_mz = sld_mz[is_nonzero]
	752	pix_symbol = data.pix_symbol[is_nonzero]
	753	# II. Plot selective points in color
	754	other_color = numpy.ones(len(pix_symbol), dtype='bool')
[b3e8629]	755	for key in list(color_dic.keys()):
[dc5ef15]	756	chosen_color = pix_symbol == key
	757	if numpy.any(chosen_color):
	758	other_color = other_color & (chosen_color!=True)
	759	color = color_dic[key]
	760	im = ax.plot(pos_x[chosen_color], pos_z[chosen_color],
	761	pos_y[chosen_color], marker, c=color, alpha=0.5,
	762	markeredgecolor=color, markersize=m_size, label=key)
	763	# III. Plot All others
	764	if numpy.any(other_color):
	765	a_name = ''
	766	if data.pix_type == 'atom':
	767	# Get atom names not in the list
	768	a_names = [symb for symb in pix_symbol \
[b3e8629]	769	if symb not in list(color_dic.keys())]
[dc5ef15]	770	a_name = a_names[0]
	771	for name in a_names:
	772	new_name = ", " + name
	773	if a_name.count(name) == 0:
	774	a_name += new_name
	775	# plot in black
	776	im = ax.plot(pos_x[other_color], pos_z[other_color],
	777	pos_y[other_color], marker, c="k", alpha=0.5,
	778	markeredgecolor="k", markersize=m_size, label=a_name)
	779	if data.pix_type == 'atom':
	780	ax.legend(loc='upper left', prop={'size': 10})
	781	# IV. Draws atomic bond with grey lines if any
	782	if data.has_conect:
	783	for ind in range(len(data.line_x)):
	784	im = ax.plot(data.line_x[ind], data.line_z[ind],
	785	data.line_y[ind], '-', lw=0.6, c="grey",
	786	alpha=0.3)
	787	# V. Draws magnetic vectors
	788	if has_arrow and len(pos_x) > 0:
	789	def _draw_arrow(input=None, update=None):
[fef38e8]	790	# import moved here for performance reasons
	791	from sas.qtgui.Plotting.Arrow3D import Arrow3D
[dc5ef15]	792	"""
	793	draw magnetic vectors w/arrow
	794	"""
	795	max_mx = max(numpy.fabs(sld_mx))
	796	max_my = max(numpy.fabs(sld_my))
	797	max_mz = max(numpy.fabs(sld_mz))
	798	max_m = max(max_mx, max_my, max_mz)
	799	try:
	800	max_step = max(data.xstepsize, data.ystepsize, data.zstepsize)
	801	except:
	802	max_step = 0
	803	if max_step <= 0:
	804	max_step = 5
	805	try:
	806	if max_m != 0:
	807	unit_x2 = sld_mx / max_m
	808	unit_y2 = sld_my / max_m
	809	unit_z2 = sld_mz / max_m
	810	# 0.8 is for avoiding the color becomes white=(1,1,1))
	811	color_x = numpy.fabs(unit_x2 * 0.8)
	812	color_y = numpy.fabs(unit_y2 * 0.8)
	813	color_z = numpy.fabs(unit_z2 * 0.8)
	814	x2 = pos_x + unit_x2 * max_step
	815	y2 = pos_y + unit_y2 * max_step
	816	z2 = pos_z + unit_z2 * max_step
	817	x_arrow = numpy.column_stack((pos_x, x2))
	818	y_arrow = numpy.column_stack((pos_y, y2))
	819	z_arrow = numpy.column_stack((pos_z, z2))
	820	colors = numpy.column_stack((color_x, color_y, color_z))
	821	arrows = Arrow3D(self.figure, x_arrow, z_arrow, y_arrow,
	822	colors, mutation_scale=10, lw=1,
	823	arrowstyle="->", alpha=0.5)
	824	ax.add_artist(arrows)
	825	except:
	826	pass
	827	log_msg = "Arrow Drawing completed.\n"
	828	logging.info(log_msg)
	829	log_msg = "Arrow Drawing is in progress..."
	830	logging.info(log_msg)
	831
	832	# Defer the drawing of arrows to another thread
	833	d = threads.deferToThread(_draw_arrow, ax)
	834
	835	self.figure.canvas.resizing = False
	836	self.figure.canvas.draw()
	837
[30e0be0]	838	def createContextMenu(self):
	839	"""
	840	Define common context menu and associated actions for the MPL widget
	841	"""
	842	return
	843
	844	def createContextMenuQuick(self):
	845	"""
	846	Define context menu and associated actions for the quickplot MPL widget
	847	"""
	848	return
	849
[dc5ef15]	850
[4992ff2]	851	class Plotter3D(QtWidgets.QDialog, Plotter3DWidget):
[dc5ef15]	852	def __init__(self, parent=None, graph_title=''):
	853	self.graph_title = graph_title
[4992ff2]	854	QtWidgets.QDialog.__init__(self)
[dc5ef15]	855	Plotter3DWidget.__init__(self, manager=parent)
	856	self.setWindowTitle(self.graph_title)
	857

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

SasView

source: sasview/src/sas/qtgui/Calculators/GenericScatteringCalculator.py @ 62c6dc0

Download in other formats: