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