CMS 3D CMS Logo
Public Member Functions | Private Member Functions | Private Attributes

GenericTriggerEventFlag Class Reference

Provides a code based selection for trigger and DCS information in order to have no failing filters in the CMSSW path. More...

#include <CommonTools/TriggerUtils/interface/GenericTriggerEventFlag.h>

List of all members.

Public Member Functions

bool accept (const edm::Event &event, const edm::EventSetup &setup)
 To be called from analyze/filter() methods.
bool accept (const edm::Event &event, const edm::EventSetup &setup)
std::vector< std::string > expressionsFromDB (const std::string &key, const edm::EventSetup &setup)
 GenericTriggerEventFlag (const edm::ParameterSet &config)
 To be called from the ED module's c'tor.
 GenericTriggerEventFlag (const edm::ParameterSet &config)
std::string gtDBKey ()
std::string hltDBKey ()
void initRun (const edm::Run &run, const edm::EventSetup &setup)
 To be called from beginedm::Run() methods.
void initRun (const edm::Run &run, const edm::EventSetup &setup)
std::string l1DBKey ()
bool off ()
bool off ()
bool on ()
bool on ()
 ~GenericTriggerEventFlag ()
 To be called from d'tors by 'delete'.
 ~GenericTriggerEventFlag ()

Private Member Functions

bool acceptDcs (const edm::Event &event)
bool acceptDcs (const edm::Event &event)
bool acceptDcsPartition (const edm::Handle< DcsStatusCollection > &dcsStatus, int dcsPartition) const
bool acceptDcsPartition (const edm::Handle< DcsStatusCollection > &dcsStatus, int dcsPartition) const
bool acceptGt (const edm::Event &event)
 Does this event fulfill the configured GT status logical expression combination?
bool acceptGt (const edm::Event &event)
bool acceptGtLogicalExpression (const edm::Handle< L1GlobalTriggerReadoutRecord > &gtReadoutRecord, std::string gtLogicalExpression)
 Does this event fulfill this particular GT status bits' logical expression?
bool acceptGtLogicalExpression (const edm::Event &event, std::string gtLogicalExpression)
 Does this event fulfill this particular GT status bits' logical expression?
bool acceptHlt (const edm::Event &event)
bool acceptHlt (const edm::Event &event)
 Was this event accepted by the configured HLT logical expression combination?
bool acceptHltLogicalExpression (const edm::Handle< edm::TriggerResults > &hltTriggerResults, std::string hltLogicalExpression) const
 Was this event accepted by this particular HLT paths' logical expression?
bool acceptHltLogicalExpression (const edm::Handle< edm::TriggerResults > &hltTriggerResults, std::string hltLogicalExpression) const
bool acceptL1 (const edm::Event &event, const edm::EventSetup &setup)
bool acceptL1 (const edm::Event &event, const edm::EventSetup &setup)
 Was this event accepted by the configured L1 logical expression combination?
bool acceptL1LogicalExpression (const edm::Event &event, std::string l1LogicalExpression)
bool acceptL1LogicalExpression (const edm::Event &event, std::string l1LogicalExpression)
 Was this event accepted by this particular L1 algorithms' logical expression?
std::string expandLogicalExpression (const std::vector< std::string > &target, const std::string &expr, bool useAnd=false) const
 Expand wild-carded logical expressions, giving version postfixes priority.
std::vector< std::string > expressionsFromDB (const std::string &key, const edm::EventSetup &setup)
 Reads and returns logical expressions from DB.
bool negate (std::string &word) const
 Checks for negated words.
bool negate (std::string &word) const

Private Attributes

bool andOr_
bool andOrDcs_
bool andOrGt_
bool andOrHlt_
bool andOrL1_
const std::string configError_
std::string dbLabel_
edm::InputTag dcsInputTag_
std::vector< int > dcsPartitions_
const std::string emptyKeyError_
bool errorReplyDcs_
bool errorReplyGt_
bool errorReplyHlt_
bool errorReplyL1_
std::string gtDBKey_
edm::InputTag gtEvmInputTag_
edm::InputTag gtInputTag_
std::vector< std::string > gtLogicalExpressions_
HLTConfigProvider hltConfig_
bool hltConfigInit_
std::string hltDBKey_
edm::InputTag hltInputTag_
std::vector< std::string > hltLogicalExpressions_
std::vector< std::string > hltLogicalExpressionsCache_
bool l1BeforeMask_
std::string l1DBKey_
L1GtUtils l1Gt_
std::vector< std::string > l1LogicalExpressions_
std::vector< std::string > l1LogicalExpressionsCache_
bool on_
bool onDcs_
bool onGt_
bool onHlt_
bool onL1_
unsigned verbose_
edm::ESWatcher
< AlCaRecoTriggerBitsRcd > * 		watchDB_

Detailed Description

Provides a code based selection for trigger and DCS information in order to have no failing filters in the CMSSW path.

[...]

Author:
Volker Adler
Version:
Id:
GenericTriggerEventFlag.h,v 1.3 2010/05/12 14:12:17 vadler Exp

[...]

Author:
Volker Adler
Version:
Id:
GenericTriggerEventFlag.h,v 1.6 2012/01/20 18:18:11 vadler Exp

Definition at line 35 of file GenericTriggerEventFlag.h.

Constructor & Destructor Documentation

GenericTriggerEventFlag::GenericTriggerEventFlag ( const edm::ParameterSet &  config)

To be called from the ED module's c'tor.

Definition at line 19 of file GenericTriggerEventFlag.cc.

References andOr_, andOrDcs_, andOrGt_, andOrHlt_, andOrL1_, dcsInputTag_, dcsPartitions_, errorReplyDcs_, errorReplyGt_, errorReplyHlt_, errorReplyL1_, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), gtDBKey_, gtInputTag_, gtLogicalExpressions_, hltDBKey_, hltInputTag_, hltLogicalExpressions_, l1DBKey_, l1LogicalExpressions_, on_, onDcs_, onGt_, onHlt_, onL1_, verbose_, and watchDB_.

  : watchDB_( 0 )
  , verbose_( 0 )
  , gtDBKey_( "" )
  , l1DBKey_( "" )
  , hltDBKey_( "" )
  , on_( true )
  , onDcs_( true )
  , onGt_( true )
  , onL1_( true )
  , onHlt_( true )
  , configError_( "CONFIG_ERROR" )
{

  // General switch(es)
  if ( config.exists( "andOr" ) ) {
    andOr_ = config.getParameter< bool >( "andOr" );
    if ( config.exists( "verbosityLevel" ) ) verbose_ = config.getParameter< unsigned >( "verbosityLevel" );
  } else {
    on_    = false;
    onDcs_ = false;
    onGt_  = false;
    onL1_  = false;
    onHlt_ = false;
  }

  if ( on_ ) {
    if ( config.exists( "andOrDcs" ) ) {
      andOrDcs_      = config.getParameter< bool >( "andOrDcs" );
      dcsInputTag_   = config.getParameter< edm::InputTag >( "dcsInputTag" );
      dcsPartitions_ = config.getParameter< std::vector< int > >( "dcsPartitions" );
      errorReplyDcs_ = config.getParameter< bool >( "errorReplyDcs" );
    } else {
      onDcs_ = false;
    }
    if ( config.exists( "andOrGt" ) ) {
      andOrGt_              = config.getParameter< bool >( "andOrGt" );
      gtInputTag_           = config.getParameter< edm::InputTag >( "gtInputTag" );
      gtLogicalExpressions_ = config.getParameter< std::vector< std::string > >( "gtStatusBits" );
      errorReplyGt_         = config.getParameter< bool >( "errorReplyGt" );
      if ( config.exists( "gtDBKey" ) ) gtDBKey_ = config.getParameter< std::string >( "gtDBKey" );
    } else {
      onGt_ = false;
    }
    if ( config.exists( "andOrL1" ) ) {
      andOrL1_              = config.getParameter< bool >( "andOrL1" );
      l1LogicalExpressions_ = config.getParameter< std::vector< std::string > >( "l1Algorithms" );
      errorReplyL1_         = config.getParameter< bool >( "errorReplyL1" );
      if ( config.exists( "l1DBKey" ) ) l1DBKey_ = config.getParameter< std::string >( "l1DBKey" );
    } else {
      onL1_ = false;
    }
    if ( config.exists( "andOrHlt" ) ) {
      andOrHlt_              = config.getParameter< bool >( "andOrHlt" );
      hltInputTag_           = config.getParameter< edm::InputTag >( "hltInputTag" );
      hltLogicalExpressions_ = config.getParameter< std::vector< std::string > >( "hltPaths" );
      errorReplyHlt_         = config.getParameter< bool >( "errorReplyHlt" );
      if ( config.exists( "hltDBKey" ) ) hltDBKey_ = config.getParameter< std::string >( "hltDBKey" );
    } else {
      onHlt_ = false;
    }
    if ( ! onDcs_ && ! onGt_ && ! onL1_ && ! onHlt_ ) on_      = false;
    else                                              watchDB_ = new edm::ESWatcher< AlCaRecoTriggerBitsRcd> ;
  }

}
GenericTriggerEventFlag::~GenericTriggerEventFlag ( )

To be called from d'tors by 'delete'.

Definition at line 88 of file GenericTriggerEventFlag.cc.

References on_, and watchDB_.

{

  if ( on_ ) delete watchDB_;

}
GenericTriggerEventFlag::GenericTriggerEventFlag ( const edm::ParameterSet &  config)
GenericTriggerEventFlag::~GenericTriggerEventFlag ( )

Member Function Documentation

bool GenericTriggerEventFlag::accept ( const edm::Event &  event,
const edm::EventSetup &  setup 
)

To be called from analyze/filter() methods.

Definition at line 135 of file GenericTriggerEventFlag.cc.

References acceptDcs(), acceptGt(), acceptHlt(), acceptL1(), andOr_, and on_.

Referenced by MonitorTrackResiduals::analyze(), TauTagValidation::analyze(), TrackingMonitor::analyze(), LogMessageMonitor::analyze(), and SiStripMonitorTrack::analyze().

{

  if ( ! on_ ) return true;

  // Determine decision
  if ( andOr_ ) return ( acceptDcs( event ) || acceptGt( event ) || acceptL1( event, setup ) || acceptHlt( event ) );
  return ( acceptDcs( event ) && acceptGt( event ) && acceptL1( event, setup ) && acceptHlt( event ) );

}
bool GenericTriggerEventFlag::accept ( const edm::Event &  event,
const edm::EventSetup &  setup 
)
bool GenericTriggerEventFlag::acceptDcs ( const edm::Event &  event) [private]

Definition at line 147 of file GenericTriggerEventFlag.cc.

References acceptDcsPartition(), andOr_, andOrDcs_, dcsInputTag_, dcsPartitions_, edm::InputTag::encode(), errorReplyDcs_, edm::HandleBase::isValid(), onDcs_, and verbose_.

Referenced by accept().

{

  // An empty DCS partitions list acts as switch.
  if ( ! onDcs_ || dcsPartitions_.empty() ) return ( ! andOr_ ); // logically neutral, depending on base logical connective

  // Accessing the DcsStatusCollection
  edm::Handle< DcsStatusCollection > dcsStatus;
  event.getByLabel( dcsInputTag_, dcsStatus );
  if ( ! dcsStatus.isValid() ) {
    if ( verbose_ > 2 ) edm::LogWarning( "GenericTriggerEventFlag" ) << "DcsStatusCollection product with InputTag \"" << dcsInputTag_.encode() << "\" not in event ==> decision: " << errorReplyDcs_;
    return errorReplyDcs_;
  }
  if ( ( *dcsStatus ).size() == 0 ) {
    if ( verbose_ > 2 ) edm::LogWarning( "GenericTriggerEventFlag" ) << "DcsStatusCollection product with InputTag \"" << dcsInputTag_.encode() << "\" empty ==> decision: " << errorReplyDcs_;
    return errorReplyDcs_;
  }

  // Determine decision of DCS partition combination and return
  if ( andOrDcs_ ) { // OR combination
    for ( std::vector< int >::const_iterator partitionNumber = dcsPartitions_.begin(); partitionNumber != dcsPartitions_.end(); ++partitionNumber ) {
      if ( acceptDcsPartition( dcsStatus, *partitionNumber ) ) return true;
    }
    return false;
  }
  for ( std::vector< int >::const_iterator partitionNumber = dcsPartitions_.begin(); partitionNumber != dcsPartitions_.end(); ++partitionNumber ) {
    if ( ! acceptDcsPartition( dcsStatus, *partitionNumber ) ) return false;
  }
  return true;

}
bool GenericTriggerEventFlag::acceptDcs ( const edm::Event &  event) [private]
bool GenericTriggerEventFlag::acceptDcsPartition ( const edm::Handle< DcsStatusCollection > &  dcsStatus,
int  dcsPartition 
) const [private]
bool GenericTriggerEventFlag::acceptDcsPartition ( const edm::Handle< DcsStatusCollection > &  dcsStatus,
int  dcsPartition 
) const [private]

Definition at line 180 of file GenericTriggerEventFlag.cc.

References DcsStatus::BPIX, DcsStatus::CASTOR, DcsStatus::CSCm, DcsStatus::CSCp, DcsStatus::DT0, DcsStatus::DTm, DcsStatus::DTp, DcsStatus::EBm, DcsStatus::EBp, DcsStatus::EEm, DcsStatus::EEp, errorReplyDcs_, DcsStatus::ESm, DcsStatus::ESp, DcsStatus::FPIX, DcsStatus::HBHEa, DcsStatus::HBHEb, DcsStatus::HBHEc, DcsStatus::HF, DcsStatus::HO, DcsStatus::RPC, DcsStatus::TECm, DcsStatus::TECp, DcsStatus::TIBTID, DcsStatus::TOB, and verbose_.

Referenced by acceptDcs().

{

  // Error checks
  switch( dcsPartition ) {
    case DcsStatus::EBp   :
    case DcsStatus::EBm   :
    case DcsStatus::EEp   :
    case DcsStatus::EEm   :
    case DcsStatus::HBHEa :
    case DcsStatus::HBHEb :
    case DcsStatus::HBHEc :
    case DcsStatus::HF    :
    case DcsStatus::HO    :
    case DcsStatus::RPC   :
    case DcsStatus::DT0   :
    case DcsStatus::DTp   :
    case DcsStatus::DTm   :
    case DcsStatus::CSCp  :
    case DcsStatus::CSCm  :
    case DcsStatus::CASTOR:
    case DcsStatus::TIBTID:
    case DcsStatus::TOB   :
    case DcsStatus::TECp  :
    case DcsStatus::TECm  :
    case DcsStatus::BPIX  :
    case DcsStatus::FPIX  :
    case DcsStatus::ESp   :
    case DcsStatus::ESm   :
      break;
    default:
      if ( verbose_ > 2 ) edm::LogWarning( "GenericTriggerEventFlag" ) << "DCS partition number \"" << dcsPartition << "\" does not exist ==> decision: " << errorReplyDcs_;
      return errorReplyDcs_;
  }

  // Determine decision
  return dcsStatus->at( 0 ).ready( dcsPartition );

}
bool GenericTriggerEventFlag::acceptGt ( const edm::Event &  event) [private]
bool GenericTriggerEventFlag::acceptGt ( const edm::Event &  event) [private]

Does this event fulfill the configured GT status logical expression combination?

Definition at line 222 of file GenericTriggerEventFlag.cc.

References acceptGtLogicalExpression(), andOr_, andOrGt_, edm::InputTag::encode(), errorReplyGt_, gtInputTag_, gtLogicalExpressions_, edm::HandleBase::isValid(), onGt_, and verbose_.

Referenced by accept().

{

  // An empty GT status bits logical expressions list acts as switch.
  if ( ! onGt_ || gtLogicalExpressions_.empty() ) return ( ! andOr_ ); // logically neutral, depending on base logical connective

  // Accessing the L1GlobalTriggerReadoutRecord
  edm::Handle< L1GlobalTriggerReadoutRecord > gtReadoutRecord;
  event.getByLabel( gtInputTag_, gtReadoutRecord );
  if ( ! gtReadoutRecord.isValid() ) {
    if ( verbose_ > 2 ) edm::LogWarning( "GenericTriggerEventFlag" ) << "L1GlobalTriggerReadoutRecord product with InputTag \"" << gtInputTag_.encode() << "\" not in event ==> decision: " << errorReplyGt_;
    return errorReplyGt_;
  }

  // Determine decision of GT status bits logical expression combination and return
  if ( andOrGt_ ) { // OR combination
    for ( std::vector< std::string >::const_iterator gtLogicalExpression = gtLogicalExpressions_.begin(); gtLogicalExpression != gtLogicalExpressions_.end(); ++gtLogicalExpression ) {
      if ( acceptGtLogicalExpression( gtReadoutRecord, *gtLogicalExpression ) ) return true;
    }
    return false;
  }
  for ( std::vector< std::string >::const_iterator gtLogicalExpression = gtLogicalExpressions_.begin(); gtLogicalExpression != gtLogicalExpressions_.end(); ++gtLogicalExpression ) {
    if ( ! acceptGtLogicalExpression( gtReadoutRecord, *gtLogicalExpression ) ) return false;
  }
  return true;

}
bool GenericTriggerEventFlag::acceptGtLogicalExpression ( const edm::Handle< L1GlobalTriggerReadoutRecord > &  gtReadoutRecord,
std::string  gtLogicalExpression 
) [private]

Does this event fulfill this particular GT status bits' logical expression?

Definition at line 252 of file GenericTriggerEventFlag.cc.

References errorReplyDcs_, errorReplyGt_, L1GtLogicParser::expressionResult(), negate(), L1GtLogicParser::operandTokenVector(), and verbose_.

Referenced by acceptGt().

{

  // Check empty std::strings
  if ( gtLogicalExpression.empty() ) {
    if ( verbose_ > 2 ) edm::LogWarning( "GenericTriggerEventFlag" ) << "Empty logical expression ==> decision: " << errorReplyGt_;
    return errorReplyGt_;
  }

  // Negated paths
  bool negExpr( negate( gtLogicalExpression ) );
  if ( negExpr && gtLogicalExpression.empty() ) {
    if ( verbose_ > 2 ) edm::LogWarning( "GenericTriggerEventFlag" ) << "Empty (negated) logical expression ==> decision: " << errorReplyGt_;
    return errorReplyGt_;
  }

  // Parse logical expression and determine GT status bit decision
  L1GtLogicParser gtAlgoLogicParser( gtLogicalExpression );
  // Loop over status bits
  for ( size_t iStatusBit = 0; iStatusBit < gtAlgoLogicParser.operandTokenVector().size(); ++iStatusBit ) {
    const std::string gtStatusBit( gtAlgoLogicParser.operandTokenVector().at( iStatusBit ).tokenName );
    // Manipulate status bit decision as stored in the parser
    bool decision;
    // Hard-coded status bits!!!
    if ( gtStatusBit == "PhysDecl" || gtStatusBit == "PhysicsDeclared" ) {
      decision = ( gtReadoutRecord->gtFdlWord().physicsDeclared() == 1 );
    } else {
      if ( verbose_ > 2 ) edm::LogWarning( "GenericTriggerEventFlag" ) << "GT status bit \"" << gtStatusBit << "\" is not defined ==> decision: " << errorReplyGt_;
      decision = errorReplyDcs_;
    }
    gtAlgoLogicParser.operandTokenVector().at( iStatusBit ).tokenResult = decision;
  }

  // Determine decision
  const bool gtDecision( gtAlgoLogicParser.expressionResult() );
  return negExpr ? ( ! gtDecision ) : gtDecision;

}
bool GenericTriggerEventFlag::acceptGtLogicalExpression ( const edm::Event &  event,
std::string  gtLogicalExpression 
) [private]

Does this event fulfill this particular GT status bits' logical expression?

Definition at line 322 of file GenericTriggerEventFlag.cc.

References edm::InputTag::encode(), errorReplyDcs_, errorReplyGt_, L1GtLogicParser::expressionResult(), gtEvmInputTag_, edm::HandleBase::isValid(), negate(), L1GtLogicParser::operandTokenVector(), and verbose_.

{

  // Check empty std::strings
  if ( gtLogicalExpression.empty() ) {
    if ( verbose_ > 1 ) edm::LogWarning( "GenericTriggerEventFlag" ) << "Empty logical expression ==> decision: " << errorReplyGt_;
    return errorReplyGt_;
  }

  // Negated paths
  bool negExpr( negate( gtLogicalExpression ) );
  if ( negExpr && gtLogicalExpression.empty() ) {
    if ( verbose_ > 1 ) edm::LogWarning( "GenericTriggerEventFlag" ) << "Empty (negated) logical expression ==> decision: " << errorReplyGt_;
    return errorReplyGt_;
  }

  // Parse logical expression and determine GT status bit decision
  L1GtLogicParser gtAlgoLogicParser( gtLogicalExpression );
  // Loop over status bits
  for ( size_t iStatusBit = 0; iStatusBit < gtAlgoLogicParser.operandTokenVector().size(); ++iStatusBit ) {
    const std::string gtStatusBit( gtAlgoLogicParser.operandTokenVector().at( iStatusBit ).tokenName );
    // Manipulate status bit decision as stored in the parser
    bool decision( errorReplyDcs_ );
    // Hard-coded status bits!!!
    if ( gtStatusBit == "PhysDecl" || gtStatusBit == "PhysicsDeclared" ) {
      edm::Handle< L1GlobalTriggerReadoutRecord > gtReadoutRecord;
      event.getByLabel( gtInputTag_, gtReadoutRecord );
      if ( ! gtReadoutRecord.isValid() ) {
        if ( verbose_ > 1 ) edm::LogWarning( "GenericTriggerEventFlag" ) << "L1GlobalTriggerReadoutRecord product with InputTag \"" << gtInputTag_.encode() << "\" not in event";
        event.getByType( gtReadoutRecord );
        if ( ! gtReadoutRecord.isValid() ) {
          if ( verbose_ > 1 ) edm::LogWarning( "GenericTriggerEventFlag" ) << "L1GlobalTriggerReadoutRecord product not in event at all ==> decision: " << errorReplyGt_;
          gtAlgoLogicParser.operandTokenVector().at( iStatusBit ).tokenResult = errorReplyDcs_;
          continue;
        }
      }
      decision = ( gtReadoutRecord->gtFdlWord().physicsDeclared() == 1 );
    } else if ( gtStatusBit == "Stable" || gtStatusBit == "StableBeam" || gtStatusBit == "Adjust" || gtStatusBit == "Sqeeze" || gtStatusBit == "Flat" || gtStatusBit == "FlatTop" ||
                gtStatusBit == "7TeV" || gtStatusBit == "900GeV" ) {
      edm::Handle< L1GlobalTriggerEvmReadoutRecord > gtEvmReadoutRecord;
      event.getByLabel( gtEvmInputTag_, gtEvmReadoutRecord );
      if ( ! gtEvmReadoutRecord.isValid() ) {
        if ( verbose_ > 1 ) edm::LogWarning( "GenericTriggerEventFlag" ) << "L1GlobalTriggerEvmReadoutRecord product with InputTag \"" << gtEvmInputTag_.encode() << "\" not in event";
        event.getByType( gtEvmReadoutRecord );
        if ( ! gtEvmReadoutRecord.isValid() ) {
          if ( verbose_ > 1 ) edm::LogWarning( "GenericTriggerEventFlag" ) << "L1GlobalTriggerEvmReadoutRecord product not in event at all ==> decision: " << errorReplyGt_;
          gtAlgoLogicParser.operandTokenVector().at( iStatusBit ).tokenResult = errorReplyDcs_;
          continue;
        }
      }
      if ( gtStatusBit == "Stable" || gtStatusBit == "StableBeam" ) {
        decision = ( gtEvmReadoutRecord->gtfeWord().beamMode() == 11 );
      } else if ( gtStatusBit == "Adjust" ) {
        decision = ( 10 <= gtEvmReadoutRecord->gtfeWord().beamMode() && gtEvmReadoutRecord->gtfeWord().beamMode() <= 11 );
      } else if ( gtStatusBit == "Sqeeze" ) {
        decision = ( 9 <= gtEvmReadoutRecord->gtfeWord().beamMode() && gtEvmReadoutRecord->gtfeWord().beamMode() <= 11 );
      } else if ( gtStatusBit == "Flat" || gtStatusBit == "FlatTop" ) {
        decision = ( 8 <= gtEvmReadoutRecord->gtfeWord().beamMode() && gtEvmReadoutRecord->gtfeWord().beamMode() <= 11 );
      } else if ( gtStatusBit == "7TeV" ) {
        decision = ( gtEvmReadoutRecord->gtfeWord().beamMomentum() == 3500 );
      } else if ( gtStatusBit == "900GeV" ) {
        decision = ( gtEvmReadoutRecord->gtfeWord().beamMomentum() == 450 );
      }
    } else {
      if ( verbose_ > 1 ) edm::LogWarning( "GenericTriggerEventFlag" ) << "GT status bit \"" << gtStatusBit << "\" is not defined ==> decision: " << errorReplyGt_;
    }
    gtAlgoLogicParser.operandTokenVector().at( iStatusBit ).tokenResult = decision;
  }

  // Determine decision
  const bool gtDecision( gtAlgoLogicParser.expressionResult() );
  return negExpr ? ( ! gtDecision ) : gtDecision;

}
bool GenericTriggerEventFlag::acceptHlt ( const edm::Event &  event) [private]

Was this event accepted by the configured HLT logical expression combination?

Definition at line 362 of file GenericTriggerEventFlag.cc.

References acceptHltLogicalExpression(), andOr_, andOrHlt_, edm::InputTag::encode(), errorReplyDcs_, errorReplyHlt_, hltConfigInit_, hltInputTag_, hltLogicalExpressions_, edm::HandleBase::isValid(), onHlt_, and verbose_.

Referenced by accept().

{

  // An empty HLT logical expressions list acts as switch.
  if ( ! onHlt_ || hltLogicalExpressions_.empty() ) return ( ! andOr_ ); // logically neutral, depending on base logical connective

  // Checking the HLT configuration,
  if ( ! hltConfigInit_ ) {
    if ( verbose_ > 2 ) edm::LogWarning( "GenericTriggerEventFlag" ) << "HLT config error ==> decision: " << errorReplyHlt_;
    return errorReplyHlt_;
  }

  // Accessing the TriggerResults
  edm::Handle< edm::TriggerResults > hltTriggerResults;
  event.getByLabel( hltInputTag_, hltTriggerResults );
  if ( ! hltTriggerResults.isValid() ) {
    if ( verbose_ > 2 ) edm::LogWarning( "GenericTriggerEventFlag" ) << "TriggerResults product with InputTag \"" << hltInputTag_.encode() << "\" not in event ==> decision: " << errorReplyHlt_;
    return errorReplyHlt_;
  }
  if ( ( *hltTriggerResults ).size() == 0 ) {
    if ( verbose_ > 2 ) edm::LogWarning( "GenericTriggerEventFlag" ) << "TriggerResults product with InputTag \"" << hltInputTag_.encode() << "\" empty ==> decision: " << errorReplyHlt_;
    return errorReplyDcs_;
  }

  // Determine decision of HLT logical expression combination and return
  if ( andOrHlt_ ) { // OR combination
    for ( std::vector< std::string >::const_iterator hltLogicalExpression = hltLogicalExpressions_.begin(); hltLogicalExpression != hltLogicalExpressions_.end(); ++hltLogicalExpression ) {
      if ( acceptHltLogicalExpression( hltTriggerResults, *hltLogicalExpression ) ) return true;
    }
    return false;
  }
  for ( std::vector< std::string >::const_iterator hltLogicalExpression = hltLogicalExpressions_.begin(); hltLogicalExpression != hltLogicalExpressions_.end(); ++hltLogicalExpression ) {
    if ( ! acceptHltLogicalExpression( hltTriggerResults, *hltLogicalExpression ) ) return false;
  }
  return true;

}
bool GenericTriggerEventFlag::acceptHlt ( const edm::Event &  event) [private]
bool GenericTriggerEventFlag::acceptHltLogicalExpression ( const edm::Handle< edm::TriggerResults > &  hltTriggerResults,
std::string  hltLogicalExpression 
) const [private]

Was this event accepted by this particular HLT paths' logical expression?

Definition at line 402 of file GenericTriggerEventFlag.cc.

References errorReplyHlt_, L1GtLogicParser::expressionResult(), hltConfig_, hltInputTag_, negate(), L1GtLogicParser::operandTokenVector(), edm::InputTag::process(), HLTConfigProvider::size(), HLTConfigProvider::triggerIndex(), and verbose_.

Referenced by acceptHlt().

{

  // Check empty std::strings
  if ( hltLogicalExpression.empty() ) {
    if ( verbose_ > 2 ) edm::LogWarning( "GenericTriggerEventFlag" ) << "Empty logical expression ==> decision: " << errorReplyHlt_;
    return errorReplyHlt_;
  }

  // Negated paths
  bool negExpr( negate( hltLogicalExpression ) );
  if ( negExpr && hltLogicalExpression.empty() ) {
    if ( verbose_ > 2 ) edm::LogWarning( "GenericTriggerEventFlag" ) << "Empty (negated) logical expression ==> decision: " << errorReplyHlt_;
    return errorReplyHlt_;
  }

  // Parse logical expression and determine HLT decision
  L1GtLogicParser hltAlgoLogicParser( hltLogicalExpression );
  // Loop over paths
  for ( size_t iPath = 0; iPath < hltAlgoLogicParser.operandTokenVector().size(); ++iPath ) {
    const std::string hltPathName( hltAlgoLogicParser.operandTokenVector().at( iPath ).tokenName );
    const unsigned indexPath( hltConfig_.triggerIndex( hltPathName ) );
    // Further error checks
    if ( indexPath == hltConfig_.size() ) {
      if ( verbose_ > 2 ) edm::LogWarning( "GenericTriggerEventFlag" ) << "HLT path \"" << hltPathName << "\" is not found in process " << hltInputTag_.process() << " ==> decision: " << errorReplyHlt_;
      hltAlgoLogicParser.operandTokenVector().at( iPath ).tokenResult = errorReplyHlt_;
      continue;
    }
    if ( hltTriggerResults->error( indexPath ) ) {
      if ( verbose_ > 2 ) edm::LogWarning( "GenericTriggerEventFlag" ) << "HLT path \"" << hltPathName << "\" in error ==> decision: " << errorReplyHlt_;
      hltAlgoLogicParser.operandTokenVector().at( iPath ).tokenResult = errorReplyHlt_;
      continue;
    }
    // Manipulate algo decision as stored in the parser
    const bool decision( hltTriggerResults->accept( indexPath ) );
    hltAlgoLogicParser.operandTokenVector().at( iPath ).tokenResult = decision;
  }

  // Determine decision
  const bool hltDecision( hltAlgoLogicParser.expressionResult() );
  return negExpr ? ( ! hltDecision ) : hltDecision;

}
bool GenericTriggerEventFlag::acceptHltLogicalExpression ( const edm::Handle< edm::TriggerResults > &  hltTriggerResults,
std::string  hltLogicalExpression 
) const [private]
bool GenericTriggerEventFlag::acceptL1 ( const edm::Event &  event,
const edm::EventSetup &  setup 
) [private]

Was this event accepted by the configured L1 logical expression combination?

Definition at line 293 of file GenericTriggerEventFlag.cc.

References acceptL1LogicalExpression(), andOr_, andOrL1_, l1Gt_, l1LogicalExpressions_, onL1_, and L1GtUtils::retrieveL1EventSetup().

Referenced by accept().

{

  // An empty L1 logical expressions list acts as switch.
  if ( ! onL1_ || l1LogicalExpressions_.empty() ) return ( ! andOr_ ); // logically neutral, depending on base logical connective

  // Getting the L1 event setup
  l1Gt_.retrieveL1EventSetup( setup ); // FIXME This can possibly go to initRun()

  // Determine decision of L1 logical expression combination and return
  if ( andOrL1_ ) { // OR combination
    for ( std::vector< std::string >::const_iterator l1LogicalExpression = l1LogicalExpressions_.begin(); l1LogicalExpression != l1LogicalExpressions_.end(); ++l1LogicalExpression ) {
      if ( acceptL1LogicalExpression( event, *l1LogicalExpression ) ) return true;
    }
    return false;
  }
  for ( std::vector< std::string >::const_iterator l1LogicalExpression = l1LogicalExpressions_.begin(); l1LogicalExpression != l1LogicalExpressions_.end(); ++l1LogicalExpression ) {
    if ( ! acceptL1LogicalExpression( event, *l1LogicalExpression ) ) return false;
  }
  return true;

}
bool GenericTriggerEventFlag::acceptL1 ( const edm::Event &  event,
const edm::EventSetup &  setup 
) [private]
bool GenericTriggerEventFlag::acceptL1LogicalExpression ( const edm::Event &  event,
std::string  l1LogicalExpression 
) [private]

Was this event accepted by this particular L1 algorithms' logical expression?

Definition at line 318 of file GenericTriggerEventFlag.cc.

References L1GtUtils::decision(), error, errorReplyL1_, L1GtLogicParser::expressionResult(), l1Gt_, negate(), L1GtLogicParser::operandTokenVector(), and verbose_.

Referenced by acceptL1().

{

  // Check empty std::strings
  if ( l1LogicalExpression.empty() ) {
    if ( verbose_ > 2 ) edm::LogWarning( "GenericTriggerEventFlag" ) << "Empty logical expression ==> decision: " << errorReplyL1_;
    return errorReplyL1_;
  }

  // Negated logical expression
  bool negExpr( negate( l1LogicalExpression ) );
  if ( negExpr && l1LogicalExpression.empty() ) {
    if ( verbose_ > 2 ) edm::LogWarning( "GenericTriggerEventFlag" ) << "Empty (negated) logical expression ==> decision: " << errorReplyL1_;
    return errorReplyL1_;
  }

  // Parse logical expression and determine L1 decision
  L1GtLogicParser l1AlgoLogicParser( l1LogicalExpression );
  // Loop over algorithms
  for ( size_t iAlgorithm = 0; iAlgorithm < l1AlgoLogicParser.operandTokenVector().size(); ++iAlgorithm ) {
    const std::string l1AlgoName( l1AlgoLogicParser.operandTokenVector().at( iAlgorithm ).tokenName );
    int error( -1 );
    const bool decision( l1Gt_.decision( event, l1AlgoName, error ) );
    // Error checks
    if ( error != 0 ) {
      if ( verbose_ > 2 ) {
        if ( error == 1 ) edm::LogWarning( "GenericTriggerEventFlag" ) << "L1 algorithm \"" << l1AlgoName << "\" does not exist in the L1 menu ==> decision: "                                          << errorReplyL1_;
        else              edm::LogWarning( "GenericTriggerEventFlag" ) << "L1 algorithm \"" << l1AlgoName << "\" received error code " << error << " from L1GtUtils::decisionBeforeMask ==> decision: " << errorReplyL1_;
      }
      l1AlgoLogicParser.operandTokenVector().at( iAlgorithm ).tokenResult = errorReplyL1_;
      continue;
    }
    // Manipulate algo decision as stored in the parser
    l1AlgoLogicParser.operandTokenVector().at( iAlgorithm ).tokenResult = decision;
  }

  // Return decision
  const bool l1Decision( l1AlgoLogicParser.expressionResult() );
  return negExpr ? ( ! l1Decision ) : l1Decision;

}
bool GenericTriggerEventFlag::acceptL1LogicalExpression ( const edm::Event &  event,
std::string  l1LogicalExpression 
) [private]
std::string GenericTriggerEventFlag::expandLogicalExpression ( const std::vector< std::string > &  target,
const std::string &  expr,
bool  useAnd = false 
) const [private]

Expand wild-carded logical expressions, giving version postfixes priority.

Definition at line 555 of file GenericTriggerEventFlag.cc.

References hltConfig_, HLTConfigProvider::matched(), HLTConfigProvider::restoreVersion(), and verbose_.

{

  // Find matching entries in the menu
  std::vector< std::string > matched;
  const std::string versionWildcard( "_v*" );
  if ( expr.substr( expr.size() - versionWildcard.size() ) == versionWildcard ) {
    const std::string exprBase( expr.substr( 0, expr.size() - versionWildcard.size() ) );
    matched = hltConfig_.restoreVersion( targets, exprBase );
  } else {
    matched = hltConfig_.matched( targets, expr );
  }

  // Return input, if no match is found
  if ( matched.empty() ) {
    if ( verbose_ > 1 ) edm::LogWarning( "GenericTriggerEventFlag" ) << "Logical expression: \"" << expr << "\" could not be resolved";
    return expr;
  }

  // Compose logical expression
  std::string expanded( "(" );
  for ( unsigned iVers = 0; iVers < matched.size(); ++iVers ) {
    if ( iVers > 0 ) expanded.append( useAnd ? " AND " : " OR " );
    expanded.append( matched.at( iVers ) );
  }
  expanded.append( ")" );
  if ( verbose_ > 1 ) edm::LogInfo( "GenericTriggerEventFlag" ) << "Logical expression: \"" << expr     << "\"\n"
                                                                << "   --> expanded to  \"" << expanded << "\"";

  return expanded;

}
std::vector< std::string > GenericTriggerEventFlag::expressionsFromDB ( const std::string &  key,
const edm::EventSetup &  setup 
)
std::vector< std::string > GenericTriggerEventFlag::expressionsFromDB ( const std::string &  key,
const edm::EventSetup &  setup 
) [private]

Reads and returns logical expressions from DB.

Definition at line 449 of file GenericTriggerEventFlag.cc.

References configError_, edm::EventSetup::get(), and verbose_.

Referenced by MuonRecoOneHLT::beginRun(), and initRun().

{

  edm::ESHandle< AlCaRecoTriggerBits > logicalExpressions;
  setup.get< AlCaRecoTriggerBitsRcd >().get( logicalExpressions );
  const std::map< std::string, std::string > & expressionMap = logicalExpressions->m_alcarecoToTrig;
  std::map< std::string, std::string >::const_iterator listIter = expressionMap.find( key );
  if ( listIter == expressionMap.end() ) {
    if ( verbose_ > 0 ) edm::LogWarning( "GenericTriggerEventFlag" ) << "No logical expressions found under key " << key << " in 'AlCaRecoTriggerBitsRcd'";
    return std::vector< std::string >( 1, configError_ );
  }
  return logicalExpressions->decompose( listIter->second );

}
std::string GenericTriggerEventFlag::gtDBKey ( ) [inline]

Definition at line 119 of file GenericTriggerEventFlag.h.

References gtDBKey_.

{ return gtDBKey_ ; } // can be empty
std::string GenericTriggerEventFlag::hltDBKey ( ) [inline]

Definition at line 121 of file GenericTriggerEventFlag.h.

References hltDBKey_.

Referenced by MuonRecoOneHLT::beginRun().

{ return hltDBKey_; } // can be empty
void GenericTriggerEventFlag::initRun ( const edm::Run &  run,
const edm::EventSetup &  setup 
)
void GenericTriggerEventFlag::initRun ( const edm::Run &  run,
const edm::EventSetup &  setup 
)

To be called from beginedm::Run() methods.

To be called from beginRun() methods.

Definition at line 97 of file GenericTriggerEventFlag.cc.

References edm::ESWatcher< T >::check(), configError_, edm::InputTag::encode(), expressionsFromDB(), gtDBKey_, gtLogicalExpressions_, hltConfig_, hltConfigInit_, hltDBKey_, hltInputTag_, hltLogicalExpressions_, HLTConfigProvider::init(), l1DBKey_, l1LogicalExpressions_, onGt_, onHlt_, onL1_, edm::InputTag::process(), HLTConfigProvider::size(), verbose_, and watchDB_.

Referenced by MuonRecoOneHLT::beginRun(), SiStripMonitorTrack::beginRun(), TauTagValidation::beginRun(), LogMessageMonitor::beginRun(), MonitorTrackResiduals::beginRun(), and TrackingMonitor::beginRun().

{

  // FIXME Can this stay safely in the run loop, or does it need to go to the event loop?
  // Means: Are the event setups identical?
  if ( watchDB_->check( setup ) ) {
    if ( onGt_ && gtDBKey_.size() > 0 ) {
      const std::vector< std::string > exprs( expressionsFromDB( gtDBKey_, setup ) );
      if ( exprs.empty() || exprs.at( 0 ) != configError_ ) gtLogicalExpressions_ = exprs;
    }
    if ( onL1_ && l1DBKey_.size() > 0 ) {
      const std::vector< std::string > exprs( expressionsFromDB( l1DBKey_, setup ) );
      if ( exprs.empty() || exprs.at( 0 ) != configError_ ) l1LogicalExpressions_ = exprs;
    }
    if ( onHlt_ && hltDBKey_.size() > 0 ) {
      const std::vector< std::string > exprs( expressionsFromDB( hltDBKey_, setup ) );
      if ( exprs.empty() || exprs.at( 0 ) != configError_ ) hltLogicalExpressions_ = exprs;
    }
  }

  hltConfigInit_ = false;
  if ( onHlt_ ) {
    if ( hltInputTag_.process().size() == 0 ) {
      if ( verbose_ > 0 ) edm::LogError( "GenericTriggerEventFlag" ) << "HLT TriggerResults InputTag \"" << hltInputTag_.encode() << "\" specifies no process";
    } else {
      bool hltChanged( false );
      if ( ! hltConfig_.init( run, setup, hltInputTag_.process(), hltChanged ) ) {
        if ( verbose_ > 0 ) edm::LogError( "GenericTriggerEventFlag" ) << "HLT config initialization error with process name \"" << hltInputTag_.process() << "\"";
      } else if ( hltConfig_.size() <= 0 ) {
        if ( verbose_ > 0 ) edm::LogError( "GenericTriggerEventFlag" ) << "HLT config size error";
      } else hltConfigInit_ = true;
    }
  }

}
std::string GenericTriggerEventFlag::l1DBKey ( ) [inline]

Definition at line 120 of file GenericTriggerEventFlag.h.

References l1DBKey_.

{ return l1DBKey_ ; } // can be empty
bool GenericTriggerEventFlag::negate ( std::string &  word) const [private]

Checks for negated words.

Definition at line 467 of file GenericTriggerEventFlag.cc.

Referenced by acceptGtLogicalExpression(), acceptHltLogicalExpression(), and acceptL1LogicalExpression().

{

  bool negate( false );
  if ( word.at( 0 ) == '~' ) {
    negate = true;
    word.erase( 0, 1 );
  }
  return negate;

}
bool GenericTriggerEventFlag::negate ( std::string &  word) const [private]
bool GenericTriggerEventFlag::off ( ) [inline]

Definition at line 87 of file GenericTriggerEventFlag.h.

References on_.

{ return ( ! on_ ); }
bool GenericTriggerEventFlag::off ( ) [inline]

Definition at line 80 of file GenericTriggerEventFlag.h.

References on_.

{ return ( ! on_ ); }
bool GenericTriggerEventFlag::on ( ) [inline]

Definition at line 79 of file GenericTriggerEventFlag.h.

References on_.

Referenced by MonitorTrackResiduals::analyze(), TauTagValidation::analyze(), TrackingMonitor::analyze(), LogMessageMonitor::analyze(), SiStripMonitorTrack::analyze(), MuonRecoOneHLT::beginRun(), SiStripMonitorTrack::beginRun(), TauTagValidation::beginRun(), LogMessageMonitor::beginRun(), MonitorTrackResiduals::beginRun(), and TrackingMonitor::beginRun().

{ return     on_  ; }
bool GenericTriggerEventFlag::on ( ) [inline]

Definition at line 86 of file GenericTriggerEventFlag.h.

References on_.

{ return     on_  ; }

Member Data Documentation

bool GenericTriggerEventFlag::andOr_ [private]

Definition at line 43 of file GenericTriggerEventFlag.h.

Referenced by accept(), acceptDcs(), acceptGt(), acceptHlt(), acceptL1(), and GenericTriggerEventFlag().

bool GenericTriggerEventFlag::andOrDcs_ [private]

Definition at line 45 of file GenericTriggerEventFlag.h.

Referenced by acceptDcs(), and GenericTriggerEventFlag().

bool GenericTriggerEventFlag::andOrGt_ [private]

Definition at line 49 of file GenericTriggerEventFlag.h.

Referenced by acceptGt(), and GenericTriggerEventFlag().

bool GenericTriggerEventFlag::andOrHlt_ [private]

Definition at line 58 of file GenericTriggerEventFlag.h.

Referenced by acceptHlt(), and GenericTriggerEventFlag().

bool GenericTriggerEventFlag::andOrL1_ [private]

Definition at line 54 of file GenericTriggerEventFlag.h.

Referenced by acceptL1(), and GenericTriggerEventFlag().

const std::string GenericTriggerEventFlag::configError_ [private]

Definition at line 70 of file GenericTriggerEventFlag.h.

Referenced by expressionsFromDB(), and initRun().

std::string GenericTriggerEventFlag::dbLabel_ [private]

Definition at line 45 of file GenericTriggerEventFlag.h.

edm::InputTag GenericTriggerEventFlag::dcsInputTag_ [private]

Definition at line 46 of file GenericTriggerEventFlag.h.

Referenced by acceptDcs(), and GenericTriggerEventFlag().

std::vector< int > GenericTriggerEventFlag::dcsPartitions_ [private]

Definition at line 47 of file GenericTriggerEventFlag.h.

Referenced by acceptDcs(), and GenericTriggerEventFlag().

const std::string GenericTriggerEventFlag::emptyKeyError_ [private]

Definition at line 77 of file GenericTriggerEventFlag.h.

bool GenericTriggerEventFlag::errorReplyDcs_ [private]

Definition at line 48 of file GenericTriggerEventFlag.h.

Referenced by acceptDcs(), acceptDcsPartition(), acceptGtLogicalExpression(), acceptHlt(), and GenericTriggerEventFlag().

bool GenericTriggerEventFlag::errorReplyGt_ [private]

Definition at line 53 of file GenericTriggerEventFlag.h.

Referenced by acceptGt(), acceptGtLogicalExpression(), and GenericTriggerEventFlag().

bool GenericTriggerEventFlag::errorReplyHlt_ [private]

Definition at line 62 of file GenericTriggerEventFlag.h.

Referenced by acceptHlt(), acceptHltLogicalExpression(), and GenericTriggerEventFlag().

bool GenericTriggerEventFlag::errorReplyL1_ [private]

Definition at line 57 of file GenericTriggerEventFlag.h.

Referenced by acceptL1LogicalExpression(), and GenericTriggerEventFlag().

std::string GenericTriggerEventFlag::gtDBKey_ [private]

Definition at line 51 of file GenericTriggerEventFlag.h.

Referenced by GenericTriggerEventFlag(), gtDBKey(), and initRun().

edm::InputTag GenericTriggerEventFlag::gtEvmInputTag_ [private]

Definition at line 53 of file GenericTriggerEventFlag.h.

Referenced by acceptGtLogicalExpression().

edm::InputTag GenericTriggerEventFlag::gtInputTag_ [private]

Definition at line 50 of file GenericTriggerEventFlag.h.

Referenced by acceptGt(), and GenericTriggerEventFlag().

std::vector< std::string > GenericTriggerEventFlag::gtLogicalExpressions_ [private]

Definition at line 52 of file GenericTriggerEventFlag.h.

Referenced by acceptGt(), GenericTriggerEventFlag(), and initRun().

HLTConfigProvider GenericTriggerEventFlag::hltConfig_ [private]

Definition at line 40 of file GenericTriggerEventFlag.h.

Referenced by acceptHltLogicalExpression(), expandLogicalExpression(), and initRun().

bool GenericTriggerEventFlag::hltConfigInit_ [private]

Definition at line 41 of file GenericTriggerEventFlag.h.

Referenced by acceptHlt(), and initRun().

std::string GenericTriggerEventFlag::hltDBKey_ [private]

Definition at line 60 of file GenericTriggerEventFlag.h.

Referenced by GenericTriggerEventFlag(), hltDBKey(), and initRun().

edm::InputTag GenericTriggerEventFlag::hltInputTag_ [private]

Definition at line 59 of file GenericTriggerEventFlag.h.

Referenced by acceptHlt(), acceptHltLogicalExpression(), GenericTriggerEventFlag(), and initRun().

std::vector< std::string > GenericTriggerEventFlag::hltLogicalExpressions_ [private]

Definition at line 61 of file GenericTriggerEventFlag.h.

Referenced by acceptHlt(), GenericTriggerEventFlag(), and initRun().

std::vector< std::string > GenericTriggerEventFlag::hltLogicalExpressionsCache_ [private]

Definition at line 66 of file GenericTriggerEventFlag.h.

bool GenericTriggerEventFlag::l1BeforeMask_ [private]

Definition at line 58 of file GenericTriggerEventFlag.h.

std::string GenericTriggerEventFlag::l1DBKey_ [private]

Definition at line 55 of file GenericTriggerEventFlag.h.

Referenced by GenericTriggerEventFlag(), initRun(), and l1DBKey().

L1GtUtils GenericTriggerEventFlag::l1Gt_ [private]

Definition at line 39 of file GenericTriggerEventFlag.h.

Referenced by acceptL1(), and acceptL1LogicalExpression().

std::vector< std::string > GenericTriggerEventFlag::l1LogicalExpressions_ [private]

Definition at line 56 of file GenericTriggerEventFlag.h.

Referenced by acceptL1(), GenericTriggerEventFlag(), and initRun().

std::vector< std::string > GenericTriggerEventFlag::l1LogicalExpressionsCache_ [private]

Definition at line 60 of file GenericTriggerEventFlag.h.

bool GenericTriggerEventFlag::on_ [private]

Definition at line 64 of file GenericTriggerEventFlag.h.

Referenced by accept(), GenericTriggerEventFlag(), off(), on(), and ~GenericTriggerEventFlag().

bool GenericTriggerEventFlag::onDcs_ [private]

Definition at line 65 of file GenericTriggerEventFlag.h.

Referenced by acceptDcs(), and GenericTriggerEventFlag().

bool GenericTriggerEventFlag::onGt_ [private]

Definition at line 66 of file GenericTriggerEventFlag.h.

Referenced by acceptGt(), GenericTriggerEventFlag(), and initRun().

bool GenericTriggerEventFlag::onHlt_ [private]

Definition at line 68 of file GenericTriggerEventFlag.h.

Referenced by acceptHlt(), GenericTriggerEventFlag(), and initRun().

bool GenericTriggerEventFlag::onL1_ [private]

Definition at line 67 of file GenericTriggerEventFlag.h.

Referenced by acceptL1(), GenericTriggerEventFlag(), and initRun().

unsigned GenericTriggerEventFlag::verbose_ [private]

Definition at line 44 of file GenericTriggerEventFlag.h.

Referenced by acceptDcs(), acceptDcsPartition(), acceptGt(), acceptGtLogicalExpression(), acceptHlt(), acceptHltLogicalExpression(), acceptL1LogicalExpression(), expandLogicalExpression(), expressionsFromDB(), GenericTriggerEventFlag(), and initRun().

edm::ESWatcher< AlCaRecoTriggerBitsRcd > * GenericTriggerEventFlag::watchDB_ [private]

Definition at line 38 of file GenericTriggerEventFlag.h.

Referenced by GenericTriggerEventFlag(), initRun(), and ~GenericTriggerEventFlag().

Generated for CMSSW Reference Manual by doxygen 1.7.3