cansas_reader_HDF5.py @ 082239e

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.1.1release-4.1.2release-4.2.2ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload

Last change on this file since 082239e was 082239e, checked in by krzywon, 7 years ago
Modify the cansas HDF5 reader to comply with the NXcanSAS-1.0 release format, plus linting.
Property mode set to `100644`
File size: 27.6 KB

Rev	Line
[68aa210]	1	"""
	2	CanSAS 2D data reader for reading HDF5 formatted CanSAS files.
	3	"""
	4
	5	import h5py
	6	import numpy as np
	7	import re
	8	import os
	9	import sys
	10
[082239e]	11	from sas.sascalc.dataloader.data_info import plottable_1D, plottable_2D,\
	12	Data1D, Data2D, DataInfo, Process, Aperture, Collimation, \
	13	TransmissionSpectrum, Detector
[d72567e]	14	from sas.sascalc.dataloader.data_info import combine_data_info_with_plottable
	15
[68aa210]	16
	17	class Reader():
	18	"""
[082239e]	19	A class for reading in CanSAS v2.0 data files. The existing iteration opens
	20	Mantid generated HDF5 formatted files with file extension .h5/.H5. Any
	21	number of data sets may be present within the file and any dimensionality
	22	of data may be used. Currently 1D and 2D SAS data sets are supported, but
	23	future implementations will include 1D and 2D SESANS data.
[d72567e]	24
[082239e]	25	Any number of SASdata sets may be present in a SASentry and the data within
	26	can be either 1D I(Q) or 2D I(Qx, Qy).
[68aa210]	27
[5e906207]	28	Also supports reading NXcanSAS formatted HDF5 files
	29
[68aa210]	30	:Dependencies:
[d72567e]	31	The CanSAS HDF5 reader requires h5py => v2.5.0 or later.
[68aa210]	32	"""
	33
[082239e]	34	# CanSAS version
[68aa210]	35	cansas_version = 2.0
[082239e]	36	# Logged warnings or messages
[68aa210]	37	logging = None
[082239e]	38	# List of errors for the current data set
[68aa210]	39	errors = None
[082239e]	40	# Raw file contents to be processed
[68aa210]	41	raw_data = None
[082239e]	42	# Data info currently being read in
[d72567e]	43	current_datainfo = None
[082239e]	44	# SASdata set currently being read in
[68aa210]	45	current_dataset = None
[082239e]	46	# List of plottable1D objects that should be linked to the current_datainfo
[d72567e]	47	data1d = None
[082239e]	48	# List of plottable2D objects that should be linked to the current_datainfo
[d72567e]	49	data2d = None
[082239e]	50	# Data type name
[ad52d31]	51	type_name = "CanSAS 2.0"
[082239e]	52	# Wildcards
[ad52d31]	53	type = ["CanSAS 2.0 HDF5 Files (.h5)\|.h5"]
[082239e]	54	# List of allowed extensions
[68aa210]	55	ext = ['.h5', '.H5']
[082239e]	56	# Flag to bypass extension check
[68aa210]	57	allow_all = False
[082239e]	58	# List of files to return
[68aa210]	59	output = None
	60
	61	def read(self, filename):
	62	"""
[ad52d31]	63	This is the general read method that all SasView data_loaders must have.
[68aa210]	64
	65	:param filename: A path for an HDF5 formatted CanSAS 2D data file.
[d72567e]	66	:return: List of Data1D/2D objects and/or a list of errors.
[68aa210]	67	"""
[082239e]	68	# Reinitialize when loading a new data file to reset all class variables
[d72567e]	69	self.reset_class_variables()
[082239e]	70	# Check that the file exists
[68aa210]	71	if os.path.isfile(filename):
	72	basename = os.path.basename(filename)
	73	_, extension = os.path.splitext(basename)
	74	# If the file type is not allowed, return empty list
	75	if extension in self.ext or self.allow_all:
[082239e]	76	# Load the data file
[68aa210]	77	self.raw_data = h5py.File(filename, 'r')
[082239e]	78	# Read in all child elements of top level SASroot
[d72567e]	79	self.read_children(self.raw_data, [])
[082239e]	80	# Add the last data set to the list of outputs
[68aa210]	81	self.add_data_set()
[082239e]	82	# Close the data file
[995f4eb]	83	self.raw_data.close()
[082239e]	84	# Return data set(s)
[68aa210]	85	return self.output
	86
[d72567e]	87	def reset_class_variables(self):
	88	"""
	89	Create the reader object and define initial states for class variables
	90	"""
	91	self.current_datainfo = None
	92	self.current_dataset = None
	93	self.data1d = []
	94	self.data2d = []
	95	self.raw_data = None
	96	self.errors = set()
	97	self.logging = []
	98	self.output = []
	99	self.parent_class = u''
	100	self.detector = Detector()
	101	self.collimation = Collimation()
	102	self.aperture = Aperture()
	103	self.process = Process()
	104	self.trans_spectrum = TransmissionSpectrum()
	105
	106	def read_children(self, data, parent_list):
[68aa210]	107	"""
[ad52d31]	108	A recursive method for stepping through the hierarchical data file.
[68aa210]	109
	110	:param data: h5py Group object of any kind
	111	:param parent: h5py Group parent name
	112	"""
	113
[082239e]	114	# Loop through each element of the parent and process accordingly
[68aa210]	115	for key in data.keys():
[082239e]	116	# Get all information for the current key
[68aa210]	117	value = data.get(key)
[d398285]	118	if value.attrs.get(u'canSAS_class') is not None:
	119	class_name = value.attrs.get(u'canSAS_class')
	120	else:
	121	class_name = value.attrs.get(u'NX_class')
[68aa210]	122	if class_name is not None:
	123	class_prog = re.compile(class_name)
	124	else:
	125	class_prog = re.compile(value.name)
	126
	127	if isinstance(value, h5py.Group):
[d72567e]	128	self.parent_class = class_name
	129	parent_list.append(key)
[082239e]	130	# If a new sasentry, store the current data sets and create
	131	# a fresh Data1D/2D object
[68aa210]	132	if class_prog.match(u'SASentry'):
	133	self.add_data_set(key)
[d72567e]	134	elif class_prog.match(u'SASdata'):
	135	self._initialize_new_data_set(parent_list)
[082239e]	136	# Recursion step to access data within the group
[d72567e]	137	self.read_children(value, parent_list)
	138	self.add_intermediate()
	139	parent_list.remove(key)
[68aa210]	140
	141	elif isinstance(value, h5py.Dataset):
[082239e]	142	# If this is a dataset, store the data appropriately
[68aa210]	143	data_set = data[key][:]
[7bd6860a]	144	unit = self._get_unit(value)
[ac370c5]	145
[082239e]	146	# I and Q Data
[7bd6860a]	147	if key == u'I':
[082239e]	148	if isinstance(self.current_dataset, plottable_2D):
[ac370c5]	149	self.current_dataset.data = data_set
[7bd6860a]	150	self.current_dataset.zaxis("Intensity", unit)
	151	else:
	152	self.current_dataset.y = data_set.flatten()
	153	self.current_dataset.yaxis("Intensity", unit)
	154	continue
	155	elif key == u'Idev':
[082239e]	156	if isinstance(self.current_dataset, plottable_2D):
[7bd6860a]	157	self.current_dataset.err_data = data_set.flatten()
	158	else:
	159	self.current_dataset.dy = data_set.flatten()
	160	continue
	161	elif key == u'Q':
	162	self.current_dataset.xaxis("Q", unit)
[082239e]	163	if isinstance(self.current_dataset, plottable_2D):
[7bd6860a]	164	self.current_dataset.q = data_set.flatten()
	165	else:
	166	self.current_dataset.x = data_set.flatten()
	167	continue
[bbd0f37]	168	elif key == u'Qdev':
	169	self.current_dataset.dx = data_set.flatten()
	170	continue
[082239e]	171	elif key == u'dQw':
	172	self.current_dataset.dxw = data_set.flatten()
	173	continue
	174	elif key == u'dQl':
	175	self.current_dataset.dxl = data_set.flatten()
	176	continue
[7bd6860a]	177	elif key == u'Qy':
	178	self.current_dataset.yaxis("Q_y", unit)
	179	self.current_dataset.qy_data = data_set.flatten()
	180	continue
	181	elif key == u'Qydev':
	182	self.current_dataset.dqy_data = data_set.flatten()
	183	continue
	184	elif key == u'Qx':
	185	self.current_dataset.xaxis("Q_x", unit)
	186	self.current_dataset.qx_data = data_set.flatten()
	187	continue
	188	elif key == u'Qxdev':
	189	self.current_dataset.dqx_data = data_set.flatten()
	190	continue
	191	elif key == u'Mask':
	192	self.current_dataset.mask = data_set.flatten()
	193	continue
[082239e]	194	# Transmission Spectrum
	195	elif key == u'T' and self.parent_class == \
	196	u'SAStransmission_spectrum':
	197	self.trans_spectrum.transmission = data_set.flatten()
	198	continue
	199	elif key == u'Tdev' and self.parent_class == \
	200	u'SAStransmission_spectrum':
	201	self.trans_spectrum.transmission_deviation = \
	202	data_set.flatten()
	203	continue
	204	elif key == u'lambda' and self.parent_class == \
	205	u'SAStransmission_spectrum':
	206	self.trans_spectrum.wavelength = data_set.flatten()
	207	continue
[68aa210]	208
	209	for data_point in data_set:
[082239e]	210	# Top Level Meta Data
[68aa210]	211	if key == u'definition':
[d72567e]	212	self.current_datainfo.meta_data['reader'] = data_point
[68aa210]	213	elif key == u'run':
[d72567e]	214	self.current_datainfo.run.append(data_point)
[be88076]	215	try:
	216	run_name = value.attrs['name']
	217	run_dict = {data_point: run_name}
	218	self.current_datainfo.run_name = run_dict
	219	except:
	220	pass
[68aa210]	221	elif key == u'title':
[d72567e]	222	self.current_datainfo.title = data_point
[68aa210]	223	elif key == u'SASnote':
[d72567e]	224	self.current_datainfo.notes.append(data_point)
[68aa210]	225
[082239e]	226	# Sample Information
	227	# CanSAS 2.0 format
	228	elif key == u'Title' and self.parent_class == u'SASsample':
[d72567e]	229	self.current_datainfo.sample.name = data_point
[082239e]	230	# NXcanSAS format
	231	elif key == u'name' and self.parent_class == u'SASsample':
[88d85c6]	232	self.current_datainfo.sample.name = data_point
[082239e]	233	# NXcanSAS format
	234	elif key == u'ID' and self.parent_class == u'SASsample':
	235	self.current_datainfo.sample.name = data_point
	236	elif key == u'thickness' and self.parent_class == \
	237	u'SASsample':
[d72567e]	238	self.current_datainfo.sample.thickness = data_point
[082239e]	239	elif key == u'temperature' and self.parent_class == \
	240	u'SASsample':
[d72567e]	241	self.current_datainfo.sample.temperature = data_point
[082239e]	242	elif key == u'transmission' and self.parent_class == \
	243	u'SASsample':
[5e906207]	244	self.current_datainfo.sample.transmission = data_point
[082239e]	245	elif key == u'x_position' and self.parent_class == \
	246	u'SASsample':
[5e906207]	247	self.current_datainfo.sample.position.x = data_point
[082239e]	248	elif key == u'y_position' and self.parent_class == \
	249	u'SASsample':
[5e906207]	250	self.current_datainfo.sample.position.y = data_point
[082239e]	251	elif key == u'pitch' and self.parent_class == u'SASsample':
[5e906207]	252	self.current_datainfo.sample.orientation.x = data_point
[082239e]	253	elif key == u'yaw' and self.parent_class == u'SASsample':
	254	self.current_datainfo.sample.orientation.y = data_point
	255	elif key == u'roll' and self.parent_class == u'SASsample':
[5e906207]	256	self.current_datainfo.sample.orientation.z = data_point
[082239e]	257	elif key == u'details' and self.parent_class == \
	258	u'SASsample':
[5e906207]	259	self.current_datainfo.sample.details.append(data_point)
[68aa210]	260
[082239e]	261	# Instrumental Information
	262	elif key == u'name' and self.parent_class == \
	263	u'SASinstrument':
[d72567e]	264	self.current_datainfo.instrument = data_point
	265	elif key == u'name' and self.parent_class == u'SASdetector':
[ad52d31]	266	self.detector.name = data_point
[d72567e]	267	elif key == u'SDD' and self.parent_class == u'SASdetector':
	268	self.detector.distance = float(data_point)
[d398285]	269	self.detector.distance_unit = unit
[082239e]	270	elif key == u'slit_length' and self.parent_class == \
	271	u'SASdetector':
[5e906207]	272	self.detector.slit_length = float(data_point)
	273	self.detector.slit_length_unit = unit
[082239e]	274	elif key == u'x_position' and self.parent_class == \
	275	u'SASdetector':
[5e906207]	276	self.detector.offset.x = float(data_point)
	277	self.detector.offset_unit = unit
[082239e]	278	elif key == u'y_position' and self.parent_class == \
	279	u'SASdetector':
[5e906207]	280	self.detector.offset.y = float(data_point)
	281	self.detector.offset_unit = unit
[082239e]	282	elif key == u'pitch' and self.parent_class == \
	283	u'SASdetector':
[5e906207]	284	self.detector.orientation.x = float(data_point)
	285	self.detector.orientation_unit = unit
[082239e]	286	elif key == u'roll' and self.parent_class == u'SASdetector':
[5e906207]	287	self.detector.orientation.z = float(data_point)
	288	self.detector.orientation_unit = unit
[082239e]	289	elif key == u'yaw' and self.parent_class == u'SASdetector':
	290	self.detector.orientation.y = float(data_point)
	291	self.detector.orientation_unit = unit
	292	elif key == u'beam_center_x' and self.parent_class == \
	293	u'SASdetector':
[5e906207]	294	self.detector.beam_center.x = float(data_point)
	295	self.detector.beam_center_unit = unit
[082239e]	296	elif key == u'beam_center_y' and self.parent_class == \
	297	u'SASdetector':
[5e906207]	298	self.detector.beam_center.y = float(data_point)
	299	self.detector.beam_center_unit = unit
[082239e]	300	elif key == u'x_pixel_size' and self.parent_class == \
	301	u'SASdetector':
[5e906207]	302	self.detector.pixel_size.x = float(data_point)
	303	self.detector.pixel_size_unit = unit
[082239e]	304	elif key == u'y_pixel_size' and self.parent_class == \
	305	u'SASdetector':
[5e906207]	306	self.detector.pixel_size.y = float(data_point)
	307	self.detector.pixel_size_unit = unit
[082239e]	308	elif key == u'distance' and self.parent_class == \
	309	u'SAScollimation':
[ad52d31]	310	self.collimation.length = data_point
[d398285]	311	self.collimation.length_unit = unit
[082239e]	312	elif key == u'name' and self.parent_class == \
	313	u'SAScollimation':
[ad52d31]	314	self.collimation.name = data_point
[082239e]	315	elif key == u'shape' and self.parent_class == \
	316	u'SASaperture':
	317	self.aperture.shape = data_point
	318	elif key == u'x_gap' and self.parent_class == \
	319	u'SASaperture':
	320	self.aperture.size.x = data_point
	321	elif key == u'y_gap' and self.parent_class == \
	322	u'SASaperture':
	323	self.aperture.size.y = data_point
	324
	325	# Process Information
	326	elif key == u'Title' and self.parent_class == \
	327	u'SASprocess': # CanSAS 2.0 format
[68aa210]	328	self.process.name = data_point
[082239e]	329	elif key == u'name' and self.parent_class == \
	330	u'SASprocess': # NXcanSAS format
[68aa210]	331	self.process.name = data_point
[082239e]	332	elif key == u'description' and self.parent_class == \
	333	u'SASprocess':
[68aa210]	334	self.process.description = data_point
[d72567e]	335	elif key == u'date' and self.parent_class == u'SASprocess':
[68aa210]	336	self.process.date = data_point
[082239e]	337	elif key == u'term' and self.parent_class == u'SASprocess':
	338	self.process.term = data_point
[d72567e]	339	elif self.parent_class == u'SASprocess':
[ad52d31]	340	self.process.notes.append(data_point)
	341
[082239e]	342	# Source
	343	elif key == u'wavelength' and self.parent_class == \
	344	u'SASdata':
[d72567e]	345	self.current_datainfo.source.wavelength = data_point
[5e906207]	346	self.current_datainfo.source.wavelength_unit = unit
[082239e]	347	elif key == u'incident_wavelength' and self.parent_class == \
	348	u'SASsource':
[5e906207]	349	self.current_datainfo.source.wavelength = data_point
	350	self.current_datainfo.source.wavelength_unit = unit
[082239e]	351	elif key == u'wavelength_max' and self.parent_class == \
	352	u'SASsource':
[5e906207]	353	self.current_datainfo.source.wavelength_max = data_point
	354	self.current_datainfo.source.wavelength_max_unit = unit
[082239e]	355	elif key == u'wavelength_min' and self.parent_class == \
	356	u'SASsource':
[5e906207]	357	self.current_datainfo.source.wavelength_min = data_point
	358	self.current_datainfo.source.wavelength_min_unit = unit
[082239e]	359	elif key == u'incident_wavelength_spread' and \
	360	self.parent_class == u'SASsource':
	361	self.current_datainfo.source.wavelength_spread = \
	362	data_point
	363	self.current_datainfo.source.wavelength_spread_unit = \
	364	unit
	365	elif key == u'beam_size_x' and self.parent_class == \
	366	u'SASsource':
[5e906207]	367	self.current_datainfo.source.beam_size.x = data_point
	368	self.current_datainfo.source.beam_size_unit = unit
[082239e]	369	elif key == u'beam_size_y' and self.parent_class == \
	370	u'SASsource':
[5e906207]	371	self.current_datainfo.source.beam_size.y = data_point
	372	self.current_datainfo.source.beam_size_unit = unit
[082239e]	373	elif key == u'beam_shape' and self.parent_class == \
	374	u'SASsource':
[5e906207]	375	self.current_datainfo.source.beam_shape = data_point
[082239e]	376	elif key == u'radiation' and self.parent_class == \
	377	u'SASsource':
[d72567e]	378	self.current_datainfo.source.radiation = data_point
[082239e]	379	elif key == u'transmission' and self.parent_class == \
	380	u'SASdata':
[d72567e]	381	self.current_datainfo.sample.transmission = data_point
[68aa210]	382
[082239e]	383	# Everything else goes in meta_data
[68aa210]	384	else:
[082239e]	385	new_key = self._create_unique_key(
	386	self.current_datainfo.meta_data, key)
[d72567e]	387	self.current_datainfo.meta_data[new_key] = data_point
[68aa210]	388
	389	else:
[082239e]	390	# I don't know if this reachable code
[68aa210]	391	self.errors.add("ShouldNeverHappenException")
	392
[d72567e]	393	def add_intermediate(self):
[ad52d31]	394	"""
[082239e]	395	This method stores any intermediate objects within the final data set
	396	after fully reading the set.
[ad52d31]	397
[082239e]	398	:param parent: The NXclass name for the h5py Group object that just
	399	finished being processed
[ad52d31]	400	"""
	401
[d72567e]	402	if self.parent_class == u'SASprocess':
	403	self.current_datainfo.process.append(self.process)
[ad52d31]	404	self.process = Process()
[d72567e]	405	elif self.parent_class == u'SASdetector':
	406	self.current_datainfo.detector.append(self.detector)
[ad52d31]	407	self.detector = Detector()
[d72567e]	408	elif self.parent_class == u'SAStransmission_spectrum':
	409	self.current_datainfo.trans_spectrum.append(self.trans_spectrum)
[ad52d31]	410	self.trans_spectrum = TransmissionSpectrum()
[d72567e]	411	elif self.parent_class == u'SAScollimation':
	412	self.current_datainfo.collimation.append(self.collimation)
[ad52d31]	413	self.collimation = Collimation()
[d72567e]	414	elif self.parent_class == u'SASaperture':
[ad52d31]	415	self.collimation.aperture.append(self.aperture)
	416	self.aperture = Aperture()
[d72567e]	417	elif self.parent_class == u'SASdata':
[082239e]	418	if isinstance(self.current_dataset, plottable_2D):
[d72567e]	419	self.data2d.append(self.current_dataset)
[082239e]	420	elif isinstance(self.current_dataset, plottable_1D):
[d72567e]	421	self.data1d.append(self.current_dataset)
[68aa210]	422
	423	def final_data_cleanup(self):
	424	"""
[082239e]	425	Does some final cleanup and formatting on self.current_datainfo and
	426	all data1D and data2D objects and then combines the data and info into
	427	Data1D and Data2D objects
[68aa210]	428	"""
	429
[082239e]	430	# Type cast data arrays to float64
[d72567e]	431	if len(self.current_datainfo.trans_spectrum) > 0:
[ad52d31]	432	spectrum_list = []
[d72567e]	433	for spectrum in self.current_datainfo.trans_spectrum:
[ad52d31]	434	spectrum.transmission = np.delete(spectrum.transmission, [0])
	435	spectrum.transmission = spectrum.transmission.astype(np.float64)
[082239e]	436	spectrum.transmission_deviation = np.delete(
	437	spectrum.transmission_deviation, [0])
	438	spectrum.transmission_deviation = \
	439	spectrum.transmission_deviation.astype(np.float64)
[ad52d31]	440	spectrum.wavelength = np.delete(spectrum.wavelength, [0])
	441	spectrum.wavelength = spectrum.wavelength.astype(np.float64)
[d72567e]	442	if len(spectrum.transmission) > 0:
	443	spectrum_list.append(spectrum)
	444	self.current_datainfo.trans_spectrum = spectrum_list
[68aa210]	445
[082239e]	446	# Append errors to dataset and reset class errors
[d72567e]	447	self.current_datainfo.errors = self.errors
[68aa210]	448	self.errors.clear()
	449
[082239e]	450	# Combine all plottables with datainfo and append each to output
	451	# Type cast data arrays to float64 and find min/max as appropriate
[d72567e]	452	for dataset in self.data2d:
	453	dataset.data = dataset.data.astype(np.float64)
	454	dataset.err_data = dataset.err_data.astype(np.float64)
	455	if dataset.qx_data is not None:
	456	dataset.xmin = np.min(dataset.qx_data)
	457	dataset.xmax = np.max(dataset.qx_data)
	458	dataset.qx_data = dataset.qx_data.astype(np.float64)
	459	if dataset.dqx_data is not None:
	460	dataset.dqx_data = dataset.dqx_data.astype(np.float64)
	461	if dataset.qy_data is not None:
	462	dataset.ymin = np.min(dataset.qy_data)
	463	dataset.ymax = np.max(dataset.qy_data)
	464	dataset.qy_data = dataset.qy_data.astype(np.float64)
	465	if dataset.dqy_data is not None:
	466	dataset.dqy_data = dataset.dqy_data.astype(np.float64)
	467	if dataset.q_data is not None:
	468	dataset.q_data = dataset.q_data.astype(np.float64)
	469	zeros = np.ones(dataset.data.size, dtype=bool)
	470	try:
[082239e]	471	for i in range(0, dataset.mask.size - 1):
[d72567e]	472	zeros[i] = dataset.mask[i]
	473	except:
	474	self.errors.add(sys.exc_value)
	475	dataset.mask = zeros
[082239e]	476	# Calculate the actual Q matrix
[d72567e]	477	try:
	478	if dataset.q_data.size <= 1:
[082239e]	479	dataset.q_data = np.sqrt(dataset.qx_data * dataset.qx_data +
	480	dataset.qy_data * dataset.qy_data)
[d72567e]	481	except:
	482	dataset.q_data = None
[ac370c5]	483
	484	if dataset.data.ndim == 2:
	485	(n_rows, n_cols) = dataset.data.shape
[479799c]	486	dataset.y_bins = dataset.qy_data[0::n_cols]
[ac370c5]	487	dataset.x_bins = dataset.qx_data[:n_cols]
	488	dataset.data = dataset.data.flatten()
	489
[082239e]	490	final_dataset = combine_data_info_with_plottable(
	491	dataset, self.current_datainfo)
[d72567e]	492	self.output.append(final_dataset)
	493
	494	for dataset in self.data1d:
	495	if dataset.x is not None:
	496	dataset.x = dataset.x.astype(np.float64)
	497	dataset.xmin = np.min(dataset.x)
	498	dataset.xmax = np.max(dataset.x)
	499	if dataset.y is not None:
	500	dataset.y = dataset.y.astype(np.float64)
	501	dataset.ymin = np.min(dataset.y)
	502	dataset.ymax = np.max(dataset.y)
	503	if dataset.dx is not None:
	504	dataset.dx = dataset.dx.astype(np.float64)
	505	if dataset.dxl is not None:
	506	dataset.dxl = dataset.dxl.astype(np.float64)
	507	if dataset.dxw is not None:
	508	dataset.dxw = dataset.dxw.astype(np.float64)
	509	if dataset.dy is not None:
	510	dataset.dy = dataset.dy.astype(np.float64)
[082239e]	511	final_dataset = combine_data_info_with_plottable(
	512	dataset, self.current_datainfo)
[d72567e]	513	self.output.append(final_dataset)
	514
[68aa210]	515	def add_data_set(self, key=""):
	516	"""
[082239e]	517	Adds the current_dataset to the list of outputs after preforming final
	518	processing on the data and then calls a private method to generate a
	519	new data set.
[68aa210]	520
	521	:param key: NeXus group name for current tree level
	522	"""
[d72567e]	523
	524	if self.current_datainfo and self.current_dataset:
[68aa210]	525	self.final_data_cleanup()
[d72567e]	526	self.data1d = []
	527	self.data2d = []
	528	self.current_datainfo = DataInfo()
[68aa210]	529
[54ba66e]	530
[082239e]	531	def _initialize_new_data_set(self, parent_list=None):
[68aa210]	532	"""
[082239e]	533	A private class method to generate a new 1D or 2D data object based on
	534	the type of data within the set. Outside methods should call
	535	add_data_set() to be sure any existing data is stored properly.
[68aa210]	536
[d72567e]	537	:param parent_list: List of names of parent elements
[68aa210]	538	"""
[d72567e]	539
	540	if parent_list is None:
	541	parent_list = []
	542	if self._find_intermediate(parent_list, "Qx"):
	543	self.current_dataset = plottable_2D()
[68aa210]	544	else:
	545	x = np.array(0)
	546	y = np.array(0)
[d72567e]	547	self.current_dataset = plottable_1D(x, y)
	548	self.current_datainfo.filename = self.raw_data.filename
[68aa210]	549
[d72567e]	550	def _find_intermediate(self, parent_list, basename=""):
[ad52d31]	551	"""
[082239e]	552	A private class used to find an entry by either using a direct key or
	553	knowing the approximate basename.
[ad52d31]	554
[082239e]	555	:param parent_list: List of parents nodes in the HDF5 file
[d72567e]	556	:param basename: Approximate name of an entry to search for
[ad52d31]	557	:return:
	558	"""
[d72567e]	559
	560	entry = False
	561	key_prog = re.compile(basename)
	562	top = self.raw_data
	563	for parent in parent_list:
	564	top = top.get(parent)
	565	for key in top.keys():
[082239e]	566	if key_prog.match(key):
[d72567e]	567	entry = True
	568	break
[ad52d31]	569	return entry
	570
[68aa210]	571	def _create_unique_key(self, dictionary, name, numb=0):
	572	"""
	573	Create a unique key value for any dictionary to prevent overwriting
	574	Recurses until a unique key value is found.
	575
	576	:param dictionary: A dictionary with any number of entries
	577	:param name: The index of the item to be added to dictionary
	578	:param numb: The number to be appended to the name, starts at 0
[d72567e]	579	:return: The new name for the dictionary entry
[68aa210]	580	"""
	581	if dictionary.get(name) is not None:
	582	numb += 1
	583	name = name.split("_")[0]
	584	name += "_{0}".format(numb)
	585	name = self._create_unique_key(dictionary, name, numb)
[d398285]	586	return name
	587
	588	def _get_unit(self, value):
	589	"""
	590	Find the unit for a particular value within the h5py dictionary
	591
	592	:param value: attribute dictionary for a particular value set
[d72567e]	593	:return: unit for the value passed to the method
[d398285]	594	"""
	595	unit = value.attrs.get(u'units')
	596	if unit == None:
	597	unit = value.attrs.get(u'unit')
[082239e]	598	# Convert the unit formats
[d398285]	599	if unit == "1/A":
	600	unit = "A^{-1}"
	601	elif unit == "1/cm":
	602	unit = "cm^{-1}"
[54ba66e]	603	return unit

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

SasView

source: sasview/src/sas/sascalc/dataloader/readers/cansas_reader_HDF5.py @ 082239e

Download in other formats: