dunedaq::confmodel::python Namespace Reference

Classes
struct	ObjectLocator

Functions
std::vector< ObjectLocator >	session_get_all_applications (Configuration &db, const std::string &session_name)
std::vector< ObjectLocator >	session_get_enabled_applications (Configuration &db, const std::string &session_name)
void	disable_component (Configuration &db, const std::string &session_id, const std::string &component_id)
void	enable_component (Configuration &db, const std::string &session_id, const std::string &component_id)
bool	component_disabled (Configuration &db, const std::string &session_id, const std::string &component_id)
std::vector< std::vector< ObjectLocator > >	component_get_parents (Configuration &db, const std::string &session_id, const std::string &component_id)
std::vector< std::string >	daq_application_get_used_hostresources (Configuration &db, const std::string &app_id)
std::vector< std::string >	daq_application_construct_commandline_parameters (Configuration &db, const std::string &session_id, const std::string &app_id)
std::vector< std::string >	rc_application_construct_commandline_parameters (Configuration &db, const std::string &session_id, const std::string &app_id)
std::string	d2d_receiver (Configuration &db, const std::string &d2d_id)
std::vector< std::string >	d2d_senders (Configuration &db, const std::string &d2d_id)
std::vector< std::string >	d2d_streams (Configuration &db, const std::string &d2d_id)
std::vector< std::string >	resourceset_contains (Configuration &db, const std::string &res_id)
void	register_dal_methods (py::module &m)
	PYBIND11_MODULE (_daq_confmodel_dal_py, m)

Function Documentation

component_disabled()

bool dunedaq::confmodel::python::component_disabled	(	Configuration &	db,
		const std::string &	session_id,
		const std::string &	component_id )

Definition at line 91 of file dal_methods.cpp.

                                                         {
    const dunedaq::confmodel::Session* session_ptr = db.get<dunedaq::confmodel::Session>(session_id);
    const dunedaq::confmodel::Resource* component_ptr = db.get<dunedaq::confmodel::Resource>(component_id);
    if (component_ptr == nullptr) {
      return false;
    }
    return component_ptr->is_disabled(*session_ptr);
  }

component_get_parents()

std::vector< std::vector< ObjectLocator > > dunedaq::confmodel::python::component_get_parents	(	Configuration &	db,
		const std::string &	session_id,
		const std::string &	component_id )

Definition at line 103 of file dal_methods.cpp.

                                                                                               {
    const dunedaq::confmodel::Session* session_ptr = db.get<dunedaq::confmodel::Session>(session_id);
    const dunedaq::confmodel::Resource* component_ptr = db.get<dunedaq::confmodel::Resource>(component_id);
 
    std::list<std::vector<const dunedaq::confmodel::Resource*>> parents;
    std::vector<std::vector<ObjectLocator>> parent_ids;
 
    component_ptr->parents(*session_ptr, parents);
 
    for (const auto& parent : parents) {
      std::vector<ObjectLocator> parents_components;
      for (const auto& ancestor_component_ptr : parent) {
        parents_components.emplace_back(
          ObjectLocator(ancestor_component_ptr->UID(),
                        ancestor_component_ptr->class_name()) );
      }
      parent_ids.emplace_back(parents_components);
    }
    return parent_ids;
  }

d2d_receiver()

std::string dunedaq::confmodel::python::d2d_receiver	(	Configuration &	db,
		const std::string &	d2d_id )

Definition at line 152 of file dal_methods.cpp.

                                                    {
    const auto* d2d = db.get<dunedaq::confmodel::DetectorToDaqConnection>(d2d_id);
    if (d2d == nullptr) {
      return "";
    }
    return d2d->receiver()->UID();
  }

d2d_senders()

std::vector< std::string > dunedaq::confmodel::python::d2d_senders	(	Configuration &	db,
		const std::string &	d2d_id )

Definition at line 161 of file dal_methods.cpp.

                                                                {
    std::vector<std::string> senders;
    const auto* d2d = db.get<dunedaq::confmodel::DetectorToDaqConnection>(d2d_id);
    if (d2d != nullptr) {
      for (auto sender: d2d->senders()) {
        senders.push_back(sender->UID());
      }
    }
    return senders;
  }

d2d_streams()

std::vector< std::string > dunedaq::confmodel::python::d2d_streams	(	Configuration &	db,
		const std::string &	d2d_id )

Definition at line 173 of file dal_methods.cpp.

                                                                {
    std::vector<std::string> streams;
    const auto* d2d = db.get<dunedaq::confmodel::DetectorToDaqConnection>(d2d_id);
    if (d2d != nullptr) {
      for (auto stream: d2d->streams()) {
        streams.push_back(stream->UID());
      }
    }
    return streams;
  }

daq_application_construct_commandline_parameters()

std::vector< std::string > dunedaq::confmodel::python::daq_application_construct_commandline_parameters	(	Configuration &	db,
		const std::string &	session_id,
		const std::string &	app_id )

Definition at line 135 of file dal_methods.cpp.

                                                                                                     {
    const auto* app = db.get<dunedaq::confmodel::DaqApplication>(app_id);
    const auto* session = db.get<dunedaq::confmodel::Session>(session_id);
    return app->construct_commandline_parameters(db, session);
  }

daq_application_get_used_hostresources()

std::vector< std::string > dunedaq::confmodel::python::daq_application_get_used_hostresources	(	Configuration &	db,
		const std::string &	app_id )

Definition at line 126 of file dal_methods.cpp.

                                                                                                          {
    auto app = db.get<dunedaq::confmodel::DaqApplication>(app_id);
    std::vector<std::string> resources;
    for (auto res : app->get_used_hostresources()) {
      resources.push_back(res->UID());
    }
    return resources;
  }

disable_component()

void dunedaq::confmodel::python::disable_component	(	Configuration &	db,
		const std::string &	session_id,
		const std::string &	component_id )

Definition at line 63 of file dal_methods.cpp.

                                                        {
    auto session_ptr = const_cast<dunedaq::confmodel::Session*>(db.get<dunedaq::confmodel::Session>(session_id));
    auto component_ptr = db.get<dunedaq::confmodel::Resource>(component_id);
    if (session_ptr == nullptr) {
      throw (std::runtime_error(std::format("Session {} not found", session_id)));
    }
    if (component_ptr == nullptr) {
      throw (std::runtime_error(std::format("Component {} not found", component_id)));
    }
    session_ptr->disable(component_ptr);
  }

enable_component()

void dunedaq::confmodel::python::enable_component	(	Configuration &	db,
		const std::string &	session_id,
		const std::string &	component_id )

Definition at line 76 of file dal_methods.cpp.

                                                        {
    auto session_ptr = const_cast<dunedaq::confmodel::Session*>(db.get<dunedaq::confmodel::Session>(session_id));
    auto component_ptr = db.get<dunedaq::confmodel::Resource>(component_id);
    if (session_ptr == nullptr) {
      throw (std::runtime_error(std::format("Session {} not found", session_id)));
    }
    if (component_ptr == nullptr) {
      throw (std::runtime_error(std::format("Component {} not found", component_id)));
    }
    session_ptr->enable(component_ptr);
  }

PYBIND11_MODULE()

dunedaq::confmodel::python::PYBIND11_MODULE	(	_daq_confmodel_dal_py	,
		m	)

Definition at line 22 of file module.cpp.

{
 
  m.doc() = "C++ implementation of the confmodel modules";
#if 0
  py::class_<dunedaq::confmodel::DaqApplication>(m,"DaqApplication")
    .def(py::init<conffwk::Configuration& , const conffwk::ConfigObject&>())
    .def("get_used_hostresources", &dunedaq::confmodel::DaqApplication::get_used_hostresources);
  py::class_<dunedaq::confmodel::HostComponent>(m,"HostComponent");
#endif
  register_dal_methods(m);
}

rc_application_construct_commandline_parameters()

std::vector< std::string > dunedaq::confmodel::python::rc_application_construct_commandline_parameters	(	Configuration &	db,
		const std::string &	session_id,
		const std::string &	app_id )

Definition at line 143 of file dal_methods.cpp.

                                                                                                    {
    const auto* app = db.get<dunedaq::confmodel::RCApplication>(app_id);
    const auto* session = db.get<dunedaq::confmodel::Session>(session_id);
    return app->construct_commandline_parameters(db, session);
  }

register_dal_methods()

void dunedaq::confmodel::python::register_dal_methods

(

py::module &

m

)

Definition at line 200 of file dal_methods.cpp.

{
  py::class_<ObjectLocator>(m, "ObjectLocator")
    .def(py::init<const std::string&, const std::string&>())
    .def_readonly("id", &ObjectLocator::id)
    .def_readonly("class_name", &ObjectLocator::class_name)
    ;
 
  m.def("session_get_all_applications", &session_get_all_applications, "Get list of ALL applications (regardless of enabled/disabled state) in the requested session");
  m.def("session_get_enabled_applications", &session_get_enabled_applications, "Get list of enabled applications in the requested session");
 
  m.def("disable_component", &disable_component, "Disable a Resource-derived object (e.g. a Segment)");
  m.def("enable_component", &enable_component, "Enable a Resource-derived object (e.g. a Segment)");
 
  m.def("component_disabled", &component_disabled, "Determine if a Resource-derived object (e.g. a Segment) has been disabled");
  m.def("component_get_parents", &component_get_parents, "Get the Resource-derived class instances of the parent(s) of the Resource-derived object in question");
  m.def("daqapp_get_used_resources", &daq_application_get_used_hostresources, "Get list of HostResources used by DAQApplication");
  m.def("daq_application_construct_commandline_parameters", &daq_application_construct_commandline_parameters, "Get a version of the command line agruments parsed");
  m.def("rc_application_construct_commandline_parameters", &rc_application_construct_commandline_parameters, "Get a version of the command line agruments parsed");
 
  m.def("d2d_receiver", &d2d_receiver, "Get receiver associated with DetectorToDaqConnection");
  m.def("d2d_senders", &d2d_senders, "Get senders associated with DetectorToDaqConnection");
  m.def("d2d_streams", &d2d_streams, "Get streams associated with DetectorToDaqConnection");
  m.def("resourceset_contains", &resourceset_contains, "Get contained Resources from ResourceSet");
}

resourceset_contains()

std::vector< std::string > dunedaq::confmodel::python::resourceset_contains	(	Configuration &	db,
		const std::string &	res_id )

Definition at line 186 of file dal_methods.cpp.

                                                {
    std::vector<std::string> resources;
    auto res_set = db.get<dunedaq::confmodel::ResourceSet>(res_id);
    if (res_set != nullptr) {
      for (auto res: res_set->contained_resources()) {
        resources.push_back(res->UID());
      }
    }
    return resources;
  }

session_get_all_applications()

std::vector< ObjectLocator > dunedaq::confmodel::python::session_get_all_applications	(	Configuration &	db,
		const std::string &	session_name )

Definition at line 41 of file dal_methods.cpp.

                                                              {
    auto session=db.get<Session>(session_name);
    std::vector<ObjectLocator> apps;
    for (auto app : session->all_applications()) {
      apps.push_back({app->UID(),app->class_name()});
    }
    return apps;
  }

session_get_enabled_applications()

std::vector< ObjectLocator > dunedaq::confmodel::python::session_get_enabled_applications	(	Configuration &	db,
		const std::string &	session_name )

Definition at line 52 of file dal_methods.cpp.

                                                                  {
    auto session=db.get<Session>(session_name);
    std::vector<ObjectLocator> apps;
    for (auto app : session->enabled_applications()) {
      apps.push_back({app->UID(),app->class_name()});
    }
    return apps;
  }