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)
 
 PYBIND11_MODULE (_daq_fddetdataformats_py, m)
 
void register_wib2 (pybind11::module &)
 
void register_wibeth (pybind11::module &)
 
void register_wib (pybind11::module &)
 
void register_daphne (pybind11::module &)
 
void register_tde (pybind11::module &)
 
void register_tdeeth (pybind11::module &)
 
void register_tde (py::module &m)
 
void register_tdeeth (py::module &m)
 
void register_wib (py::module &m)
 
void register_wib2 (py::module &m)
 
void register_wibeth (py::module &m)
 

Function Documentation

◆ PYBIND11_MODULE()

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

Definition at line 18 of file module.cpp.

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

◆ register_daphne() [1/2]

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

Definition at line 20 of file daphne.cpp.

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

◆ register_daphne() [2/2]

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

◆ register_tde() [1/2]

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

Definition at line 19 of file tde.cpp.

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

◆ register_tde() [2/2]

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

◆ register_tdeeth() [1/2]

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

Definition at line 19 of file tdeeth.cpp.

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

◆ register_tdeeth() [2/2]

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

◆ register_wib() [1/2]

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

Definition at line 19 of file wib.cpp.

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

◆ register_wib() [2/2]

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

◆ register_wib2() [1/2]

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

Definition at line 19 of file wib2.cpp.

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

◆ register_wib2() [2/2]

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

◆ register_wibeth() [1/2]

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

Definition at line 19 of file wibeth.cpp.

20{
21
22
23 py::class_<WIBEthFrame::WIBEthHeader>(m, "WIBEthHeader")
24 .def_property("channel",
25 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t {return self.channel;},
26 [](WIBEthFrame::WIBEthHeader& self, uint32_t channel) {self.channel = channel;}
27 )
28 .def_property("version",
29 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t {return self.version;},
30 [](WIBEthFrame::WIBEthHeader& self, uint32_t version) {self.version = version;}
31 )
32 // .def_property("reserved",
33 // [](WIBEthFrame::WIBEthHeader& self) -> uint32_t {return self.reserved;},
34 // [](WIBEthFrame::WIBEthHeader& self, uint32_t reserved) {self.reserved = reserved;}
35 // )
36 .def_property("cd",
37 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t {return self.cd;},
38 [](WIBEthFrame::WIBEthHeader& self, uint32_t cd) {self.version = cd;}
39 )
40 .def_property("context",
41 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t {return self.context;},
42 [](WIBEthFrame::WIBEthHeader& self, uint32_t context) {self.version = context;}
43 )
44 .def_property("ready",
45 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t {return self.ready;},
46 [](WIBEthFrame::WIBEthHeader& self, uint32_t ready) {self.ready = ready;}
47 )
48 .def_property("calibration",
49 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t {return self.calibration;},
50 [](WIBEthFrame::WIBEthHeader& self, uint32_t calibration) {self.calibration = calibration;}
51 )
52 .def_property("pulser",
53 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t {return self.pulser;},
54 [](WIBEthFrame::WIBEthHeader& self, uint32_t pulser) {self.pulser = pulser;}
55 )
56 .def_property("femb_sync",
57 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t {return self.femb_sync;},
58 [](WIBEthFrame::WIBEthHeader& self, uint32_t femb_sync) {self.femb_sync = femb_sync;}
59 )
60 .def_property("wib_sync",
61 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t {return self.wib_sync;},
62 [](WIBEthFrame::WIBEthHeader& self, uint32_t wib_sync) {self.wib_sync = wib_sync;}
63 )
64 .def_property("lol",
65 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t {return self.lol;},
66 [](WIBEthFrame::WIBEthHeader& self, uint32_t lol) {self.lol = lol;}
67 )
68 .def_property("link_valid",
69 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t {return self.link_valid;},
70 [](WIBEthFrame::WIBEthHeader& self, uint32_t link_valid) {self.link_valid = link_valid;}
71 )
72 .def_property("crc_err",
73 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t {return self.crc_err;},
74 [](WIBEthFrame::WIBEthHeader& self, uint32_t crc_err) {self.crc_err = crc_err;}
75 )
76 .def_property("colddata_timestamp_1",
77 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t {return self.colddata_timestamp_1;},
78 [](WIBEthFrame::WIBEthHeader& self, uint32_t colddata_timestamp_1) {self.lol = colddata_timestamp_1;}
79 )
80 .def_property("colddata_timestamp_0",
81 [](WIBEthFrame::WIBEthHeader& self) -> uint32_t {return self.colddata_timestamp_0;},
82 [](WIBEthFrame::WIBEthHeader& self, uint32_t colddata_timestamp_0) {self.colddata_timestamp_0 = colddata_timestamp_0;}
83 )
84 .def_property("extra_data",
85 [](WIBEthFrame::WIBEthHeader& self) -> uint64_t {return self.extra_data;},
86 [](WIBEthFrame::WIBEthHeader& self, uint64_t extra_data) {self.extra_data = extra_data;}
87 )
88 ;
89
90 py::class_<WIBEthFrame>(m, "WIBEthFrame", py::buffer_protocol())
91 .def(py::init())
92 .def(py::init([](py::capsule capsule) {
93 auto wfp = *static_cast<WIBEthFrame*>(capsule.get_pointer());
94 return wfp;
95 } ))
96 .def(py::init([](py::bytes bytes){
97 py::buffer_info info(py::buffer(bytes).request());
98 auto wfp = *static_cast<WIBEthFrame*>(info.ptr);
99 return wfp;
100 }))
101 .def("get_daqheader", [](WIBEthFrame& self) -> const detdataformats::DAQEthHeader& {return self.daq_header;}, py::return_value_policy::reference_internal)
102 .def("get_wibheader", [](WIBEthFrame& self) -> const WIBEthFrame::WIBEthHeader& {return self.header;}, py::return_value_policy::reference_internal)
103 .def("get_adc", &WIBEthFrame::get_adc)
104 .def("set_adc", &WIBEthFrame::set_adc)
105 .def("get_timestamp", &WIBEthFrame::get_timestamp)
106 .def("set_timestamp", &WIBEthFrame::set_timestamp)
107 .def("get_channel", &WIBEthFrame::get_channel)
108 .def("set_channel", &WIBEthFrame::set_channel)
109 .def_static("sizeof", [](){ return sizeof(WIBEthFrame); })
110 .def("get_bytes",
111 [](WIBEthFrame* fr) -> py::bytes {
112 return py::bytes(reinterpret_cast<char*>(fr), sizeof(WIBEthFrame));
113 })
114 ;
115}

◆ register_wibeth() [2/2]

void dunedaq::fddetdataformats::python::register_wibeth ( pybind11::module & )
Generated on Sat Jun 28 2025 for DUNE-DAQ by doxygen 1.12.0