TriggerCondition.h

Go to the documentation of this file.

#ifndef DataFormats_PatCandidates_TriggerCondition_h
#define DataFormats_PatCandidates_TriggerCondition_h


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

#include "FWCore/Utilities/interface/InputTag.h"
#include "DataFormats/Common/interface/Ref.h"
#include "DataFormats/Common/interface/RefProd.h"
#include "DataFormats/Common/interface/RefVector.h"
#include "DataFormats/Common/interface/RefVectorIterator.h"
#include "CondFormats/L1TObjects/interface/L1GtFwd.h"
#include "DataFormats/HLTReco/interface/TriggerTypeDefs.h"

namespace pat {

  class TriggerCondition {


      std::string name_;
      bool accept_;
      L1GtConditionCategory category_;
      L1GtConditionType type_;
      std::vector< trigger::TriggerObjectType > triggerObjectTypes_;
      std::vector< unsigned > objectKeys_;

    public:


      TriggerCondition();
      TriggerCondition( const std::string & name );
      TriggerCondition( const std::string & name, bool accept );

      virtual ~TriggerCondition() {};


      void setName( const std::string & name ) { name_ = name; };
      void setAccept( bool accept ) { accept_ = accept; };
      void setCategory( L1GtConditionCategory category ) { category_ = category; };
      void setCategory( int category )                   { category_ = L1GtConditionCategory( category ); };
      void setType( L1GtConditionType type ) { type_ = type; };
      void setType( int type )               { type_ = L1GtConditionType( type ); };
      void addTriggerObjectType( trigger::TriggerObjectType triggerObjectType ) { triggerObjectTypes_.push_back( triggerObjectType ); }; // explicitely NOT checking for existence
      void addTriggerObjectType( int triggerObjectType )                        { addTriggerObjectType( trigger::TriggerObjectType( triggerObjectType ) ); };
      void addObjectKey( unsigned objectKey ) { if ( ! hasObjectKey( objectKey ) ) objectKeys_.push_back( objectKey ); };
      std::string name() const { return name_; };
      bool wasAccept() const { return accept_; };
      int category() const { return int( category_ ); };
      int type() const { return int( type_ ); };
      std::vector< int > triggerObjectTypes() const;
      bool hasTriggerObjectType( trigger::TriggerObjectType triggerObjectType ) const;
      bool hasTriggerObjectType( int triggerObjectType ) const { return hasTriggerObjectType( trigger::TriggerObjectType( triggerObjectType ) ); };
      std::vector< unsigned > objectKeys() const { return objectKeys_; };
      bool hasObjectKey( unsigned objectKey ) const;

  };


  typedef std::vector< TriggerCondition >                      TriggerConditionCollection;
  typedef edm::Ref< TriggerConditionCollection >               TriggerConditionRef;
  typedef edm::RefProd< TriggerConditionCollection >           TriggerConditionRefProd;
  typedef edm::RefVector< TriggerConditionCollection >         TriggerConditionRefVector;
  typedef edm::RefVectorIterator< TriggerConditionCollection > TriggerConditionRefVectorIterator;

}


#endif