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

Classes

struct  TriggerActivityHolder
struct  TriggerCandidateHolder

Functions

 PYBIND11_MODULE (_daq_trgdataformats_py, m)
void register_types (pybind11::module &)
void register_trigger_primitive (pybind11::module &)
void register_trigger_activity (pybind11::module &)
void register_trigger_candidate (pybind11::module &)
void register_trigger_activity (py::module &m)
void register_trigger_candidate (py::module &m)
void register_trigger_primitive (py::module &m)
void register_types (py::module &m)

Function Documentation

◆ PYBIND11_MODULE()

dunedaq::trgdataformats::python::PYBIND11_MODULE ( _daq_trgdataformats_py ,
m  )

Definition at line 18 of file module.cpp.

19{
20
21 m.doc() = "C++ implementation of the trgdataformats modules";
22
23 register_types(m);
24 register_trigger_primitive(m);
25 // register_trigger_bitwords(m);
26 register_trigger_activity(m);
27 register_trigger_candidate(m);
28}
dunedaq::trgdataformats::python::register_trigger_activity
void register_trigger_activity(pybind11::module &)
dunedaq::trgdataformats::python::register_trigger_primitive
void register_trigger_primitive(pybind11::module &)
dunedaq::trgdataformats::python::register_types
void register_types(pybind11::module &)
dunedaq::trgdataformats::python::register_trigger_candidate
void register_trigger_candidate(pybind11::module &)

◆ register_trigger_activity() [1/2]

void dunedaq::trgdataformats::python::register_trigger_activity ( py::module & m)

Definition at line 41 of file trigger_activity.cpp.

42{
43
44
45 py::class_<TriggerActivityData> trigger_activity_data(m, "TriggerActivityData", py::buffer_protocol());
46 trigger_activity_data
47 .def(py::init())
48 .def(py::init([](py::capsule capsule) {
49 auto tp = *static_cast<TriggerActivityData*>(capsule.get_pointer());
50 return tp;
51 } ))
52 .def(py::init([](py::bytes bytes){
53 py::buffer_info info(py::buffer(bytes).request());
54 auto tp = *static_cast<TriggerActivityData*>(info.ptr);
55 return tp;
56 }))
57 .def_property_readonly_static("s_trigger_activity_version", [](py::object /*self*/) { return TriggerActivityData::s_trigger_activity_version; })
58 .def_property_readonly_static("s_invalid_channel", [](py::object /*self*/) { return TriggerActivityData::s_invalid_channel; })
59 .def_property_readonly("version", [](TriggerActivityData& self) -> uint16_t {return self.version;})
60 .def_property_readonly("time_start", [](TriggerActivityData& self) -> uint64_t {return self.time_start;})
61 .def_property_readonly("time_end", [](TriggerActivityData& self) -> uint64_t {return self.time_end;})
62 .def_property_readonly("time_peak", [](TriggerActivityData& self) -> uint64_t {return self.time_peak;})
63 .def_property_readonly("time_activity", [](TriggerActivityData& self) -> uint64_t {return self.time_activity;})
64 .def_property_readonly("channel_start", [](TriggerActivityData& self) -> channel_t {return self.channel_start;})
65 .def_property_readonly("channel_end", [](TriggerActivityData& self) -> channel_t {return self.channel_end;})
66 .def_property_readonly("channel_peak", [](TriggerActivityData& self) -> channel_t {return self.channel_peak;})
67 .def_property_readonly("adc_integral", [](TriggerActivityData& self) -> uint32_t {return self.adc_integral;})
68 .def_property_readonly("adc_peak", [](TriggerActivityData& self) -> uint32_t {return self.adc_peak;})
69 .def_property_readonly("detid", [](TriggerActivityData& self) -> uint16_t {return self.detid;})
70 .def_property_readonly("type", [](TriggerActivityData& self) -> TriggerActivityData::Type {return self.type;})
71 .def_property_readonly("algorithm", [](TriggerActivityData& self) -> TriggerActivityData::Algorithm {return self.algorithm;})
72 .def_static("sizeof", [](){ return sizeof(TriggerActivityData); })
73 ;
74
75
76 py::enum_<TriggerActivityData::Type>(trigger_activity_data, "Type")
77 .value("kUnknown", TriggerActivityData::Type::kUnknown)
78 .value("kTPC", TriggerActivityData::Type::kTPC)
79 .value("kPDS", TriggerActivityData::Type::kPDS);
80
81 py::enum_<TriggerActivityData::Algorithm>(trigger_activity_data, "Algorithm")
82 .value("kUnknown", TriggerActivityData::Algorithm::kUnknown)
83 .value("kSupernova", TriggerActivityData::Algorithm::kSupernova)
84 .value("kPrescale", TriggerActivityData::Algorithm::kPrescale)
85 .value("kADCSimpleWindow", TriggerActivityData::Algorithm::kADCSimpleWindow)
86 .value("kHorizontalMuon", TriggerActivityData::Algorithm::kHorizontalMuon)
87 .value("kMichelElectron", TriggerActivityData::Algorithm::kMichelElectron)
88 .value("kDBSCAN", TriggerActivityData::Algorithm::kDBSCAN)
89 .value("kPlaneCoincidence", TriggerActivityData::Algorithm::kPlaneCoincidence)
90 .value("kBundle", TriggerActivityData::Algorithm::kBundle)
91 .value("kChannelDistance", TriggerActivityData::Algorithm::kChannelDistance)
92 .value("kChannelAdjacency", TriggerActivityData::Algorithm::kChannelAdjacency)
93 .value("kSWIFT", TriggerActivityData::Algorithm::kSWIFT)
94 .value("kProtoDUNEBSMWindow", TriggerActivityData::Algorithm::kProtoDUNEBSMWindow);
95
96 py::class_<TriggerActivity>(m, "TriggerActivityOverlay", py::buffer_protocol())
97 .def(py::init())
98 .def(py::init([](py::capsule capsule) {
99 auto tp = *static_cast<TriggerActivity*>(capsule.get_pointer());
100 return tp;
101 } ))
102 .def_property_readonly("data", [](TriggerActivity& self) -> TriggerActivityData& {return self.data;})
103 .def("__len__", [](TriggerActivity& self){ return self.n_inputs; })
104 .def("sizeof", [](TriggerActivity& self){ return sizeof(TriggerActivity)+self.n_inputs*sizeof(TriggerPrimitive); })
105 ;
106
107
108 py::class_<TriggerActivityHolder>(m, "TriggerActivity", py::buffer_protocol())
109 // .def(py::init())
110 .def(py::init([](py::capsule capsule) {
111 auto ta_ptr = static_cast<TriggerActivity*>(capsule.get_pointer());
112 TriggerActivityHolder tah(ta_ptr, sizeof(TriggerActivity)+ta_ptr->n_inputs*sizeof(TriggerPrimitive));
113 return tah;
114 }))
115 .def(py::init([](py::bytes bytes){
116 py::buffer_info info(py::buffer(bytes).request());
117 TriggerActivityHolder tah(info.ptr, info.size);
118
119 return tah;
120 }))
121
122 .def("get_bytes",
123 [](TriggerActivityHolder& tah) -> py::bytes {
124 return py::bytes(reinterpret_cast<char*>(tah.ptr()), tah.m_size);
125 }, py::return_value_policy::reference_internal
126 )
127 .def_property_readonly("data", [](TriggerActivityHolder& self) -> TriggerActivityData& {return self.ptr()->data;})
128 .def("n_inputs", [](TriggerActivityHolder& self){ return self.ptr()->n_inputs; })
129 .def("__len__", [](TriggerActivityHolder& self){ return self.ptr()->n_inputs; })
130 .def("__getitem__",
131 [](TriggerActivityHolder &self, size_t i) -> const TriggerPrimitive& {
132 if (i >= self.ptr()->n_inputs) {
133 throw py::index_error();
134 }
135 return self.ptr()->inputs[i];
136 }, py::return_value_policy::reference_internal)
137 .def("sizeof", [](TriggerActivityHolder& self){ return self.m_size; })
138
139 ;
140} // NOLINT function length, while long enough to trip the linter, is fine
dunedaq::trgdataformats::TriggerActivity
TriggerObjectOverlay< TriggerActivityData, TriggerPrimitive > TriggerActivity
Definition TriggerObjectOverlay.hpp:50

◆ register_trigger_activity() [2/2]

void dunedaq::trgdataformats::python::register_trigger_activity ( pybind11::module & )

◆ register_trigger_candidate() [1/2]

void dunedaq::trgdataformats::python::register_trigger_candidate ( py::module & m)

Definition at line 43 of file trigger_candidate.cpp.

44{
45
46 m.def("string_to_trigger_candidate_type", &trgdataformats::string_to_trigger_candidate_type);
47 m.def("trigger_candidate_type_to_string", &trgdataformats::trigger_candidate_type_to_string);
48
49 py::class_<TriggerCandidateData> trigger_candidate_data(m, "TriggerCandidateData", py::buffer_protocol());
50 trigger_candidate_data
51 .def(py::init())
52 .def(py::init([](py::capsule capsule) {
53 auto tp = *static_cast<TriggerCandidateData*>(capsule.get_pointer());
54 return tp;
55 } ))
56 .def(py::init([](py::bytes bytes){
57 py::buffer_info info(py::buffer(bytes).request());
58 auto tp = *static_cast<TriggerCandidateData*>(info.ptr);
59 return tp;
60 }))
61 .def_property_readonly_static("s_trigger_candidate_version", [](py::object /*self*/) { return TriggerCandidateData::s_trigger_candidate_version; })
62 .def_property_readonly("version", [](TriggerCandidateData& self) -> uint16_t {return self.version;})
63 .def_property_readonly("time_start", [](TriggerCandidateData& self) -> uint64_t {return self.time_start;})
64 .def_property_readonly("time_end", [](TriggerCandidateData& self) -> uint64_t {return self.time_end;})
65 .def_property_readonly("time_candidate", [](TriggerCandidateData& self) -> uint64_t {return self.time_candidate;})
66 .def_property_readonly("detid", [](TriggerCandidateData& self) -> uint16_t {return self.detid;})
67 .def_property_readonly("type", [](TriggerCandidateData& self) -> TriggerCandidateData::Type {return self.type;})
68 .def_property_readonly("algorithm", [](TriggerCandidateData& self) -> TriggerCandidateData::Algorithm {return self.algorithm;})
69 .def_static("sizeof", [](){ return sizeof(TriggerCandidateData); })
70 ;
71
72 py::enum_<TriggerCandidateData::Type>(trigger_candidate_data, "Type")
73 .value("kUnknown", TriggerCandidateData::Type::kUnknown)
74 .value("kTiming", TriggerCandidateData::Type::kTiming)
75 .value("kTPCLowE", TriggerCandidateData::Type::kTPCLowE)
76 .value("kSupernova", TriggerCandidateData::Type::kSupernova)
77 .value("kRandom", TriggerCandidateData::Type::kRandom)
78 .value("kPrescale", TriggerCandidateData::Type::kPrescale)
79 .value("kADCSimpleWindow", TriggerCandidateData::Type::kADCSimpleWindow)
80 .value("kHorizontalMuon", TriggerCandidateData::Type::kHorizontalMuon)
81 .value("kMichelElectron", TriggerCandidateData::Type::kMichelElectron)
82 .value("kPlaneCoincidence", TriggerCandidateData::Type::kPlaneCoincidence)
83 .value("kBundle", TriggerCandidateData::Type::kBundle)
84 .value("kChannelDistance", TriggerCandidateData::Type::kChannelDistance)
85 .value("kDBSCAN", TriggerCandidateData::Type::kDBSCAN)
86 .value("kCTBFakeTrigger", TriggerCandidateData::Type::kCTBFakeTrigger)
87 .value("kCTBBeam", TriggerCandidateData::Type::kCTBBeam)
88 .value("kCTBBeamChkvHL", TriggerCandidateData::Type::kCTBBeamChkvHL)
89 .value("kCTBCustomD", TriggerCandidateData::Type::kCTBCustomD)
90 .value("kCTBCustomE", TriggerCandidateData::Type::kCTBCustomE)
91 .value("kCTBCustomF", TriggerCandidateData::Type::kCTBCustomF)
92 .value("kCTBCustomG", TriggerCandidateData::Type::kCTBCustomG)
93 .value("kCTBBeamChkvHLx", TriggerCandidateData::Type::kCTBBeamChkvHLx)
94 .value("kCTBBeamChkvHxL", TriggerCandidateData::Type::kCTBBeamChkvHxL)
95 .value("kCTBBeamChkvHxLx", TriggerCandidateData::Type::kCTBBeamChkvHxLx)
96 .value("kNeutronSourceCalib", TriggerCandidateData::Type::kNeutronSourceCalib)
97 .value("kChannelAdjacency", TriggerCandidateData::Type::kChannelAdjacency)
98 .value("kCIBFakeTrigger", TriggerCandidateData::Type::kCIBFakeTrigger)
99 .value("kCIBLaserTriggerP1", TriggerCandidateData::Type::kCIBLaserTriggerP1)
100 .value("kCIBLaserTriggerP2", TriggerCandidateData::Type::kCIBLaserTriggerP2)
101 .value("kCIBLaserTriggerP3", TriggerCandidateData::Type::kCIBLaserTriggerP3)
102 .value("kCTBOffSpillSnapshot", TriggerCandidateData::Type::kCTBOffSpillSnapshot)
103 .value("kCTBOffSpillCosmicJura", TriggerCandidateData::Type::kCTBOffSpillCosmicJura)
104 .value("kCTBOffSpillCRTCosmic", TriggerCandidateData::Type::kCTBOffSpillCRTCosmic)
105 .value("kCTBBeamSpillStart", TriggerCandidateData::Type::kCTBBeamSpillStart)
106 .value("kCTBBeamSpillSnapshot", TriggerCandidateData::Type::kCTBBeamSpillSnapshot)
107 .value("kCTBCustomC", TriggerCandidateData::Type::kCTBCustomC)
108 .value("kCTBCustomPulseTrain", TriggerCandidateData::Type::kCTBCustomPulseTrain)
109 .value("kDTSPulser", TriggerCandidateData::Type::kDTSPulser)
110 .value("kDTSCosmic", TriggerCandidateData::Type::kDTSCosmic)
111 .value("kSSPLEDCalibration", TriggerCandidateData::Type::kSSPLEDCalibration)
112 .value("kProtoDUNEBSMWindow", TriggerCandidateData::Type::kProtoDUNEBSMWindow);
113
114 py::enum_<TriggerCandidateData::Algorithm>(trigger_candidate_data, "Algorithm")
115 .value("kUnknown", TriggerCandidateData::Algorithm::kUnknown)
116 .value("kSupernova", TriggerCandidateData::Algorithm::kSupernova)
117 .value("kHSIEventToTriggerCandidate", TriggerCandidateData::Algorithm::kHSIEventToTriggerCandidate)
118 .value("kPrescale", TriggerCandidateData::Algorithm::kPrescale)
119 .value("kADCSimpleWindow", TriggerCandidateData::Algorithm::kADCSimpleWindow)
120 .value("kHorizontalMuon", TriggerCandidateData::Algorithm::kHorizontalMuon)
121 .value("kMichelElectron", TriggerCandidateData::Algorithm::kMichelElectron)
122 .value("kPlaneCoincidence", TriggerCandidateData::Algorithm::kPlaneCoincidence)
123 .value("kCustom", TriggerCandidateData::Algorithm::kCustom)
124 .value("kDBSCAN", TriggerCandidateData::Algorithm::kDBSCAN)
125 .value("kChannelDistance", TriggerCandidateData::Algorithm::kChannelDistance)
126 .value("kBundle", TriggerCandidateData::Algorithm::kBundle)
127 .value("kChannelAdjacency", TriggerCandidateData::Algorithm::kChannelAdjacency);
128
129 py::class_<TriggerCandidate>(m, "TriggerCandidateOverlay", py::buffer_protocol())
130 .def(py::init([](py::capsule capsule) {
131 auto tp = *static_cast<TriggerCandidate*>(capsule.get_pointer());
132 return tp;
133 } ))
134 .def_property_readonly("data", [](TriggerCandidate& self) -> TriggerCandidateData& {return self.data;})
135 .def("__len__", [](TriggerCandidate& self){ return self.n_inputs; })
136 .def("sizeof", [](TriggerCandidate& self){ return sizeof(TriggerCandidate)+self.n_inputs*sizeof(TriggerActivityData); })
137 ;
138
139
140 py::class_<TriggerCandidateHolder>(m, "TriggerCandidate", py::buffer_protocol())
141 .def(py::init([](py::capsule capsule) {
142 auto tc_ptr = static_cast<TriggerCandidate*>(capsule.get_pointer());
143 TriggerCandidateHolder tch(tc_ptr, sizeof(TriggerCandidate)+tc_ptr->n_inputs*sizeof(TriggerActivityData));
144 return tch;
145 }))
146 .def(py::init([](py::bytes bytes){
147 py::buffer_info info(py::buffer(bytes).request());
148
149 TriggerCandidateHolder tch(info.ptr, info.size);
150
151 return tch;
152 }))
153
154 .def("get_bytes",
155 [](TriggerCandidateHolder& tch) -> py::bytes {
156 return py::bytes(reinterpret_cast<char*>(tch.ptr()), tch.m_size);
157 }, py::return_value_policy::reference_internal
158 )
159 .def_property_readonly("data", [](TriggerCandidateHolder& self) -> TriggerCandidateData& {return self.ptr()->data;})
160 .def("n_inputs", [](TriggerCandidateHolder& self){ return self.ptr()->n_inputs; })
161 .def("__len__", [](TriggerCandidateHolder& self){ return self.ptr()->n_inputs; })
162 .def("__getitem__",
163 [](TriggerCandidateHolder &self, size_t i) -> const TriggerActivityData& {
164 if (i >= self.ptr()->n_inputs) {
165 throw py::index_error();
166 }
167 return self.ptr()->inputs[i];
168 }, py::return_value_policy::reference_internal)
169 .def("sizeof", [](TriggerCandidateHolder& self){ return self.m_size; })
170 ;
171} // NOLINT function length, while long enough to trip the linter, is fine
dunedaq::trgdataformats::string_to_trigger_candidate_type
TriggerCandidateData::Type string_to_trigger_candidate_type(const std::string &name)
Definition TriggerCandidateData.hxx:72
dunedaq::trgdataformats::trigger_candidate_type_to_string
std::string trigger_candidate_type_to_string(const TriggerCandidateData::Type type)
Definition TriggerCandidateData.hxx:81
dunedaq::trgdataformats::TriggerCandidate
TriggerObjectOverlay< TriggerCandidateData, TriggerActivityData > TriggerCandidate
Definition TriggerObjectOverlay.hpp:52

◆ register_trigger_candidate() [2/2]

void dunedaq::trgdataformats::python::register_trigger_candidate ( pybind11::module & )

◆ register_trigger_primitive() [1/2]

void dunedaq::trgdataformats::python::register_trigger_primitive ( py::module & m)

Definition at line 21 of file trigger_primitive.cpp.

22{
23
24
25 py::class_<TriggerPrimitive> trigger_primitive(m, "TriggerPrimitive", py::buffer_protocol());
26 trigger_primitive
27 .def(py::init())
28 .def(py::init([](py::capsule capsule) {
29 auto tp = *static_cast<TriggerPrimitive*>(capsule.get_pointer());
30 return tp;
31 } ))
32 .def_property_readonly_static("s_trigger_primitive_version", [](py::object /*self*/) {return TriggerPrimitive::s_trigger_primitive_version;})
33 .def_property_readonly_static("s_invalid_samples_over_threshold", [](py::object /*self*/) {return TriggerPrimitive::s_invalid_samples_over_threshold;})
34 .def_property_readonly_static("s_invalid_samples_to_peak", [](py::object /*self*/) {return TriggerPrimitive::s_invalid_samples_to_peak;})
35 .def_property_readonly_static("s_invalid_tp_channel", [](py::object /*self*/) {return TriggerPrimitive::s_invalid_tp_channel;})
36 .def_property_readonly_static("s_expected_bytes", [](py::object /*self*/) {return TriggerPrimitive::s_expected_bytes;})
37 .def_property_readonly("version", [](TriggerPrimitive& self) -> uint8_t {return self.version;})
38 .def_property_readonly("flag", [](TriggerPrimitive& self) -> uint8_t {return self.flag;})
39 .def_property_readonly("detid", [](TriggerPrimitive& self) -> uint8_t {return self.detid;})
40 .def_property_readonly("channel", [](TriggerPrimitive& self) -> uint32_t {return uint32_t(self.channel);})
41 .def_property_readonly("samples_over_threshold", [](TriggerPrimitive& self) -> uint16_t {return self.samples_over_threshold;})
42 .def_property_readonly("time_start", [](TriggerPrimitive& self) -> uint64_t {return self.time_start;})
43 .def_property_readonly("samples_to_peak", [](TriggerPrimitive& self) -> uint16_t {return self.samples_to_peak;})
44 .def_property_readonly("adc_integral", [](TriggerPrimitive& self) -> uint32_t {return self.adc_integral;})
45 .def_property_readonly("adc_peak", [](TriggerPrimitive& self) -> uint16_t {return self.adc_peak;})
46 .def("get_timestamp", &TriggerPrimitive::get_timestamp)
47 .def("set_timestamp", &TriggerPrimitive::set_timestamp)
48 .def("__lt__", &TriggerPrimitive::operator<)
49 .def_static("sizeof", [](){ return sizeof(TriggerPrimitive); })
50 ;
51
52}
triggeralgs::TriggerPrimitive
dunedaq::trgdataformats::TriggerPrimitive TriggerPrimitive
Definition TriggerPrimitive.hpp:22
dunedaq::trgdataformats::TriggerPrimitive
A single energy deposition on a TPC or PDS channel.
Definition TriggerPrimitive.hpp:32
dunedaq::trgdataformats::TriggerPrimitive::s_invalid_tp_channel
static constexpr channel_t s_invalid_tp_channel
Definition TriggerPrimitive.hpp:38
dunedaq::trgdataformats::TriggerPrimitive::s_trigger_primitive_version
static constexpr version_t s_trigger_primitive_version
Definition TriggerPrimitive.hpp:33
dunedaq::trgdataformats::TriggerPrimitive::s_invalid_samples_over_threshold
static constexpr uint16_t s_invalid_samples_over_threshold
Definition TriggerPrimitive.hpp:36
dunedaq::trgdataformats::TriggerPrimitive::s_expected_bytes
static constexpr std::size_t s_expected_bytes
Definition TriggerPrimitive.hpp:34
dunedaq::trgdataformats::TriggerPrimitive::s_invalid_samples_to_peak
static constexpr uint16_t s_invalid_samples_to_peak
Definition TriggerPrimitive.hpp:37

◆ register_trigger_primitive() [2/2]

void dunedaq::trgdataformats::python::register_trigger_primitive ( pybind11::module & )

◆ register_types() [1/2]

void dunedaq::trgdataformats::python::register_types ( py::module & m)

Definition at line 18 of file types.cpp.

19{
20 py::class_<TypeDefaults>(m, "TypeDefaults")
21 .def_property_readonly_static("s_invalid_timestamp", [](py::object /*self*/) { return TypeDefaults::s_invalid_timestamp; })
22 .def_property_readonly_static("s_invalid_detid", [](py::object /*self*/) { return TypeDefaults::s_invalid_detid; })
23 .def_property_readonly_static("s_invalid_trigger_number", [](py::object /*self*/) { return TypeDefaults::s_invalid_trigger_number; });
24
25 m.attr("g_whole_detector") = py::int_(g_whole_detector);
26}
dunedaq::trgdataformats::g_whole_detector
constexpr detid_t g_whole_detector
Definition Types.hpp:69
dunedaq::trgdataformats::TypeDefaults::s_invalid_trigger_number
static constexpr trigger_number_t s_invalid_trigger_number
Definition Types.hpp:65
dunedaq::trgdataformats::TypeDefaults::s_invalid_timestamp
static constexpr timestamp_t s_invalid_timestamp
Definition Types.hpp:63
dunedaq::trgdataformats::TypeDefaults::s_invalid_detid
static constexpr detid_t s_invalid_detid
Definition Types.hpp:64

◆ register_types() [2/2]

void dunedaq::trgdataformats::python::register_types ( pybind11::module & )
Generated on for DUNE-DAQ by doxygen 1.18.0