Line data Source code
1 : /**
2 : * @file fragment.cpp
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 "daqdataformats/Fragment.hpp"
10 : #include "daqdataformats/FragmentHeader.hpp"
11 :
12 : #include <pybind11/pybind11.h>
13 : #include <pybind11/stl.h>
14 :
15 : #include <sstream>
16 :
17 : namespace py = pybind11;
18 : using namespace pybind11::literals; // to bring in the `_a` literal
19 :
20 : namespace dunedaq::daqdataformats::python {
21 :
22 : void
23 0 : register_fragment(py::module& m)
24 : {
25 :
26 0 : py::class_<Fragment> py_fragment(m, "Fragment", py::buffer_protocol());
27 :
28 0 : py_fragment.def("get_header", &Fragment::get_header, py::return_value_policy::reference_internal)
29 0 : .def("get_storage_location", &Fragment::get_storage_location, py::return_value_policy::reference_internal)
30 0 : .def("get_trigger_number", &Fragment::get_trigger_number)
31 0 : .def("get_run_number", &Fragment::get_run_number)
32 0 : .def("get_trigger_timestamp", &Fragment::get_trigger_timestamp)
33 0 : .def("get_window_begin", &Fragment::get_window_begin)
34 0 : .def("get_window_end", &Fragment::get_window_end)
35 0 : .def("get_element_id", &Fragment::get_element_id)
36 0 : .def("get_detector_id", &Fragment::get_detector_id)
37 0 : .def("get_status_bits", [](Fragment& self) { return self.get_status_bits().to_ullong(); })
38 0 : .def("get_status_bit", &Fragment::get_status_bit)
39 0 : .def("get_fragment_type_code", &Fragment::get_fragment_type_code)
40 0 : .def("get_fragment_type", &Fragment::get_fragment_type)
41 0 : .def("get_sequence_number", &Fragment::get_sequence_number)
42 0 : .def("get_size", &Fragment::get_size)
43 0 : .def("get_data_size", &Fragment::get_data_size)
44 0 : .def(
45 : "get_data",
46 0 : [](Fragment& self, size_t offset) {
47 0 : return static_cast<void*>(static_cast<char*>(self.get_data()) + offset); // NOLINT
48 : },
49 0 : "offset"_a = 0,
50 0 : py::return_value_policy::reference_internal)
51 0 : .def(
52 : "get_data_bytes",
53 0 : [](Fragment* self, size_t offset) -> py::bytes {
54 0 : if (offset > self->get_data_size()) {
55 0 : throw std::runtime_error("Fragment.get_data_bytes: offset exceeds fragment size.");
56 : }
57 0 : size_t bytes_size = self->get_data_size() - offset;
58 0 : return py::bytes(reinterpret_cast<char*>(self->get_data()) + offset, bytes_size); // NOLINT
59 : },
60 0 : "offset"_a = 0,
61 0 : py::return_value_policy::reference_internal);
62 :
63 0 : py::enum_<Fragment::BufferAdoptionMode>(py_fragment, "BufferAdoptionMode")
64 0 : .value("kTakeOverBuffer", Fragment::BufferAdoptionMode::kTakeOverBuffer)
65 0 : .value("kCopyFromBuffer", Fragment::BufferAdoptionMode::kCopyFromBuffer)
66 0 : .export_values();
67 :
68 0 : py::class_<FragmentHeader>(m, "FragmentHeader")
69 0 : .def(py::init<>())
70 0 : .def_property_readonly_static(
71 : "s_fragment_header_marker",
72 0 : [](const py::object&) -> uint32_t { return FragmentHeader::s_fragment_header_marker; }) // NOLINT(build/unsigned)
73 0 : .def_property_readonly_static(
74 : "s_fragment_header_version",
75 0 : [](const py::object&) -> uint32_t { return FragmentHeader::s_fragment_header_version; }) // NOLINT(build/unsigned)
76 0 : .def_property_readonly_static(
77 : "s_default_status_bits",
78 0 : [](const py::object&) -> uint32_t { return FragmentHeader::s_default_status_bits; }) // NOLINT(build/unsigned)
79 0 : .def_property_readonly(
80 : "fragment_header_marker",
81 0 : [](const FragmentHeader& self) -> uint32_t { return self.fragment_header_marker; }) // NOLINT(build/unsigned)
82 0 : .def_property_readonly(
83 0 : "version", [](const FragmentHeader& self) -> uint32_t { return self.version; }) // NOLINT(build/unsigned)
84 0 : .def_property_readonly("size", [](const FragmentHeader& self) -> fragment_size_t { return self.size; })
85 0 : .def_property_readonly("trigger_number",
86 0 : [](const FragmentHeader& self) -> trigger_number_t { return self.trigger_number; })
87 0 : .def_property_readonly("trigger_timestamp",
88 0 : [](const FragmentHeader& self) -> timestamp_t { return self.trigger_timestamp; })
89 0 : .def_property_readonly("window_begin", [](const FragmentHeader& self) -> timestamp_t { return self.window_begin; })
90 0 : .def_property_readonly("window_end", [](const FragmentHeader& self) -> timestamp_t { return self.window_end; })
91 0 : .def_property_readonly("run_number", [](const FragmentHeader& self) -> run_number_t { return self.run_number; })
92 0 : .def_property_readonly(
93 0 : "status_bits", [](const FragmentHeader& self) -> uint32_t { return self.status_bits; }) // NOLINT(build/unsigned)
94 0 : .def_property_readonly("fragment_type",
95 0 : [](const FragmentHeader& self) -> fragment_type_t { return self.fragment_type; })
96 0 : .def_property_readonly("sequence_number",
97 0 : [](const FragmentHeader& self) -> sequence_number_t { return self.sequence_number; })
98 0 : .def_property_readonly(
99 0 : "detector_id", [](const FragmentHeader& self) -> uint16_t { return self.detector_id; }) // NOLINT(build/unsigned)
100 0 : .def_property_readonly("element_id", [](const FragmentHeader& self) -> SourceID { return self.element_id; })
101 :
102 0 : .def_static("sizeof", []() { return sizeof(FragmentHeader); })
103 0 : .def("__str__",
104 0 : [](const FragmentHeader& hdr) {
105 0 : std::ostringstream oss;
106 0 : oss << hdr;
107 0 : return oss.str();
108 0 : })
109 0 : .def("__repr__", [](const FragmentHeader& hdr) {
110 0 : std::ostringstream oss;
111 0 : oss << "<daqdataformats::FragmentHeader " << hdr << ">";
112 0 : return oss.str();
113 0 : });
114 :
115 0 : py::enum_<FragmentStatusBits>(m, "FragmentStatusBits")
116 0 : .value("kLatencyBufferEmpty", FragmentStatusBits::kLatencyBufferEmpty)
117 0 : .value("kIncomplete", FragmentStatusBits::kIncomplete)
118 0 : .value("kInvalidRequestWindow", FragmentStatusBits::kInvalidRequestWindow)
119 0 : .value("kRequestTimeout", FragmentStatusBits::kRequestTimeout)
120 0 : .value("kRequestWindowBeforeBuffer", FragmentStatusBits::kRequestWindowBeforeBuffer)
121 0 : .value("kRequestWindowAfterBuffer", FragmentStatusBits::kRequestWindowAfterBuffer)
122 0 : .value("kEmptyFragment", FragmentStatusBits::kEmptyFragment)
123 : // TODO, Alessandro Thea <thea@github.com> Oct-31-2021: Add unassigned
124 0 : .export_values();
125 :
126 0 : py::enum_<FragmentType>(m, "FragmentType")
127 0 : .value("kUnknown", FragmentType::kUnknown)
128 0 : .value("kProtoWIB", FragmentType::kProtoWIB)
129 0 : .value("kWIB", FragmentType::kWIB)
130 0 : .value("kDAPHNE", FragmentType::kDAPHNE)
131 0 : .value("kTDE_AMC", FragmentType::kTDE_AMC)
132 0 : .value("kFW_TriggerPrimitive", FragmentType::kFW_TriggerPrimitive)
133 0 : .value("kTriggerPrimitive", FragmentType::kTriggerPrimitive)
134 0 : .value("kTriggerActivity", FragmentType::kTriggerActivity)
135 0 : .value("kTriggerCandidate", FragmentType::kTriggerCandidate)
136 0 : .value("kHardwareSignal", FragmentType::kHardwareSignal)
137 0 : .value("kPACMAN", FragmentType::kPACMAN)
138 0 : .value("kWIBEth", FragmentType::kWIBEth)
139 0 : .value("kMPD", FragmentType::kMPD)
140 0 : .value("kDAPHNEStream", FragmentType::kDAPHNEStream)
141 0 : .value("kCRT", FragmentType::kCRT)
142 0 : .value("kTDEEth", FragmentType::kTDEEth)
143 0 : .value("kCRTBern", FragmentType::kCRTBern)
144 0 : .value("kCRTGrenoble", FragmentType::kCRTGrenoble)
145 0 : .value("kDAPHNEEth", FragmentType::kDAPHNEEth)
146 0 : .value("kDAPHNEEthStream", FragmentType::kDAPHNEEthStream)
147 0 : .export_values();
148 :
149 0 : m.def("fragment_type_to_string", &fragment_type_to_string);
150 0 : m.def("string_to_fragment_type", &string_to_fragment_type);
151 0 : m.def("get_fragment_type_names", &get_fragment_type_names);
152 0 : } // NOLINT(readability/fn_size)
153 :
154 : } // namespace dunedaq::daqdataformats::python
|
