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 "DataFormats/L1GlobalTrigger/interface/L1GtTriggerMenuLite.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/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:
  // Using this constructor will require InputTags to be specified in the configuration
  L1GtUtils(edm::ParameterSet const& pset, edm::ConsumesCollector&& iC, bool useL1GtTriggerMenuLite);

  L1GtUtils(edm::ParameterSet const& pset, edm::ConsumesCollector& iC, bool useL1GtTriggerMenuLite);

  // 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);

  template <typename T>
  L1GtUtils(edm::ParameterSet const& pset, edm::ConsumesCollector& iC, bool useL1GtTriggerMenuLite, T& module);

  // 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);

  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);

  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&);


  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();


  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;
};

template <typename T>
L1GtUtils::L1GtUtils(edm::ParameterSet const& pset, edm::ConsumesCollector&& iC, bool useL1GtTriggerMenuLite, T& module)
    : L1GtUtils(pset, iC, useL1GtTriggerMenuLite, module) {}

template <typename T>
L1GtUtils::L1GtUtils(edm::ParameterSet const& pset, edm::ConsumesCollector& iC, bool useL1GtTriggerMenuLite, T& module)
    : L1GtUtils() {
  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)
    : L1GtUtils(pset,
                iC,
                useL1GtTriggerMenuLite,
                module,
                l1GtRecordInputTag,
                l1GtReadoutRecordInputTag,
                l1GtTriggerMenuLiteInputTag) {}

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)
    : L1GtUtils() {
  m_l1GtUtilsHelper.reset(new L1GtUtilsHelper(pset,
                                              iC,
                                              useL1GtTriggerMenuLite,
                                              module,
                                              l1GtRecordInputTag,
                                              l1GtReadoutRecordInputTag,
                                              l1GtTriggerMenuLiteInputTag));
}

#endif /*GlobalTriggerAnalyzer_L1GtUtils_h*/