DUNE-DAQ
DUNE Trigger and Data Acquisition software
Loading...
Searching...
No Matches
Functions
dunedaq::fddetdataformats::python Namespace Reference

Functions

void register_daphne (py::module &m)
void register_daphneeth (py::module &m)
void register_daphneethstream (py::module &m)
 PYBIND11_MODULE (_daq_fddetdataformats_py, m)
void register_wib2 (pybind11::module &)
void register_wibeth (pybind11::module &)
void register_wib (pybind11::module &)
void register_daphne (pybind11::module &)
void register_daphneeth (pybind11::module &)
void register_daphneethstream (pybind11::module &)
void register_tde (pybind11::module &)
void register_tdeeth (pybind11::module &)
void register_tde (py::module &m)
void register_tdeeth (py::module &m)
void register_wib (py::module &m)
void register_wib2 (py::module &m)
void register_wibeth (py::module &m)

Function Documentation

◆ PYBIND11_MODULE()

dunedaq::fddetdataformats::python::PYBIND11_MODULE ( _daq_fddetdataformats_py ,
m  )

Definition at line 16 of file module.cpp.

17{
18
19 m.doc() = "C++ implementation of the fddetdataformats modules";
20
21 register_wib(m);
22 register_wib2(m);
23 register_wibeth(m);
24 register_daphne(m);
25 register_daphneeth(m);
26 register_daphneethstream(m);
27 register_tde(m);
28 register_tdeeth(m);
29}
dunedaq::fddetdataformats::python::register_wib2
void register_wib2(pybind11::module &)
dunedaq::fddetdataformats::python::register_daphneethstream
void register_daphneethstream(py::module &m)
Definition daphneethstream.cpp:21
dunedaq::fddetdataformats::python::register_tdeeth
void register_tdeeth(pybind11::module &)
dunedaq::fddetdataformats::python::register_daphne
void register_daphne(py::module &m)
Definition daphne.cpp:22
dunedaq::fddetdataformats::python::register_wibeth
void register_wibeth(pybind11::module &)
dunedaq::fddetdataformats::python::register_daphneeth
void register_daphneeth(py::module &m)
Definition daphneeth.cpp:21
dunedaq::fddetdataformats::python::register_tde
void register_tde(pybind11::module &)
dunedaq::fddetdataformats::python::register_wib
void register_wib(pybind11::module &)

◆ register_daphne() [1/2]

void dunedaq::fddetdataformats::python::register_daphne ( py::module & m)

Definition at line 22 of file daphne.cpp.

23{
24
25 py::class_<DAPHNEFrame>(m, "DAPHNEFrame", py::buffer_protocol())
26 .def(py::init())
27 .def(py::init([](py::capsule capsule) {
28 auto wfp = *static_cast<DAPHNEFrame*>(capsule.get_pointer());
29 return wfp;
30 }))
31 .def(py::init([](py::bytes bytes) {
32 py::buffer_info info(py::buffer(bytes).request());
33 auto wfp = *static_cast<DAPHNEFrame*>(info.ptr);
34 return wfp;
35 }))
36 .def(
37 "get_daqheader",
38 [](DAPHNEFrame& self) -> const detdataformats::DAQHeader& { return self.daq_header; },
39 py::return_value_policy::reference_internal)
40 .def(
41 "get_header",
42 [](DAPHNEFrame& self) -> const DAPHNEFrame::Header& { return self.header; },
43 py::return_value_policy::reference_internal)
44 .def(
45 "get_peaks_data",
46 [](DAPHNEFrame& self) -> const DAPHNEFrame::PeakDescriptorData& { return self.peaks_data; },
47 py::return_value_policy::reference_internal)
48 .def("get_adc", static_cast<uint16_t (DAPHNEFrame::*)(const int) const>(&DAPHNEFrame::get_adc))
49 .def("get_timestamp", &DAPHNEFrame::get_timestamp)
50 .def("get_channel", &DAPHNEFrame::get_channel)
51 .def_static("sizeof", []() { return sizeof(DAPHNEFrame); });
52
53 py::class_<DAPHNEFrame::Header>(m, "DAPHNEFrameHeader")
54 .def_property(
55 "channel",
56 [](DAPHNEFrame::Header& self) -> uint8_t { return self.channel; },
57 [](DAPHNEFrame::Header& self, uint8_t channel) { self.channel = channel; })
58 .def_property(
59 "algorithm_id",
60 [](DAPHNEFrame::Header& self) -> uint8_t { return self.algorithm_id; },
61 [](DAPHNEFrame::Header& self, uint8_t algorithm_id) { self.algorithm_id = algorithm_id; })
62 .def_property(
63 "r1",
64 [](DAPHNEFrame::Header& self) -> uint8_t { return self.r1; },
65 [](DAPHNEFrame::Header& self, uint8_t r1) { self.r1 = r1; })
66 .def_property(
67 "trigger_sample_value",
68 [](DAPHNEFrame::Header& self) -> uint16_t { return self.trigger_sample_value; },
69 [](DAPHNEFrame::Header& self, uint16_t tsv) { self.trigger_sample_value = tsv; })
70 .def_property(
71 "threshold",
72 [](DAPHNEFrame::Header& self) -> uint16_t { return self.threshold; },
73 [](DAPHNEFrame::Header& self, uint16_t threshold) { self.threshold = threshold; })
74 .def_property(
75 "baseline",
76 [](DAPHNEFrame::Header& self) -> uint16_t { return self.baseline; },
77 [](DAPHNEFrame::Header& self, uint16_t baseline) { self.baseline = baseline; });
78
79 py::class_<DAPHNEFrame::PeakDescriptorData>(m, "DAPHNEFramePeakDescriptorData")
80 .def("is_found", &DAPHNEFrame::PeakDescriptorData::is_found)
81 .def("set_found", &DAPHNEFrame::PeakDescriptorData::set_found)
82
83 .def("get_adc_integral", &DAPHNEFrame::PeakDescriptorData::get_adc_integral)
84 .def("set_adc_integral", &DAPHNEFrame::PeakDescriptorData::set_adc_integral)
85
86 .def("get_num_subpeaks", &DAPHNEFrame::PeakDescriptorData::get_num_subpeaks)
87 .def("set_num_subpeaks", &DAPHNEFrame::PeakDescriptorData::set_num_subpeaks)
88
89 .def("get_samples_over_baseline", &DAPHNEFrame::PeakDescriptorData::get_samples_over_baseline)
90 .def("set_samples_over_baseline", &DAPHNEFrame::PeakDescriptorData::set_samples_over_baseline)
91
92 .def("get_adc_max", &DAPHNEFrame::PeakDescriptorData::get_adc_max)
93 .def("set_adc_max", &DAPHNEFrame::PeakDescriptorData::set_adc_max)
94
95 .def("get_sample_start", &DAPHNEFrame::PeakDescriptorData::get_sample_start)
96 .def("set_sample_start", &DAPHNEFrame::PeakDescriptorData::set_sample_start)
97
98 .def_property(
99 "num_subpeaks_0",
100 [](DAPHNEFrame::PeakDescriptorData& self) -> uint8_t { return self.num_subpeaks_0; },
101 [](DAPHNEFrame::PeakDescriptorData& self, uint8_t val) { self.num_subpeaks_0 = val; })
102 .def_property(
103 "adc_integral_0",
104 [](DAPHNEFrame::PeakDescriptorData& self) -> uint32_t { return self.adc_integral_0; },
105 [](DAPHNEFrame::PeakDescriptorData& self, uint32_t val) { self.adc_integral_0 = val; })
106 .def_property(
107 "found_0",
108 [](DAPHNEFrame::PeakDescriptorData& self) -> uint8_t { return self.found_0; },
109 [](DAPHNEFrame::PeakDescriptorData& self, uint8_t val) { self.found_0 = val; })
110 .def_property(
111 "adc_max_0",
112 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.adc_max_0; },
113 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.adc_max_0 = val; })
114 .def_property(
115 "sample_max_0",
116 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.sample_max_0; },
117 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.sample_max_0 = val; })
118 .def_property(
119 "samples_over_baseline_0",
120 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.samples_over_baseline_0; },
121 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.samples_over_baseline_0 = val; })
122
123 .def_property(
124 "num_subpeaks_1",
125 [](DAPHNEFrame::PeakDescriptorData& self) -> uint8_t { return self.num_subpeaks_1; },
126 [](DAPHNEFrame::PeakDescriptorData& self, uint8_t val) { self.num_subpeaks_1 = val; })
127 .def_property(
128 "adc_integral_1",
129 [](DAPHNEFrame::PeakDescriptorData& self) -> uint32_t { return self.adc_integral_1; },
130 [](DAPHNEFrame::PeakDescriptorData& self, uint32_t val) { self.adc_integral_1 = val; })
131 .def_property(
132 "found_1",
133 [](DAPHNEFrame::PeakDescriptorData& self) -> uint8_t { return self.found_1; },
134 [](DAPHNEFrame::PeakDescriptorData& self, uint8_t val) { self.found_1 = val; })
135 .def_property(
136 "adc_max_1",
137 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.adc_max_1; },
138 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.adc_max_1 = val; })
139 .def_property(
140 "sample_max_1",
141 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.sample_max_1; },
142 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.sample_max_1 = val; })
143 .def_property(
144 "samples_over_baseline_1",
145 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.samples_over_baseline_1; },
146 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.samples_over_baseline_1 = val; })
147
148 .def_property(
149 "num_subpeaks_2",
150 [](DAPHNEFrame::PeakDescriptorData& self) -> uint8_t { return self.num_subpeaks_2; },
151 [](DAPHNEFrame::PeakDescriptorData& self, uint8_t val) { self.num_subpeaks_2 = val; })
152 .def_property(
153 "adc_integral_2",
154 [](DAPHNEFrame::PeakDescriptorData& self) -> uint32_t { return self.adc_integral_2; },
155 [](DAPHNEFrame::PeakDescriptorData& self, uint32_t val) { self.adc_integral_2 = val; })
156 .def_property(
157 "found_2",
158 [](DAPHNEFrame::PeakDescriptorData& self) -> uint8_t { return self.found_2; },
159 [](DAPHNEFrame::PeakDescriptorData& self, uint8_t val) { self.found_2 = val; })
160 .def_property(
161 "adc_max_2",
162 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.adc_max_2; },
163 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.adc_max_2 = val; })
164 .def_property(
165 "sample_max_2",
166 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.sample_max_2; },
167 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.sample_max_2 = val; })
168 .def_property(
169 "samples_over_baseline_2",
170 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.samples_over_baseline_2; },
171 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.samples_over_baseline_2 = val; })
172
173 .def_property(
174 "num_subpeaks_3",
175 [](DAPHNEFrame::PeakDescriptorData& self) -> uint8_t { return self.num_subpeaks_3; },
176 [](DAPHNEFrame::PeakDescriptorData& self, uint8_t val) { self.num_subpeaks_3 = val; })
177 .def_property(
178 "adc_integral_3",
179 [](DAPHNEFrame::PeakDescriptorData& self) -> uint32_t { return self.adc_integral_3; },
180 [](DAPHNEFrame::PeakDescriptorData& self, uint32_t val) { self.adc_integral_3 = val; })
181 .def_property(
182 "found_3",
183 [](DAPHNEFrame::PeakDescriptorData& self) -> uint8_t { return self.found_3; },
184 [](DAPHNEFrame::PeakDescriptorData& self, uint8_t val) { self.found_3 = val; })
185 .def_property(
186 "adc_max_3",
187 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.adc_max_3; },
188 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.adc_max_3 = val; })
189 .def_property(
190 "sample_max_3",
191 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.sample_max_3; },
192 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.sample_max_3 = val; })
193 .def_property(
194 "samples_over_baseline_3",
195 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.samples_over_baseline_3; },
196 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.samples_over_baseline_3 = val; })
197
198 .def_property(
199 "num_subpeaks_4",
200 [](DAPHNEFrame::PeakDescriptorData& self) -> uint8_t { return self.num_subpeaks_4; },
201 [](DAPHNEFrame::PeakDescriptorData& self, uint8_t val) { self.num_subpeaks_4 = val; })
202 .def_property(
203 "adc_integral_4",
204 [](DAPHNEFrame::PeakDescriptorData& self) -> uint32_t { return self.adc_integral_4; },
205 [](DAPHNEFrame::PeakDescriptorData& self, uint32_t val) { self.adc_integral_4 = val; })
206 .def_property(
207 "found_4",
208 [](DAPHNEFrame::PeakDescriptorData& self) -> uint8_t { return self.found_4; },
209 [](DAPHNEFrame::PeakDescriptorData& self, uint8_t val) { self.found_4 = val; })
210 .def_property(
211 "adc_max_4",
212 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.adc_max_4; },
213 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.adc_max_4 = val; })
214 .def_property(
215 "sample_max_4",
216 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.sample_max_4; },
217 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.sample_max_4 = val; })
218 .def_property(
219 "samples_over_baseline_4",
220 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.samples_over_baseline_4; },
221 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.samples_over_baseline_4 = val; });
222
223 py::class_<DAPHNEStreamFrame::Header>(m, "DAPHNEStreamHeader")
224 .def_property(
225 "channel_0",
226 [](DAPHNEStreamFrame::Header& self) -> uint32_t { return self.channel_0; },
227 [](DAPHNEStreamFrame::Header& self, uint32_t channel_0) { self.channel_0 = channel_0; })
228 .def_property(
229 "channel_1",
230 [](DAPHNEStreamFrame::Header& self) -> uint32_t { return self.channel_1; },
231 [](DAPHNEStreamFrame::Header& self, uint32_t channel_1) { self.channel_1 = channel_1; })
232 .def_property(
233 "channel_2",
234 [](DAPHNEStreamFrame::Header& self) -> uint32_t { return self.channel_2; },
235 [](DAPHNEStreamFrame::Header& self, uint32_t channel_2) { self.channel_2 = channel_2; })
236 .def_property(
237 "channel_3",
238 [](DAPHNEStreamFrame::Header& self) -> uint32_t { return self.channel_3; },
239 [](DAPHNEStreamFrame::Header& self, uint32_t channel_3) { self.channel_3 = channel_3; });
240
241 py::class_<DAPHNEStreamFrame>(m, "DAPHNEStreamFrame", py::buffer_protocol())
242 .def(py::init())
243 .def(py::init([](py::capsule capsule) {
244 auto wfp = *static_cast<DAPHNEStreamFrame*>(capsule.get_pointer());
245 return wfp;
246 }))
247 .def(
248 "get_daqheader",
249 [](DAPHNEStreamFrame& self) -> const detdataformats::DAQHeader& { return self.daq_header; },
250 py::return_value_policy::reference_internal)
251 .def(
252 "get_header",
253 [](DAPHNEStreamFrame& self) -> const DAPHNEStreamFrame::Header& { return self.header; },
254 py::return_value_policy::reference_internal)
255 //.def("get_trailer", [](DAPHNEStreamFrame& self) -> const DAPHNEStreamFrame::PeakDescriptorData& {return
256 //self.trailer;}, py::return_value_policy::reference_internal)
257 .def("get_timestamp", &DAPHNEStreamFrame::get_timestamp)
258 .def("set_timestamp", &DAPHNEStreamFrame::set_timestamp)
259 .def("get_adc", &DAPHNEStreamFrame::get_adc)
260 .def("set_adc", &DAPHNEStreamFrame::set_adc)
261 .def("get_channel0", &DAPHNEStreamFrame::get_channel0)
262 .def("get_channel1", &DAPHNEStreamFrame::get_channel1)
263 .def("get_channel2", &DAPHNEStreamFrame::get_channel2)
264 .def("get_channel3", &DAPHNEStreamFrame::get_channel3)
265 .def_static("sizeof", []() { return sizeof(DAPHNEStreamFrame); })
266 .def("get_bytes", [](DAPHNEStreamFrame* fr) -> py::bytes {
267 return py::bytes(reinterpret_cast<char*>(fr), sizeof(DAPHNEStreamFrame)); // NOLINT
268 });
269} // NOLINT function length
dunedaq::fddetdataformats::DAPHNEFrame::get_timestamp
uint64_t get_timestamp() const
Get the 64-bit timestamp of the frame.
Definition DAPHNEFrame.hpp:262
dunedaq::fddetdataformats::DAPHNEFrame::get_adc
uint16_t get_adc(int i) const
Get the ith ADC value in the frame.
Definition DAPHNEFrame.hxx:5
dunedaq::fddetdataformats::DAPHNEStreamFrame::get_channel1
uint8_t get_channel1() const
Get the channel 1 from the DAPHNE Stream frame header.
Definition DAPHNEStreamFrame.hpp:83
dunedaq::fddetdataformats::DAPHNEStreamFrame::set_timestamp
void set_timestamp(const uint64_t new_timestamp)
Set the 64-bit timestamp of the frame.
Definition DAPHNEStreamFrame.hpp:67
dunedaq::fddetdataformats::DAPHNEStreamFrame::get_adc
uint16_t get_adc(uint i_adc, uint i_channel) const
Get the i ADC value of chn in the frame.
Definition DAPHNEStreamFrame.hxx:5
dunedaq::fddetdataformats::DAPHNEStreamFrame::get_channel2
uint8_t get_channel2() const
Get the channel 2 from the DAPHNE Stream frame header.
Definition DAPHNEStreamFrame.hpp:86
dunedaq::fddetdataformats::DAPHNEStreamFrame::get_channel0
uint8_t get_channel0() const
Get the channel 0 from the DAPHNE Stream frame header.
Definition DAPHNEStreamFrame.hpp:80
dunedaq::fddetdataformats::DAPHNEStreamFrame::get_channel3
uint8_t get_channel3() const
Get the channel 3 from the DAPHNE Stream frame header.
Definition DAPHNEStreamFrame.hpp:89
dunedaq::fddetdataformats::DAPHNEStreamFrame::set_adc
void set_adc(uint i, uint chn, uint16_t val)
Set the i ADC value of chn in the frame to val.
Definition DAPHNEStreamFrame.hxx:14
plot_trigprim_output_data.channel
channel
Definition plot_trigprim_output_data.py:21
dunedaq::detdataformats::DAQHeader
DAQHeader is a versioned and unified structure for every FE electronics.
Definition DAQHeader.hpp:23
dunedaq::fddetdataformats::DAPHNEFrame::PeakDescriptorData::is_found
bool is_found(int idx) const
Get the Found value for a specific peak (channel) from the trailer. (Word 2*idx, bit 31).
Definition DAPHNEFrame.hxx:21
dunedaq::fddetdataformats::DAPHNEFrame::PeakDescriptorData::set_adc_integral
void set_adc_integral(uint32_t val, int idx)
Set the ADC_Integral value for a specific peak.
Definition DAPHNEFrame.hxx:52
dunedaq::fddetdataformats::DAPHNEFrame::PeakDescriptorData::get_adc_max
uint16_t get_adc_max(int idx) const
Get the ADC Max value for a specific peak. (Word 2*idx+1, bits [31:18]).
Definition DAPHNEFrame.hxx:128
dunedaq::fddetdataformats::DAPHNEFrame::PeakDescriptorData::set_num_subpeaks
void set_num_subpeaks(uint8_t val, int idx)
Set the Num_SubPeaks value for a specific peak.
Definition DAPHNEFrame.hxx:73
dunedaq::fddetdataformats::DAPHNEFrame::PeakDescriptorData::get_sample_start
uint16_t get_sample_start(int idx) const
Get the Time_Start value for a given index (0-4).
Definition DAPHNEFrame.hxx:150
dunedaq::fddetdataformats::DAPHNEFrame::PeakDescriptorData::set_found
void set_found(uint8_t val, int idx)
Set the Found value for a specific peak (channel) in the trailer.
Definition DAPHNEFrame.hxx:31
dunedaq::fddetdataformats::DAPHNEFrame::PeakDescriptorData::get_adc_integral
uint32_t get_adc_integral(int idx) const
Get the ADC_Integral value for a specific peak. (Word 2*idx, bits [30:8]).
Definition DAPHNEFrame.hxx:43
dunedaq::fddetdataformats::DAPHNEFrame::PeakDescriptorData::set_sample_start
void set_sample_start(uint16_t val, int idx)
Set the time_start field for Peak index 0–4 using bit shifts.
Definition DAPHNEFrame.hxx:166
dunedaq::fddetdataformats::DAPHNEFrame::PeakDescriptorData::set_adc_max
void set_adc_max(uint16_t val, int idx)
Set the ADC Max value for a specific peak.
Definition DAPHNEFrame.hxx:138
dunedaq::fddetdataformats::DAPHNEFrame::PeakDescriptorData::get_num_subpeaks
uint8_t get_num_subpeaks(int idx) const
Get the Num_SubPeaks value for a specific peak. (Word 2*idx, bits [3:0]).
Definition DAPHNEFrame.hxx:64
dunedaq::fddetdataformats::DAPHNEFrame::PeakDescriptorData::get_samples_over_baseline
uint16_t get_samples_over_baseline(int idx) const
Get the Time_Over_Baseline value for a specific peak. (Word 2*idx+1, bits [8:0]).
Definition DAPHNEFrame.hxx:84

◆ register_daphne() [2/2]

void dunedaq::fddetdataformats::python::register_daphne ( pybind11::module & )

◆ register_daphneeth() [1/2]

void dunedaq::fddetdataformats::python::register_daphneeth ( py::module & m)

Definition at line 21 of file daphneeth.cpp.

22{
23
24 py::class_<DAPHNEEthFrame::Header>(m, "DAPHNEEthHeader")
25 // .def_property("w0",
26 // [](DAPHNEEthFrame::Header& self) -> uint32_t {return self.w0;},
27 // [](DAPHNEEthFrame::Header& self, uint32_t w0) {self.w0 = w0;}
28 // )
29 .def_property(
30 "w1",
31 [](DAPHNEEthFrame::Header& self) -> uint32_t { return self.w1; },
32 [](DAPHNEEthFrame::Header& self, uint32_t w1) { self.w1 = w1; })
33 .def_property(
34 "w2",
35 [](DAPHNEEthFrame::Header& self) -> uint32_t { return self.w2; },
36 [](DAPHNEEthFrame::Header& self, uint32_t w2) { self.w2 = w2; })
37 .def_property(
38 "w3",
39 [](DAPHNEEthFrame::Header& self) -> uint32_t { return self.w3; },
40 [](DAPHNEEthFrame::Header& self, uint32_t w3) { self.w3 = w3; })
41 .def_property(
42 "w4",
43 [](DAPHNEEthFrame::Header& self) -> uint32_t { return self.w4; },
44 [](DAPHNEEthFrame::Header& self, uint32_t w4) { self.w4 = w4; })
45 .def_property(
46 "w5",
47 [](DAPHNEEthFrame::Header& self) -> uint32_t { return self.w5; },
48 [](DAPHNEEthFrame::Header& self, uint32_t w5) { self.w5 = w5; })
49 .def_property(
50 "w6",
51 [](DAPHNEEthFrame::Header& self) -> uint32_t { return self.w6; },
52 [](DAPHNEEthFrame::Header& self, uint32_t w6) { self.w6 = w6; })
53 .def_property(
54 "channel",
55 [](DAPHNEEthFrame::Header& self) -> uint32_t { return self.channel; },
56 [](DAPHNEEthFrame::Header& self, uint32_t channel) { self.channel = channel; })
57 .def_property(
58 "version",
59 [](DAPHNEEthFrame::Header& self) -> uint32_t { return self.version; },
60 [](DAPHNEEthFrame::Header& self, uint32_t version) { self.version = version; })
61 .def_property(
62 "trigger_sample_value",
63 [](DAPHNEEthFrame::Header& self) -> uint32_t { return self.trig_sample; },
64 [](DAPHNEEthFrame::Header& self, uint32_t trig_sample) { self.trig_sample = trig_sample; })
65 .def_property(
66 "threshold",
67 [](DAPHNEEthFrame::Header& self) -> uint32_t { return self.threshold; },
68 [](DAPHNEEthFrame::Header& self, uint32_t threshold) { self.threshold = threshold; })
69 .def_property(
70 "baseline",
71 [](DAPHNEEthFrame::Header& self) -> uint32_t { return self.baseline; },
72 [](DAPHNEEthFrame::Header& self, uint32_t baseline) { self.baseline = baseline; });
73
74 py::class_<DAPHNEEthFrame>(m, "DAPHNEEthFrame", py::buffer_protocol())
75 .def(py::init())
76 .def(py::init([](py::capsule capsule) {
77 auto wfp = *static_cast<DAPHNEEthFrame*>(capsule.get_pointer());
78 return wfp;
79 }))
80 .def(py::init([](py::bytes bytes) {
81 py::buffer_info info(py::buffer(bytes).request());
82 auto wfp = *static_cast<DAPHNEEthFrame*>(info.ptr);
83 return wfp;
84 }))
85 .def(
86 "get_daqheader",
87 [](DAPHNEEthFrame& self) -> const detdataformats::DAQEthHeader& { return self.daq_header; },
88 py::return_value_policy::reference_internal)
89 .def(
90 "get_daphneheader",
91 [](DAPHNEEthFrame& self) -> const DAPHNEEthFrame::Header& { return self.header; },
92 py::return_value_policy::reference_internal)
93 .def(
94 "get_header",
95 [](DAPHNEEthFrame& self) -> const DAPHNEEthFrame::Header& { return self.header; },
96 py::return_value_policy::reference_internal)
97 .def("get_adc", &DAPHNEEthFrame::get_adc)
98 .def("set_adc", &DAPHNEEthFrame::set_adc)
99 .def("get_timestamp", &DAPHNEEthFrame::get_timestamp)
100 .def("set_timestamp", &DAPHNEEthFrame::set_timestamp)
101 .def("get_channel", &DAPHNEEthFrame::get_channel)
102 .def("set_channel", &DAPHNEEthFrame::set_channel)
103 .def_static("sizeof", []() { return sizeof(DAPHNEEthFrame); })
104 .def("get_bytes", [](DAPHNEEthFrame* fr) -> py::bytes {
105 return py::bytes(reinterpret_cast<char*>(fr), sizeof(DAPHNEEthFrame)); // NOLINT reinterpret_cast
106 });
107}
version
version
Definition TriggerActivity_serialization.hpp:50
dunedaq::fddetdataformats::DAPHNEEthFrame::set_adc
void set_adc(int i, uint16_t val)
Set the ith ADC value in the frame to val.
Definition DAPHNEEthFrame.hxx:17
dunedaq::fddetdataformats::DAPHNEEthFrame::set_timestamp
void set_timestamp(const uint64_t new_timestamp)
Set the starting 64-bit timestamp of the frame.
Definition DAPHNEEthFrame.hpp:93
dunedaq::fddetdataformats::DAPHNEEthFrame::get_timestamp
uint64_t get_timestamp() const
Get the starting 64-bit timestamp of the frame.
Definition DAPHNEEthFrame.hpp:90
dunedaq::fddetdataformats::DAPHNEEthFrame::set_channel
void set_channel(const uint8_t new_channel)
Set the channel identifier of the frame.
Definition DAPHNEEthFrame.hpp:99
dunedaq::fddetdataformats::DAPHNEEthFrame::get_channel
uint8_t get_channel() const
Get the channel identifier of the frame.
Definition DAPHNEEthFrame.hpp:96
dunedaq::fddetdataformats::DAPHNEEthFrame::get_adc
uint16_t get_adc(int i) const
Get the ith ADC value in the frame.
Definition DAPHNEEthFrame.hxx:5

◆ register_daphneeth() [2/2]

void dunedaq::fddetdataformats::python::register_daphneeth ( pybind11::module & )

◆ register_daphneethstream() [1/2]

void dunedaq::fddetdataformats::python::register_daphneethstream ( py::module & m)

Definition at line 21 of file daphneethstream.cpp.

22{
23
24 py::class_<DAPHNEEthStreamFrame::ChannelWord>(m, "DAPHNEEthStreamChannelWord")
25 .def_property(
26 "tbd",
27 [](DAPHNEEthStreamFrame::ChannelWord& self) -> uint64_t { return self.tbd; },
28 [](DAPHNEEthStreamFrame::ChannelWord& self, uint64_t tbd) { self.tbd = tbd; })
29 .def_property(
30 "version",
31 [](DAPHNEEthStreamFrame::ChannelWord& self) -> uint64_t { return self.version; },
32 [](DAPHNEEthStreamFrame::ChannelWord& self, uint64_t version) { self.version = version; })
33 .def_property(
34 "channel",
35 [](DAPHNEEthStreamFrame::ChannelWord& self) -> uint64_t { return self.channel; },
36 [](DAPHNEEthStreamFrame::ChannelWord& self, uint64_t channel) { self.channel = channel; });
37
38 py::class_<DAPHNEEthStreamFrame::Header>(m, "DAPHNEEthStreamHeader")
39 .def_property(
40 "channel_words",
41 [](DAPHNEEthStreamFrame::Header& self) -> py::list {
42 py::list result;
43 for (int i = 0; i < 4; i++) {
44 result.append(self.channel_words[i]);
45 }
46 return result;
47 },
48 [](DAPHNEEthStreamFrame::Header& self, py::list channel_words) {
49 for (int i = 0; i < 4 && i < static_cast<int>(len(channel_words)); i++) {
50 self.channel_words[i] = channel_words[i].cast<DAPHNEEthStreamFrame::ChannelWord>();
51 }
52 });
53
54 py::class_<DAPHNEEthStreamFrame>(m, "DAPHNEEthStreamFrame", py::buffer_protocol())
55 .def(py::init())
56 .def(py::init([](py::capsule capsule) {
57 auto wfp = *static_cast<DAPHNEEthStreamFrame*>(capsule.get_pointer());
58 return wfp;
59 }))
60 .def(py::init([](py::bytes bytes) {
61 py::buffer_info info(py::buffer(bytes).request());
62 auto wfp = *static_cast<DAPHNEEthStreamFrame*>(info.ptr);
63 return wfp;
64 }))
65 .def(
66 "get_daqheader",
67 [](DAPHNEEthStreamFrame& self) -> const detdataformats::DAQEthHeader& { return self.daq_header; },
68 py::return_value_policy::reference_internal)
69 .def(
70 "get_daphneheader",
71 [](DAPHNEEthStreamFrame& self) -> const DAPHNEEthStreamFrame::Header& { return self.header; },
72 py::return_value_policy::reference_internal)
73 .def(
74 "get_header",
75 [](DAPHNEEthStreamFrame& self) -> const DAPHNEEthStreamFrame::Header& { return self.header; },
76 py::return_value_policy::reference_internal)
77 .def("get_adc", &DAPHNEEthStreamFrame::get_adc)
78 .def("set_adc", &DAPHNEEthStreamFrame::set_adc)
79 .def("get_timestamp", &DAPHNEEthStreamFrame::get_timestamp)
80 .def("set_timestamp", &DAPHNEEthStreamFrame::set_timestamp)
81 .def("get_channel", &DAPHNEEthStreamFrame::get_channel)
82 .def("set_channel", &DAPHNEEthStreamFrame::set_channel)
83 .def("get_channel0", &DAPHNEEthStreamFrame::get_channel0)
84 .def("get_channel1", &DAPHNEEthStreamFrame::get_channel1)
85 .def("get_channel2", &DAPHNEEthStreamFrame::get_channel2)
86 .def("get_channel3", &DAPHNEEthStreamFrame::get_channel3)
87 .def_static("sizeof", []() { return sizeof(DAPHNEEthStreamFrame); })
88 .def("get_bytes", [](DAPHNEEthStreamFrame* fr) -> py::bytes {
89 return py::bytes(reinterpret_cast<char*>(fr), sizeof(DAPHNEEthStreamFrame)); // NOLINT reinterpret_cast
90 });
91}
dunedaq::fddetdataformats::DAPHNEEthStreamFrame::get_channel1
uint8_t get_channel1() const
Get the channel 1 from the DAPHNE Stream frame header.
Definition DAPHNEEthStreamFrame.hpp:99
dunedaq::fddetdataformats::DAPHNEEthStreamFrame::set_timestamp
void set_timestamp(const uint64_t new_timestamp)
Set the starting 64-bit timestamp of the frame.
Definition DAPHNEEthStreamFrame.hpp:87
dunedaq::fddetdataformats::DAPHNEEthStreamFrame::get_channel0
uint8_t get_channel0() const
Get the channel 0 from the DAPHNE Stream frame header.
Definition DAPHNEEthStreamFrame.hpp:96
dunedaq::fddetdataformats::DAPHNEEthStreamFrame::set_adc
void set_adc(uint i_channel, uint i_adc, uint16_t val)
Set the i_adc-th ADC value of i_channel-th channel in the frame to val.
Definition DAPHNEEthStreamFrame.hxx:37
dunedaq::fddetdataformats::DAPHNEEthStreamFrame::get_adc
uint16_t get_adc(uint i_adc, uint i_channel) const
Get the i_adc-th ADC value of i_channel-th channel in the frame.
Definition DAPHNEEthStreamFrame.hxx:28
dunedaq::fddetdataformats::DAPHNEEthStreamFrame::get_channel3
uint8_t get_channel3() const
Get the channel 3 from the DAPHNE Stream frame header.
Definition DAPHNEEthStreamFrame.hpp:105
dunedaq::fddetdataformats::DAPHNEEthStreamFrame::get_channel2
uint8_t get_channel2() const
Get the channel 2 from the DAPHNE Stream frame header.
Definition DAPHNEEthStreamFrame.hpp:102
dunedaq::fddetdataformats::DAPHNEEthStreamFrame::get_channel
uint8_t get_channel(const uint i_channel) const
Get the channel identifier of the frame.
Definition DAPHNEEthStreamFrame.hxx:5
dunedaq::fddetdataformats::DAPHNEEthStreamFrame::set_channel
void set_channel(const uint i_channel, const uint8_t new_channel_val)
Set the channel identifier of the frame.
Definition DAPHNEEthStreamFrame.hxx:16
dunedaq::fddetdataformats::DAPHNEEthStreamFrame::get_timestamp
uint64_t get_timestamp() const
Get the starting 64-bit timestamp of the frame.
Definition DAPHNEEthStreamFrame.hpp:84
afc.click_texttable.len
len(iterable)
Definition click_texttable.py:110

◆ register_daphneethstream() [2/2]

void dunedaq::fddetdataformats::python::register_daphneethstream ( pybind11::module & )

◆ register_tde() [1/2]

void dunedaq::fddetdataformats::python::register_tde ( py::module & m)

Definition at line 19 of file tde.cpp.

20{
21
22 py::class_<TDE16Frame>(m, "TDE16Frame", py::buffer_protocol())
23 .def(py::init())
24 .def(py::init([](py::capsule capsule) {
25 auto wfp = *static_cast<TDE16Frame*>(capsule.get_pointer());
26 return wfp;
27 }))
28 .def(py::init([](py::bytes bytes) {
29 py::buffer_info info(py::buffer(bytes).request());
30 auto wfp = *static_cast<TDE16Frame*>(info.ptr);
31 return wfp;
32 }))
33 .def("get_timestamp", &TDE16Frame::get_timestamp)
34 .def("set_timestamp", &TDE16Frame::set_timestamp)
35 .def("get_channel", &TDE16Frame::get_channel)
36 .def(
37 "get_daq_header",
38 [](TDE16Frame& self) -> detdataformats::DAQEthHeader* { return self.get_daq_header(); },
39 py::return_value_policy::reference_internal)
40 .def(
41 "get_tde_header",
42 [](TDE16Frame& self) -> TDEHeader* { return self.get_tde_header(); },
43 py::return_value_policy::reference_internal)
44 .def("get_adc_sample", &TDE16Frame::get_adc_sample)
45 .def_static("sizeof", []() { return sizeof(TDE16Frame); })
46 .def("get_bytes",
47 [](TDE16Frame* fr) -> py::bytes { return py::bytes(reinterpret_cast<char*>(fr), sizeof(TDE16Frame)); });
48
49 py::class_<TDEHeader>(m, "TDEHeader")
50 .def_property_readonly("channel", [](TDEHeader& self) -> uint16_t { return self.channel; })
51 .def_property_readonly("version", [](TDEHeader& self) -> uint16_t { return self.version; })
52 .def_property_readonly("tde_header", [](TDEHeader& self) -> uint16_t { return self.tde_header; })
53 .def_property_readonly("tde_errors", [](TDEHeader& self) -> uint16_t { return self.tde_errors; })
54 .def_property_readonly("TAItime", [](TDEHeader& self) -> uint64_t { return self.TAItime; });
55}
dunedaq::fddetdataformats::TDE16Frame::set_timestamp
void set_timestamp(const uint64_t new_timestamp)
Definition TDE16Frame.hpp:65
dunedaq::fddetdataformats::TDE16Frame::get_adc_sample
uint16_t get_adc_sample(int sample_no) const
Definition TDE16Frame.hpp:78
dunedaq::detdataformats::DAQEthHeader
DAQEthHeader is a versioned and unified structure for every FE electronics.
Definition DAQEthHeader.hpp:23

◆ register_tde() [2/2]

void dunedaq::fddetdataformats::python::register_tde ( pybind11::module & )

◆ register_tdeeth() [1/2]

void dunedaq::fddetdataformats::python::register_tdeeth ( py::module & m)

Definition at line 19 of file tdeeth.cpp.

20{
21
22 // NOLINTBEGIN(build/unsigned)
23
24 // py::class_<TDEEthFrame::TDEHeader>(m, "TDEHeader")
25 // .def_property("channel",
26 // [](TDEEthFrame::TDEHeader& self) -> uint32_t {return self.channel;},
27 // [](TDEEthFrame::TDEHeader& self, uint32_t channel) {self.channel = channel;}
28 // )
29 // .def_property("version",
30 // [](TDEEthFrame::TDEHeader& self) -> uint32_t {return self.version;},
31 // [](TDEEthFrame::TDEHeader& self, uint32_t version) {self.version = version;}
32 // )
33 // // .def_property("reserved",
34 // // [](TDEEthFrame::TDEHeader& self) -> uint32_t {return self.reserved;},
35 // // [](TDEEthFrame::TDEHeader& self, uint32_t reserved) {self.reserved = reserved;}
36 // // )
37 // .def_property("cd",
38 // [](TDEEthFrame::TDEHeader& self) -> uint32_t {return self.cd;},
39 // [](TDEEthFrame::TDEHeader& self, uint32_t cd) {self.version = cd;}
40 // )
41 // .def_property("context",
42 // [](TDEEthFrame::TDEHeader& self) -> uint32_t {return self.context;},
43 // [](TDEEthFrame::TDEHeader& self, uint32_t context) {self.version = context;}
44 // )
45 // .def_property("ready",
46 // [](TDEEthFrame::TDEHeader& self) -> uint32_t {return self.ready;},
47 // [](TDEEthFrame::TDEHeader& self, uint32_t ready) {self.ready = ready;}
48 // )
49 // .def_property("calibration",
50 // [](TDEEthFrame::TDEHeader& self) -> uint32_t {return self.calibration;},
51 // [](TDEEthFrame::TDEHeader& self, uint32_t calibration) {self.calibration = calibration;}
52 // )
53 // .def_property("pulser",
54 // [](TDEEthFrame::TDEHeader& self) -> uint32_t {return self.pulser;},
55 // [](TDEEthFrame::TDEHeader& self, uint32_t pulser) {self.pulser = pulser;}
56 // )
57 // .def_property("femb_sync",
58 // [](TDEEthFrame::TDEHeader& self) -> uint32_t {return self.femb_sync;},
59 // [](TDEEthFrame::TDEHeader& self, uint32_t femb_sync) {self.femb_sync = femb_sync;}
60 // )
61 // .def_property("wib_sync",
62 // [](TDEEthFrame::TDEHeader& self) -> uint32_t {return self.wib_sync;},
63 // [](TDEEthFrame::TDEHeader& self, uint32_t wib_sync) {self.wib_sync = wib_sync;}
64 // )
65 // .def_property("lol",
66 // [](TDEEthFrame::TDEHeader& self) -> uint32_t {return self.lol;},
67 // [](TDEEthFrame::TDEHeader& self, uint32_t lol) {self.lol = lol;}
68 // )
69 // .def_property("link_valid",
70 // [](TDEEthFrame::TDEHeader& self) -> uint32_t {return self.link_valid;},
71 // [](TDEEthFrame::TDEHeader& self, uint32_t link_valid) {self.link_valid = link_valid;}
72 // )
73 // .def_property("crc_err",
74 // [](TDEEthFrame::TDEHeader& self) -> uint32_t {return self.crc_err;},
75 // [](TDEEthFrame::TDEHeader& self, uint32_t crc_err) {self.crc_err = crc_err;}
76 // )
77 // .def_property("colddata_timestamp_1",
78 // [](TDEEthFrame::TDEHeader& self) -> uint32_t {return self.colddata_timestamp_1;},
79 // [](TDEEthFrame::TDEHeader& self, uint32_t colddata_timestamp_1) {self.lol = colddata_timestamp_1;}
80 // )
81 // .def_property("colddata_timestamp_0",
82 // [](TDEEthFrame::TDEHeader& self) -> uint32_t {return self.colddata_timestamp_0;},
83 // [](TDEEthFrame::TDEHeader& self, uint32_t colddata_timestamp_0) {self.colddata_timestamp_0 =
84 // colddata_timestamp_0;}
85 // )
86 // .def_property("extra_data",
87 // [](TDEEthFrame::TDEHeader& self) -> uint64_t {return self.extra_data;},
88 // [](TDEEthFrame::TDEHeader& self, uint64_t extra_data) {self.extra_data = extra_data;}
89 // )
90 // ;
91
92 py::class_<TDEEthFrame::TDEEthHeader>(m, "TDEEthHeader")
93 .def_property(
94 "channel",
95 [](TDEEthFrame::TDEEthHeader& self) -> uint16_t { return self.channel; },
96 [](TDEEthFrame::TDEEthHeader& self, uint16_t channel) { self.channel = channel; })
97 .def_property(
98 "version",
99 [](TDEEthFrame::TDEEthHeader& self) -> uint16_t { return self.version; },
100 [](TDEEthFrame::TDEEthHeader& self, uint16_t version) { self.version = version; })
101 .def_property(
102 "tde_header",
103 [](TDEEthFrame::TDEEthHeader& self) -> uint16_t { return self.tde_header; },
104 [](TDEEthFrame::TDEEthHeader& self, uint16_t tde_header) { self.tde_header = tde_header; })
105 .def_property(
106 "tde_errors",
107 [](TDEEthFrame::TDEEthHeader& self) -> uint16_t { return self.tde_errors; },
108 [](TDEEthFrame::TDEEthHeader& self, uint16_t tde_errors) { self.tde_errors = tde_errors; })
109 .def_property(
110 "TAItime",
111 [](TDEEthFrame::TDEEthHeader& self) -> uint64_t { return self.TAItime; },
112 [](TDEEthFrame::TDEEthHeader& self, uint64_t TAItime) { self.TAItime = TAItime; });
113
114 py::class_<TDEEthFrame>(m, "TDEEthFrame", py::buffer_protocol())
115 .def(py::init())
116 .def(py::init([](py::capsule capsule) {
117 auto tfp = *static_cast<TDEEthFrame*>(capsule.get_pointer());
118 return tfp;
119 }))
120 .def(py::init([](py::bytes bytes) {
121 py::buffer_info info(py::buffer(bytes).request());
122 auto tfp = *static_cast<TDEEthFrame*>(info.ptr);
123 return tfp;
124 }))
125 .def(
126 "get_daqheader",
127 [](TDEEthFrame& self) -> const detdataformats::DAQEthHeader& { return self.daq_header; },
128 py::return_value_policy::reference_internal)
129 .def(
130 "get_tdeheader",
131 [](TDEEthFrame& self) -> const TDEEthFrame::TDEEthHeader& { return self.header; },
132 py::return_value_policy::reference_internal)
133 .def("get_adc", &TDEEthFrame::get_adc)
134 .def("set_adc", &TDEEthFrame::set_adc)
135 .def("get_timestamp", &TDEEthFrame::get_timestamp)
136 .def("set_timestamp", &TDEEthFrame::set_timestamp)
137 .def("get_channel", &TDEEthFrame::get_channel)
138 .def("set_channel", &TDEEthFrame::set_channel)
139 .def_static("sizeof", []() { return sizeof(TDEEthFrame); })
140 .def("get_bytes", [](TDEEthFrame* fr) -> py::bytes {
141 return py::bytes(reinterpret_cast<char*>(fr), sizeof(TDEEthFrame)); // NOLINT reinterpret_cast
142 });
143}
dunedaq::fddetdataformats::TDEEthFrame::set_channel
void set_channel(const uint8_t new_channel)
Set the channel identifier of the frame.
Definition TDEEthFrame.hpp:89
dunedaq::fddetdataformats::TDEEthFrame::get_adc
uint16_t get_adc(int i_channel, int i_sample=0) const
Get the i_channel-th ADC value in the i_sample-th time sample.
Definition TDEEthFrame.hxx:5
dunedaq::fddetdataformats::TDEEthFrame::set_adc
void set_adc(int i_channel, int i_sample, uint16_t val)
Set the i_channel-th ADC value in the i_sample-th time sample to val.
Definition TDEEthFrame.hxx:20
dunedaq::fddetdataformats::TDEEthFrame::get_channel
uint8_t get_channel() const
Get the channel identifier of the frame.
Definition TDEEthFrame.hpp:86
dunedaq::fddetdataformats::TDEEthFrame::set_timestamp
void set_timestamp(const uint64_t new_timestamp)
Set the starting 64-bit timestamp of the frame.
Definition TDEEthFrame.hpp:83
dunedaq::fddetdataformats::TDEEthFrame::get_timestamp
uint64_t get_timestamp() const
Get the starting 64-bit timestamp of the frame.
Definition TDEEthFrame.hpp:80

◆ register_tdeeth() [2/2]

void dunedaq::fddetdataformats::python::register_tdeeth ( pybind11::module & )

◆ register_wib() [1/2]

void dunedaq::fddetdataformats::python::register_wib ( py::module & m)

Definition at line 19 of file wib.cpp.

20{
21
22 py::class_<WIBFrame>(m, "WIBFrame", py::buffer_protocol())
23 .def(py::init())
24 .def(py::init([](py::capsule capsule) {
25 auto wfp = *static_cast<WIBFrame*>(capsule.get_pointer());
26 return wfp;
27 }))
28 .def(py::init([](py::bytes bytes) {
29 py::buffer_info info(py::buffer(bytes).request());
30 auto wfp = *static_cast<WIBFrame*>(info.ptr);
31 return wfp;
32 }))
33 .def("get_wib_header",
34 static_cast<const WIBHeader* (WIBFrame::*)() const>(&WIBFrame::get_wib_header),
35 py::return_value_policy::reference_internal)
36 .def("get_coldata_header", &WIBFrame::get_coldata_header, py::return_value_policy::reference_internal)
37 .def("get_block", &WIBFrame::get_block, py::return_value_policy::reference_internal)
38 .def("get_channel",
39 static_cast<uint16_t (WIBFrame::*)(const uint8_t, const uint8_t, const uint8_t) const>(&WIBFrame::get_channel))
40 .def("get_channel", static_cast<uint16_t (WIBFrame::*)(const uint8_t, const uint8_t) const>(&WIBFrame::get_channel))
41 .def("get_channel", static_cast<uint16_t (WIBFrame::*)(const uint8_t) const>(&WIBFrame::get_channel))
42 .def("set_channel", static_cast<void (WIBFrame::*)(const uint8_t, const uint16_t)>(&WIBFrame::set_channel))
43 .def("get_timestamp", &WIBFrame::get_timestamp)
44 .def_static("sizeof", []() { return sizeof(WIBFrame); })
45 .def("get_bytes",
46 [](WIBFrame* fr) -> py::bytes { return py::bytes(reinterpret_cast<char*>(fr), sizeof(WIBFrame)); });
47
48 py::class_<WIBHeader>(m, "WIBHeader")
49 .def_property_readonly("sof", [](WIBHeader& self) -> uint32_t { return self.sof; })
50 .def_property_readonly("version", [](WIBHeader& self) -> uint32_t { return self.version; })
51 .def_property_readonly("fiber_no", [](WIBHeader& self) -> uint32_t { return self.fiber_no; })
52 .def_property_readonly("crate_no", [](WIBHeader& self) -> uint32_t { return self.crate_no; })
53 .def_property_readonly("slot_no", [](WIBHeader& self) -> uint32_t { return self.slot_no; })
54 .def_property_readonly("mm", [](WIBHeader& self) -> uint32_t { return self.mm; })
55 .def_property_readonly("oos", [](WIBHeader& self) -> uint32_t { return self.oos; })
56 .def_property_readonly("mm", [](WIBHeader& self) -> uint32_t { return self.mm; })
57 .def_property_readonly("wib_errors", [](WIBHeader& self) -> uint32_t { return self.wib_errors; })
58 .def("get_timestamp", &WIBHeader::get_timestamp)
59 .def("get_wib_counter", &WIBHeader::get_wib_counter);
60 py::class_<ColdataHeader>(m, "ColdataHeader")
61 .def_property_readonly("s1_error", [](ColdataHeader& self) -> uint32_t { return self.s1_error; })
62 .def_property_readonly("s2_error", [](ColdataHeader& self) -> uint32_t { return self.s2_error; })
63 .def_property_readonly("coldata_convert_count",
64 [](ColdataHeader& self) -> uint32_t { return self.coldata_convert_count; })
65 .def_property_readonly("error_register", [](ColdataHeader& self) -> uint32_t { return self.error_register; })
66 .def_property_readonly("hdr_1", [](ColdataHeader& self) -> uint32_t { return self.hdr_1; })
67 .def_property_readonly("hdr_3", [](ColdataHeader& self) -> uint32_t { return self.hdr_3; })
68 .def_property_readonly("hdr_2", [](ColdataHeader& self) -> uint32_t { return self.hdr_2; })
69 .def_property_readonly("hdr_4", [](ColdataHeader& self) -> uint32_t { return self.hdr_4; })
70 .def_property_readonly("hdr_5", [](ColdataHeader& self) -> uint32_t { return self.hdr_5; })
71 .def_property_readonly("hdr_7", [](ColdataHeader& self) -> uint32_t { return self.hdr_7; })
72 .def_property_readonly("hdr_6", [](ColdataHeader& self) -> uint32_t { return self.hdr_6; })
73 .def_property_readonly("hdr_8", [](ColdataHeader& self) -> uint32_t { return self.hdr_8; })
74 .def("get_checksum_a", &ColdataHeader::get_checksum_a)
75 .def("get_checksum_b", &ColdataHeader::get_checksum_b)
76 .def("get_hdr", &ColdataHeader::get_hdr);
77
78 py::class_<ColdataSegment>(m, "ColdataSegment").def("get_channel", &ColdataSegment::get_channel);
79 py::class_<ColdataBlock>(m, "ColdataBlock").def("get_channel", &ColdataBlock::get_channel);
80}
dunedaq::fddetdataformats::WIBFrame::get_wib_header
const WIBHeader * get_wib_header() const
Definition WIBFrame.hpp:360
dunedaq::fddetdataformats::WIBFrame::get_channel
uint16_t get_channel(const uint8_t block_num, const uint8_t adc, const uint8_t ch) const
Definition WIBFrame.hpp:381
dunedaq::fddetdataformats::WIBFrame::get_block
const ColdataBlock & get_block(const uint8_t b) const
Definition WIBFrame.hpp:368
dunedaq::fddetdataformats::WIBFrame::get_coldata_header
const ColdataHeader * get_coldata_header(const unsigned block_index) const
Definition WIBFrame.hpp:363
dunedaq::fddetdataformats::WIBFrame::set_channel
void set_channel(const uint8_t block_num, const uint8_t adc, const uint8_t ch, const uint16_t new_val)
Definition WIBFrame.hpp:397
dunedaq::fddetdataformats::ColdataBlock::get_channel
uint16_t get_channel(const uint8_t adc, const uint8_t ch) const
Definition WIBFrame.hpp:305
dunedaq::fddetdataformats::ColdataHeader::get_hdr
uint8_t get_hdr(const uint8_t i) const
Definition WIBFrame.hpp:105
dunedaq::fddetdataformats::ColdataSegment::get_channel
uint16_t get_channel(const uint8_t adc, const uint8_t ch) const
Definition WIBFrame.hpp:219

◆ register_wib() [2/2]

void dunedaq::fddetdataformats::python::register_wib ( pybind11::module & )

◆ register_wib2() [1/2]

void dunedaq::fddetdataformats::python::register_wib2 ( py::module & m)

Definition at line 19 of file wib2.cpp.

20{
21
22 py::class_<WIB2Frame>(m, "WIB2Frame", py::buffer_protocol())
23 .def(py::init())
24 .def(py::init([](py::capsule capsule) {
25 auto wfp = *static_cast<WIB2Frame*>(capsule.get_pointer());
26 return wfp;
27 }))
28 .def(py::init([](py::bytes bytes) {
29 py::buffer_info info(py::buffer(bytes).request());
30 auto wfp = *static_cast<WIB2Frame*>(info.ptr);
31 return wfp;
32 }))
33 .def("get_adc", static_cast<uint16_t (WIB2Frame::*)(const int) const>(&WIB2Frame::get_adc))
34 .def("set_adc", static_cast<void (WIB2Frame::*)(int, uint16_t)>(&WIB2Frame::set_adc))
35 .def("get_timestamp", &WIB2Frame::get_timestamp)
36 .def("get_header", [](WIB2Frame& self) -> const WIB2Frame::Header& { return self.header; })
37 .def("get_trailer", [](WIB2Frame& self) -> const WIB2Frame::Trailer& { return self.trailer; })
38 .def_static("sizeof", []() { return sizeof(WIB2Frame); })
39 .def("get_bytes",
40 [](WIB2Frame* fr) -> py::bytes { return py::bytes(reinterpret_cast<char*>(fr), sizeof(WIB2Frame)); });
41
42 py::class_<WIB2Frame::Header>(m, "WIB2Header")
43 .def_property_readonly("version", [](WIB2Frame::Header& self) -> uint32_t { return self.version; })
44 .def_property_readonly("detector_id", [](WIB2Frame::Header& self) -> uint32_t { return self.detector_id; })
45 .def_property_readonly("crate", [](WIB2Frame::Header& self) -> uint32_t { return self.crate; })
46 .def_property_readonly("slot", [](WIB2Frame::Header& self) -> uint32_t { return self.slot; })
47 .def_property_readonly("link", [](WIB2Frame::Header& self) -> uint32_t { return self.link; })
48 .def_property_readonly("timestamp_1", [](WIB2Frame::Header& self) -> uint32_t { return self.timestamp_1; })
49 .def_property_readonly("timestamp_2", [](WIB2Frame::Header& self) -> uint32_t { return self.timestamp_2; })
50 .def_property_readonly("colddata_timestamp_id",
51 [](WIB2Frame::Header& self) -> uint32_t { return self.colddata_timestamp_id; })
52 .def_property_readonly("femb_valid", [](WIB2Frame::Header& self) -> uint32_t { return self.femb_valid; })
53 .def_property_readonly("link_mask", [](WIB2Frame::Header& self) -> uint32_t { return self.link_mask; })
54 .def_property_readonly("lock_output_status",
55 [](WIB2Frame::Header& self) -> uint32_t { return self.lock_output_status; })
56 .def_property_readonly("femb_pulser_frame_bits",
57 [](WIB2Frame::Header& self) -> uint32_t { return self.femb_pulser_frame_bits; })
58 .def_property_readonly("femb_sync_flags", [](WIB2Frame::Header& self) -> uint32_t { return self.femb_sync_flags; })
59 .def_property_readonly("colddata_timestamp",
60 [](WIB2Frame::Header& self) -> uint32_t { return self.colddata_timestamp; });
61
62 py::class_<WIB2Frame::Trailer>(m, "WIB2Trailer")
63 .def_property_readonly("flex_bits", [](WIB2Frame::Trailer& self) -> uint32_t { return self.flex_bits; })
64 .def_property_readonly("ws", [](WIB2Frame::Trailer& self) -> uint32_t { return self.ws; })
65 .def_property_readonly("psr_cal", [](WIB2Frame::Trailer& self) -> uint32_t { return self.psr_cal; })
66 .def_property_readonly("ready", [](WIB2Frame::Trailer& self) -> uint32_t { return self.ready; })
67 .def_property_readonly("context_code", [](WIB2Frame::Trailer& self) -> uint32_t { return self.context_code; });
68}
dunedaq::fddetdataformats::WIB2Frame
Class for accessing raw WIB v2 frames, as used in ProtoDUNE-SP-II.
Definition WIB2Frame.hpp:31
dunedaq::fddetdataformats::WIB2Frame::get_adc
uint16_t get_adc(int i) const
Get the ith ADC value in the frame.
Definition WIB2Frame.hpp:88
dunedaq::fddetdataformats::WIB2Frame::get_timestamp
uint64_t get_timestamp() const
Get the 64-bit timestamp of the frame.
Definition WIB2Frame.hpp:139
dunedaq::fddetdataformats::WIB2Frame::set_adc
void set_adc(int i, uint16_t val)
Set the ith ADC value in the frame to val.
Definition WIB2Frame.hpp:113

◆ register_wib2() [2/2]

void dunedaq::fddetdataformats::python::register_wib2 ( pybind11::module & )

◆ register_wibeth() [1/2]

void dunedaq::fddetdataformats::python::register_wibeth ( py::module & m)

Definition at line 19 of file wibeth.cpp.

20{
21
22 // NOLINTBEGIN(build/unsigned)
23
24 py::class_<WIBEthFrame::WIBEthHeader>(m, "WIBEthHeader")
25 .def_property(
26 "channel",
27 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t { return self.channel; },
28 [](WIBEthFrame::WIBEthHeader& self, uint32_t channel) { self.channel = channel; })
29 .def_property(
30 "version",
31 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t { return self.version; },
32 [](WIBEthFrame::WIBEthHeader& self, uint32_t version) { self.version = version; })
33 // .def_property("reserved",
34 // [](WIBEthFrame::WIBEthHeader& self) -> uint32_t {return self.reserved;},
35 // [](WIBEthFrame::WIBEthHeader& self, uint32_t reserved) {self.reserved = reserved;}
36 // )
37 .def_property(
38 "cd",
39 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t { return self.cd; },
40 [](WIBEthFrame::WIBEthHeader& self, uint32_t cd) { self.version = cd; })
41 .def_property(
42 "context",
43 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t { return self.context; },
44 [](WIBEthFrame::WIBEthHeader& self, uint32_t context) { self.version = context; })
45 .def_property(
46 "ready",
47 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t { return self.ready; },
48 [](WIBEthFrame::WIBEthHeader& self, uint32_t ready) { self.ready = ready; })
49 .def_property(
50 "calibration",
51 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t { return self.calibration; },
52 [](WIBEthFrame::WIBEthHeader& self, uint32_t calibration) { self.calibration = calibration; })
53 .def_property(
54 "pulser",
55 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t { return self.pulser; },
56 [](WIBEthFrame::WIBEthHeader& self, uint32_t pulser) { self.pulser = pulser; })
57 .def_property(
58 "femb_sync",
59 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t { return self.femb_sync; },
60 [](WIBEthFrame::WIBEthHeader& self, uint32_t femb_sync) { self.femb_sync = femb_sync; })
61 .def_property(
62 "wib_sync",
63 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t { return self.wib_sync; },
64 [](WIBEthFrame::WIBEthHeader& self, uint32_t wib_sync) { self.wib_sync = wib_sync; })
65 .def_property(
66 "lol",
67 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t { return self.lol; },
68 [](WIBEthFrame::WIBEthHeader& self, uint32_t lol) { self.lol = lol; })
69 .def_property(
70 "link_valid",
71 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t { return self.link_valid; },
72 [](WIBEthFrame::WIBEthHeader& self, uint32_t link_valid) { self.link_valid = link_valid; })
73 .def_property(
74 "crc_err",
75 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t { return self.crc_err; },
76 [](WIBEthFrame::WIBEthHeader& self, uint32_t crc_err) { self.crc_err = crc_err; })
77 .def_property(
78 "colddata_timestamp_1",
79 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t { return self.colddata_timestamp_1; },
80 [](WIBEthFrame::WIBEthHeader& self, uint32_t colddata_timestamp_1) { self.lol = colddata_timestamp_1; })
81 .def_property(
82 "colddata_timestamp_0",
83 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t { return self.colddata_timestamp_0; },
84 [](WIBEthFrame::WIBEthHeader& self, uint32_t colddata_timestamp_0) {
85 self.colddata_timestamp_0 = colddata_timestamp_0;
86 })
87 .def_property(
88 "extra_data",
89 [](WIBEthFrame::WIBEthHeader& self) -> uint64_t { return self.extra_data; },
90 [](WIBEthFrame::WIBEthHeader& self, uint64_t extra_data) { self.extra_data = extra_data; });
91
92 py::class_<WIBEthFrame>(m, "WIBEthFrame", py::buffer_protocol())
93 .def(py::init())
94 .def(py::init([](py::capsule capsule) {
95 auto wfp = *static_cast<WIBEthFrame*>(capsule.get_pointer());
96 return wfp;
97 }))
98 .def(py::init([](py::bytes bytes) {
99 py::buffer_info info(py::buffer(bytes).request());
100 auto wfp = *static_cast<WIBEthFrame*>(info.ptr);
101 return wfp;
102 }))
103 .def(
104 "get_daqheader",
105 [](WIBEthFrame& self) -> const detdataformats::DAQEthHeader& { return self.daq_header; },
106 py::return_value_policy::reference_internal)
107 .def(
108 "get_wibheader",
109 [](WIBEthFrame& self) -> const WIBEthFrame::WIBEthHeader& { return self.header; },
110 py::return_value_policy::reference_internal)
111 .def("get_adc", &WIBEthFrame::get_adc)
112 .def("set_adc", &WIBEthFrame::set_adc)
113 .def("get_timestamp", &WIBEthFrame::get_timestamp)
114 .def("set_timestamp", &WIBEthFrame::set_timestamp)
115 .def("get_channel", &WIBEthFrame::get_channel)
116 .def("set_channel", &WIBEthFrame::set_channel)
117 .def_static("sizeof", []() { return sizeof(WIBEthFrame); })
118 .def("get_bytes", [](WIBEthFrame* fr) -> py::bytes {
119 return py::bytes(reinterpret_cast<char*>(fr), sizeof(WIBEthFrame)); // NOLINT reinterpret_cast
120 });
121} // NOLINT function length
dunedaq::fddetdataformats::WIBEthFrame::get_timestamp
uint64_t get_timestamp() const
Get the starting 64-bit timestamp of the frame.
Definition WIBEthFrame.hpp:91
dunedaq::fddetdataformats::WIBEthFrame::set_channel
void set_channel(const uint8_t new_channel)
Set the channel identifier of the frame.
Definition WIBEthFrame.hpp:100
dunedaq::fddetdataformats::WIBEthFrame::get_channel
uint8_t get_channel() const
Get the channel identifier of the frame.
Definition WIBEthFrame.hpp:97
dunedaq::fddetdataformats::WIBEthFrame::get_adc
uint16_t get_adc(int i_channel, int i_sample=0) const
Get the i_channel-th ADC value in the i_sample-th time sample.
Definition WIBEthFrame.hxx:5
dunedaq::fddetdataformats::WIBEthFrame::set_adc
void set_adc(int i_channel, int i_sample, uint16_t adc_val)
Set the i_channel-th ADC value in the i_sample-th time sample to adc_val.
Definition WIBEthFrame.hxx:15
dunedaq::fddetdataformats::WIBEthFrame::set_timestamp
void set_timestamp(const uint64_t new_timestamp)
Set the starting 64-bit timestamp of the frame.
Definition WIBEthFrame.hpp:94

◆ register_wibeth() [2/2]

void dunedaq::fddetdataformats::python::register_wibeth ( pybind11::module & )
Generated on for DUNE-DAQ by doxygen 1.16.1