Line data Source code
1 : /**
2 : * @file streamed_TPs_to_text.cxx Dump streamed TPs from an HDF5 into the text format used by trigger
3 : *
4 : * This is part of the DUNE DAQ Application Framework, copyright 2020.
5 : * Licensing/copyright details are in the COPYING file that you should have
6 : * received with this code.
7 : */
8 : #include "CLI/CLI.hpp"
9 :
10 : #include "trgdataformats/TriggerObjectOverlay.hpp"
11 : #include "trgdataformats/TriggerPrimitive.hpp"
12 : #include "hdf5libs/HDF5RawDataFile.hpp"
13 :
14 : #include <daqdataformats/Fragment.hpp>
15 : #include <daqdataformats/SourceID.hpp>
16 : #include <daqdataformats/TimeSlice.hpp>
17 : #include <daqdataformats/TimeSliceHeader.hpp>
18 : #include <daqdataformats/Types.hpp>
19 :
20 : #include <iostream>
21 :
22 : using dunedaq::trgdataformats::TriggerActivity;
23 : using dunedaq::trgdataformats::TriggerActivityData;
24 : using dunedaq::trgdataformats::TriggerCandidate;
25 : using dunedaq::trgdataformats::TriggerPrimitive;
26 :
27 : void
28 0 : print_tp(const TriggerPrimitive& prim, size_t offset = 0)
29 : {
30 0 : for (size_t i = 0; i < offset; ++i)
31 0 : std::cout << "\t";
32 0 : std::cout << "\t" << prim.time_start << "\t" << prim.samples_over_threshold << "\t" << prim.samples_to_peak << "\t"
33 0 : << prim.channel << "\t" << prim.adc_integral << "\t" << prim.adc_peak << "\t" << prim.detid << "\t"
34 0 : << std::endl;
35 0 : }
36 :
37 : void
38 0 : print_tps(std::unique_ptr<dunedaq::daqdataformats::Fragment>&& frag, size_t offset = 0)
39 : {
40 0 : size_t payload_size = frag->get_size() - sizeof(dunedaq::daqdataformats::FragmentHeader);
41 0 : size_t n_tps = payload_size / sizeof(TriggerPrimitive);
42 0 : size_t remainder = payload_size % sizeof(TriggerPrimitive);
43 0 : assert(remainder == 0);
44 0 : const TriggerPrimitive* prim = reinterpret_cast<TriggerPrimitive*>(frag->get_data());
45 0 : std::cout << "Trigger primitives for SourceID [" << frag->get_element_id() << "]" << std::endl;
46 0 : for (size_t i = 0; i < n_tps; ++i) {
47 0 : print_tp(*prim, offset);
48 0 : ++prim;
49 : }
50 0 : }
51 :
52 : void
53 0 : print_ta(const TriggerActivity& activity)
54 : {
55 0 : std::cout << "\t" << activity.data.time_start << "\t" << activity.data.time_end << "\t" << activity.data.channel_start
56 0 : << "\t" << activity.data.channel_end << std::endl;
57 0 : std::cout << "\tInput TPs:" << std::endl;
58 0 : for (size_t i = 0; i < activity.n_inputs; ++i) {
59 0 : const TriggerPrimitive& prim = activity.inputs[i];
60 0 : print_tp(prim, 1);
61 : }
62 0 : std::cout << std::endl;
63 0 : }
64 :
65 : void
66 0 : print_tas(std::unique_ptr<dunedaq::daqdataformats::Fragment>&& frag)
67 : {
68 0 : size_t payload_size = frag->get_size() - sizeof(dunedaq::daqdataformats::FragmentHeader);
69 :
70 0 : std::cout << "Trigger activities for SourceID [" << frag->get_element_id() << "]" << std::endl;
71 : // The fragment contains a number of variable-sized TAs stored
72 : // contiguously so we can't calculate the number of TAs a priori. We
73 : // have to do this pointer arithmetic business while looping over
74 : // the items in the fragment
75 0 : char* buffer = static_cast<char*>(frag->get_data());
76 0 : size_t offset = 0;
77 0 : const TriggerActivity* activity = reinterpret_cast<TriggerActivity*>(buffer);
78 0 : while (offset < payload_size) {
79 0 : print_ta(*activity);
80 0 : offset += sizeof(TriggerActivity) + activity->n_inputs * sizeof(TriggerActivity::input_t);
81 0 : activity = reinterpret_cast<TriggerActivity*>(buffer + offset);
82 : }
83 0 : }
84 :
85 : void
86 0 : print_ta_data(const dunedaq::trgdataformats::TriggerActivityData& ta_data)
87 : {
88 0 : std::cout << "\t\t" << ta_data.time_start << "\t" << ta_data.time_end << "\t" << ta_data.channel_start << "\t"
89 0 : << ta_data.channel_end << std::endl;
90 0 : }
91 :
92 : void
93 0 : print_tc(const TriggerCandidate& candidate)
94 : {
95 0 : std::cout << "\t" << candidate.data.time_start << "\t" << candidate.data.time_end << std::endl;
96 0 : std::cout << "\tInput TAs:" << std::endl;
97 0 : for (size_t i = 0; i < candidate.n_inputs; ++i) {
98 0 : const TriggerActivityData& activity_data = candidate.inputs[i];
99 0 : print_ta_data(activity_data);
100 : }
101 0 : std::cout << std::endl;
102 0 : }
103 :
104 : void
105 0 : print_tcs(std::unique_ptr<dunedaq::daqdataformats::Fragment>&& frag)
106 : {
107 0 : size_t payload_size = frag->get_size() - sizeof(dunedaq::daqdataformats::FragmentHeader);
108 :
109 0 : std::cout << "Trigger candidates for SourceID [" << frag->get_element_id() << "]" << std::endl;
110 : // The fragment contains a number of variable-sized TCs stored
111 : // contiguously so we can't calculate the number of TCs a priori. We
112 : // have to do this pointer arithmetic business while looping over
113 : // the items in the fragment
114 0 : char* buffer = static_cast<char*>(frag->get_data());
115 0 : size_t offset = 0;
116 0 : const TriggerCandidate* candidate = reinterpret_cast<TriggerCandidate*>(buffer);
117 0 : while (offset < payload_size) {
118 0 : print_tc(*candidate);
119 0 : offset += sizeof(TriggerCandidate) + candidate->n_inputs * sizeof(TriggerCandidate::input_t);
120 0 : candidate = reinterpret_cast<TriggerCandidate*>(buffer + offset);
121 : }
122 0 : }
123 :
124 : int
125 0 : main(int argc, char** argv)
126 : {
127 0 : CLI::App app{ "Print DS fragments from an HDF5 file" };
128 :
129 0 : std::string in_filename;
130 0 : app.add_option("-i,--input", in_filename, "Input HDF5 file");
131 :
132 0 : CLI11_PARSE(app, argc, argv);
133 :
134 0 : dunedaq::hdf5libs::HDF5RawDataFile hdf5file(in_filename);
135 :
136 0 : auto record_ids = hdf5file.get_all_trigger_record_ids();
137 :
138 0 : for (auto const& record_id : record_ids) {
139 0 : std::cout << "-----------------------------------------------------------------------------------" << std::endl;
140 0 : std::cout << "Trigger record " << record_id.first << std::endl;
141 0 : auto frag_paths =
142 0 : hdf5file.get_fragment_dataset_paths(record_id, dunedaq::daqdataformats::SourceID::Subsystem::kTrigger);
143 0 : for (auto const& frag_path : frag_paths) {
144 0 : auto frag_ptr = hdf5file.get_frag_ptr(frag_path);
145 0 : if (frag_ptr->get_fragment_type() == dunedaq::daqdataformats::FragmentType::kTriggerPrimitive) {
146 0 : print_tps(std::move(frag_ptr));
147 : }
148 0 : if (frag_ptr->get_fragment_type() == dunedaq::daqdataformats::FragmentType::kTriggerActivity) {
149 0 : print_tas(std::move(frag_ptr));
150 : }
151 0 : if (frag_ptr->get_fragment_type() == dunedaq::daqdataformats::FragmentType::kTriggerCandidate) {
152 0 : print_tcs(std::move(frag_ptr));
153 : }
154 :
155 : // std::cout << frag_path << std::endl;
156 0 : }
157 0 : std::cout << std::endl;
158 0 : }
159 0 : }
|
