PFIsolationEstimator Class Reference

#include <PFIsolationEstimator.h>

Public Types
enum	VetoType { kElectron = -1, kPhoton = 1 }

Public Member Functions
VertexRef	chargedHadronVertex (edm::Handle< reco::VertexCollection > verticies, const reco::PFCandidate &pfcand)
float	fGetIsolation (const reco::PFCandidate *pfCandidate, const reco::PFCandidateCollection *pfParticlesColl, reco::VertexRef vtx, edm::Handle< reco::VertexCollection > vertices)
float	fGetIsolation (const reco::Photon *photon, const reco::PFCandidateCollection *pfParticlesColl, reco::VertexRef vtx, edm::Handle< reco::VertexCollection > vertices)
float	fGetIsolation (const reco::GsfElectron *electron, const reco::PFCandidateCollection *pfParticlesColl, const reco::VertexRef vtx, edm::Handle< reco::VertexCollection > vertices)
vector< float >	fGetIsolationInRings (const reco::PFCandidate *pfCandidate, const reco::PFCandidateCollection *pfParticlesColl, reco::VertexRef vtx, edm::Handle< reco::VertexCollection > vertices)
vector< float >	fGetIsolationInRings (const reco::Photon *photon, const reco::PFCandidateCollection *pfParticlesColl, reco::VertexRef vtx, edm::Handle< reco::VertexCollection > vertices)
vector< float >	fGetIsolationInRings (const reco::GsfElectron *electron, const reco::PFCandidateCollection *pfParticlesColl, reco::VertexRef vtx, edm::Handle< reco::VertexCollection > vertices)
float	getIsolationCharged ()
float	getIsolationChargedAll ()
vector< float >	getIsolationInRingsCharged ()
vector< float >	getIsolationInRingsChargedAll ()
vector< float >	getIsolationInRingsNeutral ()
vector< float >	getIsolationInRingsPhoton ()
float	getIsolationNeutral ()
float	getIsolationPhoton ()
int	getNumbersOfRings ()
float	getRingSize ()
void	initializeElectronIsolation (Bool_t bApplyVeto)
void	initializeElectronIsolationInRings (Bool_t bApplyVeto, int iNumberOfRings, float fRingSize)
void	initializePhotonIsolation (Bool_t bApplyVeto)
void	initializePhotonIsolationInRings (Bool_t bApplyVeto, int iNumberOfRings, float fRingSize)
void	initializeRings (int iNumberOfRings, float fRingSize)
float	isChargedParticleVetoed (const reco::PFCandidate *pfIsoCand, edm::Handle< reco::VertexCollection > vertices)
float	isChargedParticleVetoed (const reco::PFCandidate *pfIsoCand, reco::VertexRef vtx, edm::Handle< reco::VertexCollection > vertices)
Bool_t	isInitialized () const
float	isNeutralParticleVetoed (const reco::PFCandidate *pfIsoCand)
float	isPhotonParticleVetoed (const reco::PFCandidate *pfIsoCand)
int	matchPFObject (const reco::Photon *photon, const reco::PFCandidateCollection *pfParticlesColl)
int	matchPFObject (const reco::GsfElectron *photon, const reco::PFCandidateCollection *pfParticlesColl)
	PFIsolationEstimator ()
void	setApplyDzDxyVeto (Bool_t bValue=kTRUE)
void	setApplyMissHitPhVeto (Bool_t bValue=kFALSE)
void	setApplyPFPUVeto (Bool_t bValue=kFALSE)
void	setApplyVeto (Bool_t bValue=kTRUE)
void	setConeSize (float fValue=0.4)
void	setDeltaRVetoBarrel (Bool_t bValue=kTRUE)
void	setDeltaRVetoBarrelCharged (float fValue=-1.0)
void	setDeltaRVetoBarrelNeutrals (float fValue=-1.0)
void	setDeltaRVetoBarrelPhotons (float fValue=-1.0)
void	setDeltaRVetoEndcap (Bool_t bValue=kTRUE)
void	setDeltaRVetoEndcapCharged (float fValue=-1.0)
void	setDeltaRVetoEndcapNeutrals (float fValue=-1.0)
void	setDeltaRVetoEndcapPhotons (float fValue=-1.0)
void	setNumberOfCrystalEndcapPhotons (float fValue=-1)
void	setNumbersOfRings (int iValue=1)
void	setParticleType (int iValue)
void	setRectangleDeltaEtaVetoBarrelCharged (float fValue=-1.0)
void	setRectangleDeltaEtaVetoBarrelNeutrals (float fValue=-1.0)
void	setRectangleDeltaEtaVetoBarrelPhotons (float fValue=-1.0)
void	setRectangleDeltaEtaVetoEndcapCharged (float fValue=-1.0)
void	setRectangleDeltaEtaVetoEndcapNeutrals (float fValue=-1.0)
void	setRectangleDeltaEtaVetoEndcapPhotons (float fValue=-1.0)
void	setRectangleDeltaPhiVetoBarrelCharged (float fValue=-1.0)
void	setRectangleDeltaPhiVetoBarrelNeutrals (float fValue=-1.0)
void	setRectangleDeltaPhiVetoBarrelPhotons (float fValue=-1.0)
void	setRectangleDeltaPhiVetoEndcapCharged (float fValue=-1.0)
void	setRectangleDeltaPhiVetoEndcapNeutrals (float fValue=-1.0)
void	setRectangleDeltaPhiVetoEndcapPhotons (float fValue=-1.0)
void	setRectangleVetoBarrel (Bool_t bValue=kTRUE)
void	setRectangleVetoEndcap (Bool_t bValue=kTRUE)
void	setRingSize (float fValue=0.4)
void	setUseCrystalSize (Bool_t bValue=kFALSE)
	~PFIsolationEstimator ()

Private Member Functions
void	initialize (Bool_t bApplyVeto, int iParticleType)

Private Attributes
Bool_t	bApplyDzDxyVeto
Bool_t	bApplyMissHitPhVeto
Bool_t	bApplyPFPUVeto
Bool_t	bApplyVeto
Bool_t	bDeltaRVetoBarrel
Bool_t	bDeltaRVetoEndcap
Bool_t	bRectangleVetoBarrel
Bool_t	bRectangleVetoEndcap
Bool_t	bUseCrystalSize
Bool_t	checkClosestZVertex
float	fConeSize
float	fDeltaEta
float	fDeltaPhi
float	fDeltaR
float	fDeltaRVetoBarrelCharged
float	fDeltaRVetoBarrelNeutrals
float	fDeltaRVetoBarrelPhotons
float	fDeltaRVetoEndcapCharged
float	fDeltaRVetoEndcapNeutrals
float	fDeltaRVetoEndcapPhotons
float	fEta
float	fEtaSC
Bool_t	fisInitialized
float	fIsolation
float	fIsolationCharged
float	fIsolationChargedAll
vector< float >	fIsolationInRings
vector< float >	fIsolationInRingsCharged
vector< float >	fIsolationInRingsChargedAll
vector< float >	fIsolationInRingsNeutral
vector< float >	fIsolationInRingsPhoton
float	fIsolationNeutral
float	fIsolationPhoton
float	fNumberOfCrystalEndcapPhotons
float	fPhi
float	fPhiSC
float	fPt
float	fRectangleDeltaEtaVetoBarrelCharged
float	fRectangleDeltaEtaVetoBarrelNeutrals
float	fRectangleDeltaEtaVetoBarrelPhotons
float	fRectangleDeltaEtaVetoEndcapCharged
float	fRectangleDeltaEtaVetoEndcapNeutrals
float	fRectangleDeltaEtaVetoEndcapPhotons
float	fRectangleDeltaPhiVetoBarrelCharged
float	fRectangleDeltaPhiVetoBarrelNeutrals
float	fRectangleDeltaPhiVetoBarrelPhotons
float	fRectangleDeltaPhiVetoEndcapCharged
float	fRectangleDeltaPhiVetoEndcapNeutrals
float	fRectangleDeltaPhiVetoEndcapPhotons
float	fRingSize
float	fVx
float	fVy
float	fVz
int	iMissHits
int	iNumberOfRings
int	iParticleType
bool	pivotInBarrel
SuperClusterRef	refSC
math::XYZVector	vtxWRTCandidate

Detailed Description

Definition at line 58 of file PFIsolationEstimator.h.

Member Enumeration Documentation

enum PFIsolationEstimator::VetoType

Enumerator
kElectron
kPhoton

Definition at line 63 of file PFIsolationEstimator.h.

                {
    kElectron = -1,      // MVA for non-triggering electrons          
    kPhoton  =  1            // MVA for triggering electrons
  };

Constructor & Destructor Documentation

PFIsolationEstimator::PFIsolationEstimator

(

)

Definition at line 29 of file PFIsolationEstimator.cc.

                                           :
fisInitialized(kFALSE)
{
  // Constructor.
}

PFIsolationEstimator::~PFIsolationEstimator

(

)

Definition at line 38 of file PFIsolationEstimator.cc.

{

}

Member Function Documentation

VertexRef PFIsolationEstimator::chargedHadronVertex	(	edm::Handle< reco::VertexCollection >	verticies,
		const reco::PFCandidate &	pfcand
	)

Definition at line 688 of file PFIsolationEstimator.cc.

References checkClosestZVertex, cmsHarvester::index, edm::Handle< T >::product(), reco::PFCandidate::trackRef(), reco::Vertex::tracks_begin(), reco::Vertex::tracks_end(), reco::Vertex::trackWeight(), reco::PFCandidate::vertex(), HLT_25ns14e33_v1_cff::vertices, and w.

Referenced by isChargedParticleVetoed().

                                                                                                                                     {

  //code copied from Florian's PFNoPU class
    
  reco::TrackBaseRef trackBaseRef( pfcand.trackRef() );

  size_t  iVertex = 0;
  unsigned index=0;
  unsigned nFoundVertex = 0;

  float bestweight=0;
  
  const reco::VertexCollection& vertices = *(verticesColl.product());

  for( reco::VertexCollection::const_iterator iv=vertices.begin(); iv!=vertices.end(); ++iv, ++index) {
    
    const reco::Vertex& vtx = *iv;
    
    // loop on tracks in vertices
    for(reco::Vertex::trackRef_iterator iTrack=vtx.tracks_begin();iTrack!=vtx.tracks_end(); ++iTrack) {

      const reco::TrackBaseRef& baseRef = *iTrack;

      // one of the tracks in the vertex is the same as 
      // the track considered in the function
      if(baseRef == trackBaseRef ) {
        float w = vtx.trackWeight(baseRef);
        //select the vertex for which the track has the highest weight
        if (w > bestweight){
          bestweight=w;
          iVertex=index;
          nFoundVertex++;
        }
      }
    }
    
  }
 
 
  
  if (nFoundVertex>0){
    if (nFoundVertex!=1)
      edm::LogWarning("TrackOnTwoVertex")<<"a track is shared by at least two verteces. Used to be an assert";
    return  VertexRef( verticesColl, iVertex);
  }
  // no vertex found with this track. 

  // optional: as a secondary solution, associate the closest vertex in z
  if ( checkClosestZVertex ) {

    double dzmin = 10000.;
    double ztrack = pfcand.vertex().z();
    bool foundVertex = false;
    index = 0;
    for( reco::VertexCollection::const_iterator  iv=vertices.begin(); iv!=vertices.end(); ++iv, ++index) {

      double dz = fabs(ztrack - iv->z());
      if(dz<dzmin) {
        dzmin = dz;
        iVertex = index;
        foundVertex = true;
      }
    }

    if( foundVertex ) 
      return  VertexRef( verticesColl, iVertex);  
  
  }
   
  return  VertexRef( );
}

float PFIsolationEstimator::fGetIsolation	(	const reco::PFCandidate *	pfCandidate,
		const reco::PFCandidateCollection *	pfParticlesColl,
		reco::VertexRef	vtx,
		edm::Handle< reco::VertexCollection >	vertices
	)

Definition at line 205 of file PFIsolationEstimator.cc.

References fGetIsolationInRings(), fIsolation, fIsolationInRings, and refSC.

Referenced by AdHocNTupler::fill().

                                                                                                                                                                                             {
 
  fGetIsolationInRings( pfCandidate, pfParticlesColl, vtx, vertices);
  refSC = SuperClusterRef();
  fIsolation = fIsolationInRings[0];
  
  return fIsolation;
}

float PFIsolationEstimator::fGetIsolation	(	const reco::Photon *	photon,
		const reco::PFCandidateCollection *	pfParticlesColl,
		reco::VertexRef	vtx,
		edm::Handle< reco::VertexCollection >	vertices
	)

Definition at line 282 of file PFIsolationEstimator.cc.

References fGetIsolationInRings(), fIsolation, and fIsolationInRings.

                                                                                                                                                                                   {
 
  fGetIsolationInRings( photon, pfParticlesColl, vtx, vertices);
  fIsolation = fIsolationInRings[0];
  
  return fIsolation;
}

float PFIsolationEstimator::fGetIsolation	(	const reco::GsfElectron *	electron,
		const reco::PFCandidateCollection *	pfParticlesColl,
		const reco::VertexRef	vtx,
		edm::Handle< reco::VertexCollection >	vertices
	)

Definition at line 387 of file PFIsolationEstimator.cc.

References fGetIsolationInRings(), fIsolation, and fIsolationInRings.

                                                                                                                                                                                          {
 
  fGetIsolationInRings( electron, pfParticlesColl, vtx, vertices);
  fIsolation = fIsolationInRings[0];
  
  return fIsolation;
}

vector< float > PFIsolationEstimator::fGetIsolationInRings	(	const reco::PFCandidate *	pfCandidate,
		const reco::PFCandidateCollection *	pfParticlesColl,
		reco::VertexRef	vtx,
		edm::Handle< reco::VertexCollection >	vertices
	)

Definition at line 216 of file PFIsolationEstimator.cc.

References funct::abs(), reco::LeafCandidate::eta(), fDeltaR, fEta, fIsolationInRings, fIsolationInRingsCharged, fIsolationInRingsChargedAll, fIsolationInRingsNeutral, fIsolationInRingsPhoton, fPhi, fPt, fRingSize, fVx, fVy, fVz, iNumberOfRings, isChargedParticleVetoed(), isNeutralParticleVetoed(), isPhotonParticleVetoed(), reco::LeafCandidate::pdgId(), reco::LeafCandidate::phi(), pivotInBarrel, reco::PFCandidate::positionAtECALEntrance(), reco::LeafCandidate::pt(), reco::PFCandidate::vx(), reco::PFCandidate::vy(), and reco::PFCandidate::vz().

Referenced by fGetIsolation().

                                                                                                                                                                                                              {

  int isoBin;

  
  for(isoBin =0;isoBin<iNumberOfRings;isoBin++){
    fIsolationInRings[isoBin]=0.;
    fIsolationInRingsPhoton[isoBin]=0.;
    fIsolationInRingsNeutral[isoBin]=0.;
    fIsolationInRingsCharged[isoBin]=0.;
    fIsolationInRingsChargedAll[isoBin]=0.;
  }
  
 

  fEta =  pfCandidate->eta();
  fPhi =  pfCandidate->phi();
  fPt =  pfCandidate->pt();
  fVx =  pfCandidate->vx();
  fVy =  pfCandidate->vy();
  fVz =  pfCandidate->vz();

  pivotInBarrel = fabs(pfCandidate->positionAtECALEntrance().eta())<1.479;

  for(unsigned iPF=0; iPF<pfParticlesColl->size(); iPF++) {

    const reco::PFCandidate& pfParticle= (*pfParticlesColl)[iPF]; 

    if(&pfParticle==(pfCandidate))
      continue;

    if(pfParticle.pdgId()==22){
      
      if(isPhotonParticleVetoed( &pfParticle)>=0.){
    isoBin = (int)(fDeltaR/fRingSize);
    fIsolationInRingsPhoton[isoBin]  = fIsolationInRingsPhoton[isoBin] + pfParticle.pt();
      }
      
    }else if(abs(pfParticle.pdgId())==130){
        
      if(isNeutralParticleVetoed(  &pfParticle)>=0.){
        isoBin = (int)(fDeltaR/fRingSize);
    fIsolationInRingsNeutral[isoBin]  = fIsolationInRingsNeutral[isoBin] + pfParticle.pt();
      }
    

      //}else if(abs(pfParticle.pdgId()) == 11 ||abs(pfParticle.pdgId()) == 13 || abs(pfParticle.pdgId()) == 211){
    }else if(abs(pfParticle.pdgId()) == 211){
      if(isChargedParticleVetoed( &pfParticle, vtx, vertices)>=0.){
    isoBin = (int)(fDeltaR/fRingSize);
    fIsolationInRingsCharged[isoBin]  = fIsolationInRingsCharged[isoBin] + pfParticle.pt();
      }

    }
  }

 
  for(int isoBin =0;isoBin<iNumberOfRings;isoBin++){
    fIsolationInRings[isoBin]= fIsolationInRingsPhoton[isoBin]+ fIsolationInRingsNeutral[isoBin] +  fIsolationInRingsCharged[isoBin];
  }

  return fIsolationInRings;
}

vector< float > PFIsolationEstimator::fGetIsolationInRings	(	const reco::Photon *	photon,
		const reco::PFCandidateCollection *	pfParticlesColl,
		reco::VertexRef	vtx,
		edm::Handle< reco::VertexCollection >	vertices
	)

Definition at line 292 of file PFIsolationEstimator.cc.

References funct::abs(), fDeltaR, fEta, fIsolationInRings, fIsolationInRingsCharged, fIsolationInRingsChargedAll, fIsolationInRingsNeutral, fIsolationInRingsPhoton, fPhi, fRingSize, fVx, fVy, fVz, iMissHits, iNumberOfRings, isChargedParticleVetoed(), isNeutralParticleVetoed(), edm::Ref< C, T, F >::isNonnull(), isPhotonParticleVetoed(), reco::LeafCandidate::pdgId(), pivotInBarrel, reco::LeafCandidate::pt(), refSC, reco::Photon::superCluster(), reco::PFCandidate::superClusterRef(), reco::PFCandidate::vx(), reco::PFCandidate::vy(), and reco::PFCandidate::vz().

                                                                                                                                                                                                    {

  int isoBin;
  
  for(isoBin =0;isoBin<iNumberOfRings;isoBin++){
    fIsolationInRings[isoBin]=0.;
    fIsolationInRingsPhoton[isoBin]=0.;
    fIsolationInRingsNeutral[isoBin]=0.;
    fIsolationInRingsCharged[isoBin]=0.;
    fIsolationInRingsChargedAll[isoBin]=0.;
  }
  
  iMissHits = 0;

  refSC = photon->superCluster();
  pivotInBarrel = fabs((refSC->position().eta()))<1.479;

  for(unsigned iPF=0; iPF<pfParticlesColl->size(); iPF++) {

    const reco::PFCandidate& pfParticle= (*pfParticlesColl)[iPF]; 

    if (pfParticle.superClusterRef().isNonnull() && 
    photon->superCluster().isNonnull() && 
    pfParticle.superClusterRef() == photon->superCluster())
      continue;

    if(pfParticle.pdgId()==22){
    
      // Set the vertex of reco::Photon to the first PV
      math::XYZVector direction = math::XYZVector(photon->superCluster()->x() - pfParticle.vx(), 
                                  photon->superCluster()->y() - pfParticle.vy(), 
                              photon->superCluster()->z() - pfParticle.vz());

      fEta = direction.Eta();
      fPhi = direction.Phi();
      fVx  = pfParticle.vx();
      fVy  = pfParticle.vy();
      fVz  = pfParticle.vz();

      if(isPhotonParticleVetoed(&pfParticle)>=0.){
    isoBin = (int)(fDeltaR/fRingSize);
    fIsolationInRingsPhoton[isoBin]  = fIsolationInRingsPhoton[isoBin] + pfParticle.pt();
      }
      
    }else if(abs(pfParticle.pdgId())==130){
       
       // Set the vertex of reco::Photon to the first PV
      math::XYZVector direction = math::XYZVector(photon->superCluster()->x() - pfParticle.vx(), 
                                                  photon->superCluster()->y() - pfParticle.vy(),
                                                  photon->superCluster()->z() - pfParticle.vz());

      fEta = direction.Eta();
      fPhi = direction.Phi();
      fVx  = pfParticle.vx();
      fVy  = pfParticle.vy();
      fVz  = pfParticle.vz();
 
      if(isNeutralParticleVetoed( &pfParticle)>=0.){
        isoBin = (int)(fDeltaR/fRingSize);
    fIsolationInRingsNeutral[isoBin]  = fIsolationInRingsNeutral[isoBin] + pfParticle.pt();
      }

      //}else if(abs(pfParticle.pdgId()) == 11 ||abs(pfParticle.pdgId()) == 13 || abs(pfParticle.pdgId()) == 211){
    }else if(abs(pfParticle.pdgId()) == 211){
 
      // Set the vertex of reco::Photon to the first PV
      math::XYZVector direction = math::XYZVector(photon->superCluster()->x() - (*vtx).x(),
                                                  photon->superCluster()->y() - (*vtx).y(),
                                                  photon->superCluster()->z() - (*vtx).z());

      fEta = direction.Eta();
      fPhi = direction.Phi();
      fVx  = (*vtx).x();
      fVy  = (*vtx).y();
      fVz  = (*vtx).z();

      if(isChargedParticleVetoed(  &pfParticle, vtx, vertices)>=0.){
    isoBin = (int)(fDeltaR/fRingSize);
    fIsolationInRingsCharged[isoBin]  = fIsolationInRingsCharged[isoBin] + pfParticle.pt();
      }

    }
  }

 
  for(int isoBin =0;isoBin<iNumberOfRings;isoBin++){
    fIsolationInRings[isoBin]= fIsolationInRingsPhoton[isoBin]+ fIsolationInRingsNeutral[isoBin] +  fIsolationInRingsCharged[isoBin];
    }
  
  return fIsolationInRings;
}

vector< float > PFIsolationEstimator::fGetIsolationInRings	(	const reco::GsfElectron *	electron,
		const reco::PFCandidateCollection *	pfParticlesColl,
		reco::VertexRef	vtx,
		edm::Handle< reco::VertexCollection >	vertices
	)

Definition at line 397 of file PFIsolationEstimator.cc.

References funct::abs(), reco::LeafCandidate::eta(), fDeltaR, fEta, fIsolationInRings, fIsolationInRingsCharged, fIsolationInRingsChargedAll, fIsolationInRingsNeutral, fIsolationInRingsPhoton, fPhi, fPt, fRingSize, fVx, fVy, fVz, reco::GsfElectron::gsfTrack(), iMissHits, iNumberOfRings, isChargedParticleVetoed(), isNeutralParticleVetoed(), isPhotonParticleVetoed(), reco::LeafCandidate::pdgId(), reco::LeafCandidate::phi(), pivotInBarrel, reco::LeafCandidate::pt(), refSC, reco::GsfElectron::superCluster(), reco::LeafCandidate::vx(), reco::LeafCandidate::vy(), and reco::LeafCandidate::vz().

                                                                                                                                                                                                           {

  int isoBin;
  
  for(isoBin =0;isoBin<iNumberOfRings;isoBin++){
    fIsolationInRings[isoBin]=0.;
    fIsolationInRingsPhoton[isoBin]=0.;
    fIsolationInRingsNeutral[isoBin]=0.;
    fIsolationInRingsCharged[isoBin]=0.;
    fIsolationInRingsChargedAll[isoBin]=0.;
  }
  
  //  int iMatch =  matchPFObject(electron,pfParticlesColl);


  fEta =  electron->eta();
  fPhi =  electron->phi();
  fPt =  electron->pt();
  fVx =  electron->vx();
  fVy =  electron->vy();
  fVz =  electron->vz();
  iMissHits = electron->gsfTrack()->hitPattern().numberOfHits(HitPattern::MISSING_INNER_HITS);
  
  //  if(electron->ecalDrivenSeed())
  refSC = electron->superCluster();
  pivotInBarrel = fabs((refSC->position().eta()))<1.479;

  for(unsigned iPF=0; iPF<pfParticlesColl->size(); iPF++) {

    const reco::PFCandidate& pfParticle= (*pfParticlesColl)[iPF]; 
 
 
    if(pfParticle.pdgId()==22){
    
      if(isPhotonParticleVetoed(&pfParticle)>=0.){
    isoBin = (int)(fDeltaR/fRingSize);
    fIsolationInRingsPhoton[isoBin]  = fIsolationInRingsPhoton[isoBin] + pfParticle.pt();

      }
      
    }else if(abs(pfParticle.pdgId())==130){
        
      if(isNeutralParticleVetoed( &pfParticle)>=0.){
        isoBin = (int)(fDeltaR/fRingSize);
    fIsolationInRingsNeutral[isoBin]  = fIsolationInRingsNeutral[isoBin] + pfParticle.pt();
      }

      //}else if(abs(pfParticle.pdgId()) == 11 ||abs(pfParticle.pdgId()) == 13 || abs(pfParticle.pdgId()) == 211){
    }else if(abs(pfParticle.pdgId()) == 211){
      if(isChargedParticleVetoed(  &pfParticle, vtx, vertices)>=0.){
    isoBin = (int)(fDeltaR/fRingSize);
    
    fIsolationInRingsCharged[isoBin]  = fIsolationInRingsCharged[isoBin] + pfParticle.pt();
      }

    }
  }

 
  for(int isoBin =0;isoBin<iNumberOfRings;isoBin++){
    fIsolationInRings[isoBin]= fIsolationInRingsPhoton[isoBin]+ fIsolationInRingsNeutral[isoBin] +  fIsolationInRingsCharged[isoBin];
    }
  
  return fIsolationInRings;
}

float PFIsolationEstimator::getIsolationCharged ( )

inline

Definition at line 138 of file PFIsolationEstimator.h.

Referenced by AdHocNTupler::fill().

{  fIsolationCharged =   fIsolationInRingsCharged[0]; return fIsolationCharged; };

float PFIsolationEstimator::getIsolationChargedAll ( )

inline

Definition at line 139 of file PFIsolationEstimator.h.

{ return fIsolationChargedAll; };

vector<float > PFIsolationEstimator::getIsolationInRingsCharged ( )

inline

Definition at line 143 of file PFIsolationEstimator.h.

{ return fIsolationInRingsCharged; };

vector<float > PFIsolationEstimator::getIsolationInRingsChargedAll ( )

inline

Definition at line 144 of file PFIsolationEstimator.h.

{ return fIsolationInRingsChargedAll; };

vector<float > PFIsolationEstimator::getIsolationInRingsNeutral ( )

inline

Definition at line 142 of file PFIsolationEstimator.h.

{ return fIsolationInRingsNeutral; };

vector<float > PFIsolationEstimator::getIsolationInRingsPhoton ( )

inline

Definition at line 141 of file PFIsolationEstimator.h.

{ return fIsolationInRingsPhoton; };

float PFIsolationEstimator::getIsolationNeutral ( )

inline

Definition at line 137 of file PFIsolationEstimator.h.

Referenced by AdHocNTupler::fill().

{ fIsolationNeutral =   fIsolationInRingsNeutral[0]; return fIsolationNeutral; };

float PFIsolationEstimator::getIsolationPhoton ( )

inline

Definition at line 136 of file PFIsolationEstimator.h.

Referenced by AdHocNTupler::fill().

{   fIsolationPhoton =  fIsolationInRingsPhoton[0]; return fIsolationPhoton; };

int PFIsolationEstimator::getNumbersOfRings ( )

inline

Definition at line 150 of file PFIsolationEstimator.h.

{return iNumberOfRings;};

float PFIsolationEstimator::getRingSize ( )

inline

Definition at line 151 of file PFIsolationEstimator.h.

{return fRingSize; };

void PFIsolationEstimator::initialize ( Bool_t  bApplyVeto, int  iParticleType  )

private

Definition at line 44 of file PFIsolationEstimator.cc.

References checkClosestZVertex, kElectron, setApplyDzDxyVeto(), setApplyMissHitPhVeto(), setApplyPFPUVeto(), setApplyVeto(), setConeSize(), setDeltaRVetoBarrel(), setDeltaRVetoBarrelCharged(), setDeltaRVetoBarrelNeutrals(), setDeltaRVetoBarrelPhotons(), setDeltaRVetoEndcap(), setDeltaRVetoEndcapCharged(), setDeltaRVetoEndcapNeutrals(), setDeltaRVetoEndcapPhotons(), setNumberOfCrystalEndcapPhotons(), setParticleType(), setRectangleDeltaEtaVetoBarrelCharged(), setRectangleDeltaEtaVetoBarrelNeutrals(), setRectangleDeltaEtaVetoBarrelPhotons(), setRectangleDeltaEtaVetoEndcapCharged(), setRectangleDeltaEtaVetoEndcapNeutrals(), setRectangleDeltaEtaVetoEndcapPhotons(), setRectangleDeltaPhiVetoBarrelCharged(), setRectangleDeltaPhiVetoBarrelNeutrals(), setRectangleDeltaPhiVetoBarrelPhotons(), setRectangleDeltaPhiVetoEndcapCharged(), setRectangleDeltaPhiVetoEndcapNeutrals(), setRectangleDeltaPhiVetoEndcapPhotons(), setRectangleVetoBarrel(), setRectangleVetoEndcap(), and setUseCrystalSize().

Referenced by initializeElectronIsolation(), initializeElectronIsolationInRings(), initializePhotonIsolation(), and initializePhotonIsolationInRings().

                                                                             {

  setParticleType(iParticleType);

  //By default check for an option vertex association
  checkClosestZVertex = kTRUE;
  
  //Apply vetoes
  setApplyVeto(bApplyVeto);
  
  setDeltaRVetoBarrelPhotons();
  setDeltaRVetoBarrelNeutrals();
  setDeltaRVetoBarrelCharged();
  setDeltaRVetoEndcapPhotons();
  setDeltaRVetoEndcapNeutrals();
  setDeltaRVetoEndcapCharged();

  
  setRectangleDeltaPhiVetoBarrelPhotons();
  setRectangleDeltaPhiVetoBarrelNeutrals();
  setRectangleDeltaPhiVetoBarrelCharged();
  setRectangleDeltaPhiVetoEndcapPhotons();
  setRectangleDeltaPhiVetoEndcapNeutrals();
  setRectangleDeltaPhiVetoEndcapCharged();
  

  setRectangleDeltaEtaVetoBarrelPhotons();
  setRectangleDeltaEtaVetoBarrelNeutrals();
  setRectangleDeltaEtaVetoBarrelCharged();
  setRectangleDeltaEtaVetoEndcapPhotons();
  setRectangleDeltaEtaVetoEndcapNeutrals();
  setRectangleDeltaEtaVetoEndcapCharged();


  if(bApplyVeto && iParticleType==kElectron){
    
    //Setup veto conditions for electrons
    setDeltaRVetoBarrel(kTRUE);
    setDeltaRVetoEndcap(kTRUE);
    setRectangleVetoBarrel(kFALSE);
    setRectangleVetoEndcap(kFALSE);
    setApplyDzDxyVeto(kFALSE);
    setApplyPFPUVeto(kTRUE);
    setApplyMissHitPhVeto(kTRUE); //NOTE: decided to go for this on the 26May 2012
    //Current recommended default value for the electrons
    setUseCrystalSize(kFALSE);

    // setDeltaRVetoBarrelPhotons(1E-5);   //NOTE: just to be in synch with the isoDep: fixed isoDep in 26May
    // setDeltaRVetoBarrelCharged(1E-5);    //NOTE: just to be in synch with the isoDep: fixed isoDep in 26May
    // setDeltaRVetoBarrelNeutrals(1E-5);   //NOTE: just to be in synch with the isoDep: fixed isoDep in 26May
    setDeltaRVetoEndcapPhotons(0.08);
    setDeltaRVetoEndcapCharged(0.015);
    // setDeltaRVetoEndcapNeutrals(1E-5);  //NOTE: just to be in synch with the isoDep: fixed isoDep in 26May

    setConeSize(0.4);

    
  }else{
    //Setup veto conditions for photons
    setApplyDzDxyVeto(kTRUE);
    setApplyPFPUVeto(kTRUE);
    setApplyMissHitPhVeto(kFALSE);
    setDeltaRVetoBarrel(kTRUE);
    setDeltaRVetoEndcap(kTRUE);
    setRectangleVetoBarrel(kTRUE);
    setRectangleVetoEndcap(kFALSE);
    setUseCrystalSize(kTRUE);
    setConeSize(0.3);

    setDeltaRVetoBarrelPhotons(-1);
    setDeltaRVetoBarrelNeutrals(-1);
    setDeltaRVetoBarrelCharged(0.02);
    setRectangleDeltaPhiVetoBarrelPhotons(1.);
    setRectangleDeltaPhiVetoBarrelNeutrals(-1);
    setRectangleDeltaPhiVetoBarrelCharged(-1);
    setRectangleDeltaEtaVetoBarrelPhotons(0.015);
    setRectangleDeltaEtaVetoBarrelNeutrals(-1);
    setRectangleDeltaEtaVetoBarrelCharged(-1);

    setDeltaRVetoEndcapPhotons(0.07);
    setDeltaRVetoEndcapNeutrals(-1);
    setDeltaRVetoEndcapCharged(0.02);
    setRectangleDeltaPhiVetoEndcapPhotons(-1);
    setRectangleDeltaPhiVetoEndcapNeutrals(-1);
    setRectangleDeltaPhiVetoEndcapCharged(-1);
    setRectangleDeltaEtaVetoEndcapPhotons(-1);
    setRectangleDeltaEtaVetoEndcapNeutrals(-1);
    setRectangleDeltaEtaVetoEndcapCharged(-1);
    setNumberOfCrystalEndcapPhotons(4.);
  }


}

void PFIsolationEstimator::initializeElectronIsolation

(

Bool_t

bApplyVeto

)

Definition at line 139 of file PFIsolationEstimator.cc.

References fConeSize, initialize(), initializeRings(), and kElectron.

                                                                         {
  initialize(bApplyVeto,kElectron);
  initializeRings(1, fConeSize);

//   std::cout << " ********* Init Entering in kElectron setup "
//      << " bApplyVeto " << bApplyVeto
//      << " bDeltaRVetoBarrel " << bDeltaRVetoBarrel
//      << " bDeltaRVetoEndcap " << bDeltaRVetoEndcap
//      << " cone size " << fConeSize 
//      << " fDeltaRVetoEndcapPhotons " << fDeltaRVetoEndcapPhotons
//      << " fDeltaRVetoEndcapNeutrals " << fDeltaRVetoEndcapNeutrals
//      << " fDeltaRVetoEndcapCharged " << fDeltaRVetoEndcapCharged << std::endl;
  
}

void PFIsolationEstimator::initializeElectronIsolationInRings	(	Bool_t	bApplyVeto,
		int	iNumberOfRings,
		float	fRingSize
	)

Definition at line 162 of file PFIsolationEstimator.cc.

References initialize(), initializeRings(), and kElectron.

                                                                                                                      {
  initialize(bApplyVeto,kElectron);
  initializeRings(iNumberOfRings, fRingSize);
}

void PFIsolationEstimator::initializePhotonIsolation

(

Bool_t

bApplyVeto

)

Definition at line 155 of file PFIsolationEstimator.cc.

References fConeSize, initialize(), initializeRings(), and kPhoton.

Referenced by AdHocNTupler::fill().

                                                                       {
  initialize(bApplyVeto,kPhoton);
  initializeRings(1, fConeSize);
}

void PFIsolationEstimator::initializePhotonIsolationInRings	(	Bool_t	bApplyVeto,
		int	iNumberOfRings,
		float	fRingSize
	)

Definition at line 168 of file PFIsolationEstimator.cc.

References initialize(), initializeRings(), and kPhoton.

                                                                                                                     {
  initialize(bApplyVeto,kPhoton);
  initializeRings(iNumberOfRings, fRingSize);
}

void PFIsolationEstimator::initializeRings	(	int	iNumberOfRings,
		float	fRingSize
	)

Definition at line 175 of file PFIsolationEstimator.cc.

References fConeSize, fIsolationInRings, fIsolationInRingsCharged, fIsolationInRingsChargedAll, fIsolationInRingsNeutral, fIsolationInRingsPhoton, iNumberOfRings, setNumbersOfRings(), and setRingSize().

Referenced by initializeElectronIsolation(), initializeElectronIsolationInRings(), initializePhotonIsolation(), and initializePhotonIsolationInRings().

                                                                             {
 
  setRingSize(fRingSize);
  setNumbersOfRings(iNumberOfRings);
 
  fIsolationInRings.clear();
  for(int isoBin =0;isoBin<iNumberOfRings;isoBin++){
    float fTemp = 0.0;
    fIsolationInRings.push_back(fTemp);
    
    float fTempPhoton = 0.0;
    fIsolationInRingsPhoton.push_back(fTempPhoton);

    float fTempNeutral = 0.0;
    fIsolationInRingsNeutral.push_back(fTempNeutral);

    float fTempCharged = 0.0;
    fIsolationInRingsCharged.push_back(fTempCharged);

    float fTempChargedAll = 0.0;
    fIsolationInRingsChargedAll.push_back(fTempChargedAll);

  }

  fConeSize = fRingSize * (float)iNumberOfRings;

}

float PFIsolationEstimator::isChargedParticleVetoed	(	const reco::PFCandidate *	pfIsoCand,
		edm::Handle< reco::VertexCollection >	vertices
	)

Definition at line 573 of file PFIsolationEstimator.cc.

Referenced by fGetIsolationInRings().

                                                                                                                                   {
  //need code to handle special conditions
  
  return -999;
}

float PFIsolationEstimator::isChargedParticleVetoed	(	const reco::PFCandidate *	pfIsoCand,
		reco::VertexRef	vtx,
		edm::Handle< reco::VertexCollection >	vertices
	)

Definition at line 580 of file PFIsolationEstimator.cc.

References funct::abs(), bApplyDzDxyVeto, bApplyPFPUVeto, bApplyVeto, bDeltaRVetoBarrel, bDeltaRVetoEndcap, bRectangleVetoBarrel, bRectangleVetoEndcap, chargedHadronVertex(), SiPixelRawToDigiRegional_cfi::deltaPhi, deltaR(), reco::LeafCandidate::eta(), fConeSize, fDeltaEta, fDeltaPhi, fDeltaR, fDeltaRVetoBarrelCharged, fDeltaRVetoEndcapCharged, fEta, fPhi, fRectangleDeltaEtaVetoBarrelCharged, fRectangleDeltaEtaVetoEndcapCharged, fRectangleDeltaPhiVetoBarrelCharged, fRectangleDeltaPhiVetoEndcapCharged, fVx, fVy, iParticleType, edm::Ref< C, T, F >::isNull(), kPhoton, reco::LeafCandidate::phi(), pivotInBarrel, reco::LeafCandidate::pt(), reco::LeafCandidate::px(), reco::LeafCandidate::py(), and reco::PFCandidate::trackRef().

                                                                                                                                                         {
  
  VertexRef vtx = chargedHadronVertex(vertices,  *pfIsoCand );
  if(vtx.isNull())
    return -999.;
  
//   float fVtxMainX = (*vtxMain).x();
//   float fVtxMainY = (*vtxMain).y();
  float fVtxMainZ = (*vtxMain).z();

  if(bApplyPFPUVeto) {
    if(vtx != vtxMain)
      return -999.;
  }
    

  if(bApplyDzDxyVeto) {
    if(iParticleType==kPhoton){
      
      float dz = fabs( pfIsoCand->trackRef()->dz( (*vtxMain).position() ) );
      if (dz > 0.2)
        return -999.;
    
      double dxy = pfIsoCand->trackRef()->dxy( (*vtxMain).position() );  
      if (fabs(dxy) > 0.1)
        return -999.;
      
      /*
      float dz = fabs(vtx->z() - fVtxMainZ);
      if (dz > 1.)
    return -999.;
      
      
      double dxy = ( -(vtx->x() - fVtxMainX)*pfIsoCand->py() + (vtx->y() - fVtxMainY)*pfIsoCand->px()) / pfIsoCand->pt();
      
      if(fabs(dxy) > 0.2)
    return -999.;
      */
    }else{
      
      
      float dz = fabs(vtx->z() - fVtxMainZ);
      if (dz > 1.)
    return -999.;
      
      double dxy = ( -(vtx->x() - fVx)*pfIsoCand->py() + (vtx->y() - fVy)*pfIsoCand->px()) / pfIsoCand->pt();
      if(fabs(dxy) > 0.1)
    return -999.;
    }
  }    

  fDeltaR = deltaR(pfIsoCand->eta(),pfIsoCand->phi(),fEta,fPhi); 

  if(fDeltaR > fConeSize)
    return -999.;

  fDeltaPhi = deltaPhi(fPhi,pfIsoCand->phi()); 
  fDeltaEta = fEta-pfIsoCand->eta(); 
  

//   std::cout << " charged hadron: DR " <<  fDeltaR 
//      << " pt " <<  pfIsoCand->pt() << " eta,phi " << pfIsoCand->eta() << ", " << pfIsoCand->phi()
//      << " fVtxMainZ " << (*vtxMain).z() << " cand z " << vtx->z() << std::endl;
  

  if(!bApplyVeto)
    return fDeltaR;  
  
  //NOTE: get the direction for the EB/EE transition region from the deposit just to be in synch with the isoDep
  //      this will be changed in the future  
  if(pivotInBarrel){
    if(!bDeltaRVetoBarrel&&!bRectangleVetoBarrel){
      return fDeltaR;
    }
    
    if(bDeltaRVetoBarrel){
    if(fDeltaR < fDeltaRVetoBarrelCharged)
      return -999.;
      }
      if(bRectangleVetoBarrel){
    if(abs(fDeltaEta) < fRectangleDeltaEtaVetoBarrelCharged && abs(fDeltaPhi) < fRectangleDeltaPhiVetoBarrelCharged){
        return -999.;
    }
      }
      
    }else{
     if(!bDeltaRVetoEndcap&&!bRectangleVetoEndcap){
       return fDeltaR;
     }
      if(bDeltaRVetoEndcap){
    if(fDeltaR < fDeltaRVetoEndcapCharged)
      return -999.;
      }
      if(bRectangleVetoEndcap){
    if(abs(fDeltaEta) < fRectangleDeltaEtaVetoEndcapCharged && abs(fDeltaPhi) < fRectangleDeltaPhiVetoEndcapCharged){
      return -999.;
    }
      }
  }
           
  


  return fDeltaR;
}

Bool_t PFIsolationEstimator::isInitialized ( ) const

inline

Definition at line 74 of file PFIsolationEstimator.h.

{ return fisInitialized; }

float PFIsolationEstimator::isNeutralParticleVetoed

(

const reco::PFCandidate *

pfIsoCand

)

Definition at line 523 of file PFIsolationEstimator.cc.

References funct::abs(), bApplyVeto, bDeltaRVetoBarrel, bDeltaRVetoEndcap, bRectangleVetoBarrel, bRectangleVetoEndcap, SiPixelRawToDigiRegional_cfi::deltaPhi, deltaR(), reco::LeafCandidate::eta(), fConeSize, fDeltaEta, fDeltaPhi, fDeltaR, fDeltaRVetoBarrelNeutrals, fDeltaRVetoEndcapNeutrals, fEta, fPhi, fRectangleDeltaEtaVetoBarrelNeutrals, fRectangleDeltaEtaVetoEndcapNeutrals, fRectangleDeltaPhiVetoBarrelNeutrals, fRectangleDeltaPhiVetoEndcapNeutrals, reco::LeafCandidate::phi(), and pivotInBarrel.

Referenced by fGetIsolationInRings().

                                                                                      {

  fDeltaR = deltaR(fEta,fPhi,pfIsoCand->eta(),pfIsoCand->phi()); 
  
  if(fDeltaR > fConeSize)
    return -999;
  
  fDeltaPhi = deltaPhi(fPhi,pfIsoCand->phi()); 
  fDeltaEta = fEta-pfIsoCand->eta(); 

  if(!bApplyVeto)
    return fDeltaR;

  //NOTE: get the direction for the EB/EE transition region from the deposit just to be in synch with the isoDep
  //      this will be changed in the future
  if(pivotInBarrel){
    if(!bDeltaRVetoBarrel&&!bRectangleVetoBarrel){
      return fDeltaR;
    }
    
    if(bDeltaRVetoBarrel){
    if(fDeltaR < fDeltaRVetoBarrelNeutrals)
      return -999.;
      }
      if(bRectangleVetoBarrel){
    if(abs(fDeltaEta) < fRectangleDeltaEtaVetoBarrelNeutrals && abs(fDeltaPhi) < fRectangleDeltaPhiVetoBarrelNeutrals){
        return -999.;
    }
      }
      
    }else{
     if(!bDeltaRVetoEndcap&&!bRectangleVetoEndcap){
       return fDeltaR;
     }
      if(bDeltaRVetoEndcap){
    if(fDeltaR < fDeltaRVetoEndcapNeutrals)
      return -999.;
      }
      if(bRectangleVetoEndcap){
    if(abs(fDeltaEta) < fRectangleDeltaEtaVetoEndcapNeutrals && abs(fDeltaPhi) < fRectangleDeltaPhiVetoEndcapNeutrals){
      return -999.;
    }
      }
  }

  return fDeltaR;
}

float PFIsolationEstimator::isPhotonParticleVetoed

(

const reco::PFCandidate *

pfIsoCand

)

Definition at line 465 of file PFIsolationEstimator.cc.

References funct::abs(), bApplyMissHitPhVeto, bApplyVeto, bDeltaRVetoBarrel, bDeltaRVetoEndcap, bRectangleVetoBarrel, bRectangleVetoEndcap, bUseCrystalSize, SiPixelRawToDigiRegional_cfi::deltaPhi, deltaR(), reco::LeafCandidate::eta(), fConeSize, fDeltaEta, fDeltaPhi, fDeltaR, fDeltaRVetoBarrelPhotons, fDeltaRVetoEndcapPhotons, fEta, fNumberOfCrystalEndcapPhotons, fPhi, fRectangleDeltaEtaVetoBarrelPhotons, fRectangleDeltaEtaVetoEndcapPhotons, fRectangleDeltaPhiVetoBarrelPhotons, fRectangleDeltaPhiVetoEndcapPhotons, iMissHits, edm::Ref< C, T, F >::isNonnull(), reco::PFCandidate::mva_nothing_gamma(), reco::LeafCandidate::phi(), pivotInBarrel, refSC, and reco::PFCandidate::superClusterRef().

Referenced by fGetIsolationInRings().

                                                                                     {
  
  
  fDeltaR = deltaR(fEta,fPhi,pfIsoCand->eta(),pfIsoCand->phi()); 

  if(fDeltaR > fConeSize)
    return -999.;
  
  fDeltaPhi = deltaPhi(fPhi,pfIsoCand->phi()); 
  fDeltaEta = fEta-pfIsoCand->eta(); 

  if(!bApplyVeto)
    return fDeltaR;
 
  //NOTE: get the direction for the EB/EE transition region from the deposit just to be in synch with the isoDep
  //      this will be changed in the future
  
  if(bApplyMissHitPhVeto) {
    if(iMissHits > 0)
      if(pfIsoCand->mva_nothing_gamma() > 0.99) {
    if(pfIsoCand->superClusterRef().isNonnull() && refSC.isNonnull()) {
      if(pfIsoCand->superClusterRef() == refSC)
        return -999.;
    }
      }
  }

  if(pivotInBarrel){
    if(bDeltaRVetoBarrel){
      if(fDeltaR < fDeltaRVetoBarrelPhotons)
        return -999.;
    }
    
    if(bRectangleVetoBarrel){
      if(abs(fDeltaEta) < fRectangleDeltaEtaVetoBarrelPhotons && abs(fDeltaPhi) < fRectangleDeltaPhiVetoBarrelPhotons){
    return -999.;
      }
    }
  }else{
    if (bUseCrystalSize == true) {
      fDeltaRVetoEndcapPhotons = 0.00864*fabs(sinh(refSC->position().eta()))*fNumberOfCrystalEndcapPhotons;
    }

    if(bDeltaRVetoEndcap){
      if(fDeltaR < fDeltaRVetoEndcapPhotons)
    return -999.;
    }
    if(bRectangleVetoEndcap){
      if(abs(fDeltaEta) < fRectangleDeltaEtaVetoEndcapPhotons && abs(fDeltaPhi) < fRectangleDeltaPhiVetoEndcapPhotons){
     return -999.;
      }
    }
  }

  return fDeltaR;
}

int PFIsolationEstimator::matchPFObject	(	const reco::Photon *	photon,
		const reco::PFCandidateCollection *	pfParticlesColl
	)

Definition at line 762 of file PFIsolationEstimator.cc.

References Abs(), i, reco::LeafCandidate::pdgId(), reco::Photon::superCluster(), and reco::PFCandidate::superClusterRef().

                                                                                                             {
  
  Int_t iMatch = -1;

  int i=0;
  for(reco::PFCandidateCollection::const_iterator iPF=Candidates->begin();iPF !=Candidates->end();iPF++){
    const reco::PFCandidate& pfParticle = (*iPF);
    //    if((((pfParticle.pdgId()==22 && pfParticle.mva_nothing_gamma()>0.01) || TMath::Abs(pfParticle.pdgId())==11) )){
    if((((pfParticle.pdgId()==22 ) || TMath::Abs(pfParticle.pdgId())==11) )){
     
      if(pfParticle.superClusterRef()==photon->superCluster())
    iMatch= i;
     
    }
    
    i++;
  }
  
/*
  if(iMatch == -1){
    i=0;
    float fPt = -1;
    for(reco::PFCandidateCollection::const_iterator iPF=Candidates->begin();iPF !=Candidates->end();iPF++){
      const reco::PFCandidate& pfParticle = (*iPF);
      if((((pfParticle.pdgId()==22 ) || TMath::Abs(pfParticle.pdgId())==11) )){
    if(pfParticle.pt()>fPt){
      fDeltaR = deltaR(pfParticle.eta(),pfParticle.phi(),photon->eta(),photon->phi());
      if(fDeltaR<0.1){
        iMatch = i;
        fPt = pfParticle.pt();
      }
    }
      }
      i++;
    }
  }
*/

  return iMatch;

}

int PFIsolationEstimator::matchPFObject	(	const reco::GsfElectron *	photon,
		const reco::PFCandidateCollection *	pfParticlesColl
	)

Definition at line 808 of file PFIsolationEstimator.cc.

References Abs(), deltaR(), reco::LeafCandidate::eta(), fDeltaR, fPt, i, reco::LeafCandidate::pdgId(), reco::LeafCandidate::phi(), reco::LeafCandidate::pt(), reco::GsfElectron::superCluster(), and reco::PFCandidate::superClusterRef().

                                                                                                                    {
  
  Int_t iMatch = -1;

  int i=0;
  for(reco::PFCandidateCollection::const_iterator iPF=Candidates->begin();iPF !=Candidates->end();iPF++){
    const reco::PFCandidate& pfParticle = (*iPF);
    //    if((((pfParticle.pdgId()==22 && pfParticle.mva_nothing_gamma()>0.01) || TMath::Abs(pfParticle.pdgId())==11) )){
    if((((pfParticle.pdgId()==22 ) || TMath::Abs(pfParticle.pdgId())==11) )){
     
      if(pfParticle.superClusterRef()==electron->superCluster())
    iMatch= i;
     
    }
    
    i++;
  }
  
  if(iMatch == -1){
    i=0;
    float fPt = -1;
    for(reco::PFCandidateCollection::const_iterator iPF=Candidates->begin();iPF !=Candidates->end();iPF++){
      const reco::PFCandidate& pfParticle = (*iPF);
      if((((pfParticle.pdgId()==22 ) || TMath::Abs(pfParticle.pdgId())==11) )){
    if(pfParticle.pt()>fPt){
      fDeltaR = deltaR(pfParticle.eta(),pfParticle.phi(),electron->eta(),electron->phi());
      if(fDeltaR<0.1){
        iMatch = i;
        fPt = pfParticle.pt();
      }
    }
      }
      i++;
    }
  }
  
  return iMatch;

}

void PFIsolationEstimator::setApplyDzDxyVeto ( Bool_t  bValue = kTRUE )

inline

Definition at line 96 of file PFIsolationEstimator.h.

Referenced by initialize().

{  bApplyDzDxyVeto = bValue;};

void PFIsolationEstimator::setApplyMissHitPhVeto ( Bool_t  bValue = kFALSE )

inline

Definition at line 97 of file PFIsolationEstimator.h.

Referenced by initialize().

{  bApplyMissHitPhVeto = bValue;};

void PFIsolationEstimator::setApplyPFPUVeto ( Bool_t  bValue = kFALSE )

inline

Definition at line 95 of file PFIsolationEstimator.h.

Referenced by initialize().

{bApplyPFPUVeto = bValue;};

void PFIsolationEstimator::setApplyVeto ( Bool_t  bValue = kTRUE )

inline

Definition at line 94 of file PFIsolationEstimator.h.

Referenced by initialize().

{  bApplyVeto = bValue;};

void PFIsolationEstimator::setConeSize ( float  fValue = 0.4 )

inline

Definition at line 89 of file PFIsolationEstimator.h.

Referenced by AdHocNTupler::fill(), and initialize().

{ fConeSize = fValue;};

void PFIsolationEstimator::setDeltaRVetoBarrel ( Bool_t  bValue = kTRUE )

inline

Definition at line 98 of file PFIsolationEstimator.h.

Referenced by initialize().

{  bDeltaRVetoBarrel = bValue;};

void PFIsolationEstimator::setDeltaRVetoBarrelCharged ( float  fValue = -1.0 )

inline

Definition at line 108 of file PFIsolationEstimator.h.

Referenced by initialize().

{fDeltaRVetoBarrelCharged=fValue;};

void PFIsolationEstimator::setDeltaRVetoBarrelNeutrals ( float  fValue = -1.0 )

inline

Definition at line 107 of file PFIsolationEstimator.h.

Referenced by initialize().

{fDeltaRVetoBarrelNeutrals=fValue;};

void PFIsolationEstimator::setDeltaRVetoBarrelPhotons ( float  fValue = -1.0 )

inline

Definition at line 106 of file PFIsolationEstimator.h.

Referenced by initialize().

{fDeltaRVetoBarrelPhotons=fValue;};

void PFIsolationEstimator::setDeltaRVetoEndcap ( Bool_t  bValue = kTRUE )

inline

Definition at line 99 of file PFIsolationEstimator.h.

Referenced by initialize().

{  bDeltaRVetoEndcap = bValue;};

void PFIsolationEstimator::setDeltaRVetoEndcapCharged ( float  fValue = -1.0 )

inline

Definition at line 111 of file PFIsolationEstimator.h.

Referenced by initialize().

{fDeltaRVetoEndcapCharged=fValue;};

void PFIsolationEstimator::setDeltaRVetoEndcapNeutrals ( float  fValue = -1.0 )

inline

Definition at line 110 of file PFIsolationEstimator.h.

Referenced by initialize().

{fDeltaRVetoEndcapNeutrals=fValue;};

void PFIsolationEstimator::setDeltaRVetoEndcapPhotons ( float  fValue = -1.0 )

inline

Definition at line 109 of file PFIsolationEstimator.h.

Referenced by initialize().

{fDeltaRVetoEndcapPhotons=fValue;};

void PFIsolationEstimator::setNumberOfCrystalEndcapPhotons ( float  fValue = -1 )

inline

Definition at line 112 of file PFIsolationEstimator.h.

Referenced by initialize().

{fNumberOfCrystalEndcapPhotons=fValue;};

void PFIsolationEstimator::setNumbersOfRings ( int  iValue = 1 )

inline

Definition at line 147 of file PFIsolationEstimator.h.

Referenced by initializeRings().

{iNumberOfRings = iValue;};

void PFIsolationEstimator::setParticleType ( int  iValue )

inline

Definition at line 91 of file PFIsolationEstimator.h.

Referenced by initialize().

{iParticleType = iValue;};

void PFIsolationEstimator::setRectangleDeltaEtaVetoBarrelCharged ( float  fValue = -1.0 )

inline

Definition at line 124 of file PFIsolationEstimator.h.

Referenced by initialize().

{fRectangleDeltaEtaVetoBarrelCharged=fValue;};

void PFIsolationEstimator::setRectangleDeltaEtaVetoBarrelNeutrals ( float  fValue = -1.0 )

inline

Definition at line 123 of file PFIsolationEstimator.h.

Referenced by initialize().

{fRectangleDeltaEtaVetoBarrelNeutrals=fValue;};

void PFIsolationEstimator::setRectangleDeltaEtaVetoBarrelPhotons ( float  fValue = -1.0 )

inline

Definition at line 122 of file PFIsolationEstimator.h.

Referenced by initialize().

{fRectangleDeltaEtaVetoBarrelPhotons=fValue;};

void PFIsolationEstimator::setRectangleDeltaEtaVetoEndcapCharged ( float  fValue = -1.0 )

inline

Definition at line 127 of file PFIsolationEstimator.h.

Referenced by initialize().

{fRectangleDeltaEtaVetoEndcapCharged=fValue;};

void PFIsolationEstimator::setRectangleDeltaEtaVetoEndcapNeutrals ( float  fValue = -1.0 )

inline

Definition at line 126 of file PFIsolationEstimator.h.

Referenced by initialize().

{fRectangleDeltaEtaVetoEndcapNeutrals=fValue;};

void PFIsolationEstimator::setRectangleDeltaEtaVetoEndcapPhotons ( float  fValue = -1.0 )

inline

Definition at line 125 of file PFIsolationEstimator.h.

Referenced by initialize().

{fRectangleDeltaEtaVetoEndcapPhotons=fValue;};

void PFIsolationEstimator::setRectangleDeltaPhiVetoBarrelCharged ( float  fValue = -1.0 )

inline

Definition at line 116 of file PFIsolationEstimator.h.

Referenced by initialize().

{fRectangleDeltaPhiVetoBarrelCharged=fValue;};

void PFIsolationEstimator::setRectangleDeltaPhiVetoBarrelNeutrals ( float  fValue = -1.0 )

inline

Definition at line 115 of file PFIsolationEstimator.h.

Referenced by initialize().

{fRectangleDeltaPhiVetoBarrelNeutrals=fValue;};

void PFIsolationEstimator::setRectangleDeltaPhiVetoBarrelPhotons ( float  fValue = -1.0 )

inline

Definition at line 114 of file PFIsolationEstimator.h.

Referenced by initialize().

{fRectangleDeltaPhiVetoBarrelPhotons=fValue;};

void PFIsolationEstimator::setRectangleDeltaPhiVetoEndcapCharged ( float  fValue = -1.0 )

inline

Definition at line 119 of file PFIsolationEstimator.h.

Referenced by initialize().

{fRectangleDeltaPhiVetoEndcapCharged=fValue;};

void PFIsolationEstimator::setRectangleDeltaPhiVetoEndcapNeutrals ( float  fValue = -1.0 )

inline

Definition at line 118 of file PFIsolationEstimator.h.

Referenced by initialize().

{fRectangleDeltaPhiVetoEndcapNeutrals=fValue;};

void PFIsolationEstimator::setRectangleDeltaPhiVetoEndcapPhotons ( float  fValue = -1.0 )

inline

Definition at line 117 of file PFIsolationEstimator.h.

Referenced by initialize().

{fRectangleDeltaPhiVetoEndcapPhotons=fValue;};

void PFIsolationEstimator::setRectangleVetoBarrel ( Bool_t  bValue = kTRUE )

inline

Definition at line 100 of file PFIsolationEstimator.h.

Referenced by initialize().

{  bRectangleVetoBarrel = bValue;};

void PFIsolationEstimator::setRectangleVetoEndcap ( Bool_t  bValue = kTRUE )

inline

Definition at line 101 of file PFIsolationEstimator.h.

Referenced by initialize().

{  bRectangleVetoEndcap = bValue;};

void PFIsolationEstimator::setRingSize ( float  fValue = 0.4 )

inline

Definition at line 148 of file PFIsolationEstimator.h.

Referenced by initializeRings().

{fRingSize = fValue;};

void PFIsolationEstimator::setUseCrystalSize ( Bool_t  bValue = kFALSE )

inline

Definition at line 103 of file PFIsolationEstimator.h.

Referenced by initialize().

{ bUseCrystalSize = bValue;};

Member Data Documentation

Bool_t PFIsolationEstimator::bApplyDzDxyVeto

private

Definition at line 177 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed().

Bool_t PFIsolationEstimator::bApplyMissHitPhVeto

private

Definition at line 179 of file PFIsolationEstimator.h.

Referenced by isPhotonParticleVetoed().

Bool_t PFIsolationEstimator::bApplyPFPUVeto

private

Definition at line 178 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed().

Bool_t PFIsolationEstimator::bApplyVeto

private

Definition at line 176 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed(), isNeutralParticleVetoed(), and isPhotonParticleVetoed().

Bool_t PFIsolationEstimator::bDeltaRVetoBarrel

private

Definition at line 182 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed(), isNeutralParticleVetoed(), and isPhotonParticleVetoed().

Bool_t PFIsolationEstimator::bDeltaRVetoEndcap

private

Definition at line 183 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed(), isNeutralParticleVetoed(), and isPhotonParticleVetoed().

Bool_t PFIsolationEstimator::bRectangleVetoBarrel

private

Definition at line 185 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed(), isNeutralParticleVetoed(), and isPhotonParticleVetoed().

Bool_t PFIsolationEstimator::bRectangleVetoEndcap

private

Definition at line 186 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed(), isNeutralParticleVetoed(), and isPhotonParticleVetoed().

Bool_t PFIsolationEstimator::bUseCrystalSize

private

Definition at line 180 of file PFIsolationEstimator.h.

Referenced by isPhotonParticleVetoed().

Bool_t PFIsolationEstimator::checkClosestZVertex

private

Definition at line 174 of file PFIsolationEstimator.h.

Referenced by chargedHadronVertex(), and initialize().

float PFIsolationEstimator::fConeSize

private

Definition at line 175 of file PFIsolationEstimator.h.

Referenced by initializeElectronIsolation(), initializePhotonIsolation(), initializeRings(), isChargedParticleVetoed(), isNeutralParticleVetoed(), and isPhotonParticleVetoed().

float PFIsolationEstimator::fDeltaEta

private

Definition at line 220 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed(), isNeutralParticleVetoed(), and isPhotonParticleVetoed().

float PFIsolationEstimator::fDeltaPhi

private

Definition at line 221 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed(), isNeutralParticleVetoed(), and isPhotonParticleVetoed().

float PFIsolationEstimator::fDeltaR

private

Definition at line 219 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings(), isChargedParticleVetoed(), isNeutralParticleVetoed(), isPhotonParticleVetoed(), and matchPFObject().

float PFIsolationEstimator::fDeltaRVetoBarrelCharged

private

Definition at line 190 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed().

float PFIsolationEstimator::fDeltaRVetoBarrelNeutrals

private

Definition at line 189 of file PFIsolationEstimator.h.

Referenced by isNeutralParticleVetoed().

float PFIsolationEstimator::fDeltaRVetoBarrelPhotons

private

Definition at line 188 of file PFIsolationEstimator.h.

Referenced by isPhotonParticleVetoed().

float PFIsolationEstimator::fDeltaRVetoEndcapCharged

private

Definition at line 194 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed().

float PFIsolationEstimator::fDeltaRVetoEndcapNeutrals

private

Definition at line 193 of file PFIsolationEstimator.h.

Referenced by isNeutralParticleVetoed().

float PFIsolationEstimator::fDeltaRVetoEndcapPhotons

private

Definition at line 192 of file PFIsolationEstimator.h.

Referenced by isPhotonParticleVetoed().

float PFIsolationEstimator::fEta

private

Definition at line 223 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings(), isChargedParticleVetoed(), isNeutralParticleVetoed(), and isPhotonParticleVetoed().

float PFIsolationEstimator::fEtaSC

private

Definition at line 225 of file PFIsolationEstimator.h.

Bool_t PFIsolationEstimator::fisInitialized

private

Definition at line 161 of file PFIsolationEstimator.h.

float PFIsolationEstimator::fIsolation

private

Definition at line 162 of file PFIsolationEstimator.h.

Referenced by fGetIsolation().

float PFIsolationEstimator::fIsolationCharged

private

Definition at line 165 of file PFIsolationEstimator.h.

float PFIsolationEstimator::fIsolationChargedAll

private

Definition at line 166 of file PFIsolationEstimator.h.

vector<float > PFIsolationEstimator::fIsolationInRings

private

Definition at line 168 of file PFIsolationEstimator.h.

Referenced by fGetIsolation(), fGetIsolationInRings(), and initializeRings().

vector<float > PFIsolationEstimator::fIsolationInRingsCharged

private

Definition at line 171 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings(), and initializeRings().

vector<float > PFIsolationEstimator::fIsolationInRingsChargedAll

private

Definition at line 172 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings(), and initializeRings().

vector<float > PFIsolationEstimator::fIsolationInRingsNeutral

private

Definition at line 170 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings(), and initializeRings().

vector<float > PFIsolationEstimator::fIsolationInRingsPhoton

private

Definition at line 169 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings(), and initializeRings().

float PFIsolationEstimator::fIsolationNeutral

private

Definition at line 164 of file PFIsolationEstimator.h.

float PFIsolationEstimator::fIsolationPhoton

private

Definition at line 163 of file PFIsolationEstimator.h.

float PFIsolationEstimator::fNumberOfCrystalEndcapPhotons

private

Definition at line 196 of file PFIsolationEstimator.h.

Referenced by isPhotonParticleVetoed().

float PFIsolationEstimator::fPhi

private

Definition at line 224 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings(), isChargedParticleVetoed(), isNeutralParticleVetoed(), and isPhotonParticleVetoed().

float PFIsolationEstimator::fPhiSC

private

Definition at line 226 of file PFIsolationEstimator.h.

float PFIsolationEstimator::fPt

private

Definition at line 228 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings(), and matchPFObject().

float PFIsolationEstimator::fRectangleDeltaEtaVetoBarrelCharged

private

Definition at line 208 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed().

float PFIsolationEstimator::fRectangleDeltaEtaVetoBarrelNeutrals

private

Definition at line 207 of file PFIsolationEstimator.h.

Referenced by isNeutralParticleVetoed().

float PFIsolationEstimator::fRectangleDeltaEtaVetoBarrelPhotons

private

Definition at line 206 of file PFIsolationEstimator.h.

Referenced by isPhotonParticleVetoed().

float PFIsolationEstimator::fRectangleDeltaEtaVetoEndcapCharged

private

Definition at line 212 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed().

float PFIsolationEstimator::fRectangleDeltaEtaVetoEndcapNeutrals

private

Definition at line 211 of file PFIsolationEstimator.h.

Referenced by isNeutralParticleVetoed().

float PFIsolationEstimator::fRectangleDeltaEtaVetoEndcapPhotons

private

Definition at line 210 of file PFIsolationEstimator.h.

Referenced by isPhotonParticleVetoed().

float PFIsolationEstimator::fRectangleDeltaPhiVetoBarrelCharged

private

Definition at line 200 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed().

float PFIsolationEstimator::fRectangleDeltaPhiVetoBarrelNeutrals

private

Definition at line 199 of file PFIsolationEstimator.h.

Referenced by isNeutralParticleVetoed().

float PFIsolationEstimator::fRectangleDeltaPhiVetoBarrelPhotons

private

Definition at line 198 of file PFIsolationEstimator.h.

Referenced by isPhotonParticleVetoed().

float PFIsolationEstimator::fRectangleDeltaPhiVetoEndcapCharged

private

Definition at line 204 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed().

float PFIsolationEstimator::fRectangleDeltaPhiVetoEndcapNeutrals

private

Definition at line 203 of file PFIsolationEstimator.h.

Referenced by isNeutralParticleVetoed().

float PFIsolationEstimator::fRectangleDeltaPhiVetoEndcapPhotons

private

Definition at line 202 of file PFIsolationEstimator.h.

Referenced by isPhotonParticleVetoed().

float PFIsolationEstimator::fRingSize

private

Definition at line 217 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings().

float PFIsolationEstimator::fVx

private

Definition at line 229 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings(), and isChargedParticleVetoed().

float PFIsolationEstimator::fVy

private

Definition at line 230 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings(), and isChargedParticleVetoed().

float PFIsolationEstimator::fVz

private

Definition at line 231 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings().

int PFIsolationEstimator::iMissHits

private

Definition at line 215 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings(), and isPhotonParticleVetoed().

int PFIsolationEstimator::iNumberOfRings

private

Definition at line 214 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings(), and initializeRings().

int PFIsolationEstimator::iParticleType

private

Definition at line 159 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed().

bool PFIsolationEstimator::pivotInBarrel

private

Definition at line 234 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings(), isChargedParticleVetoed(), isNeutralParticleVetoed(), and isPhotonParticleVetoed().

SuperClusterRef PFIsolationEstimator::refSC

private

Definition at line 233 of file PFIsolationEstimator.h.

Referenced by fGetIsolation(), fGetIsolationInRings(), and isPhotonParticleVetoed().

math::XYZVector PFIsolationEstimator::vtxWRTCandidate

private

Definition at line 236 of file PFIsolationEstimator.h.