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_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)
 

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_trigger_primitive(m);
24 // register_trigger_bitwords(m);
25 register_trigger_activity(m);
26 register_trigger_candidate(m);
27}
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_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("version", [](TriggerActivityData& self) -> uint16_t {return self.version;})
58 .def_property_readonly("time_start", [](TriggerActivityData& self) -> uint64_t {return self.time_start;})
59 .def_property_readonly("time_end", [](TriggerActivityData& self) -> uint64_t {return self.time_end;})
60 .def_property_readonly("time_peak", [](TriggerActivityData& self) -> uint64_t {return self.time_peak;})
61 .def_property_readonly("time_activity", [](TriggerActivityData& self) -> uint64_t {return self.time_activity;})
62 .def_property_readonly("channel_start", [](TriggerActivityData& self) -> int32_t {return self.channel_start;})
63 .def_property_readonly("channel_end", [](TriggerActivityData& self) -> int32_t {return self.channel_end;})
64 .def_property_readonly("channel_peak", [](TriggerActivityData& self) -> int32_t {return self.channel_peak;})
65 .def_property_readonly("adc_integral", [](TriggerActivityData& self) -> uint32_t {return self.adc_integral;})
66 .def_property_readonly("adc_peak", [](TriggerActivityData& self) -> uint32_t {return self.adc_peak;})
67 .def_property_readonly("detid", [](TriggerActivityData& self) -> uint16_t {return self.detid;})
68 .def_property_readonly("type", [](TriggerActivityData& self) -> TriggerActivityData::Type {return self.type;})
69 .def_property_readonly("algorithm", [](TriggerActivityData& self) -> TriggerActivityData::Algorithm {return self.algorithm;})
70 .def_static("sizeof", [](){ return sizeof(TriggerActivityData); })
71 ;
72
73
74 py::enum_<TriggerActivityData::Type>(trigger_activity_data, "Type")
75 .value("kUnknown", TriggerActivityData::Type::kUnknown)
76 .value("kTPC", TriggerActivityData::Type::kTPC)
77 .value("kPDS", TriggerActivityData::Type::kPDS);
78
79 py::enum_<TriggerActivityData::Algorithm>(trigger_activity_data, "Algorithm")
80 .value("kUnknown", TriggerActivityData::Algorithm::kUnknown)
81 .value("kSupernova", TriggerActivityData::Algorithm::kSupernova)
82 .value("kPrescale", TriggerActivityData::Algorithm::kPrescale)
83 .value("kADCSimpleWindow", TriggerActivityData::Algorithm::kADCSimpleWindow)
84 .value("kHorizontalMuon", TriggerActivityData::Algorithm::kHorizontalMuon)
85 .value("kMichelElectron", TriggerActivityData::Algorithm::kMichelElectron)
86 .value("kDBSCAN", TriggerActivityData::Algorithm::kDBSCAN)
87 .value("kPlaneCoincidence", TriggerActivityData::Algorithm::kPlaneCoincidence)
88 .value("kBundle", TriggerActivityData::Algorithm::kBundle)
89 .value("kChannelDistance", TriggerActivityData::Algorithm::kChannelDistance)
90 .value("kChannelAdjacency", TriggerActivityData::Algorithm::kChannelAdjacency);
91
92 py::class_<TriggerActivity>(m, "TriggerActivityOverlay", py::buffer_protocol())
93 .def(py::init())
94 .def(py::init([](py::capsule capsule) {
95 auto tp = *static_cast<TriggerActivity*>(capsule.get_pointer());
96 return tp;
97 } ))
98 .def_property_readonly("data", [](TriggerActivity& self) -> TriggerActivityData& {return self.data;})
99 .def("__len__", [](TriggerActivity& self){ return self.n_inputs; })
100 .def("sizeof", [](TriggerActivity& self){ return sizeof(TriggerActivity)+self.n_inputs*sizeof(TriggerPrimitive); })
101 ;
102
103
104 py::class_<TriggerActivityHolder>(m, "TriggerActivity", py::buffer_protocol())
105 // .def(py::init())
106 .def(py::init([](py::capsule capsule) {
107 auto ta_ptr = static_cast<TriggerActivity*>(capsule.get_pointer());
108 TriggerActivityHolder tah(ta_ptr, sizeof(TriggerActivity)+ta_ptr->n_inputs*sizeof(TriggerPrimitive));
109 return tah;
110 }))
111 .def(py::init([](py::bytes bytes){
112 py::buffer_info info(py::buffer(bytes).request());
113 TriggerActivityHolder tah(info.ptr, info.size);
114
115 return tah;
116 }))
117
118 .def("get_bytes",
119 [](TriggerActivityHolder& tah) -> py::bytes {
120 return py::bytes(reinterpret_cast<char*>(tah.ptr()), tah.m_size);
121 }, py::return_value_policy::reference_internal
122 )
123 .def_property_readonly("data", [](TriggerActivityHolder& self) -> TriggerActivityData& {return self.ptr()->data;})
124 .def("n_inputs", [](TriggerActivityHolder& self){ return self.ptr()->n_inputs; })
125 .def("__len__", [](TriggerActivityHolder& self){ return self.ptr()->n_inputs; })
126 .def("__getitem__",
127 [](TriggerActivityHolder &self, size_t i) -> const TriggerPrimitive& {
128 if (i >= self.ptr()->n_inputs) {
129 throw py::index_error();
130 }
131 return self.ptr()->inputs[i];
132 }, py::return_value_policy::reference_internal)
133 .def("sizeof", [](TriggerActivityHolder& self){ return self.m_size; })
134
135 ;
136}
TriggerActivity
TriggerActivity
Definition TriggerActivity_serialization.hpp:37

◆ 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 41 of file trigger_candidate.cpp.

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

◆ 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 19 of file trigger_primitive.cpp.

20{
21
22
23 py::class_<TriggerPrimitive> trigger_primitive(m, "TriggerPrimitive", py::buffer_protocol());
24 trigger_primitive
25 .def(py::init())
26 .def(py::init([](py::capsule capsule) {
27 auto tp = *static_cast<TriggerPrimitive*>(capsule.get_pointer());
28 return tp;
29 } ))
30 .def_property_readonly_static("s_trigger_primitive_version", [](py::object /*self*/) {return TriggerPrimitive::s_trigger_primitive_version;})
31 .def_property_readonly("version", [](TriggerPrimitive& self) -> uint8_t {return self.version;})
32 .def_property_readonly("time_start", [](TriggerPrimitive& self) -> uint64_t {return self.time_start;})
33 .def_property_readonly("samples_to_peak", [](TriggerPrimitive& self) -> uint16_t {return self.samples_to_peak;})
34 .def_property_readonly("samples_over_threshold", [](TriggerPrimitive& self) -> uint16_t {return self.samples_over_threshold;})
35 .def_property_readonly("channel", [](TriggerPrimitive& self) -> uint32_t {return uint32_t(self.channel);})
36 .def_property_readonly("adc_integral", [](TriggerPrimitive& self) -> uint32_t {return self.adc_integral;})
37 .def_property_readonly("adc_peak", [](TriggerPrimitive& self) -> uint16_t {return self.adc_peak;})
38 .def_property_readonly("detid", [](TriggerPrimitive& self) -> uint8_t {return self.detid;})
39 .def_property_readonly("flag", [](TriggerPrimitive& self) -> uint8_t {return self.flag;})
40 .def_static("sizeof", [](){ return sizeof(TriggerPrimitive); })
41 ;
42
43}
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:27

◆ register_trigger_primitive() [2/2]

void dunedaq::trgdataformats::python::register_trigger_primitive ( pybind11::module & )
Generated on Sat Jun 28 2025 for DUNE-DAQ by doxygen 1.12.0