TriggerAlgorithm.h

Go to the documentation of this file.

#ifndef DataFormats_PatCandidates_TriggerAlgorithm_h
#define DataFormats_PatCandidates_TriggerAlgorithm_h


// -*- C++ -*-
//
// Package:    PatCandidates
// Class:      pat::TriggerAlgorithm
//
//
#include <string>
#include <vector>

#include "DataFormats/Common/interface/Ref.h"
#include "DataFormats/Common/interface/RefProd.h"
#include "DataFormats/Common/interface/RefVector.h"
#include "DataFormats/Common/interface/RefVectorIterator.h"


namespace pat {

  class TriggerAlgorithm {


      std::string name_;
      std::string alias_;
      std::string logic_;
      bool tech_;
      unsigned bit_;
      bool gtlResult_;
      unsigned prescale_;
      bool mask_;
      bool decisionBeforeMask_;
      bool decisionAfterMask_;
      std::vector< unsigned > conditionKeys_;

    public:


      TriggerAlgorithm();
      TriggerAlgorithm( const std::string & name );
      TriggerAlgorithm( const std::string & name, const std::string & alias, bool tech, unsigned bit, unsigned prescale, bool mask, bool decisionBeforeMask, bool decisionAfterMask ); // for backward compatibility
      TriggerAlgorithm( const std::string & name, const std::string & alias, bool tech, unsigned bit, bool gtlResult, unsigned prescale, bool mask, bool decisionBeforeMask, bool decisionAfterMask );

      virtual ~TriggerAlgorithm() {};


      void setName( const std::string & name ) { name_ = name; };
      void setAlias( const std::string & alias ) { alias_ = alias; };
      void setLogicalExpression( const std::string & expression ) { logic_ = expression; };
      void setTechTrigger( bool tech ) { tech_ = tech; };
      void setBit( unsigned bit ) { bit_ = bit; };
      void setGtlResult( bool gtlResult ) { gtlResult_ = gtlResult; };
      void setPrescale( unsigned prescale )  { prescale_ = prescale; };
      void setMask( bool mask ) { mask_ = mask; };
      void setDecisionBeforeMask( bool decisionBeforeMask ) { decisionBeforeMask_ = decisionBeforeMask; };
      void setDecisionAfterMas( bool decisionAfterMask ) { decisionAfterMask_ = decisionAfterMask; };
      void addConditionKey( unsigned conditionKey ) { if ( ! hasConditionKey( conditionKey ) ) conditionKeys_.push_back( conditionKey ); };
      const std::string & name() const { return name_; };
      const std::string & alias() const { return alias_; };
      const std::string & logicalExpression() const { return logic_; };
      bool techTrigger() const { return tech_; };
      unsigned bit() const { return bit_; };
      bool gtlResult() const { return gtlResult_; };
      unsigned prescale() const { return prescale_; };
      bool mask() const { return mask_; };
      bool decisionBeforeMask() const { return decisionBeforeMask_; };
      bool decisionAfterMask() const { return decisionAfterMask_; };
      bool decision() const { return decisionAfterMask(); };
      const std::vector< unsigned > & conditionKeys() const { return conditionKeys_; };
      bool hasConditionKey( unsigned conditionKey ) const;

  };


  typedef std::vector< TriggerAlgorithm >                      TriggerAlgorithmCollection;
  typedef edm::Ref< TriggerAlgorithmCollection >               TriggerAlgorithmRef;
  typedef edm::RefProd< TriggerAlgorithmCollection >           TriggerAlgorithmRefProd;
  typedef edm::RefVector< TriggerAlgorithmCollection >         TriggerAlgorithmRefVector;
  typedef edm::RefVectorIterator< TriggerAlgorithmCollection > TriggerAlgorithmRefVectorIterator;

}


#endif