conditions::SimpleCSVTableProvider Class Reference

Classes
struct	Entry

Public Member Functions
	SimpleCSVTableProvider (const std::string &name, const std::string &tagname, const framework::config::Parameters &parameters, framework::Process &process)
virtual std::pair< const framework::ConditionsObject *, framework::ConditionsIOV >	getCondition (const ldmx::EventHeader &context)
	Pure virtual getCondition function.
Public Member Functions inherited from framework::ConditionsObjectProvider
	DECLARE_FACTORY (ConditionsObjectProvider, std::shared_ptr< ConditionsObjectProvider >, const std::string &, const std::string &, const framework::config::Parameters &, Process &)
	declare that we have a factory for these types of classes
	ConditionsObjectProvider (const std::string &objname, const std::string &tagname, const framework::config::Parameters &parameters, Process &process)
	Class constructor.
virtual	~ConditionsObjectProvider ()=default
	Class destructor.
virtual void	releaseConditionsObject (const ConditionsObject *co)
	Called by conditions system when done with a conditions object, appropriate point for cleanup.
virtual void	onProcessStart ()
	Callback for the ConditionsObjectProvider to take any necessary action when the processing of events starts.
virtual void	onProcessEnd ()
	Callback for the ConditionsObjectProvider to take any necessary action when the processing of events finishes, such as closing database connections.
virtual void	onNewRun (ldmx::RunHeader &)
	Callback for the ConditionsObjectProvider to take any necessary action when the processing of events starts for a given run.
const std::string &	getConditionObjectName () const
	Get the list of conditions objects available from this provider.
const std::string &	getTagName () const
	Access the tag name.

Private Types
enum	{ OBJ_unknown , OBJ_int , OBJ_double }

Private Member Functions
void	entriesFromPython (std::vector< framework::config::Parameters > &)
void	entriesFromCSV ()
std::string	expandEnv (const std::string &s) const
	Utility for expanding environment variables.

Private Attributes
enum conditions::SimpleCSVTableProvider:: { ... }	object_type_
std::vector< std::string >	columns_
std::string	entries_url_
std::string	conditions_base_url_
std::vector< Entry >	entries_

Additional Inherited Members
Protected Member Functions inherited from framework::ConditionsObjectProvider
std::pair< const ConditionsObject *, ConditionsIOV >	requestParentCondition (const std::string &name, const ldmx::EventHeader &context)
	Request another condition needed to construct this condition.
const Process &	process () const
	Get the process handle.
Protected Attributes inherited from framework::ConditionsObjectProvider
logging::logger	the_log_
	The logger for this ConditionsObjectProvider.

Detailed Description

Definition at line 60 of file SimpleCSVTableProvider.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

private

Definition at line 73 of file SimpleCSVTableProvider.h.

{ OBJ_unknown, OBJ_int, OBJ_double } object_type_;

Constructor & Destructor Documentation

SimpleCSVTableProvider()

conditions::SimpleCSVTableProvider::SimpleCSVTableProvider	(	const std::string &	name,
		const std::string &	tagname,
		const framework::config::Parameters &	parameters,
		framework::Process &	process )

Definition at line 13 of file SimpleCSVTableProvider.cxx.

    : framework::ConditionsObjectProvider(name, tagname, parameters, process) {
  columns_ = parameters.get<std::vector<std::string>>("columns");
  std::string dtype = parameters.get<std::string>("dataType");
  if (dtype == "int" || dtype == "integer")
    object_type_ = SimpleCSVTableProvider::OBJ_int;
  if (dtype == "double" || dtype == "float")
    object_type_ = SimpleCSVTableProvider::OBJ_double;
 
  conditions_base_url_ = parameters.get<std::string>("conditions_baseURL");
 
  if (parameters.exists("entries")) {
    std::vector<framework::config::Parameters> plist =
        parameters.get<std::vector<framework::config::Parameters>>("entries");
    if (!plist.empty()) entriesFromPython(plist);
  }
 
  entries_url_ = parameters.get<std::string>("entriesURL");
  if (!entries_url_.empty()) entriesFromCSV();
}

~SimpleCSVTableProvider()

conditions::SimpleCSVTableProvider::~SimpleCSVTableProvider ( )

virtual

Definition at line 11 of file SimpleCSVTableProvider.cxx.

{}

Member Function Documentation

entriesFromCSV()

void conditions::SimpleCSVTableProvider::entriesFromCSV ( )

private

Definition at line 86 of file SimpleCSVTableProvider.cxx.

                                            {
  std::string csvurl = expandEnv(entries_url_);
  std::unique_ptr<std::istream> pstr = urlstream(csvurl);
 
  StreamCSVLoader loader(*(pstr.get()));
 
  if (!loader.nextRow()) return;  // need to advance to gather column headers
 
  // check that we have the expected columns
  const char* column_names[] = {"FIRST_RUN", "LAST_RUN", "RUNTYPE", "URL", 0};
  std::vector<std::string> cnames = loader.columnNames();
  for (int i = 0; column_names[i] != 0; i++) {
    bool found = false;
    for (auto name : cnames) {
      if (!strcasecmp(name.c_str(), column_names[i])) found = true;
    }
    if (!found) {
      EXCEPTION_RAISE("CSVNoSuchColumn", "No such column '" +
                                             std::string(column_names[i]) +
                                             "' reading index CSV");
    }
  }
  // ok, we're good on that...
  do {
    bool valid_for_data = strcasecmp("MC", loader.get("RUNTYPE").c_str());
    bool valid_for_mc = strcasecmp("DATA", loader.get("RUNTYPE").c_str());
    int first_run = loader.getInteger("FIRST_RUN");
    int last_run = loader.getInteger("LAST_RUN");
    Entry e;
    e.iov_ = framework::ConditionsIOV(first_run, last_run, valid_for_data,
                                      valid_for_mc);
    e.url_ = loader.get("URL");
    //    std::cout << valid_for_data << " " << valid_for_mc << " " << e.url_ <<
    //    std::endl;
    entries_.push_back(e);
  } while (loader.nextRow());
}

entriesFromPython()

void conditions::SimpleCSVTableProvider::entriesFromPython ( std::vector< framework::config::Parameters > & plist )

private

Definition at line 37 of file SimpleCSVTableProvider.cxx.

                                                 {
  for (auto aprov : plist) {
    SimpleCSVTableProvider::Entry item;
    int first_run = aprov.get<int>("firstRun", -1);
    int last_run = aprov.get<int>("lastRun", -1);
    std::string rtype = aprov.get<std::string>("runType", "any");
    bool is_mc = (rtype == "any" || rtype == "MC");
    bool is_data = (rtype == "any" || rtype == "data");
    item.iov_ = framework::ConditionsIOV(first_run, last_run, is_data, is_mc);
    item.url_ = aprov.get<std::string>("URL");
    if (object_type_ == OBJ_int && aprov.exists("values")) {
      item.ivalues_ = aprov.get<std::vector<int>>("values");
      if (item.ivalues_.size() != columns_.size()) {
        EXCEPTION_RAISE("ConditionsException",
                        "Mismatch in values vector (" +
                            std::to_string(item.ivalues_.size()) +
                            ") and columns vector (" +
                            std::to_string(columns_.size()) + ") in " +
                            getConditionObjectName());
      }
    }
    if (object_type_ == OBJ_double && aprov.exists("values")) {
      item.dvalues_ = aprov.get<std::vector<double>>("values");
      if (item.dvalues_.size() != columns_.size()) {
        EXCEPTION_RAISE("ConditionsException",
                        "Mismatch in values vector (" +
                            std::to_string(item.dvalues_.size()) +
                            ") and columns vector (" +
                            std::to_string(columns_.size()) + ") in " +
                            getConditionObjectName());
      }
    }
    // here we check for overlaps
 
    for (auto tabledef : entries_) {
      if (item.iov_.overlaps(tabledef.iov_)) {
        std::stringstream err;
        err << "Table '" << getConditionObjectName()
            << "' has entries with overlapping providers " << tabledef.url_
            << " and " << item.url_;
        EXCEPTION_RAISE("ConditionsException", err.str());
      }
    }
    // add to the list
    entries_.push_back(item);
  }
}

expandEnv()

std::string conditions::SimpleCSVTableProvider::expandEnv ( const std::string & s ) const

private

Utility for expanding environment variables.

Definition at line 124 of file SimpleCSVTableProvider.cxx.

                                                                    {
  std::string retval;
  std::string::size_type j = 0;
  for (std::string::size_type i = s.find("${", j); i < s.size();
       i = s.find("${", j)) {
    if (i != j) retval.append(s, j, i - j);  // append
    j = s.find("}", i);                      // look for the end of request
    std::string key = std::string(s, i + 2, j - i - 2);
    if (key == "LDMX_CONDITION_TAG")
      retval += getTagName();
    else if (key == "LDMX_CONDITION_BASEURL")
      retval += conditions_base_url_;
    else {
      const char* cenv = getenv(key.c_str());
      if (cenv != 0) {
        retval += cenv;
      } else {
        // ERROR!
      }
    }
    j++;
  }
  if (j < s.size()) retval.append(s, j);
  // prepend base URL if no URL provided
  if (retval.find("://") == std::string::npos) {
    retval = conditions_base_url_ + retval;
  }
  //    std::cout << s << "=>" << retval << std::endl;
  return retval;
}

getCondition()

std::pair< const framework::ConditionsObject *, framework::ConditionsIOV > conditions::SimpleCSVTableProvider::getCondition ( const ldmx::EventHeader & context )

virtual

Pure virtual getCondition function.

Must be implemented by any Conditions providers.

Implements framework::ConditionsObjectProvider.

Definition at line 156 of file SimpleCSVTableProvider.cxx.

                                                                   {
  for (auto tabledef : entries_) {
    //      std::cout << condition_name << " " << tabledef.object_name_ << " "
    //<<
    // tabledef.iov_ << " " << std::endl;
    if (tabledef.iov_.validForEvent(context)) {
      std::string expurl = expandEnv(tabledef.url_);
 
      if (expurl == "python:") {
        // here we just copy values...
        if (object_type_ == OBJ_int) {
          IntegerTableCondition* table =
              new IntegerTableCondition(getConditionObjectName(), columns_);
          table->setIdMask(0);  // all ids are the same...
          table->add(0, tabledef.ivalues_);
          return std::pair<const framework::ConditionsObject*,
                           framework::ConditionsIOV>(table, tabledef.iov_);
        } else if (object_type_ == OBJ_double) {
          conditions::DoubleTableCondition* table =
              new conditions::DoubleTableCondition(getConditionObjectName(),
                                                   columns_);
          table->setIdMask(0);  // all ids are the same...
          table->add(0, tabledef.dvalues_);
          return std::pair<const framework::ConditionsObject*,
                           framework::ConditionsIOV>(table, tabledef.iov_);
        }
      } else {
        std::unique_ptr<std::istream> stream = urlstream(expurl);
 
        if (object_type_ == OBJ_int) {
          IntegerTableCondition* table =
              new IntegerTableCondition(getConditionObjectName(), columns_);
          conditions::utility::SimpleTableStreamerCSV::load(*table,
                                                            *(stream.get()));
          return std::pair<const framework::ConditionsObject*,
                           framework::ConditionsIOV>(table, tabledef.iov_);
        } else if (object_type_ == OBJ_double) {
          conditions::DoubleTableCondition* table =
              new conditions::DoubleTableCondition(getConditionObjectName(),
                                                   columns_);
          conditions::utility::SimpleTableStreamerCSV::load(*table,
                                                            *(stream.get()));
          return std::pair<const framework::ConditionsObject*,
                           framework::ConditionsIOV>(table, tabledef.iov_);
        }
      }
    }
  }
  return std::pair<const framework::ConditionsObject*,
                   framework::ConditionsIOV>(0, framework::ConditionsIOV());
}

References conditions::HomogenousTableCondition< T >::add(), conditions::utility::SimpleTableStreamerCSV::load(), and conditions::BaseTableCondition::setIdMask().

Member Data Documentation

columns_

std::vector<std::string> conditions::SimpleCSVTableProvider::columns_

private

Definition at line 74 of file SimpleCSVTableProvider.h.

conditions_base_url_

std::string conditions::SimpleCSVTableProvider::conditions_base_url_

private

Definition at line 76 of file SimpleCSVTableProvider.h.

entries_

std::vector<Entry> conditions::SimpleCSVTableProvider::entries_

private

Definition at line 90 of file SimpleCSVTableProvider.h.

entries_url_

std::string conditions::SimpleCSVTableProvider::entries_url_

private

Definition at line 75 of file SimpleCSVTableProvider.h.

---

The documentation for this class was generated from the following files:

• Conditions/include/Conditions/SimpleCSVTableProvider.h
• Conditions/src/Conditions/SimpleCSVTableProvider.cxx