DUNE-DAQ
DUNE Trigger and Data Acquisition software
Loading...
Searching...
No Matches
Functions
dunedaq::daqdataformats::python Namespace Reference

Functions

void register_component_request (py::module &m)
 
void register_fragment (py::module &m)
 
void register_sourceid (py::module &)
 
void register_trigger_record (py::module &)
 
void register_timeslice (py::module &)
 
 PYBIND11_MODULE (_daq_daqdataformats_py, m)
 

Function Documentation

◆ PYBIND11_MODULE()

dunedaq::daqdataformats::python::PYBIND11_MODULE ( _daq_daqdataformats_py ,
m  )

Definition at line 27 of file module.cpp.

28{
29
30 m.doc() = "c++ implementation of the dunedaq daqdataformats modules"; // optional module docstring
31
32 register_sourceid(m);
33 register_fragment(m);
34 register_component_request(m);
35 register_trigger_record(m);
36 register_timeslice(m);
37}
dunedaq::daqdataformats::python::register_fragment
void register_fragment(py::module &m)
Definition fragment.cpp:21
dunedaq::daqdataformats::python::register_trigger_record
void register_trigger_record(py::module &)
Definition trigger_record.cpp:23
dunedaq::daqdataformats::python::register_timeslice
void register_timeslice(py::module &)
Definition time_slice.cpp:23
dunedaq::daqdataformats::python::register_component_request
void register_component_request(py::module &m)
Definition component_request.cpp:19
dunedaq::daqdataformats::python::register_sourceid
void register_sourceid(py::module &)
Definition sourceid.cpp:22

◆ register_component_request()

void dunedaq::daqdataformats::python::register_component_request ( py::module & m)

Definition at line 19 of file component_request.cpp.

20{
21
22 py::class_<ComponentRequest>(m, "ComponentRequest")
23 .def(py::init())
24 .def(py::init<SourceID const&, timestamp_t const&, timestamp_t const&>())
25 .def_readonly_static("s_component_request_version", &ComponentRequest::s_component_request_version)
26 .def_readonly("unused", &ComponentRequest::unused)
27 .def_readonly("version", &ComponentRequest::version)
28 .def_readonly("window_begin", &ComponentRequest::window_begin)
29 .def_readonly("window_end", &ComponentRequest::window_end);
30}

◆ register_fragment()

void dunedaq::daqdataformats::python::register_fragment ( py::module & m)

Definition at line 21 of file fragment.cpp.

22{
23
24 py::class_<Fragment> py_fragment(m, "Fragment", py::buffer_protocol());
25
26 py_fragment.def("get_header", &Fragment::get_header, py::return_value_policy::reference_internal)
27 .def("get_storage_location", &Fragment::get_storage_location, py::return_value_policy::reference_internal)
28 .def("get_trigger_number", &Fragment::get_trigger_number)
29 .def("get_run_number", &Fragment::get_run_number)
30 .def("get_trigger_timestamp", &Fragment::get_trigger_timestamp)
31 .def("get_window_begin", &Fragment::get_window_begin)
32 .def("get_window_end", &Fragment::get_window_end)
33 .def("get_element_id", &Fragment::get_element_id)
34 .def("get_detector_id", &Fragment::get_detector_id)
35 .def("get_status_bits", [](Fragment& self) { return self.get_status_bits().to_ullong(); })
36 .def("get_status_bit", &Fragment::get_status_bit)
37 .def("get_fragment_type_code", &Fragment::get_fragment_type_code)
38 .def("get_fragment_type", &Fragment::get_fragment_type)
39 .def("get_sequence_number", &Fragment::get_sequence_number)
40 .def("get_size", &Fragment::get_size)
41 .def("get_data_size", &Fragment::get_data_size)
42 .def(
43 "get_data",
44 [](Fragment& self, size_t offset) { return static_cast<void*>(static_cast<char*>(self.get_data()) + offset); }, // NOLINT
45 "offset"_a = 0,
46 py::return_value_policy::reference_internal)
47 .def(
48 "get_data_bytes",
49 [](Fragment* self, size_t offset) -> py::bytes {
50 if (offset > self->get_data_size()) {
51 throw std::runtime_error("Fragment.get_data_bytes: offset exceeds fragment size.");
52 }
53 size_t bytes_size = self->get_data_size() - offset;
54 return py::bytes(reinterpret_cast<char*>(self->get_data()) + offset, bytes_size); // NOLINT
55 },
56 "offset"_a = 0,
57 py::return_value_policy::reference_internal);
58
59 py::enum_<Fragment::BufferAdoptionMode>(py_fragment, "BufferAdoptionMode")
60 .value("kReadOnlyMode", Fragment::BufferAdoptionMode::kReadOnlyMode)
61 .value("kTakeOverBuffer", Fragment::BufferAdoptionMode::kTakeOverBuffer)
62 .value("kCopyFromBuffer", Fragment::BufferAdoptionMode::kCopyFromBuffer)
63 .export_values();
64
65 py::class_<FragmentHeader>(m, "FragmentHeader")
66 .def_property_readonly(
67 "fragment_header_marker",
68 [](const FragmentHeader& self) -> uint32_t { return self.fragment_header_marker; }) // NOLINT(build/unsigned)
69 .def_property_readonly(
70 "version", [](const FragmentHeader& self) -> uint32_t { return self.version; }) // NOLINT(build/unsigned)
71 .def_property_readonly("size", [](const FragmentHeader& self) -> fragment_size_t { return self.size; })
72 .def_property_readonly("trigger_number",
73 [](const FragmentHeader& self) -> trigger_number_t { return self.trigger_number; })
74 .def_property_readonly("trigger_timestamp",
75 [](const FragmentHeader& self) -> timestamp_t { return self.trigger_timestamp; })
76 .def_property_readonly("window_begin", [](const FragmentHeader& self) -> timestamp_t { return self.window_begin; })
77 .def_property_readonly("window_end", [](const FragmentHeader& self) -> timestamp_t { return self.window_end; })
78 .def_property_readonly("run_number", [](const FragmentHeader& self) -> run_number_t { return self.run_number; })
79 .def_property_readonly(
80 "status_bits", [](const FragmentHeader& self) -> uint32_t { return self.status_bits; }) // NOLINT(build/unsigned)
81 .def_property_readonly("fragment_type",
82 [](const FragmentHeader& self) -> fragment_type_t { return self.fragment_type; })
83 .def_property_readonly("sequence_number",
84 [](const FragmentHeader& self) -> sequence_number_t { return self.sequence_number; })
85 .def_property_readonly(
86 "detector_id", [](const FragmentHeader& self) -> uint16_t { return self.detector_id; }) // NOLINT(build/unsigned)
87 .def_property_readonly("element_id", [](const FragmentHeader& self) -> SourceID { return self.element_id; })
88
89 .def_static("sizeof", []() { return sizeof(FragmentHeader); });
90
91 py::enum_<FragmentStatusBits>(m, "FragmentStatusBits")
92 .value("kLatencyBufferEmpty", FragmentStatusBits::kLatencyBufferEmpty)
93 .value("kIncomplete", FragmentStatusBits::kIncomplete)
94 .value("kInvalidRequestWindow", FragmentStatusBits::kInvalidRequestWindow)
95 .value("kRequestTimeout", FragmentStatusBits::kRequestTimeout)
96 .value("kRequestWindowBeforeBuffer", FragmentStatusBits::kRequestWindowBeforeBuffer)
97 .value("kRequestWindowAfterBuffer", FragmentStatusBits::kRequestWindowAfterBuffer)
98 .value("kEmptyFragment", FragmentStatusBits::kEmptyFragment)
99 // TODO, Alessandro Thea <thea@github.com> Oct-31-2021: Add unassigned
100 .export_values();
101
102 py::enum_<FragmentType>(m, "FragmentType")
103 .value("kUnknown", FragmentType::kUnknown)
104 .value("kProtoWIB", FragmentType::kProtoWIB)
105 .value("kWIB", FragmentType::kWIB)
106 .value("kDAPHNE", FragmentType::kDAPHNE)
107 .value("kTDE_AMC", FragmentType::kTDE_AMC)
108 .value("kFW_TriggerPrimitive", FragmentType::kFW_TriggerPrimitive)
109 .value("kTriggerPrimitive", FragmentType::kTriggerPrimitive)
110 .value("kTriggerActivity", FragmentType::kTriggerActivity)
111 .value("kTriggerCandidate", FragmentType::kTriggerCandidate)
112 .value("kHardwareSignal", FragmentType::kHardwareSignal)
113 .value("kPACMAN", FragmentType::kPACMAN)
114 .value("kWIBEth", FragmentType::kWIBEth)
115 .value("kDAPHNEStream", FragmentType::kDAPHNEStream)
116 .value("kCRT", FragmentType::kCRT)
117 .value("kTDEEth", FragmentType::kTDEEth)
118 .value("kCRTBern", FragmentType::kCRTBern)
119 .value("kCRTGrenoble", FragmentType::kCRTGrenoble)
120 .value("kDAPHNEEth", FragmentType::kDAPHNEEth)
121 .value("kDAPHNEEthStream", FragmentType::kDAPHNEEthStream)
122 .export_values();
123
124 m.def("fragment_type_to_string", &fragment_type_to_string);
125 m.def("string_to_fragment_type", &string_to_fragment_type);
126} // NOLINT(readability/fn_size)
dunedaq::daqdataformats::Fragment
C++ Representation of a DUNE Fragment, wrapping the flat byte array that is the Fragment's "actual" f...
Definition Fragment.hpp:36
dunedaq::daqdataformats::Fragment::get_data
void * get_data() const
Get a pointer to the data payload in the Fragmnet.
Definition Fragment.hpp:249
dunedaq::daqdataformats::Fragment::get_status_bits
std::bitset< 32 > get_status_bits() const
Get the status_bits header field.
Definition Fragment.hpp:186
offset
double offset
Definition conversions-impl.hh:28

◆ register_sourceid()

void dunedaq::daqdataformats::python::register_sourceid ( py::module & m)
extern

Definition at line 22 of file sourceid.cpp.

23{
24
25 py::class_<SourceID> py_sourceid(m, "SourceID");
26 py_sourceid.def(py::init()).def(py::init<const SourceID::Subsystem&, const SourceID::ID_t&>());
27 py_sourceid.def(py::self < py::self).def("__repr__", [](const SourceID& gid) {
28 std::ostringstream oss;
29 oss << "<daqdataformats::SourceID " << gid << ">";
30 return oss.str();
31 });
32
33 py::enum_<SourceID::Subsystem>(py_sourceid, "Subsystem")
34 .value("kUnknown", SourceID::Subsystem::kUnknown)
35 .value("kDetectorReadout", SourceID::Subsystem::kDetectorReadout)
36 .value("kHwSignalsInterface", SourceID::Subsystem::kHwSignalsInterface)
37 .value("kTrigger", SourceID::Subsystem::kTrigger)
38 .value("kTRBuilder", SourceID::Subsystem::kTRBuilder)
39 .export_values();
40
41 py_sourceid.def_readwrite("version", &SourceID::version)
42 .def_readwrite("subsystem", &SourceID::subsystem)
43 .def_readwrite("id", &SourceID::id);
44
45 py_sourceid.def("subsystem_to_string", &SourceID::subsystem_to_string)
46 .def("string_to_subsystem", &SourceID::string_to_subsystem)
47 .def("to_string", &SourceID::to_string);
48}
dunedaq::daqdataformats::SourceID
SourceID is a generalized representation of the source of a piece of data in the DAQ....
Definition SourceID.hpp:32

◆ register_timeslice()

void dunedaq::daqdataformats::python::register_timeslice ( py::module & m)
extern

Definition at line 23 of file time_slice.cpp.

24{
25 py::class_<TimeSliceHeader>(m, "TimeSliceHeader")
26 .def_property_readonly_static("s_timeslice_header_marker",
27 [](const TimeSliceHeader& self) -> uint32_t { // NOLINT(build/unsigned)
28 return self.s_timeslice_header_marker;
29 })
30 .def_property_readonly_static("s_timeslice_header_version",
31 [](const TimeSliceHeader& self) -> uint32_t { // NOLINT(build/unsigned)
32 return self.s_timeslice_header_version;
33 })
34 .def_property_readonly("timeslice_header_marker",
35 [](const TimeSliceHeader& self) -> uint32_t { // NOLINT(build/unsigned)
36 return self.timeslice_header_marker;
37 })
38 .def_property_readonly(
39 "version", [](const TimeSliceHeader& self) -> uint32_t { return self.version; }) // NOLINT(build/unsigned)
40 .def_property_readonly("timeslice_number",
41 [](const TimeSliceHeader& self) -> timeslice_number_t { return self.timeslice_number; })
42
43 .def_property_readonly("run_number", [](const TimeSliceHeader& self) -> run_number_t { return self.run_number; });
44
45 py::class_<TimeSlice> py_timeslice(m, "TimeSlice", pybind11::buffer_protocol());
46 py_timeslice.def(py::init<TimeSliceHeader const&>())
47 .def(py::init<timeslice_number_t, run_number_t>())
48 .def(
49 "get_header", [](TimeSlice& self) { return self.get_header(); }, py::return_value_policy::reference_internal)
50 // .def("set_header", &TimeSlice::set_header)
51 .def(
52 "get_fragments_ref",
53 [](TimeSlice& self) {
54 auto fragments = py::list();
55 for (auto& fragment : self.get_fragments_ref()) {
56 auto py_fragment = py::cast(*fragment, py::return_value_policy::reference);
57 fragments.append(py_fragment);
58 }
59 return fragments;
60 },
61 py::return_value_policy::reference_internal)
62 .def("get_total_size_bytes", &TimeSlice::get_total_size_bytes)
63 .def("get_sum_of_fragment_payload_sizes", &TimeSlice::get_sum_of_fragment_payload_sizes);
64} // NOLINT
dunedaq::daqdataformats::TimeSliceHeader
Additional data fields associated with a TimeSliceHeader.
Definition TimeSliceHeader.hpp:28
dunedaq::daqdataformats::TimeSliceHeader::s_timeslice_header_marker
static constexpr uint32_t s_timeslice_header_marker
Marker bytes to identify a TimeSliceHeader entry in a raw data stream.
Definition TimeSliceHeader.hpp:32
dunedaq::daqdataformats::TimeSliceHeader::s_timeslice_header_version
static constexpr uint32_t s_timeslice_header_version
The current version of the TimeSliceHeader.
Definition TimeSliceHeader.hpp:37

◆ register_trigger_record()

void dunedaq::daqdataformats::python::register_trigger_record ( py::module & m)
extern

Definition at line 23 of file trigger_record.cpp.

24{
25 py::class_<TriggerRecordHeader>(m, "TriggerRecordHeader", pybind11::buffer_protocol())
26 .def(py::init<std::vector<ComponentRequest> const&>())
27 .def(py::init([](py::capsule capsule, bool copy_from_buffer) {
28 return std::make_unique<TriggerRecordHeader>(capsule.get_pointer(), copy_from_buffer);
29 }))
30 .def(py::init<TriggerRecordHeader const&>())
31 .def("get_header", &TriggerRecordHeader::get_header)
32 .def("get_trigger_number", &TriggerRecordHeader::get_trigger_number)
33 //.def("set_trigger_number", &TriggerRecordHeader::set_trigger_number)
34 .def("get_trigger_timestamp", &TriggerRecordHeader::get_trigger_timestamp)
35 //.def("set_trigger_timestamp", &TriggerRecordHeader::set_trigger_timestamp)
36 .def("get_num_requested_components", &TriggerRecordHeader::get_num_requested_components)
37 .def("get_run_number", &TriggerRecordHeader::get_run_number)
38 //.def("set_run_number", &TriggerRecordHeader::set_run_number)
39 .def("get_status_bits", &TriggerRecordHeader::get_status_bits)
40 //.def("set_status_bits", &TriggerRecordHeader::set_status_bits)
41 .def("get_status_bit", &TriggerRecordHeader::get_status_bit)
42 //.def("set_status_bit", &TriggerRecordHeader::set_status_bit)
43 .def("get_trigger_type", &TriggerRecordHeader::get_trigger_type)
44 //.def("set_trigger_type", &TriggerRecordHeader::set_trigger_type)
45 .def("get_sequence_number", &TriggerRecordHeader::get_sequence_number)
46 //.def("set_sequence_number", &TriggerRecordHeader::set_sequence_number)
47 .def("get_max_sequence_number", &TriggerRecordHeader::get_max_sequence_number)
48 //.def("set_max_sequence_number", &TriggerRecordHeader::set_max_sequence_number)
49 .def("get_total_size_bytes", &TriggerRecordHeader::get_total_size_bytes)
50 .def(
51 "get_storage_location", &TriggerRecordHeader::get_storage_location, py::return_value_policy::reference_internal)
52 .def("at", &TriggerRecordHeader::at)
53 .def("__getitem__", &TriggerRecordHeader::operator[], py::return_value_policy::reference_internal);
54
55 py::class_<TriggerRecordHeaderData>(m, "TriggerRecordHeaderData")
56 .def_property_readonly_static("s_trigger_record_header_magic",
57 [](const TriggerRecordHeaderData& self) -> uint32_t { // NOLINT(build/unsigned)
58 return self.s_trigger_record_header_magic;
59 })
60 .def_property_readonly_static("s_trigger_record_header_version",
61 [](const TriggerRecordHeaderData& self) -> uint32_t { // NOLINT(build/unsigned)
62 return self.s_trigger_record_header_version;
63 })
64 .def_property_readonly_static("s_invalid_number_components",
65 [](const TriggerRecordHeaderData& self) -> uint64_t { // NOLINT(build/unsigned)
66 return self.s_invalid_number_components;
67 })
68 .def_property_readonly_static("s_default_status_bits",
69 [](const TriggerRecordHeaderData& self) -> uint32_t { // NOLINT(build/unsigned)
70 return self.s_default_status_bits;
71 })
72 .def_property_readonly("trigger_record_header_marker",
73 [](const TriggerRecordHeaderData& self) -> uint32_t { // NOLINT(build/unsigned)
74 return self.trigger_record_header_marker;
75 })
76 .def_property_readonly(
77 "version", [](const TriggerRecordHeaderData& self) -> uint32_t { return self.version; }) // NOLINT(build/unsigned)
78 .def_property_readonly("trigger_number",
79 [](const TriggerRecordHeaderData& self) -> trigger_number_t { return self.trigger_number; })
80 .def_property_readonly("trigger_timestamp",
81 [](const TriggerRecordHeaderData& self) -> timestamp_t { return self.trigger_timestamp; })
82 .def_property_readonly("num_requested_components",
83 [](const TriggerRecordHeaderData& self) -> uint64_t { // NOLINT(build/unsigned)
84 return self.num_requested_components;
85 })
86 .def_property_readonly("run_number",
87 [](const TriggerRecordHeaderData& self) -> run_number_t { return self.run_number; })
88 .def_property_readonly(
89 "status_bits",
90 [](const TriggerRecordHeaderData& self) -> uint32_t { return self.status_bits; }) // NOLINT(build/unsigned)
91 .def_property_readonly("trigger_type",
92 [](const TriggerRecordHeaderData& self) -> trigger_type_t { return self.trigger_type; })
93 .def_property_readonly(
94 "sequence_number", [](const TriggerRecordHeaderData& self) -> sequence_number_t { return self.sequence_number; })
95 .def_property_readonly("max_sequence_number", [](const TriggerRecordHeaderData& self) -> sequence_number_t {
96 return self.max_sequence_number;
97 });
98
99 py::enum_<TriggerRecordStatusBits>(m, "TriggerRecordStatusBits")
100 .value("kIncomplete", TriggerRecordStatusBits::kIncomplete)
101 .value("kMismatch", TriggerRecordStatusBits::kMismatch)
102 .value("kUnassigned2", TriggerRecordStatusBits::kUnassigned2)
103 .value("kUnassigned3", TriggerRecordStatusBits::kUnassigned3)
104 .value("kUnassigned4", TriggerRecordStatusBits::kUnassigned4)
105 .value("kUnassigned5", TriggerRecordStatusBits::kUnassigned5)
106 .value("kUnassigned6", TriggerRecordStatusBits::kUnassigned6)
107 .value("kUnassigned7", TriggerRecordStatusBits::kUnassigned7)
108 .value("kUnassigned8", TriggerRecordStatusBits::kUnassigned8)
109 .value("kUnassigned9", TriggerRecordStatusBits::kUnassigned9)
110 .value("kUnassigned10", TriggerRecordStatusBits::kUnassigned10)
111 .value("kUnassigned11", TriggerRecordStatusBits::kUnassigned11)
112 .value("kUnassigned12", TriggerRecordStatusBits::kUnassigned12)
113 .value("kUnassigned13", TriggerRecordStatusBits::kUnassigned13)
114 .value("kUnassigned14", TriggerRecordStatusBits::kUnassigned14)
115 .value("kUnassigned15", TriggerRecordStatusBits::kUnassigned15)
116 .value("kUnassigned16", TriggerRecordStatusBits::kUnassigned16)
117 .value("kUnassigned17", TriggerRecordStatusBits::kUnassigned17)
118 .value("kUnassigned18", TriggerRecordStatusBits::kUnassigned18)
119 .value("kUnassigned19", TriggerRecordStatusBits::kUnassigned19)
120 .value("kUnassigned20", TriggerRecordStatusBits::kUnassigned20)
121 .value("kUnassigned21", TriggerRecordStatusBits::kUnassigned21)
122 .value("kUnassigned22", TriggerRecordStatusBits::kUnassigned22)
123 .value("kUnassigned23", TriggerRecordStatusBits::kUnassigned23)
124 .value("kUnassigned24", TriggerRecordStatusBits::kUnassigned24)
125 .value("kUnassigned25", TriggerRecordStatusBits::kUnassigned25)
126 .value("kUnassigned26", TriggerRecordStatusBits::kUnassigned26)
127 .value("kUnassigned27", TriggerRecordStatusBits::kUnassigned27)
128 .value("kUnassigned28", TriggerRecordStatusBits::kUnassigned28)
129 .value("kUnassigned29", TriggerRecordStatusBits::kUnassigned29)
130 .value("kUnassigned30", TriggerRecordStatusBits::kUnassigned30)
131 .value("kUnassigned31", TriggerRecordStatusBits::kUnassigned31)
132 .value("kInvalid", TriggerRecordStatusBits::kInvalid);
133
134 py::class_<TriggerRecord> py_trigger_record(m, "TriggerRecord", pybind11::buffer_protocol());
135 py_trigger_record.def(py::init<TriggerRecordHeader const&>())
136 .def(py::init<std::vector<ComponentRequest> const&>())
137 .def(
138 "get_header_ref",
139 [](TriggerRecord& self) { return self.get_header_ref(); },
140 py::return_value_policy::reference_internal)
141 // .def("set_header", &TriggerRecord::set_header)
142 .def("get_header_data", &TriggerRecord::get_header_data)
143 .def(
144 "get_fragments_ref",
145 [](TriggerRecord& self) {
146 auto fragments = py::list();
147 for (auto& fragment : self.get_fragments_ref()) {
148 auto py_fragment = py::cast(*fragment, py::return_value_policy::reference);
149 fragments.append(py_fragment);
150 }
151 return fragments;
152 },
153 py::return_value_policy::reference_internal)
154 .def("get_total_size_bytes", &TriggerRecord::get_total_size_bytes)
155 .def("get_sum_of_fragment_payload_sizes", &TriggerRecord::get_sum_of_fragment_payload_sizes);
156} // NOLINT
dunedaq::daqdataformats::TriggerRecordHeaderData
Additional data fields associated with a TriggerRecordHeader.
Definition TriggerRecordHeaderData.hpp:28
dunedaq::daqdataformats::TriggerRecordHeaderData::s_trigger_record_header_magic
static constexpr uint32_t s_trigger_record_header_magic
Magic bytes to identify a TriggerRecordHeader entry in a raw data stream.
Definition TriggerRecordHeaderData.hpp:32
Generated on Sat Apr 4 2026 for DUNE-DAQ by doxygen 1.12.0