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 29 of file module.cpp.

30{
31
32 m.doc() = "c++ implementation of the dunedaq daqdataformats modules"; // optional module docstring
33
34 register_sourceid(m);
35 register_fragment(m);
36 register_component_request(m);
37 register_trigger_record(m);
38 register_timeslice(m);
39}
dunedaq::daqdataformats::python::register_fragment
void register_fragment(py::module &m)
Definition fragment.cpp:23
dunedaq::daqdataformats::python::register_trigger_record
void register_trigger_record(py::module &)
Definition trigger_record.cpp:25
dunedaq::daqdataformats::python::register_timeslice
void register_timeslice(py::module &)
Definition time_slice.cpp:25
dunedaq::daqdataformats::python::register_component_request
void register_component_request(py::module &m)
Definition component_request.cpp:21
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 21 of file component_request.cpp.

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

◆ register_fragment()

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

Definition at line 23 of file fragment.cpp.

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

26{
27 py::class_<TimeSliceHeader>(m, "TimeSliceHeader")
28 .def_property_readonly_static("s_timeslice_header_marker",
29 [](const TimeSliceHeader& self) -> uint32_t { // NOLINT(build/unsigned)
30 return self.s_timeslice_header_marker;
31 })
32 .def_property_readonly_static("s_timeslice_header_version",
33 [](const TimeSliceHeader& self) -> uint32_t { // NOLINT(build/unsigned)
34 return self.s_timeslice_header_version;
35 })
36 .def_property_readonly("timeslice_header_marker",
37 [](const TimeSliceHeader& self) -> uint32_t { // NOLINT(build/unsigned)
38 return self.timeslice_header_marker;
39 })
40 .def_property_readonly(
41 "version", [](const TimeSliceHeader& self) -> uint32_t { return self.version; }) // NOLINT(build/unsigned)
42 .def_property_readonly("timeslice_number",
43 [](const TimeSliceHeader& self) -> timeslice_number_t { return self.timeslice_number; })
44
45 .def_property_readonly("run_number", [](const TimeSliceHeader& self) -> run_number_t { return self.run_number; });
46
47 py::class_<TimeSlice> py_timeslice(m, "TimeSlice", pybind11::buffer_protocol());
48 py_timeslice.def(py::init<TimeSliceHeader const&>())
49 .def(py::init<timeslice_number_t, run_number_t>())
50 .def(
51 "get_header", [](TimeSlice& self) { return self.get_header(); }, py::return_value_policy::reference_internal)
52 // .def("set_header", &TimeSlice::set_header)
53 .def(
54 "get_fragments_ref",
55 [](TimeSlice& self) {
56 auto fragments = py::list();
57 for (auto& fragment : self.get_fragments_ref()) {
58 auto py_fragment = py::cast(*fragment, py::return_value_policy::reference);
59 fragments.append(py_fragment);
60 }
61 return fragments;
62 },
63 py::return_value_policy::reference_internal)
64 .def("get_total_size_bytes", &TimeSlice::get_total_size_bytes)
65 .def("get_sum_of_fragment_payload_sizes", &TimeSlice::get_sum_of_fragment_payload_sizes);
66} // 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 25 of file trigger_record.cpp.

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