GenericTriggerEventFlag.h

Go to the documentation of this file.

#ifndef GenericTriggerEventFlag_H
#define GenericTriggerEventFlag_H


// -*- C++ -*-
//
// Package:    CommonTools/TriggerUtils
// Class:      GenericTriggerEventFlag
//
// $Id: GenericTriggerEventFlag.h,v 1.5 2012/01/19 20:17:34 vadler Exp $
//
#include "FWCore/Framework/interface/Run.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/ESWatcher.h"
#include "FWCore/Framework/interface/ConsumesCollector.h"
#include "CondFormats/DataRecord/interface/AlCaRecoTriggerBitsRcd.h"
#include "DataFormats/Common/interface/TriggerResults.h"
#include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutRecord.h"
#include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerEvmReadoutRecord.h"
#include "DataFormats/Scalers/interface/DcsStatus.h"
#include "L1Trigger/GlobalTriggerAnalyzer/interface/L1GtUtils.h"
#include "L1Trigger/L1TGlobal/interface/L1TGlobalUtil.h"
#include "HLTrigger/HLTcore/interface/HLTConfigProvider.h"

#include <memory>
#include <string>


class GenericTriggerEventFlag {

    // Utility classes
    std::unique_ptr<edm::ESWatcher< AlCaRecoTriggerBitsRcd > > watchDB_;
    std::unique_ptr<L1GtUtils>                 l1Gt_;
    std::unique_ptr<l1t::L1TGlobalUtil>        l1uGt_;
    HLTConfigProvider                          hltConfig_;
    bool                                       hltConfigInit_;
    // Configuration parameters
    bool        andOr_;
    std::string dbLabel_;
    unsigned    verbose_;
    bool               andOrDcs_;
    edm::InputTag      dcsInputTag_;
    edm::EDGetTokenT< DcsStatusCollection > dcsInputToken_;
    std::vector< int > dcsPartitions_;
    bool               errorReplyDcs_;
    bool                       andOrGt_;
    edm::InputTag              gtInputTag_;
    edm::EDGetTokenT< L1GlobalTriggerReadoutRecord > gtInputToken_;
    edm::InputTag              gtEvmInputTag_;
    edm::EDGetTokenT< L1GlobalTriggerEvmReadoutRecord > gtEvmInputToken_;
    std::string                gtDBKey_;
    std::vector< std::string > gtLogicalExpressions_;
    bool                       errorReplyGt_;
    bool                       andOrL1_;
    bool                       stage2_;
    bool                       l1BeforeMask_;
    std::string                l1DBKey_;
    std::vector< std::string > l1LogicalExpressionsCache_;
    std::vector< std::string > l1LogicalExpressions_;
    bool                       errorReplyL1_;
    bool                       andOrHlt_;
    edm::InputTag              hltInputTag_;
    edm::EDGetTokenT< edm::TriggerResults > hltInputToken_;
    std::string                hltDBKey_;
    std::vector< std::string > hltLogicalExpressionsCache_;
    std::vector< std::string > hltLogicalExpressions_;
    bool                       errorReplyHlt_;
    // Switches
    bool on_;
    bool onDcs_;
    bool onGt_;
    bool onL1_;
    bool onHlt_;
    // Member constants
    const std::string configError_;
    const std::string emptyKeyError_;

  public:
    //so passing in the owning EDProducer is a pain for me (S. Harper)
    //and its only needed for legacy/stage1 L1 info which is mostly obsolete now
    //defined a new constructor which doesnt allow for the use of legacy/stage 1 L1, only stage2
    //so you no longer have to pass in the EDProducer
    //however I set things up such that its an error to try and configure the stage-1 L1 here
    //hence the extra private constructor 
    //tldr: use these constructors, not the other two if unsure, if you get it wrong, there'll be an error
    GenericTriggerEventFlag( const edm::ParameterSet & config, edm::ConsumesCollector && iC):
      GenericTriggerEventFlag(config,iC){}
    GenericTriggerEventFlag( const edm::ParameterSet & config, edm::ConsumesCollector & iC);

    // Constructors must be called from the ED module's c'tor
    template <typename T>
    GenericTriggerEventFlag( const edm::ParameterSet & config, edm::ConsumesCollector && iC, T& module );

    template <typename T>
    GenericTriggerEventFlag( const edm::ParameterSet & config, edm::ConsumesCollector & iC, T& module );


    // Public methods
    bool on()  { return     on_  ; }
    bool off() { return ( ! on_ ); }
    void initRun( const edm::Run & run, const edm::EventSetup & setup );    // To be called from beginRun() methods
    bool accept( const edm::Event & event, const edm::EventSetup & setup ); // To be called from analyze/filter() methods

  private:
    GenericTriggerEventFlag( const edm::ParameterSet & config, edm::ConsumesCollector & iC, bool stage1Valid );
    // Private methods

    // DCS
    bool acceptDcs( const edm::Event & event );
    bool acceptDcsPartition( const edm::Handle< DcsStatusCollection > & dcsStatus, int dcsPartition ) const;

    // GT status bits
    bool acceptGt( const edm::Event & event );
    bool acceptGtLogicalExpression( const edm::Event & event, std::string gtLogicalExpression );

    // L1
    bool acceptL1( const edm::Event & event, const edm::EventSetup & setup );
    bool acceptL1LogicalExpression( const edm::Event & event, const edm::EventSetup & setup, std::string l1LogicalExpression );

    // HLT
    bool acceptHlt( const edm::Event & event );
    bool acceptHltLogicalExpression( const edm::Handle< edm::TriggerResults > & hltTriggerResults, std::string hltLogicalExpression ) const;

    // Algos
    std::string expandLogicalExpression( const std::vector< std::string > & target, const std::string & expr, bool useAnd = false ) const;
    bool negate( std::string & word ) const;

  public:

    // Methods for expert analysis

    std::string gtDBKey()  { return gtDBKey_ ; } // can be empty
    std::string l1DBKey()  { return l1DBKey_ ; } // can be empty
    std::string hltDBKey() { return hltDBKey_; } // can be empty

    std::vector< std::string > expressionsFromDB( const std::string & key, const edm::EventSetup & setup );

};

template <typename T>
GenericTriggerEventFlag::GenericTriggerEventFlag( const edm::ParameterSet & config, edm::ConsumesCollector && iC, T& module ) :
  GenericTriggerEventFlag(config, iC, module) {
}

template <typename T>
GenericTriggerEventFlag::GenericTriggerEventFlag( const edm::ParameterSet & config, edm::ConsumesCollector & iC, T& module ) :
  GenericTriggerEventFlag(config, iC,true) {
  if ( config.exists( "andOrL1" ) ) {
    if (stage2_){
      l1uGt_ = std::make_unique<l1t::L1TGlobalUtil>(config, iC);
    }else{
      l1Gt_ = std::make_unique<L1GtUtils>(config, iC, false, module);
    }
  }
  //these pointers are already null so no need to reset them to a nullptr 
  //if andOrL1 doesnt exist
}
  

#endif