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
	ConditionsObjectProvider (const std::string &objname, const std::string &tagname, const framework::config::Parameters &parameters, Process &process)
	Class constructor.
virtual	~ConditionsObjectProvider ()
	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:: { ... }	objectType_
std::vector< std::string >	columns_
std::string	entriesURL_
std::string	conditions_baseURL_
std::vector< Entry >	entries_

Additional Inherited Members
Static Public Member Functions inherited from framework::ConditionsObjectProvider
static void	declare (const std::string &classname, ConditionsObjectProviderMaker *)
	Internal function which is part of the PluginFactory machinery.
Static Public Attributes inherited from framework::ConditionsObjectProvider
static const int	CLASSTYPE {10}
	Constant used to types by the PluginFactory.
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	theLog_
	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 } objectType_;

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.getParameter<std::vector<std::string>>("columns");
  std::string dtype = parameters.getParameter<std::string>("dataType");
  if (dtype == "int" || dtype == "integer")
    objectType_ = SimpleCSVTableProvider::OBJ_int;
  if (dtype == "double" || dtype == "float")
    objectType_ = SimpleCSVTableProvider::OBJ_double;
 
  conditions_baseURL_ =
      parameters.getParameter<std::string>("conditions_baseURL");
 
  if (parameters.exists("entries")) {
    std::vector<framework::config::Parameters> plist =
        parameters.getParameter<std::vector<framework::config::Parameters>>(
            "entries");
    if (!plist.empty()) entriesFromPython(plist);
  }
 
  entriesURL_ = parameters.getParameter<std::string>("entriesURL");
  if (!entriesURL_.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 88 of file SimpleCSVTableProvider.cxx.

                                            {
  std::string csvurl = expandEnv(entriesURL_);
  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 firstRun = loader.getInteger("FIRST_RUN");
    int lastRun = loader.getInteger("LAST_RUN");
    Entry e;
    e.iov_ = framework::ConditionsIOV(firstRun, lastRun, 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 39 of file SimpleCSVTableProvider.cxx.

                                                 {
  for (auto aprov : plist) {
    SimpleCSVTableProvider::Entry item;
    int firstRun = aprov.getParameter<int>("firstRun", -1);
    int lastRun = aprov.getParameter<int>("lastRun", -1);
    std::string rtype = aprov.getParameter<std::string>("runType", "any");
    bool isMC = (rtype == "any" || rtype == "MC");
    bool isData = (rtype == "any" || rtype == "data");
    item.iov_ = framework::ConditionsIOV(firstRun, lastRun, isData, isMC);
    item.url_ = aprov.getParameter<std::string>("URL");
    if (objectType_ == OBJ_int && aprov.exists("values")) {
      item.ivalues_ = aprov.getParameter<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 (objectType_ == OBJ_double && aprov.exists("values")) {
      item.dvalues_ = aprov.getParameter<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 126 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_baseURL_;
    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_baseURL_ + 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 158 of file SimpleCSVTableProvider.cxx.

                                                                   {
  for (auto tabledef : entries_) {
    //      std::cout << condition_name << " " << tabledef.objectName_ << " " <<
    // tabledef.iov_ << " " << std::endl;
    if (tabledef.iov_.validForEvent(context)) {
      std::string expurl = expandEnv(tabledef.url_);
 
      if (expurl == "python:") {
        // here we just copy values...
        if (objectType_ == 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 (objectType_ == 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 (objectType_ == 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 (objectType_ == 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_baseURL_

std::string conditions::SimpleCSVTableProvider::conditions_baseURL_

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.

entriesURL_

std::string conditions::SimpleCSVTableProvider::entriesURL_

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