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>
#include <type_traits>

//
// 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 {
    static_assert(std::is_same_v<T, double> or std::is_same_v<T, FractionalPrescale>,
                  "\n\tPlease use prescaleValue<double> or prescaleValue<FractionalPrescale>"
                  "\n\t(other types for HLT prescales are not supported anymore by HLTConfigProvider)");
    return hltConfigData_->prescaleValue<T>(set, trigger);
  }

  const std::vector<std::string>& prescaleLabels() const { return hltConfigData_->prescaleLabels(); }

  template <typename T = unsigned int>
  std::map<std::string, std::vector<T>> const& prescaleTable() const {
    static_assert(std::is_same_v<T, double> or std::is_same_v<T, FractionalPrescale>,
                  "\n\tPlease use prescaleTable<double> or prescaleTable<FractionalPrescale>"
                  "\n\t(other types for HLT prescales are not supported anymore by HLTConfigProvider)");
    return hltConfigData_->prescaleTable<T>();
  }

  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