TriggerObject.cc

Go to the documentation of this file.

//
//

#include "DataFormats/PatCandidates/interface/TriggerObject.h"

#include "FWCore/Utilities/interface/EDMException.h"


using namespace pat;


// Constructors and Destructor


// Default constructor
TriggerObject::TriggerObject() :
  reco::LeafCandidate()
{
  triggerObjectTypes_.clear();
}


// Constructor from trigger::TriggerObject
TriggerObject::TriggerObject( const trigger::TriggerObject & trigObj ) :
  reco::LeafCandidate( 0, trigObj.particle().p4(), reco::Particle::Point( 0., 0., 0. ), trigObj.id() ),
  refToOrig_()
{
  triggerObjectTypes_.clear();
}


// Constructors from base class object
TriggerObject::TriggerObject( const reco::LeafCandidate & leafCand ) :
  reco::LeafCandidate( leafCand ),
  refToOrig_()
{
  triggerObjectTypes_.clear();
}


// Constructors from base candidate reference (for 'l1extra' particles)
TriggerObject::TriggerObject( const reco::CandidateBaseRef & candRef ) :
  reco::LeafCandidate( *candRef ),
  refToOrig_( candRef )
{
  triggerObjectTypes_.clear();
}


// Constructors from Lorentz-vectors and (optional) PDG ID
TriggerObject::TriggerObject( const reco::Particle::LorentzVector & vec, int id ) :
  reco::LeafCandidate( 0, vec, reco::Particle::Point( 0., 0., 0. ), id ),
  refToOrig_()
{
  triggerObjectTypes_.clear();
}
TriggerObject::TriggerObject( const reco::Particle::PolarLorentzVector & vec, int id ) :
  reco::LeafCandidate( 0, vec, reco::Particle::Point( 0., 0., 0. ), id ),
  refToOrig_()
{
  triggerObjectTypes_.clear();
}


// Methods


// Get all trigger object type identifiers
std::vector< int > TriggerObject::triggerObjectTypes() const
{
  std::vector< int > triggerObjectTypes;
  for ( size_t iTo = 0; iTo < triggerObjectTypes_.size(); ++iTo ) {
    triggerObjectTypes.push_back( triggerObjectTypes_.at( iTo ) );
  }
  return triggerObjectTypes;
}


// Checks, if a certain label of original collection is assigned
bool TriggerObject::hasCollection( const std::string & collName ) const
{
  // True, if collection name is simply fine
  if ( collName == collection_ ) return true;
  // Check, if collection name possibly fits in an edm::InputTag approach
  const edm::InputTag collectionTag( collection_ );
  const edm::InputTag collTag( collName );
  // If evaluated collection tag contains a process name, it must have been found already by identity check
  if ( collTag.process().empty() ) {
    // Check instance ...
    if ( ( collTag.instance().empty() && collectionTag.instance().empty() ) || collTag.instance() == collectionTag.instance() ) {
      // ... and label
      return ( collTag.label() == collectionTag.label() );
    }
  }
  return false;
}


// Checks, if a certain trigger object type identifier is assigned
bool TriggerObject::hasTriggerObjectType( trigger::TriggerObjectType triggerObjectType ) const
{
  for ( size_t iF = 0; iF < triggerObjectTypes_.size(); ++iF ) {
    if ( triggerObjectType == triggerObjectTypes_.at( iF ) ) return true;
  }
  return false;
}


// Special methods for 'l1extra' particles


// Getters specific to the 'l1extra' particle types
// Exceptions of type 'edm::errors::InvalidReference' are thrown,
// if wrong particle type is requested

// EM
const l1extra::L1EmParticleRef TriggerObject::origL1EmRef() const
{
  l1extra::L1EmParticleRef l1Ref;
  try {
    l1Ref = origObjRef().castTo< l1extra::L1EmParticleRef >();
  } catch ( edm::Exception const& X ) {
    if ( X.categoryCode() != edm::errors::InvalidReference ) throw X;
  }
  return l1Ref;
}

// EtMiss
const l1extra::L1EtMissParticleRef TriggerObject::origL1EtMissRef() const
{
  l1extra::L1EtMissParticleRef l1Ref;
  try {
    l1Ref = origObjRef().castTo< l1extra::L1EtMissParticleRef >();
  } catch ( edm::Exception const & X ) {
    if ( X.categoryCode() != edm::errors::InvalidReference ) throw X;
  }
  return l1Ref;
}

// Jet
const l1extra::L1JetParticleRef TriggerObject::origL1JetRef() const
{
  l1extra::L1JetParticleRef l1Ref;
  try {
    l1Ref = origObjRef().castTo< l1extra::L1JetParticleRef >();
  } catch ( edm::Exception const & X ) {
    if ( X.categoryCode() != edm::errors::InvalidReference ) throw X;
  }
  return l1Ref;
}

// Muon
const l1extra::L1MuonParticleRef TriggerObject::origL1MuonRef() const
{
  l1extra::L1MuonParticleRef l1Ref;
  try {
    l1Ref = origObjRef().castTo< l1extra::L1MuonParticleRef >();
  } catch ( edm::Exception const& X ) {
    if ( X.categoryCode() != edm::errors::InvalidReference ) throw X;
  }
  return l1Ref;
}