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 .value("kSWIFT", TriggerActivityData::Algorithm::kSWIFT)
92 .value("kProtoDUNEBSMWindow", TriggerActivityData::Algorithm::kProtoDUNEBSMWindow);
93
94 py::class_<TriggerActivity>(m, "TriggerActivityOverlay", py::buffer_protocol())
95 .def(py::init())
96 .def(py::init([](py::capsule capsule) {
97 auto tp = *static_cast<TriggerActivity*>(capsule.get_pointer());
98 return tp;
99 } ))
100 .def_property_readonly("data", [](TriggerActivity& self) -> TriggerActivityData& {return self.data;})
101 .def("__len__", [](TriggerActivity& self){ return self.n_inputs; })
102 .def("sizeof", [](TriggerActivity& self){ return sizeof(TriggerActivity)+self.n_inputs*sizeof(TriggerPrimitive); })
103 ;
104
105
106 py::class_<TriggerActivityHolder>(m, "TriggerActivity", py::buffer_protocol())
107 // .def(py::init())
108 .def(py::init([](py::capsule capsule) {
109 auto ta_ptr = static_cast<TriggerActivity*>(capsule.get_pointer());
110 TriggerActivityHolder tah(ta_ptr, sizeof(TriggerActivity)+ta_ptr->n_inputs*sizeof(TriggerPrimitive));
111 return tah;
112 }))
113 .def(py::init([](py::bytes bytes){
114 py::buffer_info info(py::buffer(bytes).request());
115 TriggerActivityHolder tah(info.ptr, info.size);
116
117 return tah;
118 }))
119
120 .def("get_bytes",
121 [](TriggerActivityHolder& tah) -> py::bytes {
122 return py::bytes(reinterpret_cast<char*>(tah.ptr()), tah.m_size);
123 }, py::return_value_policy::reference_internal
124 )
125 .def_property_readonly("data", [](TriggerActivityHolder& self) -> TriggerActivityData& {return self.ptr()->data;})
126 .def("n_inputs", [](TriggerActivityHolder& self){ return self.ptr()->n_inputs; })
127 .def("__len__", [](TriggerActivityHolder& self){ return self.ptr()->n_inputs; })
128 .def("__getitem__",
129 [](TriggerActivityHolder &self, size_t i) -> const TriggerPrimitive& {
130 if (i >= self.ptr()->n_inputs) {
131 throw py::index_error();
132 }
133 return self.ptr()->inputs[i];
134 }, py::return_value_policy::reference_internal)
135 .def("sizeof", [](TriggerActivityHolder& self){ return self.m_size; })
136
137 ;
138}
dunedaq::trgdataformats::TriggerActivity
TriggerObjectOverlay< TriggerActivityData, TriggerPrimitive > TriggerActivity
Definition TriggerObjectOverlay.hpp:31

◆ 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("kCTBBeamSpillStart", TriggerCandidateData::Type::kCTBBeamSpillStart)
103 .value("kCTBBeamSpillSnapshot", TriggerCandidateData::Type::kCTBBeamSpillSnapshot)
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 .value("kProtoDUNEBSMWindow", TriggerCandidateData::Type::kProtoDUNEBSMWindow);
110
111 py::enum_<TriggerCandidateData::Algorithm>(trigger_candidate_data, "Algorithm")
112 .value("kUnknown", TriggerCandidateData::Algorithm::kUnknown)
113 .value("kSupernova", TriggerCandidateData::Algorithm::kSupernova)
114 .value("kHSIEventToTriggerCandidate", TriggerCandidateData::Algorithm::kHSIEventToTriggerCandidate)
115 .value("kPrescale", TriggerCandidateData::Algorithm::kPrescale)
116 .value("kADCSimpleWindow", TriggerCandidateData::Algorithm::kADCSimpleWindow)
117 .value("kHorizontalMuon", TriggerCandidateData::Algorithm::kHorizontalMuon)
118 .value("kMichelElectron", TriggerCandidateData::Algorithm::kMichelElectron)
119 .value("kPlaneCoincidence", TriggerCandidateData::Algorithm::kPlaneCoincidence)
120 .value("kCustom", TriggerCandidateData::Algorithm::kCustom)
121 .value("kDBSCAN", TriggerCandidateData::Algorithm::kDBSCAN)
122 .value("kChannelDistance", TriggerCandidateData::Algorithm::kChannelDistance)
123 .value("kBundle", TriggerCandidateData::Algorithm::kBundle)
124 .value("kChannelAdjacency", TriggerCandidateData::Algorithm::kChannelAdjacency);
125
126 py::class_<TriggerCandidate>(m, "TriggerCandidateOverlay", py::buffer_protocol())
127 .def(py::init([](py::capsule capsule) {
128 auto tp = *static_cast<TriggerCandidate*>(capsule.get_pointer());
129 return tp;
130 } ))
131 .def_property_readonly("data", [](TriggerCandidate& self) -> TriggerCandidateData& {return self.data;})
132 .def("__len__", [](TriggerCandidate& self){ return self.n_inputs; })
133 .def("sizeof", [](TriggerCandidate& self){ return sizeof(TriggerCandidate)+self.n_inputs*sizeof(TriggerActivityData); })
134 ;
135
136
137 py::class_<TriggerCandidateHolder>(m, "TriggerCandidate", py::buffer_protocol())
138 .def(py::init([](py::capsule capsule) {
139 auto tc_ptr = static_cast<TriggerCandidate*>(capsule.get_pointer());
140 TriggerCandidateHolder tch(tc_ptr, sizeof(TriggerCandidate)+tc_ptr->n_inputs*sizeof(TriggerActivityData));
141 return tch;
142 }))
143 .def(py::init([](py::bytes bytes){
144 py::buffer_info info(py::buffer(bytes).request());
145
146 TriggerCandidateHolder tch(info.ptr, info.size);
147
148 return tch;
149 }))
150
151 .def("get_bytes",
152 [](TriggerCandidateHolder& tch) -> py::bytes {
153 return py::bytes(reinterpret_cast<char*>(tch.ptr()), tch.m_size);
154 }, py::return_value_policy::reference_internal
155 )
156 .def_property_readonly("data", [](TriggerCandidateHolder& self) -> TriggerCandidateData& {return self.ptr()->data;})
157 .def("n_inputs", [](TriggerCandidateHolder& self){ return self.ptr()->n_inputs; })
158 .def("__len__", [](TriggerCandidateHolder& self){ return self.ptr()->n_inputs; })
159 .def("__getitem__",
160 [](TriggerCandidateHolder &self, size_t i) -> const TriggerActivityData& {
161 if (i >= self.ptr()->n_inputs) {
162 throw py::index_error();
163 }
164 return self.ptr()->inputs[i];
165 }, py::return_value_policy::reference_internal)
166 .def("sizeof", [](TriggerCandidateHolder& self){ return self.m_size; })
167 ;
168}
dunedaq::trgdataformats::trigger_candidate_type_to_string
std::string trigger_candidate_type_to_string(const TriggerCandidateData::Type &type)
Definition TriggerCandidateData.hpp:159
dunedaq::trgdataformats::TriggerCandidate
TriggerObjectOverlay< TriggerCandidateData, TriggerActivityData > TriggerCandidate
Definition TriggerObjectOverlay.hpp:33
dunedaq::trgdataformats::string_to_trigger_candidate_type
int string_to_trigger_candidate_type(const std::string &name)
Definition TriggerCandidateData.hpp:149

◆ 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
dunedaq::trgdataformats::TriggerPrimitive::s_trigger_primitive_version
static constexpr uint8_t s_trigger_primitive_version
Definition TriggerPrimitive.hpp:28

◆ register_trigger_primitive() [2/2]

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