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)
void register_daphnestream (py::module &m)
 PYBIND11_MODULE (_daq_fddetdataformats_py, m)
void register_wibeth (pybind11::module &)
void register_daphne (pybind11::module &)
void register_daphnestream (pybind11::module &)
void register_daphneeth (pybind11::module &)
void register_daphneethstream (pybind11::module &)
void register_tdeeth (pybind11::module &)
void register_tdeeth (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_wibeth(m);
22 register_daphne(m);
23 register_daphnestream(m);
24 register_daphneeth(m);
25 register_daphneethstream(m);
26 register_tdeeth(m);
27}
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:21
dunedaq::fddetdataformats::python::register_daphnestream
void register_daphnestream(py::module &m)
Definition daphnestream.cpp:21
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

◆ register_daphne() [1/2]

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

Definition at line 21 of file daphne.cpp.

22{
23
24 py::class_<DAPHNEFrame>(m, "DAPHNEFrame", py::buffer_protocol())
25 .def(py::init())
26 .def(py::init([](py::capsule capsule) {
27 auto wfp = *static_cast<DAPHNEFrame*>(capsule.get_pointer());
28 return wfp;
29 }))
30 .def(py::init([](py::bytes bytes) {
31 py::buffer_info info(py::buffer(bytes).request());
32 auto wfp = *static_cast<DAPHNEFrame*>(info.ptr);
33 return wfp;
34 }))
35 .def(
36 "get_daqheader",
37 [](DAPHNEFrame& self) -> const detdataformats::DAQHeader& { return self.daq_header; },
38 py::return_value_policy::reference_internal)
39 .def(
40 "get_header",
41 [](DAPHNEFrame& self) -> const DAPHNEFrame::Header& { return self.header; },
42 py::return_value_policy::reference_internal)
43 .def_property_readonly(
44 "daq_header",
45 [](DAPHNEFrame& self) -> detdataformats::DAQHeader& { return self.daq_header; },
46 py::return_value_policy::reference_internal)
47 .def_property_readonly(
48 "header",
49 [](DAPHNEFrame& self) -> DAPHNEFrame::Header& { return self.header; },
50 py::return_value_policy::reference_internal)
51 .def(
52 "peaks_data",
53 [](DAPHNEFrame& self) -> DAPHNEFrame::PeakDescriptorData& { return self.peaks_data; },
54 py::return_value_policy::reference_internal)
55 .def("get_adc", static_cast<uint16_t (DAPHNEFrame::*)(const int) const>(&DAPHNEFrame::get_adc))
56 .def("set_adc", &DAPHNEFrame::set_adc)
57 .def("get_timestamp", &DAPHNEFrame::get_timestamp)
58 .def("set_timestamp", &DAPHNEFrame::set_timestamp)
59 .def("get_channel", &DAPHNEFrame::get_channel)
60 .def("set_channel", &DAPHNEFrame::set_channel)
61 .def("__lt__", [](const DAPHNEFrame& lhs, const DAPHNEFrame& rhs) { return lhs < rhs; })
62 .def_property_readonly_static("version", [](py::object /*self*/) { return DAPHNEFrame::version; })
63 .def_property_readonly_static("s_bits_per_adc", [](py::object /*self*/) { return DAPHNEFrame::s_bits_per_adc; })
64 .def_property_readonly_static("s_bits_per_word", [](py::object /*self*/) { return DAPHNEFrame::s_bits_per_word; })
65 .def_property_readonly_static("s_num_adcs", [](py::object /*self*/) { return DAPHNEFrame::s_num_adcs; })
66 .def_property_readonly_static("s_num_adc_words", [](py::object /*self*/) { return DAPHNEFrame::s_num_adc_words; })
67 .def_property_readonly_static("s_expected_bytes", [](py::object /*self*/) { return DAPHNEFrame::s_expected_bytes; })
68 .def_static("sizeof", []() { return sizeof(DAPHNEFrame); })
69 .def("get_bytes", [](DAPHNEFrame* fr) -> py::bytes {
70 return py::bytes(reinterpret_cast<char*>(fr), sizeof(DAPHNEFrame)); // NOLINT
71 });
72
73 py::class_<DAPHNEFrame::Header>(m, "DAPHNEFrameHeader")
74 .def_property(
75 "channel",
76 [](DAPHNEFrame::Header& self) -> uint8_t { return self.channel; },
77 [](DAPHNEFrame::Header& self, uint8_t channel) { self.channel = channel; })
78 .def_property(
79 "algorithm_id",
80 [](DAPHNEFrame::Header& self) -> uint8_t { return self.algorithm_id; },
81 [](DAPHNEFrame::Header& self, uint8_t algorithm_id) { self.algorithm_id = algorithm_id; })
82 .def_property(
83 "r1",
84 [](DAPHNEFrame::Header& self) -> uint8_t { return self.r1; },
85 [](DAPHNEFrame::Header& self, uint8_t r1) { self.r1 = r1; })
86 .def_property(
87 "trigger_sample_value",
88 [](DAPHNEFrame::Header& self) -> uint16_t { return self.trigger_sample_value; },
89 [](DAPHNEFrame::Header& self, uint16_t tsv) { self.trigger_sample_value = tsv; })
90 .def_property(
91 "threshold",
92 [](DAPHNEFrame::Header& self) -> uint16_t { return self.threshold; },
93 [](DAPHNEFrame::Header& self, uint16_t threshold) { self.threshold = threshold; })
94 .def_property(
95 "baseline",
96 [](DAPHNEFrame::Header& self) -> uint16_t { return self.baseline; },
97 [](DAPHNEFrame::Header& self, uint16_t baseline) { self.baseline = baseline; })
98 .def_property_readonly_static("s_expected_bytes", [](py::object /*self*/) { return sizeof(DAPHNEFrame::Header); });
99
100 py::class_<DAPHNEFrame::PeakDescriptorData>(m, "DAPHNEFramePeakDescriptorData")
101 .def_property_readonly_static("s_expected_bytes",
102 [](py::object /*self*/) { return DAPHNEFrame::PeakDescriptorData::s_expected_bytes; })
103 .def_property_readonly_static("max_peaks",
104 [](py::object /*self*/) { return DAPHNEFrame::PeakDescriptorData::max_peaks; })
105 .def("is_found", &DAPHNEFrame::PeakDescriptorData::is_found)
106 .def("set_found", &DAPHNEFrame::PeakDescriptorData::set_found)
107
108 .def("get_adc_integral", &DAPHNEFrame::PeakDescriptorData::get_adc_integral)
109 .def("set_adc_integral", &DAPHNEFrame::PeakDescriptorData::set_adc_integral)
110
111 .def("get_num_subpeaks", &DAPHNEFrame::PeakDescriptorData::get_num_subpeaks)
112 .def("set_num_subpeaks", &DAPHNEFrame::PeakDescriptorData::set_num_subpeaks)
113
114 .def("get_samples_over_baseline", &DAPHNEFrame::PeakDescriptorData::get_samples_over_baseline)
115 .def("set_samples_over_baseline", &DAPHNEFrame::PeakDescriptorData::set_samples_over_baseline)
116
117 .def("get_sample_max", &DAPHNEFrame::PeakDescriptorData::get_sample_max)
118 .def("set_sample_max", &DAPHNEFrame::PeakDescriptorData::set_sample_max)
119
120 .def("get_adc_max", &DAPHNEFrame::PeakDescriptorData::get_adc_max)
121 .def("set_adc_max", &DAPHNEFrame::PeakDescriptorData::set_adc_max)
122
123 .def("get_sample_start", &DAPHNEFrame::PeakDescriptorData::get_sample_start)
124 .def("set_sample_start", &DAPHNEFrame::PeakDescriptorData::set_sample_start)
125
126 .def_property(
127 "num_subpeaks_0",
128 [](DAPHNEFrame::PeakDescriptorData& self) -> uint8_t { return self.num_subpeaks_0; },
129 [](DAPHNEFrame::PeakDescriptorData& self, uint8_t val) { self.num_subpeaks_0 = val; })
130 .def_property(
131 "adc_integral_0",
132 [](DAPHNEFrame::PeakDescriptorData& self) -> uint32_t { return self.adc_integral_0; },
133 [](DAPHNEFrame::PeakDescriptorData& self, uint32_t val) { self.adc_integral_0 = val; })
134 .def_property(
135 "found_0",
136 [](DAPHNEFrame::PeakDescriptorData& self) -> uint8_t { return self.found_0; },
137 [](DAPHNEFrame::PeakDescriptorData& self, uint8_t val) { self.found_0 = val; })
138 .def_property(
139 "adc_max_0",
140 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.adc_max_0; },
141 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.adc_max_0 = val; })
142 .def_property(
143 "sample_max_0",
144 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.sample_max_0; },
145 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.sample_max_0 = val; })
146 .def_property(
147 "samples_over_baseline_0",
148 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.samples_over_baseline_0; },
149 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.samples_over_baseline_0 = val; })
150
151 .def_property(
152 "num_subpeaks_1",
153 [](DAPHNEFrame::PeakDescriptorData& self) -> uint8_t { return self.num_subpeaks_1; },
154 [](DAPHNEFrame::PeakDescriptorData& self, uint8_t val) { self.num_subpeaks_1 = val; })
155 .def_property(
156 "adc_integral_1",
157 [](DAPHNEFrame::PeakDescriptorData& self) -> uint32_t { return self.adc_integral_1; },
158 [](DAPHNEFrame::PeakDescriptorData& self, uint32_t val) { self.adc_integral_1 = val; })
159 .def_property(
160 "found_1",
161 [](DAPHNEFrame::PeakDescriptorData& self) -> uint8_t { return self.found_1; },
162 [](DAPHNEFrame::PeakDescriptorData& self, uint8_t val) { self.found_1 = val; })
163 .def_property(
164 "adc_max_1",
165 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.adc_max_1; },
166 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.adc_max_1 = val; })
167 .def_property(
168 "sample_max_1",
169 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.sample_max_1; },
170 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.sample_max_1 = val; })
171 .def_property(
172 "samples_over_baseline_1",
173 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.samples_over_baseline_1; },
174 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.samples_over_baseline_1 = val; })
175
176 .def_property(
177 "num_subpeaks_2",
178 [](DAPHNEFrame::PeakDescriptorData& self) -> uint8_t { return self.num_subpeaks_2; },
179 [](DAPHNEFrame::PeakDescriptorData& self, uint8_t val) { self.num_subpeaks_2 = val; })
180 .def_property(
181 "adc_integral_2",
182 [](DAPHNEFrame::PeakDescriptorData& self) -> uint32_t { return self.adc_integral_2; },
183 [](DAPHNEFrame::PeakDescriptorData& self, uint32_t val) { self.adc_integral_2 = val; })
184 .def_property(
185 "found_2",
186 [](DAPHNEFrame::PeakDescriptorData& self) -> uint8_t { return self.found_2; },
187 [](DAPHNEFrame::PeakDescriptorData& self, uint8_t val) { self.found_2 = val; })
188 .def_property(
189 "adc_max_2",
190 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.adc_max_2; },
191 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.adc_max_2 = val; })
192 .def_property(
193 "sample_max_2",
194 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.sample_max_2; },
195 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.sample_max_2 = val; })
196 .def_property(
197 "samples_over_baseline_2",
198 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.samples_over_baseline_2; },
199 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.samples_over_baseline_2 = val; })
200
201 .def_property(
202 "num_subpeaks_3",
203 [](DAPHNEFrame::PeakDescriptorData& self) -> uint8_t { return self.num_subpeaks_3; },
204 [](DAPHNEFrame::PeakDescriptorData& self, uint8_t val) { self.num_subpeaks_3 = val; })
205 .def_property(
206 "adc_integral_3",
207 [](DAPHNEFrame::PeakDescriptorData& self) -> uint32_t { return self.adc_integral_3; },
208 [](DAPHNEFrame::PeakDescriptorData& self, uint32_t val) { self.adc_integral_3 = val; })
209 .def_property(
210 "found_3",
211 [](DAPHNEFrame::PeakDescriptorData& self) -> uint8_t { return self.found_3; },
212 [](DAPHNEFrame::PeakDescriptorData& self, uint8_t val) { self.found_3 = val; })
213 .def_property(
214 "adc_max_3",
215 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.adc_max_3; },
216 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.adc_max_3 = val; })
217 .def_property(
218 "sample_max_3",
219 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.sample_max_3; },
220 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.sample_max_3 = val; })
221 .def_property(
222 "samples_over_baseline_3",
223 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.samples_over_baseline_3; },
224 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.samples_over_baseline_3 = val; })
225
226 .def_property(
227 "num_subpeaks_4",
228 [](DAPHNEFrame::PeakDescriptorData& self) -> uint8_t { return self.num_subpeaks_4; },
229 [](DAPHNEFrame::PeakDescriptorData& self, uint8_t val) { self.num_subpeaks_4 = val; })
230 .def_property(
231 "adc_integral_4",
232 [](DAPHNEFrame::PeakDescriptorData& self) -> uint32_t { return self.adc_integral_4; },
233 [](DAPHNEFrame::PeakDescriptorData& self, uint32_t val) { self.adc_integral_4 = val; })
234 .def_property(
235 "found_4",
236 [](DAPHNEFrame::PeakDescriptorData& self) -> uint8_t { return self.found_4; },
237 [](DAPHNEFrame::PeakDescriptorData& self, uint8_t val) { self.found_4 = val; })
238 .def_property(
239 "adc_max_4",
240 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.adc_max_4; },
241 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.adc_max_4 = val; })
242 .def_property(
243 "sample_max_4",
244 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.sample_max_4; },
245 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.sample_max_4 = val; })
246 .def_property(
247 "samples_over_baseline_4",
248 [](DAPHNEFrame::PeakDescriptorData& self) -> uint16_t { return self.samples_over_baseline_4; },
249 [](DAPHNEFrame::PeakDescriptorData& self, uint16_t val) { self.samples_over_baseline_4 = val; });
250
251} // NOLINT function length
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::get_sample_max
uint16_t get_sample_max(int idx) const
Get the Time_Peak value for a specific peak. (Word 2*idx+1, bits [17:9]).
Definition DAPHNEFrame.hxx:106
dunedaq::fddetdataformats::DAPHNEFrame::PeakDescriptorData::set_sample_max
void set_sample_max(uint16_t val, int idx)
Set the Time_Peak value for a specific peak.
Definition DAPHNEFrame.hxx:116
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
dunedaq::fddetdataformats::DAPHNEFrame::set_adc
void set_adc(int i, uint16_t val)
Set the ith ADC value in the frame to val.
Definition DAPHNEFrame.hxx:13
dunedaq::fddetdataformats::DAPHNEFrame::get_timestamp
uint64_t get_timestamp() const
Get the 64-bit timestamp of the frame.
Definition DAPHNEFrame.hpp:263
dunedaq::fddetdataformats::DAPHNEFrame::s_expected_bytes
static constexpr std::size_t s_expected_bytes
Definition DAPHNEFrame.hpp:243
dunedaq::fddetdataformats::DAPHNEFrame::get_adc
uint16_t get_adc(int i) const
Get the ith ADC value in the frame.
Definition DAPHNEFrame.hxx:5

◆ 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.trigger_sample_value; },
64 [](DAPHNEEthFrame::Header& self, uint32_t trigger_sample_value) {
65 self.trigger_sample_value = trigger_sample_value;
66 })
67 .def_property(
68 "threshold",
69 [](DAPHNEEthFrame::Header& self) -> uint32_t { return self.threshold; },
70 [](DAPHNEEthFrame::Header& self, uint32_t threshold) { self.threshold = threshold; })
71 .def_property(
72 "baseline",
73 [](DAPHNEEthFrame::Header& self) -> uint32_t { return self.baseline; },
74 [](DAPHNEEthFrame::Header& self, uint32_t baseline) { self.baseline = baseline; })
75 .def_property_readonly_static("s_expected_bytes",
76 [](py::object /*self*/) { return DAPHNEEthFrame::Header::s_expected_bytes; });
77
78 py::class_<DAPHNEEthFrame>(m, "DAPHNEEthFrame", py::buffer_protocol())
79 .def(py::init())
80 .def(py::init([](py::capsule capsule) {
81 auto wfp = *static_cast<DAPHNEEthFrame*>(capsule.get_pointer());
82 return wfp;
83 }))
84 .def(py::init([](py::bytes bytes) {
85 py::buffer_info info(py::buffer(bytes).request());
86 auto wfp = *static_cast<DAPHNEEthFrame*>(info.ptr);
87 return wfp;
88 }))
89 .def(
90 "get_daqheader",
91 [](DAPHNEEthFrame& self) -> const detdataformats::DAQEthHeader& { return self.daq_header; },
92 py::return_value_policy::reference_internal)
93 .def(
94 "get_daphneheader",
95 [](DAPHNEEthFrame& self) -> const DAPHNEEthFrame::Header& { return self.header; },
96 py::return_value_policy::reference_internal)
97 .def(
98 "get_header",
99 [](DAPHNEEthFrame& self) -> const DAPHNEEthFrame::Header& { return self.header; },
100 py::return_value_policy::reference_internal)
101 .def_property_readonly(
102 "daq_header",
103 [](DAPHNEEthFrame& self) -> detdataformats::DAQEthHeader& { return self.daq_header; },
104 py::return_value_policy::reference_internal)
105 .def_property_readonly(
106 "header",
107 [](DAPHNEEthFrame& self) -> DAPHNEEthFrame::Header& { return self.header; },
108 py::return_value_policy::reference_internal)
109 .def("get_adc", &DAPHNEEthFrame::get_adc)
110 .def("set_adc", &DAPHNEEthFrame::set_adc)
111 .def("get_timestamp", &DAPHNEEthFrame::get_timestamp)
112 .def("set_timestamp", &DAPHNEEthFrame::set_timestamp)
113 .def("get_channel", &DAPHNEEthFrame::get_channel)
114 .def("set_channel", &DAPHNEEthFrame::set_channel)
115 .def("__lt__", [](const DAPHNEEthFrame& lhs, const DAPHNEEthFrame& rhs) { return lhs < rhs; })
116 .def_property_readonly_static("version", [](py::object /*self*/) { return DAPHNEEthFrame::version; })
117 .def_property_readonly_static("s_bits_per_adc", [](py::object /*self*/) { return DAPHNEEthFrame::s_bits_per_adc; })
118 .def_property_readonly_static("s_bits_per_word",
119 [](py::object /*self*/) { return DAPHNEEthFrame::s_bits_per_word; })
120 .def_property_readonly_static("s_num_adcs", [](py::object /*self*/) { return DAPHNEEthFrame::s_num_adcs; })
121 .def_property_readonly_static("s_num_adc_words",
122 [](py::object /*self*/) { return DAPHNEEthFrame::s_num_adc_words; })
123 .def_property_readonly_static("s_expected_bytes",
124 [](py::object /*self*/) { return DAPHNEEthFrame::s_expected_bytes; })
125 .def_static("sizeof", []() { return sizeof(DAPHNEEthFrame); })
126 .def("get_bytes", [](DAPHNEEthFrame* fr) -> py::bytes {
127 return py::bytes(reinterpret_cast<char*>(fr), sizeof(DAPHNEEthFrame)); // NOLINT reinterpret_cast
128 });
129} // NOLINT (defensible use of "overly long" function)
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:96
dunedaq::fddetdataformats::DAPHNEEthFrame::get_timestamp
uint64_t get_timestamp() const
Get the starting 64-bit timestamp of the frame.
Definition DAPHNEEthFrame.hpp:93
dunedaq::fddetdataformats::DAPHNEEthFrame::set_channel
void set_channel(const uint8_t new_channel)
Set the channel identifier of the frame.
Definition DAPHNEEthFrame.hpp:102
dunedaq::fddetdataformats::DAPHNEEthFrame::get_channel
uint8_t get_channel() const
Get the channel identifier of the frame.
Definition DAPHNEEthFrame.hpp:99
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 .def_property_readonly_static("s_expected_bytes",
38 [](py::object /*self*/) { return sizeof(DAPHNEEthStreamFrame::ChannelWord); });
39
40 py::class_<DAPHNEEthStreamFrame::Header>(m, "DAPHNEEthStreamHeader")
41 .def_property(
42 "channel_words",
43 [](DAPHNEEthStreamFrame::Header& self) -> py::list {
44 py::list result;
45 for (int i = 0; i < 4; i++) {
46 result.append(self.channel_words[i]);
47 }
48 return result;
49 },
50 [](DAPHNEEthStreamFrame::Header& self, py::list channel_words) {
51 for (int i = 0; i < 4 && i < static_cast<int>(len(channel_words)); i++) {
52 self.channel_words[i] = channel_words[i].cast<DAPHNEEthStreamFrame::ChannelWord>();
53 }
54 })
55 .def_property_readonly_static("s_expected_bytes",
56 [](py::object /*self*/) { return sizeof(DAPHNEEthStreamFrame::Header); });
57
58 py::class_<DAPHNEEthStreamFrame>(m, "DAPHNEEthStreamFrame", py::buffer_protocol())
59 .def(py::init())
60 .def(py::init([](py::capsule capsule) {
61 auto wfp = *static_cast<DAPHNEEthStreamFrame*>(capsule.get_pointer());
62 return wfp;
63 }))
64 .def(py::init([](py::bytes bytes) {
65 py::buffer_info info(py::buffer(bytes).request());
66 auto wfp = *static_cast<DAPHNEEthStreamFrame*>(info.ptr);
67 return wfp;
68 }))
69 .def(
70 "get_daqheader",
71 [](DAPHNEEthStreamFrame& self) -> const detdataformats::DAQEthHeader& { return self.daq_header; },
72 py::return_value_policy::reference_internal)
73 .def(
74 "get_daphneheader",
75 [](DAPHNEEthStreamFrame& self) -> const DAPHNEEthStreamFrame::Header& { return self.header; },
76 py::return_value_policy::reference_internal)
77 .def(
78 "get_header",
79 [](DAPHNEEthStreamFrame& self) -> const DAPHNEEthStreamFrame::Header& { return self.header; },
80 py::return_value_policy::reference_internal)
81 .def_property_readonly(
82 "daq_header",
83 [](DAPHNEEthStreamFrame& self) -> detdataformats::DAQEthHeader& { return self.daq_header; },
84 py::return_value_policy::reference_internal)
85 .def_property_readonly(
86 "header",
87 [](DAPHNEEthStreamFrame& self) -> DAPHNEEthStreamFrame::Header& { return self.header; },
88 py::return_value_policy::reference_internal)
89 .def("get_adc", &DAPHNEEthStreamFrame::get_adc)
90 .def("set_adc", &DAPHNEEthStreamFrame::set_adc)
91 .def("get_timestamp", &DAPHNEEthStreamFrame::get_timestamp)
92 .def("set_timestamp", &DAPHNEEthStreamFrame::set_timestamp)
93 .def("__lt__", [](const DAPHNEEthStreamFrame& lhs, const DAPHNEEthStreamFrame& rhs) { return lhs < rhs; })
94 .def("get_channel", &DAPHNEEthStreamFrame::get_channel)
95 .def("set_channel", &DAPHNEEthStreamFrame::set_channel)
96 .def_property_readonly_static("version", [](py::object /*self*/) { return DAPHNEEthStreamFrame::version; })
97 .def_property_readonly_static("s_bits_per_adc",
98 [](py::object /*self*/) { return DAPHNEEthStreamFrame::s_bits_per_adc; })
99 .def_property_readonly_static("s_bits_per_word",
100 [](py::object /*self*/) { return DAPHNEEthStreamFrame::s_bits_per_word; })
101 .def_property_readonly_static("s_adcs_per_channel",
102 [](py::object /*self*/) { return DAPHNEEthStreamFrame::s_adcs_per_channel; })
103 .def_property_readonly_static("s_num_channels",
104 [](py::object /*self*/) { return DAPHNEEthStreamFrame::s_num_channels; })
105 .def_property_readonly_static("s_num_adc_words",
106 [](py::object /*self*/) { return DAPHNEEthStreamFrame::s_num_adc_words; })
107 .def_property_readonly_static("s_expected_bytes",
108 [](py::object /*self*/) { return DAPHNEEthStreamFrame::s_expected_bytes; })
109 .def("get_channel0", &DAPHNEEthStreamFrame::get_channel0)
110 .def("get_channel1", &DAPHNEEthStreamFrame::get_channel1)
111 .def("get_channel2", &DAPHNEEthStreamFrame::get_channel2)
112 .def("get_channel3", &DAPHNEEthStreamFrame::get_channel3)
113 .def_static("sizeof", []() { return sizeof(DAPHNEEthStreamFrame); })
114 .def("get_bytes", [](DAPHNEEthStreamFrame* fr) -> py::bytes {
115 return py::bytes(reinterpret_cast<char*>(fr), sizeof(DAPHNEEthStreamFrame)); // NOLINT reinterpret_cast
116 });
117} // NOLINT (defensible use of "overly long" function)
afc.click_texttable.len
len(iterable)
Definition click_texttable.py:110
dunedaq::fddetdataformats::DAPHNEEthStreamFrame::get_channel1
uint8_t get_channel1() const
Get the channel 1 from the DAPHNE Stream frame header.
Definition DAPHNEEthStreamFrame.hpp:95
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:83
dunedaq::fddetdataformats::DAPHNEEthStreamFrame::get_channel0
uint8_t get_channel0() const
Get the channel 0 from the DAPHNE Stream frame header.
Definition DAPHNEEthStreamFrame.hpp:92
dunedaq::fddetdataformats::DAPHNEEthStreamFrame::get_channel
uint8_t get_channel(const int i_channel) const
Get the channel identifier of the frame.
Definition DAPHNEEthStreamFrame.hxx:5
dunedaq::fddetdataformats::DAPHNEEthStreamFrame::set_channel
void set_channel(const int i_channel, const uint8_t new_channel_val)
Set the channel identifier of the frame.
Definition DAPHNEEthStreamFrame.hxx:16
dunedaq::fddetdataformats::DAPHNEEthStreamFrame::get_adc
uint16_t get_adc(int i_adc, int 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::set_adc
void set_adc(int i_adc, int i_channel, 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_channel3
uint8_t get_channel3() const
Get the channel 3 from the DAPHNE Stream frame header.
Definition DAPHNEEthStreamFrame.hpp:101
dunedaq::fddetdataformats::DAPHNEEthStreamFrame::get_channel2
uint8_t get_channel2() const
Get the channel 2 from the DAPHNE Stream frame header.
Definition DAPHNEEthStreamFrame.hpp:98
dunedaq::fddetdataformats::DAPHNEEthStreamFrame::get_timestamp
uint64_t get_timestamp() const
Get the starting 64-bit timestamp of the frame.
Definition DAPHNEEthStreamFrame.hpp:80

◆ register_daphneethstream() [2/2]

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

◆ register_daphnestream() [1/2]

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

Definition at line 21 of file daphnestream.cpp.

22{
23
24 py::class_<DAPHNEStreamFrame::Header>(m, "DAPHNEStreamHeader")
25 .def_property(
26 "channel_0",
27 [](DAPHNEStreamFrame::Header& self) -> uint32_t { return self.channel_0; },
28 [](DAPHNEStreamFrame::Header& self, uint32_t channel_0) { self.channel_0 = channel_0; })
29 .def_property(
30 "channel_1",
31 [](DAPHNEStreamFrame::Header& self) -> uint32_t { return self.channel_1; },
32 [](DAPHNEStreamFrame::Header& self, uint32_t channel_1) { self.channel_1 = channel_1; })
33 .def_property(
34 "channel_2",
35 [](DAPHNEStreamFrame::Header& self) -> uint32_t { return self.channel_2; },
36 [](DAPHNEStreamFrame::Header& self, uint32_t channel_2) { self.channel_2 = channel_2; })
37 .def_property(
38 "channel_3",
39 [](DAPHNEStreamFrame::Header& self) -> uint32_t { return self.channel_3; },
40 [](DAPHNEStreamFrame::Header& self, uint32_t channel_3) { self.channel_3 = channel_3; })
41 .def_property_readonly_static("s_expected_bytes",
42 [](py::object /*self*/) { return sizeof(DAPHNEStreamFrame::Header); });
43
44 py::class_<DAPHNEStreamFrame>(m, "DAPHNEStreamFrame", py::buffer_protocol())
45 .def(py::init())
46 .def(py::init([](py::capsule capsule) {
47 auto wfp = *static_cast<DAPHNEStreamFrame*>(capsule.get_pointer());
48 return wfp;
49 }))
50 .def(py::init([](py::bytes bytes) {
51 py::buffer_info info(py::buffer(bytes).request());
52 auto wfp = *static_cast<DAPHNEStreamFrame*>(info.ptr);
53 return wfp;
54 }))
55 .def_property_readonly(
56 "daq_header",
57 [](DAPHNEStreamFrame& self) -> detdataformats::DAQHeader& { return self.daq_header; },
58 py::return_value_policy::reference_internal)
59 .def_property_readonly(
60 "header",
61 [](DAPHNEStreamFrame& self) -> DAPHNEStreamFrame::Header& { return self.header; },
62 py::return_value_policy::reference_internal)
63 .def("get_timestamp", &DAPHNEStreamFrame::get_timestamp)
64 .def("set_timestamp", &DAPHNEStreamFrame::set_timestamp)
65 .def("get_adc", &DAPHNEStreamFrame::get_adc)
66 .def("set_adc", &DAPHNEStreamFrame::set_adc)
67 .def("__lt__", [](const DAPHNEStreamFrame& lhs, const DAPHNEStreamFrame& rhs) { return lhs < rhs; })
68 .def_property_readonly_static("s_bits_per_adc",
69 [](py::object /*self*/) { return DAPHNEStreamFrame::s_bits_per_adc; })
70 .def_property_readonly_static("s_bits_per_word",
71 [](py::object /*self*/) { return DAPHNEStreamFrame::s_bits_per_word; })
72 .def_property_readonly_static("s_channels_per_frame",
73 [](py::object /*self*/) { return DAPHNEStreamFrame::s_channels_per_frame; })
74 .def_property_readonly_static("s_adcs_per_channel",
75 [](py::object /*self*/) { return DAPHNEStreamFrame::s_adcs_per_channel; })
76 .def_property_readonly_static("s_daphnes_per_frame",
77 [](py::object /*self*/) { return DAPHNEStreamFrame::s_daphnes_per_frame; })
78 .def_property_readonly_static("s_num_adc_words",
79 [](py::object /*self*/) { return DAPHNEStreamFrame::s_num_adc_words; })
80 .def_property_readonly_static("s_expected_bytes",
81 [](py::object /*self*/) { return DAPHNEStreamFrame::s_expected_bytes; })
82 .def("get_channel0", &DAPHNEStreamFrame::get_channel0)
83 .def("get_channel1", &DAPHNEStreamFrame::get_channel1)
84 .def("get_channel2", &DAPHNEStreamFrame::get_channel2)
85 .def("get_channel3", &DAPHNEStreamFrame::get_channel3)
86 .def_static("sizeof", []() { return sizeof(DAPHNEStreamFrame); })
87 .def("get_bytes", [](DAPHNEStreamFrame* fr) -> py::bytes {
88 return py::bytes(reinterpret_cast<char*>(fr), sizeof(DAPHNEStreamFrame)); // NOLINT
89 });
90}
dunedaq::fddetdataformats::DAPHNEStreamFrame::set_adc
void set_adc(int i, int i_channel, uint16_t val)
Set the i ADC value of chn in the frame to val.
Definition DAPHNEStreamFrame.hxx:14
dunedaq::fddetdataformats::DAPHNEStreamFrame::set_timestamp
void set_timestamp(const uint64_t new_timestamp)
Set the 64-bit timestamp of the frame.
Definition DAPHNEStreamFrame.hpp:65
dunedaq::fddetdataformats::DAPHNEStreamFrame::get_adc
uint16_t get_adc(int i_adc, int i_channel) const
Get the i ADC value of chn in the frame.
Definition DAPHNEStreamFrame.hxx:5

◆ register_daphnestream() [2/2]

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

◆ register_tdeeth() [1/2]

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

Definition at line 21 of file tdeeth.cpp.

22{
23 py::class_<TDEEthFrame::TDEEthHeader>(m, "TDEEthHeader")
24 .def_property(
25 "channel",
26 [](TDEEthFrame::TDEEthHeader& self) -> uint16_t { return self.channel; },
27 [](TDEEthFrame::TDEEthHeader& self, uint16_t channel) { self.channel = channel; })
28 .def_property(
29 "version",
30 [](TDEEthFrame::TDEEthHeader& self) -> uint16_t { return self.version; },
31 [](TDEEthFrame::TDEEthHeader& self, uint16_t version) { self.version = version; })
32 .def_property(
33 "tde_header",
34 [](TDEEthFrame::TDEEthHeader& self) -> uint16_t { return self.tde_header; },
35 [](TDEEthFrame::TDEEthHeader& self, uint16_t tde_header) { self.tde_header = tde_header; })
36 .def_property(
37 "tde_errors",
38 [](TDEEthFrame::TDEEthHeader& self) -> uint16_t { return self.tde_errors; },
39 [](TDEEthFrame::TDEEthHeader& self, uint16_t tde_errors) { self.tde_errors = tde_errors; })
40 .def_property(
41 "TAItime",
42 [](TDEEthFrame::TDEEthHeader& self) -> uint64_t { return self.TAItime; },
43 [](TDEEthFrame::TDEEthHeader& self, uint64_t TAItime) { self.TAItime = TAItime; })
44 .def_property_readonly_static("s_expected_bytes",
45 [](py::object /*self*/) { return TDEEthFrame::TDEEthHeader::s_expected_bytes; });
46
47 py::class_<TDEEthFrame>(m, "TDEEthFrame", py::buffer_protocol())
48 .def(py::init())
49 .def(py::init([](py::capsule capsule) {
50 auto tfp = *static_cast<TDEEthFrame*>(capsule.get_pointer());
51 return tfp;
52 }))
53 .def(py::init([](py::bytes bytes) {
54 py::buffer_info info(py::buffer(bytes).request());
55 auto tfp = *static_cast<TDEEthFrame*>(info.ptr);
56 return tfp;
57 }))
58 .def(
59 "get_daqheader",
60 [](TDEEthFrame& self) -> const detdataformats::DAQEthHeader& { return self.daq_header; },
61 py::return_value_policy::reference_internal)
62 .def(
63 "get_tdeheader",
64 [](TDEEthFrame& self) -> const TDEEthFrame::TDEEthHeader& { return self.header; },
65 py::return_value_policy::reference_internal)
66 .def_property_readonly(
67 "daq_header",
68 [](TDEEthFrame& self) -> detdataformats::DAQEthHeader& { return self.daq_header; },
69 py::return_value_policy::reference_internal)
70 .def_property_readonly(
71 "header",
72 [](TDEEthFrame& self) -> TDEEthFrame::TDEEthHeader& { return self.header; },
73 py::return_value_policy::reference_internal)
74 .def("get_adc", &TDEEthFrame::get_adc)
75 .def("set_adc", &TDEEthFrame::set_adc)
76 .def("get_timestamp", &TDEEthFrame::get_timestamp)
77 .def("set_timestamp", &TDEEthFrame::set_timestamp)
78 .def("get_channel", &TDEEthFrame::get_channel)
79 .def("set_channel", &TDEEthFrame::set_channel)
80 .def("__lt__", [](const TDEEthFrame& lhs, const TDEEthFrame& rhs) { return lhs < rhs; })
81 .def_property_readonly_static("s_bits_per_adc", [](py::object /*self*/) { return TDEEthFrame::s_bits_per_adc; })
82 .def_property_readonly_static("s_bits_per_word", [](py::object /*self*/) { return TDEEthFrame::s_bits_per_word; })
83 .def_property_readonly_static("s_time_samples_per_frame",
84 [](py::object /*self*/) { return TDEEthFrame::s_time_samples_per_frame; })
85 .def_property_readonly_static("s_channels_per_half_femb",
86 [](py::object /*self*/) { return TDEEthFrame::s_channels_per_half_femb; })
87 .def_property_readonly_static("s_half_fembs_per_frame",
88 [](py::object /*self*/) { return TDEEthFrame::s_half_fembs_per_frame; })
89 .def_property_readonly_static("s_num_channels", [](py::object /*self*/) { return TDEEthFrame::s_num_channels; })
90 .def_property_readonly_static("s_num_adc_words_per_ts",
91 [](py::object /*self*/) { return TDEEthFrame::s_num_adc_words_per_ts; })
92 .def_property_readonly_static("s_expected_bytes", [](py::object /*self*/) { return TDEEthFrame::s_expected_bytes; })
93 .def_static("sizeof", []() { return sizeof(TDEEthFrame); })
94 .def("get_bytes", [](TDEEthFrame* fr) -> py::bytes {
95 return py::bytes(reinterpret_cast<char*>(fr), sizeof(TDEEthFrame)); // NOLINT reinterpret_cast
96 });
97} // NOLINT (defensible use of "overly long" function)
dunedaq::fddetdataformats::TDEEthFrame::s_channels_per_half_femb
static constexpr int s_channels_per_half_femb
Definition TDEEthFrame.hpp:49
dunedaq::fddetdataformats::TDEEthFrame::s_expected_bytes
static constexpr size_t s_expected_bytes
Definition TDEEthFrame.hpp:67
dunedaq::fddetdataformats::TDEEthFrame::set_channel
void set_channel(const uint8_t new_channel)
Set the channel identifier of the frame.
Definition TDEEthFrame.hpp:92
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::s_time_samples_per_frame
static constexpr int s_time_samples_per_frame
Definition TDEEthFrame.hpp:48
dunedaq::fddetdataformats::TDEEthFrame::get_channel
uint8_t get_channel() const
Get the channel identifier of the frame.
Definition TDEEthFrame.hpp:89
dunedaq::fddetdataformats::TDEEthFrame::s_num_adc_words_per_ts
static constexpr int s_num_adc_words_per_ts
Definition TDEEthFrame.hpp:52
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:86
dunedaq::fddetdataformats::TDEEthFrame::get_timestamp
uint64_t get_timestamp() const
Get the starting 64-bit timestamp of the frame.
Definition TDEEthFrame.hpp:83
dunedaq::fddetdataformats::TDEEthFrame::s_half_fembs_per_frame
static constexpr int s_half_fembs_per_frame
Definition TDEEthFrame.hpp:50

◆ register_tdeeth() [2/2]

void dunedaq::fddetdataformats::python::register_tdeeth ( 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(
34 "cd",
35 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t { return self.cd; },
36 [](WIBEthFrame::WIBEthHeader& self, uint32_t cd) { self.cd = cd; })
37 .def_property(
38 "context",
39 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t { return self.context; },
40 [](WIBEthFrame::WIBEthHeader& self, uint32_t context) { self.context = context; })
41 .def_property(
42 "ready",
43 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t { return self.ready; },
44 [](WIBEthFrame::WIBEthHeader& self, uint32_t ready) { self.ready = ready; })
45 .def_property(
46 "calibration",
47 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t { return self.calibration; },
48 [](WIBEthFrame::WIBEthHeader& self, uint32_t calibration) { self.calibration = calibration; })
49 .def_property(
50 "pulser",
51 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t { return self.pulser; },
52 [](WIBEthFrame::WIBEthHeader& self, uint32_t pulser) { self.pulser = pulser; })
53 .def_property(
54 "femb_sync",
55 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t { return self.femb_sync; },
56 [](WIBEthFrame::WIBEthHeader& self, uint32_t femb_sync) { self.femb_sync = femb_sync; })
57 .def_property(
58 "wib_sync",
59 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t { return self.wib_sync; },
60 [](WIBEthFrame::WIBEthHeader& self, uint32_t wib_sync) { self.wib_sync = wib_sync; })
61 .def_property(
62 "lol",
63 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t { return self.lol; },
64 [](WIBEthFrame::WIBEthHeader& self, uint32_t lol) { self.lol = lol; })
65 .def_property(
66 "link_valid",
67 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t { return self.link_valid; },
68 [](WIBEthFrame::WIBEthHeader& self, uint32_t link_valid) { self.link_valid = link_valid; })
69 .def_property(
70 "crc_err",
71 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t { return self.crc_err; },
72 [](WIBEthFrame::WIBEthHeader& self, uint32_t crc_err) { self.crc_err = crc_err; })
73 .def_property(
74 "colddata_timestamp_1",
75 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t { return self.colddata_timestamp_1; },
76 [](WIBEthFrame::WIBEthHeader& self, uint32_t colddata_timestamp_1) {
77 self.colddata_timestamp_1 = colddata_timestamp_1;
78 })
79 .def_property(
80 "colddata_timestamp_0",
81 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t { return self.colddata_timestamp_0; },
82 [](WIBEthFrame::WIBEthHeader& self, uint32_t colddata_timestamp_0) {
83 self.colddata_timestamp_0 = colddata_timestamp_0;
84 })
85 .def_property(
86 "extra_data",
87 [](WIBEthFrame::WIBEthHeader& self) -> uint64_t { return self.extra_data; },
88 [](WIBEthFrame::WIBEthHeader& self, uint64_t extra_data) { self.extra_data = extra_data; })
89 .def_property_readonly_static("s_expected_bytes",
90 [](py::object /*self*/) { return WIBEthFrame::WIBEthHeader::s_expected_bytes; });
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_property_readonly(
112 "daq_header",
113 [](WIBEthFrame& self) -> detdataformats::DAQEthHeader& { return self.daq_header; },
114 py::return_value_policy::reference_internal)
115 .def_property_readonly(
116 "header",
117 [](WIBEthFrame& self) -> WIBEthFrame::WIBEthHeader& { return self.header; },
118 py::return_value_policy::reference_internal)
119 .def("get_adc", &WIBEthFrame::get_adc)
120 .def("set_adc", &WIBEthFrame::set_adc)
121 .def("get_timestamp", &WIBEthFrame::get_timestamp)
122 .def("set_timestamp", &WIBEthFrame::set_timestamp)
123 .def("get_channel", &WIBEthFrame::get_channel)
124 .def("set_channel", &WIBEthFrame::set_channel)
125 .def("__lt__", [](const WIBEthFrame& lhs, const WIBEthFrame& rhs) { return lhs < rhs; })
126 .def_property_readonly_static("s_bits_per_adc", [](py::object /*self*/) { return WIBEthFrame::s_bits_per_adc; })
127 .def_property_readonly_static("s_bits_per_word", [](py::object /*self*/) { return WIBEthFrame::s_bits_per_word; })
128 .def_property_readonly_static("s_time_samples_per_frame",
129 [](py::object /*self*/) { return WIBEthFrame::s_time_samples_per_frame; })
130 .def_property_readonly_static("s_channels_per_half_femb",
131 [](py::object /*self*/) { return WIBEthFrame::s_channels_per_half_femb; })
132 .def_property_readonly_static("s_half_fembs_per_frame",
133 [](py::object /*self*/) { return WIBEthFrame::s_half_fembs_per_frame; })
134 .def_property_readonly_static("s_num_channels", [](py::object /*self*/) { return WIBEthFrame::s_num_channels; })
135 .def_property_readonly_static("s_num_adc_words_per_ts",
136 [](py::object /*self*/) { return WIBEthFrame::s_num_adc_words_per_ts; })
137 .def_property_readonly_static("s_expected_bytes", [](py::object /*self*/) { return WIBEthFrame::s_expected_bytes; })
138 .def_static("sizeof", []() { return sizeof(WIBEthFrame); })
139 .def("get_bytes", [](WIBEthFrame* fr) -> py::bytes {
140 return py::bytes(reinterpret_cast<char*>(fr), sizeof(WIBEthFrame)); // NOLINT reinterpret_cast
141 });
142} // 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:93
dunedaq::fddetdataformats::WIBEthFrame::s_half_fembs_per_frame
static constexpr int s_half_fembs_per_frame
Definition WIBEthFrame.hpp:49
dunedaq::fddetdataformats::WIBEthFrame::set_channel
void set_channel(const uint8_t new_channel)
Set the channel identifier of the frame.
Definition WIBEthFrame.hpp:102
dunedaq::fddetdataformats::WIBEthFrame::s_expected_bytes
static constexpr size_t s_expected_bytes
Definition WIBEthFrame.hpp:77
dunedaq::fddetdataformats::WIBEthFrame::get_channel
uint8_t get_channel() const
Get the channel identifier of the frame.
Definition WIBEthFrame.hpp:99
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::s_time_samples_per_frame
static constexpr int s_time_samples_per_frame
Definition WIBEthFrame.hpp:47
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:96
dunedaq::fddetdataformats::WIBEthFrame::s_num_adc_words_per_ts
static constexpr int s_num_adc_words_per_ts
Definition WIBEthFrame.hpp:51
dunedaq::fddetdataformats::WIBEthFrame::s_channels_per_half_femb
static constexpr int s_channels_per_half_femb
Definition WIBEthFrame.hpp:48

◆ register_wibeth() [2/2]

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