/data/refman/pasoursint/CMSSW_5_3_3/src/DataFormats/PatCandidates/interface/TriggerObject.h

Go to the documentation of this file.

#ifndef DataFormats_PatCandidates_TriggerObject_h
#define DataFormats_PatCandidates_TriggerObject_h


// -*- C++ -*-
//
// Package:    PatCandidates
// Class:      pat::TriggerObject
//
// $Id: TriggerObject.h,v 1.13 2010/12/20 20:05:52 vadler Exp $
//
#include "DataFormats/Candidate/interface/LeafCandidate.h"

#include <map>
#include <string>
#include <vector>
#include <algorithm>

#include "DataFormats/L1Trigger/interface/L1EmParticle.h"
#include "DataFormats/L1Trigger/interface/L1EmParticleFwd.h"
#include "DataFormats/L1Trigger/interface/L1EtMissParticle.h"
#include "DataFormats/L1Trigger/interface/L1EtMissParticleFwd.h"
#include "DataFormats/L1Trigger/interface/L1JetParticle.h"
#include "DataFormats/L1Trigger/interface/L1JetParticleFwd.h"
#include "DataFormats/L1Trigger/interface/L1MuonParticle.h"
#include "DataFormats/L1Trigger/interface/L1MuonParticleFwd.h"
#include "DataFormats/HLTReco/interface/TriggerTypeDefs.h"
#include "DataFormats/HLTReco/interface/TriggerObject.h"
#include "DataFormats/Common/interface/RefVectorIterator.h"
#include "DataFormats/Common/interface/Association.h"
#include "FWCore/Utilities/interface/InputTag.h"


namespace pat {

  class TriggerObject : public reco::LeafCandidate {


      std::string collection_;
      std::vector< trigger::TriggerObjectType > triggerObjectTypes_;
      reco::CandidateBaseRef refToOrig_;

    public:


      TriggerObject();
      TriggerObject( const trigger::TriggerObject & trigObj );
      TriggerObject( const reco::LeafCandidate    & leafCand );
      TriggerObject( const reco::CandidateBaseRef & candRef );
      TriggerObject( const reco::Particle::LorentzVector      & vec, int id = 0 );
      TriggerObject( const reco::Particle::PolarLorentzVector & vec, int id = 0 );

      virtual ~TriggerObject() {};


      void setCollection( const std::string & collName )   { collection_ = collName; };
      void setCollection( const edm::InputTag & collName ) { collection_ = collName.encode(); };
      void addTriggerObjectType( trigger::TriggerObjectType triggerObjectType ) { if ( ! hasTriggerObjectType( triggerObjectType ) ) triggerObjectTypes_.push_back( triggerObjectType ); };
      void addTriggerObjectType( int                        triggerObjectType ) { addTriggerObjectType( trigger::TriggerObjectType( triggerObjectType ) ); };
      void addFilterId( trigger::TriggerObjectType triggerObjectType ) { addTriggerObjectType( triggerObjectType ); };                               // for backward compatibility
      void addFilterId( int                        triggerObjectType ) { addTriggerObjectType( trigger::TriggerObjectType( triggerObjectType ) ); }; // for backward compatibility
      std::string collection() const { return collection_; };
//       std::vector< trigger::TriggerObjectType > triggerObjectTypes() const { return triggerObjectTypes_; };
//       std::vector< trigger::TriggerObjectType > filterIds()          const { return triggerObjectTypes(); }; // for backward compatibility
      std::vector< int > triggerObjectTypes() const;                                  // for backward compatibility
      std::vector< int > filterIds()          const { return triggerObjectTypes(); }; // for double backward compatibility
      virtual bool hasCollection( const std::string   & collName ) const;
      virtual bool hasCollection( const edm::InputTag & collName ) const { return hasCollection( collName.encode() ); };
      bool hasTriggerObjectType( trigger::TriggerObjectType triggerObjectType ) const;
      bool hasTriggerObjectType( int                        triggerObjectType ) const { return hasTriggerObjectType( trigger::TriggerObjectType( triggerObjectType ) ); };
      bool hasFilterId( trigger::TriggerObjectType triggerObjectType ) const { return hasTriggerObjectType( triggerObjectType ); };                               // for backward compatibility
      bool hasFilterId( int                        triggerObjectType ) const { return hasTriggerObjectType( trigger::TriggerObjectType( triggerObjectType ) ); }; // for backward compatibility


      const reco::CandidateBaseRef & origObjRef()  const { return refToOrig_; };
      const reco::Candidate        * origObjCand() const { return refToOrig_.get(); };
      const l1extra::L1EmParticleRef origL1EmRef() const;
      const L1GctEmCand * origL1GctEmCand() const { return origL1EmRef().isNonnull() ? origL1EmRef()->gctEmCand() : 0; };
      const l1extra::L1EtMissParticleRef origL1EtMissRef() const;
      const L1GctEtMiss  * origL1GctEtMiss()  const { return origL1EtMissRef().isNonnull() ? origL1EtMissRef()->gctEtMiss()  : 0; };
      const L1GctEtTotal * origL1GctEtTotal() const { return origL1EtMissRef().isNonnull() ? origL1EtMissRef()->gctEtTotal() : 0; };
      const L1GctHtMiss  * origL1GctHtMiss()  const { return origL1EtMissRef().isNonnull() ? origL1EtMissRef()->gctHtMiss()  : 0; };
      const L1GctEtHad   * origL1GctEtHad()   const { return origL1EtMissRef().isNonnull() ? origL1EtMissRef()->gctEtHad()   : 0; };
      const l1extra::L1JetParticleRef origL1JetRef() const;
      const L1GctJetCand * origL1GctJetCand() const { return origL1JetRef().isNonnull() ? origL1JetRef()->gctJetCand() : 0; };
      const l1extra::L1MuonParticleRef origL1MuonRef() const;
      const L1MuGMTExtendedCand * origL1GmtMuonCand() const { return origL1MuonRef().isNonnull() ? &( origL1MuonRef()->gmtMuonCand() ) : 0; };


      virtual bool coll( const std::string & collName ) const { return hasCollection( collName ); };
      bool type( trigger::TriggerObjectType triggerObjectType ) const { return hasTriggerObjectType( triggerObjectType ); };
      bool type( int                        triggerObjectType ) const { return hasTriggerObjectType( trigger::TriggerObjectType ( triggerObjectType ) ); };
      bool id( trigger::TriggerObjectType triggerObjectType ) const { return hasTriggerObjectType( triggerObjectType ); };                                // for backward compatibility
      bool id( int                        triggerObjectType ) const { return hasTriggerObjectType( trigger::TriggerObjectType ( triggerObjectType ) ); }; // for backward compatibility

  };


  typedef std::vector< TriggerObject >                       TriggerObjectCollection;
  typedef edm::Ref< TriggerObjectCollection >                TriggerObjectRef;
  typedef std::map< std::string, TriggerObjectRef >          TriggerObjectMatchMap;
  typedef edm::RefProd< TriggerObjectCollection >            TriggerObjectRefProd;
  typedef edm::RefVector< TriggerObjectCollection >          TriggerObjectRefVector;
  typedef edm::RefVectorIterator< TriggerObjectCollection >  TriggerObjectRefVectorIterator;
  typedef edm::Association< TriggerObjectCollection >        TriggerObjectMatch;
  typedef edm::RefProd< TriggerObjectMatch >                 TriggerObjectMatchRefProd;
  typedef std::map< std::string, TriggerObjectMatchRefProd > TriggerObjectMatchContainer;

}


#endif