cansas_reader_HDF5.py @ b799f09

magnetic_scattrelease-4.2.2ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249unittest-saveload

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

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

SasView

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

Download in other formats: