#include <PFBlockBasedIsolation.h>

Public Member Functions
std::vector< reco::PFCandidateRef >	calculate (math::XYZTLorentzVectorD p4, const reco::PFCandidateRef pfEGCand, const edm::Handle< reco::PFCandidateCollection > pfCandidateHandle)

	PFBlockBasedIsolation ()

void	setup (const edm::ParameterSet &conf)

	~PFBlockBasedIsolation ()

Private Member Functions
bool	elementPassesCleaning (const reco::PFCandidateRef &pfCand, const reco::PFCandidateRef &pfEGCand)

const reco::PFBlockElementCluster *	getHighestEtECALCluster (const reco::PFCandidate &pfCand)

bool	passesCleaningChargedHadron (const reco::PFCandidateRef &pfCand, const reco::PFCandidateRef &pfEGCand)

bool	passesCleaningNeutralHadron (const reco::PFCandidateRef &pfCand, const reco::PFCandidateRef &pfEGCand)

bool	passesCleaningPhoton (const reco::PFCandidateRef &pfCand, const reco::PFCandidateRef &pfEGCand)

Private Attributes
double	coneSize_

Detailed Description

Definition at line 33 of file PFBlockBasedIsolation.h.

Constructor & Destructor Documentation

◆ PFBlockBasedIsolation()

PFBlockBasedIsolation::PFBlockBasedIsolation ( )

Definition at line 22 of file PFBlockBasedIsolation.cc.

                                              {
   // Default Constructor.
 }

◆ ~PFBlockBasedIsolation()

PFBlockBasedIsolation::~PFBlockBasedIsolation ( )

Definition at line 27 of file PFBlockBasedIsolation.cc.

27 {}

Member Function Documentation

◆ calculate()

std::vector< reco::PFCandidateRef > PFBlockBasedIsolation::calculate	(	math::XYZTLorentzVectorD	p4,
		const reco::PFCandidateRef	pfEGCand,
		const edm::Handle< reco::PFCandidateCollection >	pfCandidateHandle
	)

Definition at line 31 of file PFBlockBasedIsolation.cc.

                                                                   {
   std::vector<reco::PFCandidateRef> myVec;
  
   math::XYZVector candidateMomentum(p4.px(), p4.py(), p4.pz());
   math::XYZVector candidateDirection = candidateMomentum.Unit();
  
   const reco::PFCandidate::ElementsInBlocks& theElementsInpfEGcand = (*pfEGCand).elementsInBlocks();
   reco::PFCandidate::ElementsInBlocks::const_iterator ieg = theElementsInpfEGcand.begin();
   const reco::PFBlockRef egblock = ieg->first;
  
   unsigned nObj = pfCandidateHandle->size();
   for (unsigned int lCand = 0; lCand < nObj; lCand++) {
     reco::PFCandidateRef pfCandRef(reco::PFCandidateRef(pfCandidateHandle, lCand));
  
     float dR = 0.0;
     if (coneSize_ < 10.0) {
       dR = deltaR(candidateDirection.Eta(), candidateDirection.Phi(), pfCandRef->eta(), pfCandRef->phi());
       if (dR > coneSize_)
         continue;
     }
  
     const reco::PFCandidate::ElementsInBlocks& theElementsInPFcand = pfCandRef->elementsInBlocks();
  
     bool elementFound = false;
     for (reco::PFCandidate::ElementsInBlocks::const_iterator ipf = theElementsInPFcand.begin();
          ipf < theElementsInPFcand.end();
          ++ipf) {
       if (ipf->first == egblock && !elementFound) {
         for (ieg = theElementsInpfEGcand.begin(); ieg < theElementsInpfEGcand.end(); ++ieg) {
           if (ipf->second == ieg->second && !elementFound) {
             if (elementPassesCleaning(pfCandRef, pfEGCand)) {
               myVec.push_back(pfCandRef);
               elementFound = true;
             }
           }
         }
       }
     }
   }
  
   return myVec;
 }

References coneSize_, PbPb_ZMuSkimMuonDPG_cff::deltaR, HGC3DClusterGenMatchSelector_cfi::dR, elementPassesCleaning(), and p4.

Referenced by ParticleBasedIsoProducer::produce().

◆ elementPassesCleaning()

bool PFBlockBasedIsolation::elementPassesCleaning	(	const reco::PFCandidateRef &	pfCand,
		const reco::PFCandidateRef &	pfEGCand
	)

private

Definition at line 77 of file PFBlockBasedIsolation.cc.

                                                                                       {
   if (pfCand->particleId() == reco::PFCandidate::h)
     return passesCleaningChargedHadron(pfCand, pfEGCand);
   else if (pfCand->particleId() == reco::PFCandidate::h0)
     return passesCleaningNeutralHadron(pfCand, pfEGCand);
   else if (pfCand->particleId() == reco::PFCandidate::gamma)
     return passesCleaningPhoton(pfCand, pfEGCand);
   else
     return true;  //doesnt really matter here as if its not a photon,neutral or charged it wont be included in isolation
 }

References reco::PFCandidate::gamma, reco::PFCandidate::h, reco::PFCandidate::h0, passesCleaningChargedHadron(), passesCleaningNeutralHadron(), and passesCleaningPhoton().

Referenced by calculate().

◆ getHighestEtECALCluster()

const reco::PFBlockElementCluster * PFBlockBasedIsolation::getHighestEtECALCluster ( const reco::PFCandidate & pfCand )

private

Definition at line 129 of file PFBlockBasedIsolation.cc.

                                                                                                              {
   float maxECALEt = -1;
   const reco::PFBlockElement* maxEtECALCluster = nullptr;
   const reco::PFCandidate::ElementsInBlocks& elementsInPFCand = pfCand.elementsInBlocks();
   for (auto& elemIndx : elementsInPFCand) {
     const reco::PFBlockElement* elem =
         elemIndx.second < elemIndx.first->elements().size() ? &elemIndx.first->elements()[elemIndx.second] : nullptr;
     if (elem && elem->type() == reco::PFBlockElement::ECAL && elem->clusterRef()->pt() > maxECALEt) {
       maxECALEt = elem->clusterRef()->pt();
       maxEtECALCluster = elem;
     }
   }
   return dynamic_cast<const reco::PFBlockElementCluster*>(maxEtECALCluster);
 }

References reco::PFBlockElement::clusterRef(), reco::PFBlockElement::ECAL, reco::PFCandidate::elementsInBlocks(), and reco::PFBlockElement::type().

Referenced by passesCleaningPhoton().

◆ passesCleaningChargedHadron()

bool PFBlockBasedIsolation::passesCleaningChargedHadron	(	const reco::PFCandidateRef &	pfCand,
		const reco::PFCandidateRef &	pfEGCand
	)

private

Definition at line 90 of file PFBlockBasedIsolation.cc.

                                                                                             {
   return true;
 }

Referenced by elementPassesCleaning().

◆ passesCleaningNeutralHadron()

bool PFBlockBasedIsolation::passesCleaningNeutralHadron	(	const reco::PFCandidateRef &	pfCand,
		const reco::PFCandidateRef &	pfEGCand
	)

private

Definition at line 98 of file PFBlockBasedIsolation.cc.

                                                                                             {
   return true;
 }

Referenced by elementPassesCleaning().

◆ passesCleaningPhoton()

bool PFBlockBasedIsolation::passesCleaningPhoton	(	const reco::PFCandidateRef &	pfCand,
		const reco::PFCandidateRef &	pfEGCand
	)

private

Definition at line 104 of file PFBlockBasedIsolation.cc.

                                                                                      {
   bool passesCleaning = false;
   const reco::PFBlockElementCluster* ecalClusWithMaxEt = getHighestEtECALCluster(*pfCand);
   if (ecalClusWithMaxEt) {
     if (ecalClusWithMaxEt->superClusterRef().isNonnull() &&
         ecalClusWithMaxEt->superClusterRef()->seed()->seed() ==
             pfEGCand->superClusterRef()
                 ->seed()
                 ->seed()) {  //being sure to match, some concerned about different collections, shouldnt be but to be safe
       passesCleaning = true;
     } else {
       for (auto cluster : pfEGCand->superClusterRef()->clusters()) {
         //the PF clusters there are in two different collections so cant reference match
         //but we can match on the seed id, no clusters can share a seed so if the seeds are
         //equal, it must be the same cluster
         if (ecalClusWithMaxEt->clusterRef()->seed() == cluster->seed()) {
           passesCleaning = true;
         }
       }  //end of loop over clusters
     }
   }  //end of null check for highest ecal cluster
   return passesCleaning;
 }