Inheritance diagram for PhotonPFIsolationWithMapBasedVeto:

Public Member Functions
void	getEventInfo (const edm::Event &iEvent) override

bool	isInIsolationCone (const reco::CandidatePtr &photon, const reco::CandidatePtr &pfCandidate) const final

PhotonPFIsolationWithMapBasedVeto &	operator= (const PhotonPFIsolationWithMapBasedVeto &)=delete

	PhotonPFIsolationWithMapBasedVeto (const edm::ParameterSet &c)

	PhotonPFIsolationWithMapBasedVeto (const PhotonPFIsolationWithMapBasedVeto &)=delete

void	setConsumes (edm::ConsumesCollector iC) override

	~PhotonPFIsolationWithMapBasedVeto () override
	Destructor. More...

Public Member Functions inherited from citk::IsolationConeDefinitionBase
const std::string &	additionalCode () const

virtual void	getEventSetupInfo (const edm::EventSetup &)

	IsolationConeDefinitionBase (const edm::ParameterSet &c)

	IsolationConeDefinitionBase (const IsolationConeDefinitionBase &)=delete

const std::string &	name () const

IsolationConeDefinitionBase &	operator= (const IsolationConeDefinitionBase &)=delete

virtual	~IsolationConeDefinitionBase ()
	Destructor. More...

Public Attributes
edm::Handle< edm::ValueMap< std::vector< reco::PFCandidateRef > > >	particleBasedIsolationMap

edm::EDGetTokenT< edm::ValueMap< std::vector< reco::PFCandidateRef > > >	particleBasedIsolationToken_

Private Attributes
const std::string	_isolateAgainst

const std::vector< unsigned >	_miniAODVertexCodes

const edm::InputTag	_particleBasedIsolation

const std::string	_vertexCollection

const unsigned	_vertexIndex

Additional Inherited Members
Protected Attributes inherited from citk::IsolationConeDefinitionBase
std::string	_additionalCode

const float	_coneSize2

Detailed Description

Definition at line 66 of file PhotonPFIsolationWithMapBasedVeto.cc.

Constructor & Destructor Documentation

PhotonPFIsolationWithMapBasedVeto::PhotonPFIsolationWithMapBasedVeto ( const edm::ParameterSet & c )

inline

Definition at line 68 of file PhotonPFIsolationWithMapBasedVeto.cc.

References muons2muons_cfi::photon.

       : citk::IsolationConeDefinitionBase(c),
         _isolateAgainst(c.getParameter<std::string>("isolateAgainst")),  //isolate against either h+, h0 or gamma
         _miniAODVertexCodes(c.getParameter<std::vector<unsigned> >(
             "miniAODVertexCodes")),  //quality flags to be used for association with the vertex configurable, the vertex can be chosen
         _vertexIndex(c.getParameter<int>("vertexIndex")),  //vertex of interest
         _particleBasedIsolation(c.getParameter<edm::InputTag>("particleBasedIsolation")) {}

PhotonPFIsolationWithMapBasedVeto::PhotonPFIsolationWithMapBasedVeto ( const PhotonPFIsolationWithMapBasedVeto & )

delete

PhotonPFIsolationWithMapBasedVeto::~PhotonPFIsolationWithMapBasedVeto ( )

inlineoverride

Destructor.

Definition at line 96 of file PhotonPFIsolationWithMapBasedVeto.cc.

References AlCaHLTBitMon_QueryRunRegistry::string.

96 {};

Member Function Documentation

void PhotonPFIsolationWithMapBasedVeto::getEventInfo ( const edm::Event & iEvent )

inlineoverridevirtual

Reimplemented from citk::IsolationConeDefinitionBase.

Definition at line 85 of file PhotonPFIsolationWithMapBasedVeto.cc.

References edm::Event::getByToken().

                                                      {
     iEvent.getByToken(particleBasedIsolationToken_, particleBasedIsolationMap);
   };

bool PhotonPFIsolationWithMapBasedVeto::isInIsolationCone	(	const reco::CandidatePtr &	photon,
		const reco::CandidatePtr &	pfCandidate
	)		const

finalvirtual

Implements citk::IsolationConeDefinitionBase.

Definition at line 111 of file PhotonPFIsolationWithMapBasedVeto.cc.

References reco::deltaR2(), Exception, edm::Ptr< T >::get(), edm::Ptr< T >::isNonnull(), and mps_fire::result.

                                                                                                      {
   //convert the photon and candidate objects to the corresponding pat or reco objects. What is used depends on what is user running on: miniAOD or AOD
   pat::patPhotonPtr aspat_photonptr(photon);
 
   pat::PackedCandidatePtr aspacked(pfCandidate);
   reco::PFCandidatePtr aspf(pfCandidate);
 
   bool inFootprint = false;
   bool result = true;
   const float deltar2 =
       reco::deltaR2(*photon, *pfCandidate);  //calculate deltaR2 distance between PFCandidate and photon
 
   // dealing here with patObjects: miniAOD case
   if (aspacked.get()) {
     inFootprint = isInFootprint(aspat_photonptr->associatedPackedPFCandidates(), aspacked);
 
     //checking if the charged candidates come from the appropriate vertex
     if (aspacked->charge() != 0) {
       bool is_vertex_allowed = false;
       for (const unsigned vtxtype : _miniAODVertexCodes) {
         if (vtxtype == aspacked->fromPV(_vertexIndex)) {
           is_vertex_allowed = true;
           break;
         }
       }
 
       result &= (is_vertex_allowed);
     }
     //return true if the candidate is inside the cone and not in the footprint
     result &= deltar2 < _coneSize2 && (!inFootprint);
 
   }
 
   // dealing here with recoObjects: AOD case
   else if (aspf.get() && aspf.isNonnull()) {
     inFootprint = isInFootprintAlternative((*particleBasedIsolationMap)[photon], aspf);
     result &= deltar2 < _coneSize2 && (!inFootprint);
 
   }
 
   // throw exception if it is not a patObject or recoObject
   else {
     throw cms::Exception("InvalidIsolationInput") << "The supplied candidate to be used as isolation "
                                                   << "was neither a reco::Photon nor a pat::Photon!";
   }
 
   return result;
 }

PhotonPFIsolationWithMapBasedVeto& PhotonPFIsolationWithMapBasedVeto::operator= ( const PhotonPFIsolationWithMapBasedVeto & )

delete

void PhotonPFIsolationWithMapBasedVeto::setConsumes ( edm::ConsumesCollector iC )

inlineoverridevirtual

Implements citk::IsolationConeDefinitionBase.

Definition at line 90 of file PhotonPFIsolationWithMapBasedVeto.cc.

References edm::ConsumesCollector::mayConsume().

                                                      {
     particleBasedIsolationToken_ =
         iC.mayConsume<edm::ValueMap<std::vector<reco::PFCandidateRef> > >(_particleBasedIsolation);
   }