HLTConfigProvider.h

Go to the documentation of this file.

#ifndef HLTcore_HLTConfigProvider_h
#define HLTcore_HLTConfigProvider_h
 
#include "FWCore/Framework/interface/Run.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/LuminosityBlock.h"
 
#include "HLTrigger/HLTcore/interface/HLTConfigData.h"
#include "HLTrigger/HLTcore/interface/FractionalPrescale.h"
 
#include <map>
#include <string>
#include <vector>
 
//
// class declaration
//
 
class HLTConfigProvider {
private:
public:
  HLTConfigProvider();
  //  ~HLTConfigProvider();
 
public:
  bool init(const edm::Run& iRun, const edm::EventSetup& iSetup, const std::string& processName, bool& changed);
 
  void dump(const std::string& what) const { hltConfigData_->dump(what); }
 
 
  bool inited() const { return inited_; }
  bool changed() const { return changed_; }
 
  const std::string& processName() const { return hltConfigData_->processName(); }
 
  const std::string& globalTag() const { return hltConfigData_->globalTag(); }
 
  const std::string& tableName() const { return hltConfigData_->tableName(); }
 
  unsigned int size() const { return hltConfigData_->size(); }
  unsigned int size(unsigned int trigger) const { return hltConfigData_->size(trigger); }
  unsigned int size(const std::string& trigger) const { return hltConfigData_->size(trigger); }
 
  const std::vector<std::string>& triggerNames() const { return hltConfigData_->triggerNames(); }
  const std::string& triggerName(unsigned int triggerIndex) const { return hltConfigData_->triggerName(triggerIndex); }
 
  unsigned int triggerIndex(const std::string& triggerName) const { return hltConfigData_->triggerIndex(triggerName); }
 
  const std::vector<std::string>& moduleLabels(unsigned int trigger) const {
    return hltConfigData_->moduleLabels(trigger);
  }
  const std::vector<std::string>& moduleLabels(const std::string& trigger) const {
    return hltConfigData_->moduleLabels(trigger);
  }
  const std::vector<std::string>& saveTagsModules(unsigned int trigger) const {
    return hltConfigData_->saveTagsModules(trigger);
  }
  const std::vector<std::string>& saveTagsModules(const std::string& trigger) const {
    return hltConfigData_->saveTagsModules(trigger);
  }
  const std::string& moduleLabel(unsigned int trigger, unsigned int module) const {
    return hltConfigData_->moduleLabel(trigger, module);
  }
  const std::string& moduleLabel(const std::string& trigger, unsigned int module) const {
    return hltConfigData_->moduleLabel(trigger, module);
  }
 
  unsigned int moduleIndex(unsigned int trigger, const std::string& module) const {
    return hltConfigData_->moduleIndex(trigger, module);
  }
  unsigned int moduleIndex(const std::string& trigger, const std::string& module) const {
    return hltConfigData_->moduleIndex(trigger, module);
  }
 
  const std::string moduleType(const std::string& module) const { return hltConfigData_->moduleType(module); }
 
  const std::string moduleEDMType(const std::string& module) const { return hltConfigData_->moduleEDMType(module); }
 
  const edm::ParameterSet& processPSet() const { return hltConfigData_->processPSet(); }
 
  const edm::ParameterSet& modulePSet(const std::string& module) const { return hltConfigData_->modulePSet(module); }
 
  bool saveTags(const std::string& module) const { return hltConfigData_->saveTags(module); }
 
  unsigned int l1tType() const { return hltConfigData_->l1tType(); }
 
  const std::vector<std::vector<std::pair<bool, std::string> > >& hltL1GTSeeds() const {
    return hltConfigData_->hltL1GTSeeds();
  }
  const std::vector<std::pair<bool, std::string> >& hltL1GTSeeds(const std::string& trigger) const {
    return hltConfigData_->hltL1GTSeeds(trigger);
  }
  const std::vector<std::pair<bool, std::string> >& hltL1GTSeeds(unsigned int trigger) const {
    return hltConfigData_->hltL1GTSeeds(trigger);
  }
 
  const std::vector<std::vector<std::string> >& hltL1TSeeds() const { return hltConfigData_->hltL1TSeeds(); }
  const std::vector<std::string>& hltL1TSeeds(const std::string& trigger) const {
    return hltConfigData_->hltL1TSeeds(trigger);
  }
  const std::vector<std::string>& hltL1TSeeds(unsigned int trigger) const {
    return hltConfigData_->hltL1TSeeds(trigger);
  }
 
  const std::vector<std::string>& streamNames() const { return hltConfigData_->streamNames(); }
  const std::string& streamName(unsigned int stream) const { return hltConfigData_->streamName(stream); }
  unsigned int streamIndex(const std::string& stream) const { return hltConfigData_->streamIndex(stream); }
  const std::vector<std::vector<std::string> >& streamContents() const { return hltConfigData_->streamContents(); }
  const std::vector<std::string>& streamContent(unsigned int stream) const {
    return hltConfigData_->streamContent(stream);
  }
  const std::vector<std::string>& streamContent(const std::string& stream) const {
    return hltConfigData_->streamContent(stream);
  }
 
  const std::vector<std::string>& datasetNames() const { return hltConfigData_->datasetNames(); }
  const std::string& datasetName(unsigned int dataset) const { return hltConfigData_->datasetName(dataset); }
  unsigned int datasetIndex(const std::string& dataset) const { return hltConfigData_->datasetIndex(dataset); }
  const std::vector<std::vector<std::string> >& datasetContents() const { return hltConfigData_->datasetContents(); }
  const std::vector<std::string>& datasetContent(unsigned int dataset) const {
    return hltConfigData_->datasetContent(dataset);
  }
  const std::vector<std::string>& datasetContent(const std::string& dataset) const {
    return hltConfigData_->datasetContent(dataset);
  }
 
  unsigned int prescaleSize() const { return hltConfigData_->prescaleSize(); }
  template <typename T = unsigned int>
  T prescaleValue(unsigned int set, const std::string& trigger) const {
    //limit to only 4 allowed types
    static_assert(std::is_same_v<T, unsigned int> or std::is_same_v<T, FractionalPrescale> or std::is_same_v<T, int> or
                      std::is_same_v<T, double>,
                  "Please use prescaleValue<unsigned int>, prescaleValue<int>, prescaleValue<double>, or "
                  "prescaleValue<FractionalPrescale>,\n note int and unsigned int will be depreated soon");
    return hltConfigData_->prescaleValue(set, trigger);
  }
 
  const std::vector<std::string>& prescaleLabels() const { return hltConfigData_->prescaleLabels(); }
  const std::map<std::string, std::vector<unsigned int> >& prescaleTable() const {
    return hltConfigData_->prescaleTable();
  }
 
  static const std::vector<std::string> matched(const std::vector<std::string>& inputs, const std::string& pattern);
  static const std::string removeVersion(const std::string& trigger);
  static const std::vector<std::string> restoreVersion(const std::vector<std::string>& inputs,
                                                       const std::string& trigger);
 
private:
  void getDataFrom(const edm::ParameterSetID& iID);
  void init(const edm::ProcessHistory& iHistory, const std::string& processName);
  void init(const std::string& processName);
  void clear();
 
  std::string processName_;
  bool inited_;
  bool changed_;
  const HLTConfigData* hltConfigData_;
};
#endif