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 = std::make_unique<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 = std::make_unique<L1GtUtilsHelper>(pset,
                                                        iC,
                                                        useL1GtTriggerMenuLite,
                                                        module,
                                                        l1GtRecordInputTag,
                                                        l1GtReadoutRecordInputTag,
                                                        l1GtTriggerMenuLiteInputTag);
}

#endif /*GlobalTriggerAnalyzer_L1GtUtils_h*/