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.

{
 
  m.doc() = "c++ implementation of the dunedaq daqdataformats modules"; // optional module docstring
 
  register_sourceid(m);
  register_fragment(m);
  register_component_request(m);
  register_trigger_record(m);
  register_timeslice(m);
}

register_component_request()

void dunedaq::daqdataformats::python::register_component_request

(

py::module &

m

)

Definition at line 21 of file component_request.cpp.

{
 
  py::class_<ComponentRequest>(m, "ComponentRequest")
    .def(py::init())
    .def(py::init<SourceID const&, timestamp_t const&, timestamp_t const&>())
    .def("__str__",
         [](const ComponentRequest& cr) {
           std::ostringstream oss;
           oss << cr;
           return oss.str();
         })
    .def("__repr__",
         [](const ComponentRequest& cr) {
           std::ostringstream oss;
           oss << "<daqdataformats::ComponentRequest " << cr << ">";
           return oss.str();
         })
    .def_readonly_static("s_component_request_version", &ComponentRequest::s_component_request_version)
    .def_readonly("version", &ComponentRequest::version)
    .def_readonly("unused", &ComponentRequest::unused)
    .def_readonly("component", &ComponentRequest::component)
    .def_readonly("window_begin", &ComponentRequest::window_begin)
    .def_readonly("window_end", &ComponentRequest::window_end);
}

register_fragment()

void dunedaq::daqdataformats::python::register_fragment

(

py::module &

m

)

Definition at line 23 of file fragment.cpp.

{
 
  py::class_<Fragment> py_fragment(m, "Fragment", py::buffer_protocol());
 
  py_fragment.def("get_header", &Fragment::get_header, py::return_value_policy::reference_internal)
    .def("get_storage_location", &Fragment::get_storage_location, py::return_value_policy::reference_internal)
    .def("get_trigger_number", &Fragment::get_trigger_number)
    .def("get_run_number", &Fragment::get_run_number)
    .def("get_trigger_timestamp", &Fragment::get_trigger_timestamp)
    .def("get_window_begin", &Fragment::get_window_begin)
    .def("get_window_end", &Fragment::get_window_end)
    .def("get_element_id", &Fragment::get_element_id)
    .def("get_detector_id", &Fragment::get_detector_id)
    .def("get_status_bits", [](Fragment& self) { return self.get_status_bits().to_ullong(); })
    .def("get_status_bit", &Fragment::get_status_bit)
    .def("get_fragment_type_code", &Fragment::get_fragment_type_code)
    .def("get_fragment_type", &Fragment::get_fragment_type)
    .def("get_sequence_number", &Fragment::get_sequence_number)
    .def("get_size", &Fragment::get_size)
    .def("get_data_size", &Fragment::get_data_size)
    .def(
      "get_data",
      [](Fragment& self, size_t offset) {
        return static_cast<void*>(static_cast<char*>(self.get_data()) + offset); // NOLINT
      },
      "offset"_a = 0,
      py::return_value_policy::reference_internal)
    .def(
      "get_data_bytes",
      [](Fragment* self, size_t offset) -> py::bytes {
        if (offset > self->get_data_size()) {
          throw std::runtime_error("Fragment.get_data_bytes: offset exceeds fragment size.");
        }
        size_t bytes_size = self->get_data_size() - offset;
        return py::bytes(reinterpret_cast<char*>(self->get_data()) + offset, bytes_size); // NOLINT
      },
      "offset"_a = 0,
      py::return_value_policy::reference_internal);
 
  py::enum_<Fragment::BufferAdoptionMode>(py_fragment, "BufferAdoptionMode")
    .value("kTakeOverBuffer", Fragment::BufferAdoptionMode::kTakeOverBuffer)
    .value("kCopyFromBuffer", Fragment::BufferAdoptionMode::kCopyFromBuffer)
    .export_values();
 
  py::class_<FragmentHeader>(m, "FragmentHeader")
    .def(py::init<>())
    .def_property_readonly_static(
      "s_fragment_header_marker",
      [](const py::object&) -> uint32_t { return FragmentHeader::s_fragment_header_marker; }) // NOLINT(build/unsigned)
    .def_property_readonly_static(
      "s_fragment_header_version",
      [](const py::object&) -> uint32_t { return FragmentHeader::s_fragment_header_version; }) // NOLINT(build/unsigned)
    .def_property_readonly_static(
      "s_default_status_bits",
      [](const py::object&) -> uint32_t { return FragmentHeader::s_default_status_bits; }) // NOLINT(build/unsigned)
    .def_property_readonly(
      "fragment_header_marker",
      [](const FragmentHeader& self) -> uint32_t { return self.fragment_header_marker; }) // NOLINT(build/unsigned)
    .def_property_readonly(
      "version", [](const FragmentHeader& self) -> uint32_t { return self.version; }) // NOLINT(build/unsigned)
    .def_property_readonly("size", [](const FragmentHeader& self) -> fragment_size_t { return self.size; })
    .def_property_readonly("trigger_number",
                           [](const FragmentHeader& self) -> trigger_number_t { return self.trigger_number; })
    .def_property_readonly("trigger_timestamp",
                           [](const FragmentHeader& self) -> timestamp_t { return self.trigger_timestamp; })
    .def_property_readonly("window_begin", [](const FragmentHeader& self) -> timestamp_t { return self.window_begin; })
    .def_property_readonly("window_end", [](const FragmentHeader& self) -> timestamp_t { return self.window_end; })
    .def_property_readonly("run_number", [](const FragmentHeader& self) -> run_number_t { return self.run_number; })
    .def_property_readonly(
      "status_bits", [](const FragmentHeader& self) -> uint32_t { return self.status_bits; }) // NOLINT(build/unsigned)
    .def_property_readonly("fragment_type",
                           [](const FragmentHeader& self) -> fragment_type_t { return self.fragment_type; })
    .def_property_readonly("sequence_number",
                           [](const FragmentHeader& self) -> sequence_number_t { return self.sequence_number; })
    .def_property_readonly(
      "detector_id", [](const FragmentHeader& self) -> uint16_t { return self.detector_id; }) // NOLINT(build/unsigned)
    .def_property_readonly("element_id", [](const FragmentHeader& self) -> SourceID { return self.element_id; })
 
    .def_static("sizeof", []() { return sizeof(FragmentHeader); })
    .def("__str__",
         [](const FragmentHeader& hdr) {
           std::ostringstream oss;
           oss << hdr;
           return oss.str();
         })
    .def("__repr__", [](const FragmentHeader& hdr) {
      std::ostringstream oss;
      oss << "<daqdataformats::FragmentHeader " << hdr << ">";
      return oss.str();
    });
 
  py::enum_<FragmentStatusBits>(m, "FragmentStatusBits")
    .value("kLatencyBufferEmpty", FragmentStatusBits::kLatencyBufferEmpty)
    .value("kIncomplete", FragmentStatusBits::kIncomplete)
    .value("kInvalidRequestWindow", FragmentStatusBits::kInvalidRequestWindow)
    .value("kRequestTimeout", FragmentStatusBits::kRequestTimeout)
    .value("kRequestWindowBeforeBuffer", FragmentStatusBits::kRequestWindowBeforeBuffer)
    .value("kRequestWindowAfterBuffer", FragmentStatusBits::kRequestWindowAfterBuffer)
    .value("kEmptyFragment", FragmentStatusBits::kEmptyFragment)
    // TODO, Alessandro Thea <thea@github.com> Oct-31-2021:  Add unassigned
    .export_values();
 
  py::enum_<FragmentType>(m, "FragmentType")
    .value("kUnknown", FragmentType::kUnknown)
    .value("kProtoWIB", FragmentType::kProtoWIB)
    .value("kWIB", FragmentType::kWIB)
    .value("kDAPHNE", FragmentType::kDAPHNE)
    .value("kTDE_AMC", FragmentType::kTDE_AMC)
    .value("kFW_TriggerPrimitive", FragmentType::kFW_TriggerPrimitive)
    .value("kTriggerPrimitive", FragmentType::kTriggerPrimitive)
    .value("kTriggerActivity", FragmentType::kTriggerActivity)
    .value("kTriggerCandidate", FragmentType::kTriggerCandidate)
    .value("kHardwareSignal", FragmentType::kHardwareSignal)
    .value("kPACMAN", FragmentType::kPACMAN)
    .value("kWIBEth", FragmentType::kWIBEth)
    .value("kMPD", FragmentType::kMPD)
    .value("kDAPHNEStream", FragmentType::kDAPHNEStream)
    .value("kCRT", FragmentType::kCRT)
    .value("kTDEEth", FragmentType::kTDEEth)
    .value("kCRTBern", FragmentType::kCRTBern)
    .value("kCRTGrenoble", FragmentType::kCRTGrenoble)
    .value("kDAPHNEEth", FragmentType::kDAPHNEEth)
    .value("kDAPHNEEthStream", FragmentType::kDAPHNEEthStream)
    .export_values();
 
  m.def("fragment_type_to_string", &fragment_type_to_string);
  m.def("string_to_fragment_type", &string_to_fragment_type);
  m.def("get_fragment_type_names", &get_fragment_type_names);
} // NOLINT(readability/fn_size)

register_sourceid()

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

extern

Definition at line 22 of file sourceid.cpp.

{
 
  py::class_<SourceID> py_sourceid(m, "SourceID");
  py_sourceid.def(py::init()).def(py::init<const SourceID::Subsystem&, const SourceID::ID_t&>());
  py_sourceid.def(py::self < py::self)
    .def(py::self == py::self)
    .def(py::self != py::self)
    .def("__hash__",
         [](const SourceID& self) {
           return py::hash(py::make_tuple(static_cast<uint32_t>(self.subsystem), self.id)); // NOLINT(build/unsigned)
         })
    .def_property_readonly_static(
      "s_source_id_version", [](const py::object&) -> SourceID::Version_t { return SourceID::s_source_id_version; })
    .def_property_readonly_static("s_invalid_id",
                                  [](const py::object&) -> SourceID::ID_t { return SourceID::s_invalid_id; })
    .def("__str__",
         [](const SourceID& gid) {
           std::ostringstream oss;
           oss << gid;
           return oss.str();
         })
    .def("__repr__", [](const SourceID& gid) {
      std::ostringstream oss;
      oss << "<daqdataformats::SourceID " << gid << ">";
      return oss.str();
    });
 
  py::enum_<SourceID::Subsystem>(py_sourceid, "Subsystem")
    .value("kUnknown", SourceID::Subsystem::kUnknown)
    .value("kDetectorReadout", SourceID::Subsystem::kDetectorReadout)
    .value("kHwSignalsInterface", SourceID::Subsystem::kHwSignalsInterface)
    .value("kTrigger", SourceID::Subsystem::kTrigger)
    .value("kTRBuilder", SourceID::Subsystem::kTRBuilder)
    .export_values();
 
  py_sourceid.def_readwrite("version", &SourceID::version)
    .def_readwrite("subsystem", &SourceID::subsystem)
    .def_readwrite("id", &SourceID::id);
 
  py_sourceid.def("subsystem_to_string", &SourceID::subsystem_to_string)
    .def("string_to_subsystem", &SourceID::string_to_subsystem)
    .def("to_string", &SourceID::to_string)
    .def("is_in_valid_state", &SourceID::is_in_valid_state);
}

register_timeslice()

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

extern

Definition at line 24 of file time_slice.cpp.

{
  py::class_<TimeSliceHeader>(m, "TimeSliceHeader")
    .def(py::init<>())
    .def_property_readonly_static("s_timeslice_header_marker",
                                  [](const py::object&) -> uint32_t { // NOLINT(build/unsigned)
                                    return TimeSliceHeader::s_timeslice_header_marker;
                                  })
    .def_property_readonly_static("s_timeslice_header_version",
                                  [](const py::object&) -> uint32_t { // NOLINT(build/unsigned)
                                    return TimeSliceHeader::s_timeslice_header_version;
                                  })
    .def_property_readonly("timeslice_header_marker",
                           [](const TimeSliceHeader& self) -> uint32_t { // NOLINT(build/unsigned)
                             return self.timeslice_header_marker;
                           })
    .def_property_readonly(
      "version", [](const TimeSliceHeader& self) -> uint32_t { return self.version; }) // NOLINT(build/unsigned)
    .def_property_readonly("timeslice_number",
                           [](const TimeSliceHeader& self) -> timeslice_number_t { return self.timeslice_number; })
    .def_property_readonly("run_number", [](const TimeSliceHeader& self) -> run_number_t { return self.run_number; })
    .def_property_readonly("element_id", [](const TimeSliceHeader& self) -> SourceID { return self.element_id; })
    .def("__str__",
         [](const TimeSliceHeader& hdr) {
           std::ostringstream oss;
           oss << hdr;
           return oss.str();
         })
    .def("__repr__", [](const TimeSliceHeader& hdr) {
      std::ostringstream oss;
      oss << "<daqdataformats::TimeSliceHeader " << hdr << ">";
      return oss.str();
    });
 
  py::class_<TimeSlice> py_timeslice(m, "TimeSlice", pybind11::buffer_protocol());
  py_timeslice.def(py::init<TimeSliceHeader const&>())
    .def(py::init<timeslice_number_t, run_number_t>())
    .def(
      "get_header", [](TimeSlice& self) { return self.get_header(); }, py::return_value_policy::reference_internal)
    //    .def("set_header", &TimeSlice::set_header)
    .def(
      "get_fragments_ref",
      [](TimeSlice& self) {
        auto fragments = py::list();
        for (auto& fragment : self.get_fragments_ref()) {
          auto py_fragment = py::cast(*fragment, py::return_value_policy::reference);
          fragments.append(py_fragment);
        }
        return fragments;
      },
      py::return_value_policy::reference_internal)
    .def("get_total_size_bytes", &TimeSlice::get_total_size_bytes)
    .def("get_sum_of_fragment_payload_sizes", &TimeSlice::get_sum_of_fragment_payload_sizes);
} // NOLINT

register_trigger_record()

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

extern

Definition at line 24 of file trigger_record.cpp.

{
  py::class_<TriggerRecordHeader>(m, "TriggerRecordHeader", pybind11::buffer_protocol())
    .def(py::init<std::vector<ComponentRequest> const&>())
    .def(py::init([](py::capsule capsule, bool copy_from_buffer) {
      return std::make_unique<TriggerRecordHeader>(capsule.get_pointer(), copy_from_buffer);
    }))
    .def(py::init<TriggerRecordHeader const&>())
    .def("get_header", &TriggerRecordHeader::get_header)
    .def("get_trigger_number", &TriggerRecordHeader::get_trigger_number)
    //.def("set_trigger_number", &TriggerRecordHeader::set_trigger_number)
    .def("get_trigger_timestamp", &TriggerRecordHeader::get_trigger_timestamp)
    //.def("set_trigger_timestamp", &TriggerRecordHeader::set_trigger_timestamp)
    .def("get_num_requested_components", &TriggerRecordHeader::get_num_requested_components)
    .def("get_run_number", &TriggerRecordHeader::get_run_number)
    //.def("set_run_number", &TriggerRecordHeader::set_run_number)
    .def("get_status_bits", &TriggerRecordHeader::get_status_bits)
    //.def("set_status_bits", &TriggerRecordHeader::set_status_bits)
    .def("get_status_bit", &TriggerRecordHeader::get_status_bit)
    //.def("set_status_bit", &TriggerRecordHeader::set_status_bit)
    .def("get_trigger_type", &TriggerRecordHeader::get_trigger_type)
    //.def("set_trigger_type", &TriggerRecordHeader::set_trigger_type)
    .def("get_sequence_number", &TriggerRecordHeader::get_sequence_number)
    //.def("set_sequence_number", &TriggerRecordHeader::set_sequence_number)
    .def("get_max_sequence_number", &TriggerRecordHeader::get_max_sequence_number)
    //.def("set_max_sequence_number", &TriggerRecordHeader::set_max_sequence_number)
    .def("get_total_size_bytes", &TriggerRecordHeader::get_total_size_bytes)
    .def(
      "get_storage_location", &TriggerRecordHeader::get_storage_location, py::return_value_policy::reference_internal)
    .def("get_element_id", &TriggerRecordHeader::get_element_id)
    .def("get_component_for_source_id",
         &TriggerRecordHeader::get_component_for_source_id,
         py::return_value_policy::reference_internal)
    .def("at", &TriggerRecordHeader::at)
    .def("__getitem__", &TriggerRecordHeader::at, py::return_value_policy::reference_internal);
 
  py::class_<TriggerRecordHeaderData>(m, "TriggerRecordHeaderData")
    .def(py::init<>())
    .def_property_readonly_static("s_trigger_record_header_magic",
                                  [](const py::object&) -> uint32_t { // NOLINT(build/unsigned)
                                    return TriggerRecordHeaderData::s_trigger_record_header_magic;
                                  })
    .def_property_readonly_static("s_trigger_record_header_version",
                                  [](const py::object&) -> uint32_t { // NOLINT(build/unsigned)
                                    return TriggerRecordHeaderData::s_trigger_record_header_version;
                                  })
    .def_property_readonly_static("s_invalid_number_components",
                                  [](const py::object&) -> uint64_t { // NOLINT(build/unsigned)
                                    return TriggerRecordHeaderData::s_invalid_number_components;
                                  })
    .def_property_readonly_static("s_default_status_bits",
                                  [](const py::object&) -> uint32_t { // NOLINT(build/unsigned)
                                    return TriggerRecordHeaderData::s_default_status_bits;
                                  })
    .def_property_readonly("trigger_record_header_marker",
                           [](const TriggerRecordHeaderData& self) -> uint32_t { // NOLINT(build/unsigned)
                             return self.trigger_record_header_marker;
                           })
    .def_property_readonly(
      "version", [](const TriggerRecordHeaderData& self) -> uint32_t { return self.version; }) // NOLINT(build/unsigned)
    .def_property_readonly("trigger_number",
                           [](const TriggerRecordHeaderData& self) -> trigger_number_t { return self.trigger_number; })
    .def_property_readonly("trigger_timestamp",
                           [](const TriggerRecordHeaderData& self) -> timestamp_t { return self.trigger_timestamp; })
    .def_property_readonly("num_requested_components",
                           [](const TriggerRecordHeaderData& self) -> uint64_t { // NOLINT(build/unsigned)
                             return self.num_requested_components;
                           })
    .def_property_readonly("run_number",
                           [](const TriggerRecordHeaderData& self) -> run_number_t { return self.run_number; })
    .def_property_readonly(
      "status_bits",
      [](const TriggerRecordHeaderData& self) -> uint32_t { return self.status_bits; }) // NOLINT(build/unsigned)
    .def_property_readonly("trigger_type",
                           [](const TriggerRecordHeaderData& self) -> trigger_type_t { return self.trigger_type; })
    .def_property_readonly(
      "sequence_number", [](const TriggerRecordHeaderData& self) -> sequence_number_t { return self.sequence_number; })
    .def_property_readonly(
      "max_sequence_number",
      [](const TriggerRecordHeaderData& self) -> sequence_number_t { return self.max_sequence_number; })
    .def_property_readonly("element_id",
                           [](const TriggerRecordHeaderData& self) -> SourceID { return self.element_id; })
    .def("__str__",
         [](const TriggerRecordHeaderData& hdr) {
           std::ostringstream oss;
           oss << hdr;
           return oss.str();
         })
    .def("__repr__", [](const TriggerRecordHeaderData& hdr) {
      std::ostringstream oss;
      oss << "<daqdataformats::TriggerRecordHeaderData " << hdr << ">";
      return oss.str();
    });
 
  py::enum_<TriggerRecordStatusBits>(m, "TriggerRecordStatusBits")
    .value("kIncomplete", TriggerRecordStatusBits::kIncomplete)
    .value("kMismatch", TriggerRecordStatusBits::kMismatch)
    .value("kUnassigned2", TriggerRecordStatusBits::kUnassigned2)
    .value("kUnassigned3", TriggerRecordStatusBits::kUnassigned3)
    .value("kUnassigned4", TriggerRecordStatusBits::kUnassigned4)
    .value("kUnassigned5", TriggerRecordStatusBits::kUnassigned5)
    .value("kUnassigned6", TriggerRecordStatusBits::kUnassigned6)
    .value("kUnassigned7", TriggerRecordStatusBits::kUnassigned7)
    .value("kUnassigned8", TriggerRecordStatusBits::kUnassigned8)
    .value("kUnassigned9", TriggerRecordStatusBits::kUnassigned9)
    .value("kUnassigned10", TriggerRecordStatusBits::kUnassigned10)
    .value("kUnassigned11", TriggerRecordStatusBits::kUnassigned11)
    .value("kUnassigned12", TriggerRecordStatusBits::kUnassigned12)
    .value("kUnassigned13", TriggerRecordStatusBits::kUnassigned13)
    .value("kUnassigned14", TriggerRecordStatusBits::kUnassigned14)
    .value("kUnassigned15", TriggerRecordStatusBits::kUnassigned15)
    .value("kUnassigned16", TriggerRecordStatusBits::kUnassigned16)
    .value("kUnassigned17", TriggerRecordStatusBits::kUnassigned17)
    .value("kUnassigned18", TriggerRecordStatusBits::kUnassigned18)
    .value("kUnassigned19", TriggerRecordStatusBits::kUnassigned19)
    .value("kUnassigned20", TriggerRecordStatusBits::kUnassigned20)
    .value("kUnassigned21", TriggerRecordStatusBits::kUnassigned21)
    .value("kUnassigned22", TriggerRecordStatusBits::kUnassigned22)
    .value("kUnassigned23", TriggerRecordStatusBits::kUnassigned23)
    .value("kUnassigned24", TriggerRecordStatusBits::kUnassigned24)
    .value("kUnassigned25", TriggerRecordStatusBits::kUnassigned25)
    .value("kUnassigned26", TriggerRecordStatusBits::kUnassigned26)
    .value("kUnassigned27", TriggerRecordStatusBits::kUnassigned27)
    .value("kUnassigned28", TriggerRecordStatusBits::kUnassigned28)
    .value("kUnassigned29", TriggerRecordStatusBits::kUnassigned29)
    .value("kUnassigned30", TriggerRecordStatusBits::kUnassigned30)
    .value("kUnassigned31", TriggerRecordStatusBits::kUnassigned31)
    .value("kInvalid", TriggerRecordStatusBits::kInvalid);
 
  py::class_<TriggerRecord> py_trigger_record(m, "TriggerRecord", pybind11::buffer_protocol());
  py_trigger_record.def(py::init<TriggerRecordHeader const&>())
    .def(py::init<std::vector<ComponentRequest> const&>())
    .def(
      "get_header_ref",
      [](TriggerRecord& self) { return self.get_header_ref(); },
      py::return_value_policy::reference_internal)
    .def("get_header_data", &TriggerRecord::get_header_data)
    .def(
      "get_fragments_ref",
      [](TriggerRecord& self) {
        auto fragments = py::list();
        for (auto& fragment : self.get_fragments_ref()) {
          auto py_fragment = py::cast(*fragment, py::return_value_policy::reference);
          fragments.append(py_fragment);
        }
        return fragments;
      },
      py::return_value_policy::reference_internal)
    .def("get_total_size_bytes", &TriggerRecord::get_total_size_bytes);
} // NOLINT