HLTConfigData.h

Go to the documentation of this file.

#ifndef HLTrigger_HLTcore_HLTConfigData_h
#define HLTrigger_HLTcore_HLTConfigData_h

#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "DataFormats/HLTReco/interface/HLTPrescaleTable.h"
#include "HLTrigger/HLTcore/interface/FractionalPrescale.h"

#include <map>
#include <string>
#include <vector>
#include <type_traits>
#include <oneapi/tbb/concurrent_unordered_map.h>

//
// class declaration
//

class HLTConfigData {
public:
  HLTConfigData();
  HLTConfigData(const edm::ParameterSet* iID);

private:
  void extract();

public:
  void dump(const std::string& what) const;


  const std::string& processName() const;

  const std::string& globalTag() const;

  const std::string& tableName() const;

  unsigned int size() const;
  unsigned int size(unsigned int trigger) const;
  unsigned int size(const std::string& trigger) const;

  const std::vector<std::string>& triggerNames() const;
  const std::string& triggerName(unsigned int triggerIndex) const;

  unsigned int triggerIndex(const std::string& triggerName) const;

  const std::vector<std::string>& moduleLabels(unsigned int trigger) const;
  const std::vector<std::string>& moduleLabels(const std::string& trigger) const;
  const std::vector<std::string>& saveTagsModules(unsigned int trigger) const;
  const std::vector<std::string>& saveTagsModules(const std::string& trigger) const;
  const std::string& moduleLabel(unsigned int trigger, unsigned int module) const;
  const std::string& moduleLabel(const std::string& trigger, unsigned int module) const;

  unsigned int moduleIndex(unsigned int trigger, const std::string& module) const;
  unsigned int moduleIndex(const std::string& trigger, const std::string& module) const;

  const std::string& moduleType(const std::string& module) const;

  const std::string& moduleEDMType(const std::string& module) const;

  const edm::ParameterSet& processPSet() const;

  const edm::ParameterSet& modulePSet(const std::string& module) const;

  bool saveTags(const std::string& module) const;

  unsigned int l1tType() const;

  const std::vector<std::vector<std::pair<bool, std::string>>>& hltL1GTSeeds() const;
  const std::vector<std::pair<bool, std::string>>& hltL1GTSeeds(const std::string& trigger) const;
  const std::vector<std::pair<bool, std::string>>& hltL1GTSeeds(unsigned int trigger) const;

  const std::vector<std::vector<std::string>>& hltL1TSeeds() const;
  const std::vector<std::string>& hltL1TSeeds(const std::string& trigger) const;
  const std::vector<std::string>& hltL1TSeeds(unsigned int trigger) const;

  const std::vector<std::string>& streamNames() const;
  const std::string& streamName(unsigned int stream) const;
  unsigned int streamIndex(const std::string& stream) const;
  const std::vector<std::vector<std::string>>& streamContents() const;
  const std::vector<std::string>& streamContent(unsigned int stream) const;
  const std::vector<std::string>& streamContent(const std::string& stream) const;

  const std::vector<std::string>& datasetNames() const;
  const std::string& datasetName(unsigned int dataset) const;
  unsigned int datasetIndex(const std::string& dataset) const;
  const std::vector<std::vector<std::string>>& datasetContents() const;
  const std::vector<std::string>& datasetContent(unsigned int dataset) const;
  const std::vector<std::string>& datasetContent(const std::string& dataset) const;

  unsigned int prescaleSize() const;
  template <typename T = unsigned int>
  T prescaleValue(unsigned int set, const std::string& trigger) const;
  const std::vector<std::string>& prescaleLabels() const;
  template <typename T = unsigned int>
  std::map<std::string, std::vector<T>> const& prescaleTable() const;

  edm::ParameterSetID id() const;

private:
  inline std::string canonicalModuleName(const std::string& module) const {
    return module.front() != '-' ? module : module.substr(1);
  }

  const edm::ParameterSet* processPSet_;

  std::string processName_;
  std::string globalTag_;
  std::string tableName_;
  std::vector<std::string> triggerNames_;
  std::vector<std::vector<std::string>> moduleLabels_;
  std::vector<std::vector<std::string>> saveTagsModules_;

  std::map<std::string, unsigned int> triggerIndex_;
  std::vector<std::map<std::string, unsigned int>> moduleIndex_;

  unsigned int l1tType_;
  std::vector<std::vector<std::pair<bool, std::string>>> hltL1GTSeeds_;
  std::vector<std::vector<std::string>> hltL1TSeeds_;

  std::vector<std::string> streamNames_;
  std::map<std::string, unsigned int> streamIndex_;
  std::vector<std::vector<std::string>> streamContents_;

  std::vector<std::string> datasetNames_;
  std::map<std::string, unsigned int> datasetIndex_;
  std::vector<std::vector<std::string>> datasetContents_;

  trigger::HLTPrescaleTable hltPrescaleTable_;
  std::map<std::string, std::vector<double>> hltPrescaleTableValuesDouble_;
  std::map<std::string, std::vector<FractionalPrescale>> hltPrescaleTableValuesFractional_;
  struct ModuleInfo {
    ModuleInfo(edm::ParameterSet const* iPSet, const std::string& iClass, const std::string& iType)
        : pset_(iPSet), class_(iClass), edmType_(iType) {}

    edm::ParameterSet const* pset_ = nullptr;
    std::string class_;
    std::string edmType_;
  };

  const ModuleInfo& moduleInfoFor(const std::string& iModule) const;
  mutable oneapi::tbb::concurrent_unordered_map<std::string, ModuleInfo> modulesInfo_;
};

template <typename T>
T HLTConfigData::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 HLTConfigData)");
  return hltPrescaleTable_.prescale(set, trigger);
}

template <typename T>
std::map<std::string, std::vector<T>> const& HLTConfigData::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 HLTConfigData)");
  return hltPrescaleTable_.table();
}

template <>
std::map<std::string, std::vector<double>> const& HLTConfigData::prescaleTable() const;

template <>
std::map<std::string, std::vector<FractionalPrescale>> const& HLTConfigData::prescaleTable() const;

#endif  // HLTrigger_HLTcore_HLTConfigData_h