Line data Source code
1 : /**
2 : * @file daphneethstream.cpp Python bindings for the DAPHNEEthStreamFrame format
3 : *
4 : * This is part of the DUNE DAQ Software Suite, copyright 2020.
5 : * Licensing/copyright details are in the COPYING file that you should have
6 : * received with this code.
7 : */
8 :
9 : #include "fddetdataformats/DAPHNEEthStreamFrame.hpp"
10 :
11 : #include <pybind11/pybind11.h>
12 : #include <pybind11/stl.h>
13 :
14 : namespace py = pybind11;
15 :
16 : namespace dunedaq::fddetdataformats::python {
17 :
18 : // NOLINTBEGIN(build/unsigned)
19 :
20 : void
21 0 : register_daphneethstream(py::module& m)
22 : {
23 :
24 0 : py::class_<DAPHNEEthStreamFrame::ChannelWord>(m, "DAPHNEEthStreamChannelWord")
25 0 : .def_property(
26 : "tbd",
27 0 : [](DAPHNEEthStreamFrame::ChannelWord& self) -> uint64_t { return self.tbd; },
28 0 : [](DAPHNEEthStreamFrame::ChannelWord& self, uint64_t tbd) { self.tbd = tbd; })
29 0 : .def_property(
30 : "version",
31 0 : [](DAPHNEEthStreamFrame::ChannelWord& self) -> uint64_t { return self.version; },
32 0 : [](DAPHNEEthStreamFrame::ChannelWord& self, uint64_t version) { self.version = version; })
33 0 : .def_property(
34 : "channel",
35 0 : [](DAPHNEEthStreamFrame::ChannelWord& self) -> uint64_t { return self.channel; },
36 0 : [](DAPHNEEthStreamFrame::ChannelWord& self, uint64_t channel) { self.channel = channel; })
37 0 : .def_property_readonly_static("s_expected_bytes", [](py::object /*self*/) {
38 : return sizeof(DAPHNEEthStreamFrame::ChannelWord);
39 : });
40 :
41 0 : py::class_<DAPHNEEthStreamFrame::Header>(m, "DAPHNEEthStreamHeader")
42 0 : .def_property(
43 : "channel_words",
44 0 : [](DAPHNEEthStreamFrame::Header& self) -> py::list {
45 0 : py::list result;
46 0 : for (int i = 0; i < 4; i++) {
47 0 : result.append(self.channel_words[i]);
48 : }
49 0 : return result;
50 0 : },
51 0 : [](DAPHNEEthStreamFrame::Header& self, py::list channel_words) {
52 0 : for (int i = 0; i < 4 && i < static_cast<int>(len(channel_words)); i++) {
53 0 : self.channel_words[i] = channel_words[i].cast<DAPHNEEthStreamFrame::ChannelWord>();
54 : }
55 0 : })
56 0 : .def_property_readonly_static("s_expected_bytes", [](py::object /*self*/) {
57 : return sizeof(DAPHNEEthStreamFrame::Header);
58 : });
59 :
60 0 : py::class_<DAPHNEEthStreamFrame>(m, "DAPHNEEthStreamFrame", py::buffer_protocol())
61 0 : .def(py::init())
62 0 : .def(py::init([](py::capsule capsule) {
63 0 : auto wfp = *static_cast<DAPHNEEthStreamFrame*>(capsule.get_pointer());
64 0 : return wfp;
65 : }))
66 0 : .def(py::init([](py::bytes bytes) {
67 0 : py::buffer_info info(py::buffer(bytes).request());
68 0 : auto wfp = *static_cast<DAPHNEEthStreamFrame*>(info.ptr);
69 0 : return wfp;
70 0 : }))
71 0 : .def(
72 : "get_daqheader",
73 0 : [](DAPHNEEthStreamFrame& self) -> const detdataformats::DAQEthHeader& { return self.daq_header; },
74 0 : py::return_value_policy::reference_internal)
75 0 : .def(
76 : "get_daphneheader",
77 0 : [](DAPHNEEthStreamFrame& self) -> const DAPHNEEthStreamFrame::Header& { return self.header; },
78 0 : py::return_value_policy::reference_internal)
79 0 : .def(
80 : "get_header",
81 0 : [](DAPHNEEthStreamFrame& self) -> const DAPHNEEthStreamFrame::Header& { return self.header; },
82 0 : py::return_value_policy::reference_internal)
83 0 : .def_property_readonly(
84 : "daq_header",
85 0 : [](DAPHNEEthStreamFrame& self) -> detdataformats::DAQEthHeader& { return self.daq_header; },
86 0 : py::return_value_policy::reference_internal)
87 0 : .def_property_readonly(
88 : "header",
89 0 : [](DAPHNEEthStreamFrame& self) -> DAPHNEEthStreamFrame::Header& { return self.header; },
90 0 : py::return_value_policy::reference_internal)
91 0 : .def("get_adc", &DAPHNEEthStreamFrame::get_adc)
92 0 : .def("set_adc", &DAPHNEEthStreamFrame::set_adc)
93 0 : .def("get_timestamp", &DAPHNEEthStreamFrame::get_timestamp)
94 0 : .def("set_timestamp", &DAPHNEEthStreamFrame::set_timestamp)
95 0 : .def("__lt__", [](const DAPHNEEthStreamFrame& lhs, const DAPHNEEthStreamFrame& rhs) { return lhs < rhs; })
96 0 : .def("get_channel", &DAPHNEEthStreamFrame::get_channel)
97 0 : .def("set_channel", &DAPHNEEthStreamFrame::set_channel)
98 0 : .def_property_readonly_static("version", [](py::object /*self*/) { return DAPHNEEthStreamFrame::version; })
99 0 : .def_property_readonly_static("s_bits_per_adc", [](py::object /*self*/) {
100 : return DAPHNEEthStreamFrame::s_bits_per_adc;
101 : })
102 0 : .def_property_readonly_static("s_bits_per_word", [](py::object /*self*/) {
103 : return DAPHNEEthStreamFrame::s_bits_per_word;
104 : })
105 0 : .def_property_readonly_static("s_adcs_per_channel", [](py::object /*self*/) {
106 : return DAPHNEEthStreamFrame::s_adcs_per_channel;
107 : })
108 0 : .def_property_readonly_static("s_num_channels", [](py::object /*self*/) {
109 : return DAPHNEEthStreamFrame::s_num_channels;
110 : })
111 0 : .def_property_readonly_static("s_num_adc_words", [](py::object /*self*/) {
112 : return DAPHNEEthStreamFrame::s_num_adc_words;
113 : })
114 0 : .def_property_readonly_static("s_expected_bytes", [](py::object /*self*/) {
115 : return DAPHNEEthStreamFrame::s_expected_bytes;
116 : })
117 0 : .def("get_channel0", &DAPHNEEthStreamFrame::get_channel0)
118 0 : .def("get_channel1", &DAPHNEEthStreamFrame::get_channel1)
119 0 : .def("get_channel2", &DAPHNEEthStreamFrame::get_channel2)
120 0 : .def("get_channel3", &DAPHNEEthStreamFrame::get_channel3)
121 0 : .def_static("sizeof", []() { return sizeof(DAPHNEEthStreamFrame); })
122 0 : .def("get_bytes", [](DAPHNEEthStreamFrame* fr) -> py::bytes {
123 0 : return py::bytes(reinterpret_cast<char*>(fr), sizeof(DAPHNEEthStreamFrame)); // NOLINT reinterpret_cast
124 : });
125 0 : } // NOLINT (defensible use of "overly long" function)
126 :
127 : // NOLINTEND(build/unsigned)
128 :
129 : } // namespace dunedaq::fddetdataformats::python
|
