L1GtUtils.h

Go to the documentation of this file.

#ifndef GlobalTriggerAnalyzer_L1GtUtils_h
#define GlobalTriggerAnalyzer_L1GtUtils_h
 
// system include files
#include <memory>
#include <string>
#include <utility>
 
// user include files
#include "CondFormats/L1TObjects/interface/L1GtStableParameters.h"
#include "CondFormats/DataRecord/interface/L1GtStableParametersRcd.h"
 
#include "CondFormats/L1TObjects/interface/L1GtPrescaleFactors.h"
#include "CondFormats/DataRecord/interface/L1GtPrescaleFactorsAlgoTrigRcd.h"
#include "CondFormats/DataRecord/interface/L1GtPrescaleFactorsTechTrigRcd.h"
 
#include "CondFormats/L1TObjects/interface/L1GtTriggerMask.h"
#include "CondFormats/DataRecord/interface/L1GtTriggerMaskAlgoTrigRcd.h"
#include "CondFormats/DataRecord/interface/L1GtTriggerMaskTechTrigRcd.h"
#include "CondFormats/DataRecord/interface/L1GtTriggerMaskVetoAlgoTrigRcd.h"
#include "CondFormats/DataRecord/interface/L1GtTriggerMaskVetoTechTrigRcd.h"
 
#include "CondFormats/L1TObjects/interface/L1GtTriggerMenu.h"
#include "CondFormats/DataRecord/interface/L1GtTriggerMenuRcd.h"
 
#include "DataFormats/L1GlobalTrigger/interface/L1GtTriggerMenuLite.h"
 
#include "FWCore/Framework/interface/ConsumesCollector.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/Run.h"
 
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/ESGetToken.h"
#include "FWCore/Utilities/interface/InputTag.h"
 
#include "CondFormats/L1TObjects/interface/L1GtTriggerMenuFwd.h"
 
#include "L1Trigger/GlobalTriggerAnalyzer/interface/L1GtUtilsHelper.h"
 
// forward declarations
class L1GtStableParameters;
class L1GtPrescaleFactors;
class L1GtTriggerMask;
class L1GtTriggerMenu;
 
class L1GlobalTriggerReadoutRecord;
class L1GlobalTriggerRecord;
 
// class declaration
 
class L1GtUtils {
public:
  // Use this enum to tell the EventSetup whether it should prefetch
  // data when processing beginRun or an Event or both. (This
  // depends on when retrieveL1EventSetup is called which can
  // be a direct call or also indirectly through a call to one
  // or both versions of getL1GtRunCache. Also note that getL1GtRunCache
  // has an argument that disables EventSetup calls and if the Run
  // version of the function is called then the Event version of the
  // function does not get EventSetup data)
  enum class UseEventSetupIn { Run, Event, RunAndEvent, Nothing };
 
  // Using this constructor will require InputTags to be specified in the configuration
  L1GtUtils(edm::ParameterSet const& pset,
            edm::ConsumesCollector&& iC,
            bool useL1GtTriggerMenuLite,
            UseEventSetupIn use = UseEventSetupIn::Run);
 
  L1GtUtils(edm::ParameterSet const& pset,
            edm::ConsumesCollector& iC,
            bool useL1GtTriggerMenuLite,
            UseEventSetupIn use = UseEventSetupIn::Run);
 
  // Using this constructor will cause it to look for valid InputTags in
  // the following ways in the specified order until they are found.
  //   1. The configuration
  //   2. Search all products from the preferred input tags for the required type
  //   3. Search all products from any other process for the required type
  template <typename T>
  L1GtUtils(edm::ParameterSet const& pset,
            edm::ConsumesCollector&& iC,
            bool useL1GtTriggerMenuLite,
            T& module,
            UseEventSetupIn use = UseEventSetupIn::Run);
 
  template <typename T>
  L1GtUtils(edm::ParameterSet const& pset,
            edm::ConsumesCollector& iC,
            bool useL1GtTriggerMenuLite,
            T& module,
            UseEventSetupIn use = UseEventSetupIn::Run);
 
  // Using this constructor will cause it to look for valid InputTags in
  // the following ways in the specified order until they are found.
  //   1. The constructor arguments
  //   2. The configuration
  //   3. Search all products from the preferred input tags for the required type
  //   4. Search all products from any other process for the required type
  template <typename T>
  L1GtUtils(edm::ParameterSet const& pset,
            edm::ConsumesCollector&& iC,
            bool useL1GtTriggerMenuLite,
            T& module,
            edm::InputTag const& l1GtRecordInputTag,
            edm::InputTag const& l1GtReadoutRecordInputTag,
            edm::InputTag const& l1GtTriggerMenuLiteInputTag,
            UseEventSetupIn use = UseEventSetupIn::Run);
 
  template <typename T>
  L1GtUtils(edm::ParameterSet const& pset,
            edm::ConsumesCollector& iC,
            bool useL1GtTriggerMenuLite,
            T& module,
            edm::InputTag const& l1GtRecordInputTag,
            edm::InputTag const& l1GtReadoutRecordInputTag,
            edm::InputTag const& l1GtTriggerMenuLiteInputTag,
            UseEventSetupIn use = UseEventSetupIn::Run);
 
  virtual ~L1GtUtils();
 
  static void fillDescription(edm::ParameterSetDescription& desc) { L1GtUtilsHelper::fillDescription(desc); }
 
public:
  enum TriggerCategory { AlgorithmTrigger = 0, TechnicalTrigger = 1 };
 
  class LogicalExpressionL1Results {
  public:
 
    explicit LogicalExpressionL1Results(const std::string&, L1GtUtils&);
 
    ~LogicalExpressionL1Results();
 
  public:
    inline bool isValid() { return m_validLogicalExpression; }
 
    const int logicalExpressionRunUpdate(const edm::Run&, const edm::EventSetup&, const std::string&);
    //
    const int logicalExpressionRunUpdate(const edm::Run&, const edm::EventSetup&);
 
 
    inline const std::vector<L1GtLogicParser::OperandToken>& expL1Triggers() { return m_expL1Triggers; }
    const std::vector<std::pair<std::string, bool> >& decisionsBeforeMask();
    const std::vector<std::pair<std::string, bool> >& decisionsAfterMask();
    const std::vector<std::pair<std::string, int> >& prescaleFactors();
    const std::vector<std::pair<std::string, int> >& triggerMasks();
 
    const std::vector<std::pair<std::string, int> >& errorCodes(const edm::Event&);
 
  private:
    bool initialize();
 
    void reset(const std::vector<std::pair<std::string, bool> >&) const;
    void reset(const std::vector<std::pair<std::string, int> >&) const;
 
    void l1Results(const edm::Event& iEvent);
 
  private:
 
    std::string m_logicalExpression;
 
    L1GtUtils& m_l1GtUtils;
 
  private:
    // private members
 
    int m_l1ConfCode;
 
    bool m_validL1Configuration;
 
    bool m_validLogicalExpression;
 
    bool m_l1ResultsAlreadyCalled;
 
    std::vector<L1GtLogicParser::OperandToken> m_expL1Triggers;
    size_t m_expL1TriggersSize;
 
    std::vector<L1GtUtils::TriggerCategory> m_expTriggerCategory;
 
    bool m_expBitsTechTrigger;
 
    std::vector<bool> m_expTriggerInMenu;
 
    std::vector<std::pair<std::string, bool> > m_decisionsBeforeMask;
    std::vector<std::pair<std::string, bool> > m_decisionsAfterMask;
    std::vector<std::pair<std::string, int> > m_prescaleFactors;
    std::vector<std::pair<std::string, int> > m_triggerMasks;
    std::vector<std::pair<std::string, int> > m_errorCodes;
  };
 
public:
 
  // enum to string for TriggerCategory
  const std::string triggerCategory(const TriggerCategory&) const;
 
  void retrieveL1EventSetup(const edm::EventSetup&, bool isRun = true);
 
 
  void retrieveL1GtTriggerMenuLite(const edm::Run&);
 
 
  void getL1GtRunCache(const edm::Run&, const edm::EventSetup&, const bool, const bool);
 
  void getL1GtRunCache(const edm::Event&, const edm::EventSetup&, const bool, const bool);
 
 
  const bool l1AlgoTechTrigBitNumber(const std::string& nameAlgoTechTrig,
                                     TriggerCategory& trigCategory,
                                     int& bitNumber) const;
 
 
  const bool l1TriggerNameFromBit(const int& bitNumber,
                                  const TriggerCategory& trigCategory,
                                  std::string& aliasL1Trigger,
                                  std::string& nameL1Trigger) const;
 
 
  const int l1Results(const edm::Event& iEvent,
                      const std::string& nameAlgoTechTrig,
                      bool& decisionBeforeMask,
                      bool& decisionAfterMask,
                      int& prescaleFactor,
                      int& triggerMask) const;
 
 
  const bool decisionBeforeMask(const edm::Event& iEvent, const std::string& nameAlgoTechTrig, int& errorCode) const;
 
  const bool decisionAfterMask(const edm::Event& iEvent, const std::string& nameAlgoTechTrig, int& errorCode) const;
 
  const bool decision(const edm::Event& iEvent, const std::string& nameAlgoTechTrig, int& errorCode) const;
 
  const int prescaleFactor(const edm::Event& iEvent, const std::string& nameAlgoTechTrig, int& errorCode) const;
 
  const int triggerMask(const edm::Event& iEvent, const std::string& nameAlgoTechTrig, int& errorCode) const;
 
  const int triggerMask(const std::string& nameAlgoTechTrig, int& errorCode) const;
 
 
  const int prescaleFactorSetIndex(const edm::Event& iEvent, const TriggerCategory& trigCategory, int& errorCode) const;
 
 
  const std::vector<int>& prescaleFactorSet(const edm::Event& iEvent,
                                            const TriggerCategory& trigCategory,
                                            int& errorCode);
 
  const std::vector<unsigned int>& triggerMaskSet(const TriggerCategory& trigCategory, int& errorCode);
 
  const std::string& l1TriggerMenu() const;
 
  const std::string& l1TriggerMenuImplementation() const;
 
  const L1GtTriggerMenu* ptrL1TriggerMenuEventSetup(int& errorCode);
 
  const L1GtTriggerMenuLite* ptrL1GtTriggerMenuLite(int& errorCode);
 
  const bool availableL1Configuration(int& errorCode, int& l1ConfCode) const;
 
private:
  static const std::string EmptyString;
  static const int L1GtNotValidError;
 
  const bool trigResult(const DecisionWord& decWord,
                        const int bitNumber,
                        const std::string& nameAlgoTechTrig,
                        const TriggerCategory& trigCategory,
                        int& errorCode) const;
 
private:
  L1GtUtils(edm::ConsumesCollector&, UseEventSetupIn);
 
 
  const L1GtStableParameters* m_l1GtStablePar;
  unsigned long long m_l1GtStableParCacheID;
 
  unsigned int m_numberAlgorithmTriggers;
 
  unsigned int m_numberTechnicalTriggers;
 
  const L1GtPrescaleFactors* m_l1GtPfAlgo;
  unsigned long long m_l1GtPfAlgoCacheID;
 
  const L1GtPrescaleFactors* m_l1GtPfTech;
  unsigned long long m_l1GtPfTechCacheID;
 
  const std::vector<std::vector<int> >* m_prescaleFactorsAlgoTrig;
  const std::vector<std::vector<int> >* m_prescaleFactorsTechTrig;
 
  const L1GtTriggerMask* m_l1GtTmAlgo;
  unsigned long long m_l1GtTmAlgoCacheID;
 
  const L1GtTriggerMask* m_l1GtTmTech;
  unsigned long long m_l1GtTmTechCacheID;
 
  const L1GtTriggerMask* m_l1GtTmVetoAlgo;
  unsigned long long m_l1GtTmVetoAlgoCacheID;
 
  const L1GtTriggerMask* m_l1GtTmVetoTech;
  unsigned long long m_l1GtTmVetoTechCacheID;
 
  const std::vector<unsigned int>* m_triggerMaskAlgoTrig;
  const std::vector<unsigned int>* m_triggerMaskTechTrig;
 
  const std::vector<unsigned int>* m_triggerMaskVetoAlgoTrig;
  const std::vector<unsigned int>* m_triggerMaskVetoTechTrig;
 
  // trigger menu
  const L1GtTriggerMenu* m_l1GtMenu;
  unsigned long long m_l1GtMenuCacheID;
 
  const AlgorithmMap* m_algorithmMap;
  const AlgorithmMap* m_algorithmAliasMap;
  const AlgorithmMap* m_technicalTriggerMap;
 
  bool m_l1EventSetupValid;
 
 
  const L1GtTriggerMenuLite* m_l1GtMenuLite;
 
  const L1GtTriggerMenuLite::L1TriggerMap* m_algorithmMapLite;
  const L1GtTriggerMenuLite::L1TriggerMap* m_algorithmAliasMapLite;
  const L1GtTriggerMenuLite::L1TriggerMap* m_technicalTriggerMapLite;
 
  const std::vector<unsigned int>* m_triggerMaskAlgoTrigLite;
  const std::vector<unsigned int>* m_triggerMaskTechTrigLite;
 
  const std::vector<std::vector<int> >* m_prescaleFactorsAlgoTrigLite;
  const std::vector<std::vector<int> >* m_prescaleFactorsTechTrigLite;
 
  bool m_l1GtMenuLiteValid;
 
  bool m_beginRunCache;
 
  edm::RunID m_runIDCache;
 
private:
  unsigned int m_physicsDaqPartition;
 
  std::vector<unsigned int> m_triggerMaskSet;
  std::vector<int> m_prescaleFactorSet;
 
  bool m_retrieveL1EventSetup;
  bool m_retrieveL1GtTriggerMenuLite;
 
  std::unique_ptr<L1GtUtilsHelper> m_l1GtUtilsHelper;
 
  // beginRun EventSetup tokens
  edm::ESGetToken<L1GtStableParameters, L1GtStableParametersRcd> m_L1GtStableParametersRunToken;
  edm::ESGetToken<L1GtPrescaleFactors, L1GtPrescaleFactorsAlgoTrigRcd> m_L1GtPrescaleFactorsAlgoTrigRunToken;
  edm::ESGetToken<L1GtPrescaleFactors, L1GtPrescaleFactorsTechTrigRcd> m_L1GtPrescaleFactorsTechTrigRunToken;
  edm::ESGetToken<L1GtTriggerMask, L1GtTriggerMaskAlgoTrigRcd> m_L1GtTriggerMaskAlgoTrigRunToken;
  edm::ESGetToken<L1GtTriggerMask, L1GtTriggerMaskTechTrigRcd> m_L1GtTriggerMaskTechTrigRunToken;
  edm::ESGetToken<L1GtTriggerMask, L1GtTriggerMaskVetoAlgoTrigRcd> m_L1GtTriggerMaskVetoAlgoTrigRunToken;
  edm::ESGetToken<L1GtTriggerMask, L1GtTriggerMaskVetoTechTrigRcd> m_L1GtTriggerMaskVetoTechTrigRunToken;
  edm::ESGetToken<L1GtTriggerMenu, L1GtTriggerMenuRcd> m_L1GtTriggerMenuRunToken;
 
  // event transition EventSetup tokens (same as run tokens except a different name)
  edm::ESGetToken<L1GtStableParameters, L1GtStableParametersRcd> m_L1GtStableParametersEventToken;
  edm::ESGetToken<L1GtPrescaleFactors, L1GtPrescaleFactorsAlgoTrigRcd> m_L1GtPrescaleFactorsAlgoTrigEventToken;
  edm::ESGetToken<L1GtPrescaleFactors, L1GtPrescaleFactorsTechTrigRcd> m_L1GtPrescaleFactorsTechTrigEventToken;
  edm::ESGetToken<L1GtTriggerMask, L1GtTriggerMaskAlgoTrigRcd> m_L1GtTriggerMaskAlgoTrigEventToken;
  edm::ESGetToken<L1GtTriggerMask, L1GtTriggerMaskTechTrigRcd> m_L1GtTriggerMaskTechTrigEventToken;
  edm::ESGetToken<L1GtTriggerMask, L1GtTriggerMaskVetoAlgoTrigRcd> m_L1GtTriggerMaskVetoAlgoTrigEventToken;
  edm::ESGetToken<L1GtTriggerMask, L1GtTriggerMaskVetoTechTrigRcd> m_L1GtTriggerMaskVetoTechTrigEventToken;
  edm::ESGetToken<L1GtTriggerMenu, L1GtTriggerMenuRcd> m_L1GtTriggerMenuEventToken;
};
 
template <typename T>
L1GtUtils::L1GtUtils(edm::ParameterSet const& pset,
                     edm::ConsumesCollector&& iC,
                     bool useL1GtTriggerMenuLite,
                     T& module,
                     UseEventSetupIn useEventSetupIn)
    : L1GtUtils(pset, iC, useL1GtTriggerMenuLite, module, useEventSetupIn) {}
 
template <typename T>
L1GtUtils::L1GtUtils(edm::ParameterSet const& pset,
                     edm::ConsumesCollector& iC,
                     bool useL1GtTriggerMenuLite,
                     T& module,
                     UseEventSetupIn useEventSetupIn)
    : L1GtUtils(iC, useEventSetupIn) {
  m_l1GtUtilsHelper.reset(new L1GtUtilsHelper(pset, iC, useL1GtTriggerMenuLite, module));
}
 
template <typename T>
L1GtUtils::L1GtUtils(edm::ParameterSet const& pset,
                     edm::ConsumesCollector&& iC,
                     bool useL1GtTriggerMenuLite,
                     T& module,
                     edm::InputTag const& l1GtRecordInputTag,
                     edm::InputTag const& l1GtReadoutRecordInputTag,
                     edm::InputTag const& l1GtTriggerMenuLiteInputTag,
                     UseEventSetupIn useEventSetupIn)
    : L1GtUtils(pset,
                iC,
                useL1GtTriggerMenuLite,
                module,
                l1GtRecordInputTag,
                l1GtReadoutRecordInputTag,
                l1GtTriggerMenuLiteInputTag,
                useEventSetupIn) {}
 
template <typename T>
L1GtUtils::L1GtUtils(edm::ParameterSet const& pset,
                     edm::ConsumesCollector& iC,
                     bool useL1GtTriggerMenuLite,
                     T& module,
                     edm::InputTag const& l1GtRecordInputTag,
                     edm::InputTag const& l1GtReadoutRecordInputTag,
                     edm::InputTag const& l1GtTriggerMenuLiteInputTag,
                     UseEventSetupIn useEventSetupIn)
    : L1GtUtils(iC, useEventSetupIn) {
  m_l1GtUtilsHelper.reset(new L1GtUtilsHelper(pset,
                                              iC,
                                              useL1GtTriggerMenuLite,
                                              module,
                                              l1GtRecordInputTag,
                                              l1GtReadoutRecordInputTag,
                                              l1GtTriggerMenuLiteInputTag));
}
 
#endif /*GlobalTriggerAnalyzer_L1GtUtils_h*/