hdf5_dump Namespace Reference

Classes
class	DAQDataFile

Functions
	tick_to_timestamp (ticks, clock_speed_hz)
	unpack_header (data_array, entry_type, required_version=0)
	print_header_dict (hdict, clock_speed_hz)
	print_trigger_record_header (data_array, clock_speed_hz, k_list_components)
	print_fragment_header (data_array, clock_speed_hz)
	print_header (data_array, record_type, clock_speed_hz, k_list_components)
	parse_args ()
	main ()

Variables
int	FILELAYOUT_MIN_VERSION = 4
int	FILELAYOUT_MAX_VERSION = 7
int	TRIGGER_RECORD_HEADER_VERSION = 4
int	FRAGMENT_HEADER_VERSION = 5
int	TIME_SLICE_HEADER_VERSION = 2
dict	DATA_FORMAT

Function Documentation

main()

hdf5_dump.main

(

)

Definition at line 326 of file hdf5_dump.py.

def main():
    args = parse_args()
    if args.print_out is None and args.check_fragments is False and \
            args.binary_output is None:
        print("Error: use at least one of the two following options:")
        print("       -p, --print-out {header, fragment, both}")
        print("       -c, --check-fragments")
        print("       -b, --binary-output")
        return
 
    h5 = DAQDataFile(args.file_name)
 
    if args.binary_output is not None:
        h5.convert_to_binary(args.binary_output, args.num_of_records)
    if args.print_out is not None:
        h5.set_clock_speed_hz(args.speed_of_clock)
        h5.printout(args.print_out, args.num_of_records, args.list_components)
    if args.check_fragments:
        h5.check_fragments(args.num_of_records)
 
    return
 
 

parse_args()

hdf5_dump.parse_args

(

)

Definition at line 283 of file hdf5_dump.py.

def parse_args():
    parser = argparse.ArgumentParser(
        description='Python script to parse DUNE-DAQ HDF5 output files.')
 
    parser.add_argument('-f', '--file-name',
                        help='path to HDF5 file',
                        required=True)
 
    parser.add_argument('-b', '--binary-output',
                        help='convert to the specified binary file')
 
    parser.add_argument('-p', '--print-out', action='append',
                        choices=['header', 'fragment', 'both', 'attributes',
                                 'all'],
                        help='''select which part of data to be displayed, this
                        option can be repeated multiple times, "-p both" is
                        equivalent to "-p header -p fragment", "-p all" is
                        equivalent to "-p attributes -p header -p fragment"''')
 
    parser.add_argument('-c', '--check-fragments',
                        help='''check if fragments written in trigger record
                        matches expected number in trigger record header''',
                        action='store_true')
 
    parser.add_argument('-l', '--list-components',
                        help='''list components in trigger record header, used
                        with "--print-out header" or "--print-out both", not
                        applicable to TimeSlice data''', action='store_true')
 
    parser.add_argument('-n', '--num-of-records', type=int,
                        help='specify number of records to be parsed',
                        default=0)
 
    parser.add_argument('-s', '--speed-of-clock', type=float,
                        help='''specify clock speed in Hz, default is
                        62500000.0 (62.5MHz)''',
                        default=62500000.0)
 
    parser.add_argument('-v', '--version', action='version',
                        version='%(prog)s 2.0')
    return parser.parse_args()
 
 

print_fragment_header()

hdf5_dump.print_fragment_header	(		data_array,
			clock_speed_hz )

Definition at line 267 of file hdf5_dump.py.

def print_fragment_header(data_array, clock_speed_hz):
    print_header_dict(unpack_header(data_array, "Fragment Header", FRAGMENT_HEADER_VERSION), clock_speed_hz)
    return
 
 

print_header()

hdf5_dump.print_header	(		data_array,
			record_type,
			clock_speed_hz,
			k_list_components )

Definition at line 272 of file hdf5_dump.py.

def print_header(data_array, record_type, clock_speed_hz, k_list_components):
    if record_type == "TriggerRecord":
        print_trigger_record_header(data_array, clock_speed_hz,
                                    k_list_components)
    elif record_type == "TimeSlice":
        print_header_dict(unpack_header(data_array, "TimeSlice Header", TIME_SLICE_HEADER_VERSION), clock_speed_hz)
    else:
        print(f"Error: Record Type {record_type} is not supported.")
    return
 
 

print_header_dict()

hdf5_dump.print_header_dict	(		hdict,
			clock_speed_hz )

Definition at line 231 of file hdf5_dump.py.

def print_header_dict(hdict, clock_speed_hz):
    filtered_list = ['Padding', 'Source ID version', 'Component request version']
    for ik, iv in hdict.items():
        if any(map(ik.__contains__, filtered_list)):
            continue
        elif "time" in ik or "begin" in ik or "end" in ik:
            print("{:<30}: {} ({})".format(
                ik, iv, tick_to_timestamp(iv, clock_speed_hz)))
        elif 'Marker word' in ik:
            print("{:<30}: {}".format(ik, hex(iv)))
        elif ik == 'Detector':
            subdet = detdataformats.DetID.Subdetector(iv)
            det_name = detdataformats.DetID.subdetector_to_string(subdet)
            print("{:<30}: {}".format(ik, det_name))
        elif ik == 'Source ID subsystem' in ik:
            subsys = daqdataformats.SourceID.Subsystem(iv)
            subsys_name = daqdataformats.SourceID.subsystem_to_string(subsys)
            print("{:<30}: {}".format(ik, subsys_name))
        else:
            print("{:<30}: {}".format(ik, iv))
    return
 
 

print_trigger_record_header()

hdf5_dump.print_trigger_record_header	(		data_array,
			clock_speed_hz,
			k_list_components )

Definition at line 254 of file hdf5_dump.py.

def print_trigger_record_header(data_array, clock_speed_hz, k_list_components):
    print_header_dict(unpack_header(data_array, "TriggerRecord Header", TRIGGER_RECORD_HEADER_VERSION), clock_speed_hz)
 
    if k_list_components:
        comp_keys = DATA_FORMAT["Component Request"]["keys"]
        comp_unpack_string = DATA_FORMAT["Component Request"]["unpack string"]
        for i_values in struct.iter_unpack(comp_unpack_string, data_array[64:]):
            i_comp = dict(zip(comp_keys, i_values))
            print(80*'-')
            print_header_dict(i_comp, clock_speed_hz)
    return
 
 

tick_to_timestamp()

hdf5_dump.tick_to_timestamp	(		ticks,
			clock_speed_hz )

Definition at line 214 of file hdf5_dump.py.

def tick_to_timestamp(ticks, clock_speed_hz):
    ns = float(ticks)/clock_speed_hz
    if ns < 3000000000:
        return datetime.datetime.fromtimestamp(ns)
    else:
        return "InvalidDateString"
 
 

unpack_header()

hdf5_dump.unpack_header	(		data_array,
			entry_type,
			required_version = 0 )

Definition at line 222 of file hdf5_dump.py.

def unpack_header(data_array, entry_type, required_version=0):
    values = struct.unpack(DATA_FORMAT[entry_type]["unpack string"],
                           data_array[:DATA_FORMAT[entry_type]["size"]])
    if required_version > 0 and len(values) >= 2 and values[1] != required_version:
        raise ValueError(f"Invalid {entry_type} format version: expected {required_version} and found {values[1]}")
    header = dict(zip(DATA_FORMAT[entry_type]["keys"], values))
    return header
 
 

Variable Documentation

DATA_FORMAT

dict hdf5_dump.DATA_FORMAT

Definition at line 22 of file hdf5_dump.py.

FILELAYOUT_MAX_VERSION

int hdf5_dump.FILELAYOUT_MAX_VERSION = 7

Definition at line 15 of file hdf5_dump.py.

FILELAYOUT_MIN_VERSION

int hdf5_dump.FILELAYOUT_MIN_VERSION = 4

Definition at line 14 of file hdf5_dump.py.

FRAGMENT_HEADER_VERSION

int hdf5_dump.FRAGMENT_HEADER_VERSION = 5

Definition at line 19 of file hdf5_dump.py.

TIME_SLICE_HEADER_VERSION

int hdf5_dump.TIME_SLICE_HEADER_VERSION = 2

Definition at line 20 of file hdf5_dump.py.

TRIGGER_RECORD_HEADER_VERSION

int hdf5_dump.TRIGGER_RECORD_HEADER_VERSION = 4

Definition at line 18 of file hdf5_dump.py.