PFBlockBasedIsolation Class Reference

#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 36 of file PFBlockBasedIsolation.h.

Constructor & Destructor Documentation

PFBlockBasedIsolation::PFBlockBasedIsolation

(

)

Definition at line 24 of file PFBlockBasedIsolation.cc.

                                             {
  // Default Constructor.
}

PFBlockBasedIsolation::~PFBlockBasedIsolation

(

)

Definition at line 32 of file PFBlockBasedIsolation.cc.

{

}

Member Function Documentation

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

Definition at line 45 of file PFBlockBasedIsolation.cc.

References coneSize_, boostedElectronIsolation_cff::deltaR, PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, and elementPassesCleaning().

Referenced by ParticleBasedIsoProducer::produce().

                                                                                                                                                                                          {
  
  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;



 }

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

private

Definition at line 102 of file PFBlockBasedIsolation.cc.

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

Referenced by calculate().

{
  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
}

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

private

Definition at line 149 of file PFBlockBasedIsolation.cc.

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

Referenced by passesCleaningPhoton().

{
  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);
    
}

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

private

Definition at line 111 of file PFBlockBasedIsolation.cc.

Referenced by elementPassesCleaning().

{
  return true;
}

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

private

Definition at line 119 of file PFBlockBasedIsolation.cc.

Referenced by elementPassesCleaning().

{
  return true;
}

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

private

Definition at line 125 of file PFBlockBasedIsolation.cc.

References reco::PFBlockElementCluster::clusterRef(), getHighestEtECALCluster(), edm::Ref< C, T, F >::isNonnull(), and reco::PFBlockElementCluster::superClusterRef().

Referenced by elementPassesCleaning().

{
  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;

}

void PFBlockBasedIsolation::setup

(

const edm::ParameterSet &

conf

)

Definition at line 38 of file PFBlockBasedIsolation.cc.

References coneSize_, and edm::ParameterSet::getParameter().

Referenced by ParticleBasedIsoProducer::beginRun().

                                                                 {

  coneSize_             = conf.getParameter<double>("coneSize");  

}

Member Data Documentation

double PFBlockBasedIsolation::coneSize_

private

Definition at line 68 of file PFBlockBasedIsolation.h.

Referenced by calculate(), and setup().