PFIsolationEstimator Class Reference

#include <PFIsolationEstimator.h>

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

Public Member Functions
reco::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)
std::vector< float >	fGetIsolationInRings (const reco::PFCandidate *pfCandidate, const reco::PFCandidateCollection *pfParticlesColl, reco::VertexRef vtx, edm::Handle< reco::VertexCollection > vertices)
std::vector< float >	fGetIsolationInRings (const reco::Photon *photon, const reco::PFCandidateCollection *pfParticlesColl, reco::VertexRef vtx, edm::Handle< reco::VertexCollection > vertices)
std::vector< float >	fGetIsolationInRings (const reco::GsfElectron *electron, const reco::PFCandidateCollection *pfParticlesColl, reco::VertexRef vtx, edm::Handle< reco::VertexCollection > vertices)
float	getIsolationCharged ()
float	getIsolationChargedAll ()
std::vector< float >	getIsolationInRingsCharged ()
std::vector< float >	getIsolationInRingsChargedAll ()
std::vector< float >	getIsolationInRingsNeutral ()
std::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
std::vector< float >	fIsolationInRings
std::vector< float >	fIsolationInRingsCharged
std::vector< float >	fIsolationInRingsChargedAll
std::vector< float >	fIsolationInRingsNeutral
std::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
reco::SuperClusterRef	refSC
math::XYZVector	vtxWRTCandidate

Detailed Description

–> NOTE if you want to use this class as standalone without the CMSSW part you need to uncomment the below line and compile normally with scramv1 b Then you need just to load it in your root macro the lib with the correct path, eg: gSystem->Load("/data/benedet/CMSSW_5_2_2/lib/slc5_amd64_gcc462/pluginEGammaEGammaAnalysisTools.so");

Definition at line 53 of file PFIsolationEstimator.h.

Member Enumeration Documentation

enum PFIsolationEstimator::VetoType

Enumerator
kElectron
kPhoton

Definition at line 58 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 24 of file PFIsolationEstimator.cc.

                                           :
fisInitialized(kFALSE)
{
  // Constructor.
}

PFIsolationEstimator::~PFIsolationEstimator

(

)

Definition at line 33 of file PFIsolationEstimator.cc.

{

}

Member Function Documentation

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

Definition at line 683 of file PFIsolationEstimator.cc.

References funct::abs(), checkClosestZVertex, PVValHelper::dz, edm::Handle< T >::product(), reco::PFCandidate::trackRef(), reco::Vertex::tracks_begin(), reco::Vertex::tracks_end(), reco::Vertex::trackWeight(), reco::PFCandidate::vertex(), electrons_cff::vertices, badGlobalMuonTaggersAOD_cff::vtx, and w.

Referenced by isChargedParticleVetoed(), and isInitialized().

                                                                                                                                        {

  //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  reco::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 = std::abs(ztrack - iv->z());
      if(dz<dzmin) {
        dzmin = dz;
        iVertex = index;
        foundVertex = true;
      }
    }

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

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

Definition at line 200 of file PFIsolationEstimator.cc.

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

Referenced by AdHocNTupler::fill(), PhotonIsoProducer::filter(), and isInitialized().

                                                                                                                                                                                             {
 
  fGetIsolationInRings( pfCandidate, pfParticlesColl, vtx, vertices);
  refSC = reco::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 277 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 382 of file PFIsolationEstimator.cc.

References fGetIsolationInRings(), fIsolation, and fIsolationInRings.

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

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

Definition at line 211 of file PFIsolationEstimator.cc.

References funct::abs(), reco::LeafCandidate::eta(), fDeltaR, fEta, fIsolationInRings, fIsolationInRingsCharged, fIsolationInRingsChargedAll, fIsolationInRingsNeutral, fIsolationInRingsPhoton, fPhi, fPt, fRingSize, fVx, fVy, fVz, createfilelist::int, 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(), and isInitialized().

                                                                                                                                                                                                                 {

  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 = std::abs(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(std::abs(pfParticle.pdgId())==130){
        
      if(isNeutralParticleVetoed(  &pfParticle)>=0.){
        isoBin = (int)(fDeltaR/fRingSize);
    fIsolationInRingsNeutral[isoBin]  = fIsolationInRingsNeutral[isoBin] + pfParticle.pt();
      }
    

      //}else if(std::abs(pfParticle.pdgId()) == 11 ||abs(pfParticle.pdgId()) == 13 || std::abs(pfParticle.pdgId()) == 211){
    }else if(std::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;
}

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

Definition at line 287 of file PFIsolationEstimator.cc.

References funct::abs(), fDeltaR, fEta, fIsolationInRings, fIsolationInRingsCharged, fIsolationInRingsChargedAll, fIsolationInRingsNeutral, fIsolationInRingsPhoton, fPhi, fRingSize, fVx, fVy, fVz, iMissHits, createfilelist::int, 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 = std::abs((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(std::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(std::abs(pfParticle.pdgId()) == 11 ||abs(pfParticle.pdgId()) == 13 || std::abs(pfParticle.pdgId()) == 211){
    }else if(std::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;
}

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

Definition at line 392 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, createfilelist::int, iNumberOfRings, isChargedParticleVetoed(), isNeutralParticleVetoed(), isPhotonParticleVetoed(), reco::HitPattern::MISSING_INNER_HITS, 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().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS);
  
  //  if(electron->ecalDrivenSeed())
  refSC = electron->superCluster();
  pivotInBarrel = std::abs((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(std::abs(pfParticle.pdgId())==130){
        
      if(isNeutralParticleVetoed( &pfParticle)>=0.){
        isoBin = (int)(fDeltaR/fRingSize);
    fIsolationInRingsNeutral[isoBin]  = fIsolationInRingsNeutral[isoBin] + pfParticle.pt();
      }

      //}else if(std::abs(pfParticle.pdgId()) == 11 ||abs(pfParticle.pdgId()) == 13 || std::abs(pfParticle.pdgId()) == 211){
    }else if(std::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 133 of file PFIsolationEstimator.h.

References fIsolationCharged, and fIsolationInRingsCharged.

Referenced by AdHocNTupler::fill(), and PhotonIsoProducer::filter().

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

float PFIsolationEstimator::getIsolationChargedAll ( )

inline

Definition at line 134 of file PFIsolationEstimator.h.

References fIsolationChargedAll.

{ return fIsolationChargedAll; };

std::vector<float > PFIsolationEstimator::getIsolationInRingsCharged ( )

inline

Definition at line 138 of file PFIsolationEstimator.h.

References fIsolationInRingsCharged.

{ return fIsolationInRingsCharged; };

std::vector<float > PFIsolationEstimator::getIsolationInRingsChargedAll ( )

inline

Definition at line 139 of file PFIsolationEstimator.h.

References fIsolationInRingsChargedAll.

{ return fIsolationInRingsChargedAll; };

std::vector<float > PFIsolationEstimator::getIsolationInRingsNeutral ( )

inline

Definition at line 137 of file PFIsolationEstimator.h.

References fIsolationInRingsNeutral.

{ return fIsolationInRingsNeutral; };

std::vector<float > PFIsolationEstimator::getIsolationInRingsPhoton ( )

inline

Definition at line 136 of file PFIsolationEstimator.h.

References fIsolationInRingsPhoton.

{ return fIsolationInRingsPhoton; };

float PFIsolationEstimator::getIsolationNeutral ( )

inline

Definition at line 132 of file PFIsolationEstimator.h.

References fIsolationInRingsNeutral, and fIsolationNeutral.

Referenced by AdHocNTupler::fill(), and PhotonIsoProducer::filter().

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

float PFIsolationEstimator::getIsolationPhoton ( )

inline

Definition at line 131 of file PFIsolationEstimator.h.

References fIsolationInRingsPhoton, and fIsolationPhoton.

Referenced by AdHocNTupler::fill(), and PhotonIsoProducer::filter().

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

int PFIsolationEstimator::getNumbersOfRings ( )

inline

Definition at line 145 of file PFIsolationEstimator.h.

References iNumberOfRings.

{return iNumberOfRings;};

float PFIsolationEstimator::getRingSize ( )

inline

Definition at line 146 of file PFIsolationEstimator.h.

References fRingSize, and matchPFObject().

{return fRingSize; };

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

private

Definition at line 39 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 134 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 157 of file PFIsolationEstimator.cc.

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

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

void PFIsolationEstimator::initializePhotonIsolation

(

Bool_t

bApplyVeto

)

Definition at line 150 of file PFIsolationEstimator.cc.

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

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

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

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

Definition at line 163 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 170 of file PFIsolationEstimator.cc.

References fConeSize, fIsolationInRings, fIsolationInRingsCharged, fIsolationInRingsChargedAll, fIsolationInRingsNeutral, fIsolationInRingsPhoton, objects.autophobj::float, 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 568 of file PFIsolationEstimator.cc.

Referenced by fGetIsolationInRings(), and setRectangleDeltaEtaVetoEndcapCharged().

                                                                                                                                   {
  //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 575 of file PFIsolationEstimator.cc.

References funct::abs(), bApplyDzDxyVeto, bApplyPFPUVeto, bApplyVeto, bDeltaRVetoBarrel, bDeltaRVetoEndcap, bRectangleVetoBarrel, bRectangleVetoEndcap, chargedHadronVertex(), hiPixelPairStep_cff::deltaPhi, boostedElectronIsolation_cff::deltaR, PVValHelper::dxy, PVValHelper::dz, 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(), reco::PFCandidate::trackRef(), and badGlobalMuonTaggersAOD_cff::vtx.

                                                                                                                                                         {
  
  reco::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 = std::abs( pfIsoCand->trackRef()->dz( (*vtxMain).position() ) );
      if (dz > 0.2)
        return -999.;
    
      double dxy = pfIsoCand->trackRef()->dxy( (*vtxMain).position() );  
      if (std::abs(dxy) > 0.1)
        return -999.;
      
      /*
      float dz = std::abs(vtx->z() - fVtxMainZ);
      if (dz > 1.)
    return -999.;
      
      
      double dxy = ( -(vtx->x() - fVtxMainX)*pfIsoCand->py() + (vtx->y() - fVtxMainY)*pfIsoCand->px()) / pfIsoCand->pt();
      
      if(std::abs(dxy) > 0.2)
    return -999.;
      */
    }else{
      
      
      float dz = std::abs(vtx->z() - fVtxMainZ);
      if (dz > 1.)
    return -999.;
      
      double dxy = ( -(vtx->x() - fVx)*pfIsoCand->py() + (vtx->y() - fVy)*pfIsoCand->px()) / pfIsoCand->pt();
      if(std::abs(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(std::abs(fDeltaEta) < fRectangleDeltaEtaVetoBarrelCharged && std::abs(fDeltaPhi) < fRectangleDeltaPhiVetoBarrelCharged){
        return -999.;
    }
      }
      
    }else{
     if(!bDeltaRVetoEndcap&&!bRectangleVetoEndcap){
       return fDeltaR;
     }
      if(bDeltaRVetoEndcap){
    if(fDeltaR < fDeltaRVetoEndcapCharged)
      return -999.;
      }
      if(bRectangleVetoEndcap){
    if(std::abs(fDeltaEta) < fRectangleDeltaEtaVetoEndcapCharged && std::abs(fDeltaPhi) < fRectangleDeltaPhiVetoEndcapCharged){
      return -999.;
    }
      }
  }
           
  


  return fDeltaR;
}

Bool_t PFIsolationEstimator::isInitialized ( ) const

inline

Definition at line 69 of file PFIsolationEstimator.h.

References chargedHadronVertex(), metsig::electron, fGetIsolation(), fGetIsolationInRings(), fisInitialized, pfDeepBoostedJetPreprocessParams_cfi::pfcand, muons2muons_cfi::photon, electrons_cff::vertices, and badGlobalMuonTaggersAOD_cff::vtx.

{ return fisInitialized; }

float PFIsolationEstimator::isNeutralParticleVetoed

(

const reco::PFCandidate *

pfIsoCand

)

Definition at line 518 of file PFIsolationEstimator.cc.

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

Referenced by fGetIsolationInRings(), and setRectangleDeltaEtaVetoEndcapCharged().

                                                                                      {

  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(std::abs(fDeltaEta) < fRectangleDeltaEtaVetoBarrelNeutrals && std::abs(fDeltaPhi) < fRectangleDeltaPhiVetoBarrelNeutrals){
        return -999.;
    }
      }
      
    }else{
     if(!bDeltaRVetoEndcap&&!bRectangleVetoEndcap){
       return fDeltaR;
     }
      if(bDeltaRVetoEndcap){
    if(fDeltaR < fDeltaRVetoEndcapNeutrals)
      return -999.;
      }
      if(bRectangleVetoEndcap){
    if(std::abs(fDeltaEta) < fRectangleDeltaEtaVetoEndcapNeutrals && std::abs(fDeltaPhi) < fRectangleDeltaPhiVetoEndcapNeutrals){
      return -999.;
    }
      }
  }

  return fDeltaR;
}

float PFIsolationEstimator::isPhotonParticleVetoed

(

const reco::PFCandidate *

pfIsoCand

)

Definition at line 460 of file PFIsolationEstimator.cc.

References funct::abs(), bApplyMissHitPhVeto, bApplyVeto, bDeltaRVetoBarrel, bDeltaRVetoEndcap, bRectangleVetoBarrel, bRectangleVetoEndcap, bUseCrystalSize, hiPixelPairStep_cff::deltaPhi, boostedElectronIsolation_cff::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(), and setRectangleDeltaEtaVetoEndcapCharged().

                                                                                     {
  
  
  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(std::abs(fDeltaEta) < fRectangleDeltaEtaVetoBarrelPhotons && std::abs(fDeltaPhi) < fRectangleDeltaPhiVetoBarrelPhotons){
    return -999.;
      }
    }
  }else{
    if (bUseCrystalSize == true) {
      fDeltaRVetoEndcapPhotons = 0.00864*std::abs(sinh(refSC->position().eta()))*fNumberOfCrystalEndcapPhotons;
    }

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

  return fDeltaR;
}

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

Definition at line 757 of file PFIsolationEstimator.cc.

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

Referenced by getRingSize().

                                                                                                             {
  
  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 803 of file PFIsolationEstimator.cc.

References Abs(), boostedElectronIsolation_cff::deltaR, reco::LeafCandidate::eta(), fDeltaR, fPt, mps_fire::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 91 of file PFIsolationEstimator.h.

References bApplyDzDxyVeto.

Referenced by initialize().

{  bApplyDzDxyVeto = bValue;};

void PFIsolationEstimator::setApplyMissHitPhVeto ( Bool_t  bValue = kFALSE )

inline

Definition at line 92 of file PFIsolationEstimator.h.

References bApplyMissHitPhVeto.

Referenced by initialize().

{  bApplyMissHitPhVeto = bValue;};

void PFIsolationEstimator::setApplyPFPUVeto ( Bool_t  bValue = kFALSE )

inline

Definition at line 90 of file PFIsolationEstimator.h.

References bApplyPFPUVeto.

Referenced by initialize().

{bApplyPFPUVeto = bValue;};

void PFIsolationEstimator::setApplyVeto ( Bool_t  bValue = kTRUE )

inline

Definition at line 89 of file PFIsolationEstimator.h.

References bApplyVeto.

Referenced by initialize().

{  bApplyVeto = bValue;};

void PFIsolationEstimator::setConeSize ( float  fValue = 0.4 )

inline

Definition at line 84 of file PFIsolationEstimator.h.

References fConeSize.

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

{ fConeSize = fValue;};

void PFIsolationEstimator::setDeltaRVetoBarrel ( Bool_t  bValue = kTRUE )

inline

Definition at line 93 of file PFIsolationEstimator.h.

References bDeltaRVetoBarrel.

Referenced by initialize().

{  bDeltaRVetoBarrel = bValue;};

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

inline

Definition at line 103 of file PFIsolationEstimator.h.

References fDeltaRVetoBarrelCharged.

Referenced by initialize().

{fDeltaRVetoBarrelCharged=fValue;};

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

inline

Definition at line 102 of file PFIsolationEstimator.h.

References fDeltaRVetoBarrelNeutrals.

Referenced by initialize().

{fDeltaRVetoBarrelNeutrals=fValue;};

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

inline

Definition at line 101 of file PFIsolationEstimator.h.

References fDeltaRVetoBarrelPhotons.

Referenced by initialize().

{fDeltaRVetoBarrelPhotons=fValue;};

void PFIsolationEstimator::setDeltaRVetoEndcap ( Bool_t  bValue = kTRUE )

inline

Definition at line 94 of file PFIsolationEstimator.h.

References bDeltaRVetoEndcap.

Referenced by initialize().

{  bDeltaRVetoEndcap = bValue;};

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

inline

Definition at line 106 of file PFIsolationEstimator.h.

References fDeltaRVetoEndcapCharged.

Referenced by initialize().

{fDeltaRVetoEndcapCharged=fValue;};

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

inline

Definition at line 105 of file PFIsolationEstimator.h.

References fDeltaRVetoEndcapNeutrals.

Referenced by initialize().

{fDeltaRVetoEndcapNeutrals=fValue;};

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

inline

Definition at line 104 of file PFIsolationEstimator.h.

References fDeltaRVetoEndcapPhotons.

Referenced by initialize().

{fDeltaRVetoEndcapPhotons=fValue;};

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

inline

Definition at line 107 of file PFIsolationEstimator.h.

References fNumberOfCrystalEndcapPhotons.

Referenced by initialize().

{fNumberOfCrystalEndcapPhotons=fValue;};

void PFIsolationEstimator::setNumbersOfRings ( int  iValue = 1 )

inline

Definition at line 142 of file PFIsolationEstimator.h.

References iNumberOfRings.

Referenced by initializeRings().

{iNumberOfRings = iValue;};

void PFIsolationEstimator::setParticleType ( int  iValue )

inline

Definition at line 86 of file PFIsolationEstimator.h.

References iParticleType.

Referenced by initialize().

{iParticleType = iValue;};

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

inline

Definition at line 119 of file PFIsolationEstimator.h.

References fRectangleDeltaEtaVetoBarrelCharged.

Referenced by initialize().

{fRectangleDeltaEtaVetoBarrelCharged=fValue;};

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

inline

Definition at line 118 of file PFIsolationEstimator.h.

References fRectangleDeltaEtaVetoBarrelNeutrals.

Referenced by initialize().

{fRectangleDeltaEtaVetoBarrelNeutrals=fValue;};

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

inline

Definition at line 117 of file PFIsolationEstimator.h.

References fRectangleDeltaEtaVetoBarrelPhotons.

Referenced by initialize().

{fRectangleDeltaEtaVetoBarrelPhotons=fValue;};

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

inline

Definition at line 122 of file PFIsolationEstimator.h.

References fRectangleDeltaEtaVetoEndcapCharged, isChargedParticleVetoed(), isNeutralParticleVetoed(), and isPhotonParticleVetoed().

Referenced by initialize().

{fRectangleDeltaEtaVetoEndcapCharged=fValue;};

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

inline

Definition at line 121 of file PFIsolationEstimator.h.

References fRectangleDeltaEtaVetoEndcapNeutrals.

Referenced by initialize().

{fRectangleDeltaEtaVetoEndcapNeutrals=fValue;};

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

inline

Definition at line 120 of file PFIsolationEstimator.h.

References fRectangleDeltaEtaVetoEndcapPhotons.

Referenced by initialize().

{fRectangleDeltaEtaVetoEndcapPhotons=fValue;};

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

inline

Definition at line 111 of file PFIsolationEstimator.h.

References fRectangleDeltaPhiVetoBarrelCharged.

Referenced by initialize().

{fRectangleDeltaPhiVetoBarrelCharged=fValue;};

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

inline

Definition at line 110 of file PFIsolationEstimator.h.

References fRectangleDeltaPhiVetoBarrelNeutrals.

Referenced by initialize().

{fRectangleDeltaPhiVetoBarrelNeutrals=fValue;};

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

inline

Definition at line 109 of file PFIsolationEstimator.h.

References fRectangleDeltaPhiVetoBarrelPhotons.

Referenced by initialize().

{fRectangleDeltaPhiVetoBarrelPhotons=fValue;};

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

inline

Definition at line 114 of file PFIsolationEstimator.h.

References fRectangleDeltaPhiVetoEndcapCharged.

Referenced by initialize().

{fRectangleDeltaPhiVetoEndcapCharged=fValue;};

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

inline

Definition at line 113 of file PFIsolationEstimator.h.

References fRectangleDeltaPhiVetoEndcapNeutrals.

Referenced by initialize().

{fRectangleDeltaPhiVetoEndcapNeutrals=fValue;};

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

inline

Definition at line 112 of file PFIsolationEstimator.h.

References fRectangleDeltaPhiVetoEndcapPhotons.

Referenced by initialize().

{fRectangleDeltaPhiVetoEndcapPhotons=fValue;};

void PFIsolationEstimator::setRectangleVetoBarrel ( Bool_t  bValue = kTRUE )

inline

Definition at line 95 of file PFIsolationEstimator.h.

References bRectangleVetoBarrel.

Referenced by initialize().

{  bRectangleVetoBarrel = bValue;};

void PFIsolationEstimator::setRectangleVetoEndcap ( Bool_t  bValue = kTRUE )

inline

Definition at line 96 of file PFIsolationEstimator.h.

References bRectangleVetoEndcap.

Referenced by initialize().

{  bRectangleVetoEndcap = bValue;};

void PFIsolationEstimator::setRingSize ( float  fValue = 0.4 )

inline

Definition at line 143 of file PFIsolationEstimator.h.

References fRingSize.

Referenced by initializeRings().

{fRingSize = fValue;};

void PFIsolationEstimator::setUseCrystalSize ( Bool_t  bValue = kFALSE )

inline

Definition at line 98 of file PFIsolationEstimator.h.

References bUseCrystalSize.

Referenced by initialize().

{ bUseCrystalSize = bValue;};

Member Data Documentation

Bool_t PFIsolationEstimator::bApplyDzDxyVeto

private

Definition at line 172 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed(), and setApplyDzDxyVeto().

Bool_t PFIsolationEstimator::bApplyMissHitPhVeto

private

Definition at line 174 of file PFIsolationEstimator.h.

Referenced by isPhotonParticleVetoed(), and setApplyMissHitPhVeto().

Bool_t PFIsolationEstimator::bApplyPFPUVeto

private

Definition at line 173 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed(), and setApplyPFPUVeto().

Bool_t PFIsolationEstimator::bApplyVeto

private

Definition at line 171 of file PFIsolationEstimator.h.

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

Bool_t PFIsolationEstimator::bDeltaRVetoBarrel

private

Definition at line 177 of file PFIsolationEstimator.h.

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

Bool_t PFIsolationEstimator::bDeltaRVetoEndcap

private

Definition at line 178 of file PFIsolationEstimator.h.

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

Bool_t PFIsolationEstimator::bRectangleVetoBarrel

private

Definition at line 180 of file PFIsolationEstimator.h.

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

Bool_t PFIsolationEstimator::bRectangleVetoEndcap

private

Definition at line 181 of file PFIsolationEstimator.h.

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

Bool_t PFIsolationEstimator::bUseCrystalSize

private

Definition at line 175 of file PFIsolationEstimator.h.

Referenced by isPhotonParticleVetoed(), and setUseCrystalSize().

Bool_t PFIsolationEstimator::checkClosestZVertex

private

Definition at line 169 of file PFIsolationEstimator.h.

Referenced by chargedHadronVertex(), and initialize().

float PFIsolationEstimator::fConeSize

private

Definition at line 170 of file PFIsolationEstimator.h.

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

float PFIsolationEstimator::fDeltaEta

private

Definition at line 215 of file PFIsolationEstimator.h.

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

float PFIsolationEstimator::fDeltaPhi

private

Definition at line 216 of file PFIsolationEstimator.h.

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

float PFIsolationEstimator::fDeltaR

private

Definition at line 214 of file PFIsolationEstimator.h.

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

float PFIsolationEstimator::fDeltaRVetoBarrelCharged

private

Definition at line 185 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed(), and setDeltaRVetoBarrelCharged().

float PFIsolationEstimator::fDeltaRVetoBarrelNeutrals

private

Definition at line 184 of file PFIsolationEstimator.h.

Referenced by isNeutralParticleVetoed(), and setDeltaRVetoBarrelNeutrals().

float PFIsolationEstimator::fDeltaRVetoBarrelPhotons

private

Definition at line 183 of file PFIsolationEstimator.h.

Referenced by isPhotonParticleVetoed(), and setDeltaRVetoBarrelPhotons().

float PFIsolationEstimator::fDeltaRVetoEndcapCharged

private

Definition at line 189 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed(), and setDeltaRVetoEndcapCharged().

float PFIsolationEstimator::fDeltaRVetoEndcapNeutrals

private

Definition at line 188 of file PFIsolationEstimator.h.

Referenced by isNeutralParticleVetoed(), and setDeltaRVetoEndcapNeutrals().

float PFIsolationEstimator::fDeltaRVetoEndcapPhotons

private

Definition at line 187 of file PFIsolationEstimator.h.

Referenced by isPhotonParticleVetoed(), and setDeltaRVetoEndcapPhotons().

float PFIsolationEstimator::fEta

private

Definition at line 218 of file PFIsolationEstimator.h.

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

float PFIsolationEstimator::fEtaSC

private

Definition at line 220 of file PFIsolationEstimator.h.

Bool_t PFIsolationEstimator::fisInitialized

private

Definition at line 156 of file PFIsolationEstimator.h.

Referenced by isInitialized().

float PFIsolationEstimator::fIsolation

private

Definition at line 157 of file PFIsolationEstimator.h.

Referenced by fGetIsolation().

float PFIsolationEstimator::fIsolationCharged

private

Definition at line 160 of file PFIsolationEstimator.h.

Referenced by getIsolationCharged().

float PFIsolationEstimator::fIsolationChargedAll

private

Definition at line 161 of file PFIsolationEstimator.h.

Referenced by getIsolationChargedAll().

std::vector<float > PFIsolationEstimator::fIsolationInRings

private

Definition at line 163 of file PFIsolationEstimator.h.

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

std::vector<float > PFIsolationEstimator::fIsolationInRingsCharged

private

Definition at line 166 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings(), getIsolationCharged(), getIsolationInRingsCharged(), and initializeRings().

std::vector<float > PFIsolationEstimator::fIsolationInRingsChargedAll

private

Definition at line 167 of file PFIsolationEstimator.h.

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

std::vector<float > PFIsolationEstimator::fIsolationInRingsNeutral

private

Definition at line 165 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings(), getIsolationInRingsNeutral(), getIsolationNeutral(), and initializeRings().

std::vector<float > PFIsolationEstimator::fIsolationInRingsPhoton

private

Definition at line 164 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings(), getIsolationInRingsPhoton(), getIsolationPhoton(), and initializeRings().

float PFIsolationEstimator::fIsolationNeutral

private

Definition at line 159 of file PFIsolationEstimator.h.

Referenced by getIsolationNeutral().

float PFIsolationEstimator::fIsolationPhoton

private

Definition at line 158 of file PFIsolationEstimator.h.

Referenced by getIsolationPhoton().

float PFIsolationEstimator::fNumberOfCrystalEndcapPhotons

private

Definition at line 191 of file PFIsolationEstimator.h.

Referenced by isPhotonParticleVetoed(), and setNumberOfCrystalEndcapPhotons().

float PFIsolationEstimator::fPhi

private

Definition at line 219 of file PFIsolationEstimator.h.

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

float PFIsolationEstimator::fPhiSC

private

Definition at line 221 of file PFIsolationEstimator.h.

float PFIsolationEstimator::fPt

private

Definition at line 223 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings(), and matchPFObject().

float PFIsolationEstimator::fRectangleDeltaEtaVetoBarrelCharged

private

Definition at line 203 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed(), and setRectangleDeltaEtaVetoBarrelCharged().

float PFIsolationEstimator::fRectangleDeltaEtaVetoBarrelNeutrals

private

Definition at line 202 of file PFIsolationEstimator.h.

Referenced by isNeutralParticleVetoed(), and setRectangleDeltaEtaVetoBarrelNeutrals().

float PFIsolationEstimator::fRectangleDeltaEtaVetoBarrelPhotons

private

Definition at line 201 of file PFIsolationEstimator.h.

Referenced by isPhotonParticleVetoed(), and setRectangleDeltaEtaVetoBarrelPhotons().

float PFIsolationEstimator::fRectangleDeltaEtaVetoEndcapCharged

private

Definition at line 207 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed(), and setRectangleDeltaEtaVetoEndcapCharged().

float PFIsolationEstimator::fRectangleDeltaEtaVetoEndcapNeutrals

private

Definition at line 206 of file PFIsolationEstimator.h.

Referenced by isNeutralParticleVetoed(), and setRectangleDeltaEtaVetoEndcapNeutrals().

float PFIsolationEstimator::fRectangleDeltaEtaVetoEndcapPhotons

private

Definition at line 205 of file PFIsolationEstimator.h.

Referenced by isPhotonParticleVetoed(), and setRectangleDeltaEtaVetoEndcapPhotons().

float PFIsolationEstimator::fRectangleDeltaPhiVetoBarrelCharged

private

Definition at line 195 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed(), and setRectangleDeltaPhiVetoBarrelCharged().

float PFIsolationEstimator::fRectangleDeltaPhiVetoBarrelNeutrals

private

Definition at line 194 of file PFIsolationEstimator.h.

Referenced by isNeutralParticleVetoed(), and setRectangleDeltaPhiVetoBarrelNeutrals().

float PFIsolationEstimator::fRectangleDeltaPhiVetoBarrelPhotons

private

Definition at line 193 of file PFIsolationEstimator.h.

Referenced by isPhotonParticleVetoed(), and setRectangleDeltaPhiVetoBarrelPhotons().

float PFIsolationEstimator::fRectangleDeltaPhiVetoEndcapCharged

private

Definition at line 199 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed(), and setRectangleDeltaPhiVetoEndcapCharged().

float PFIsolationEstimator::fRectangleDeltaPhiVetoEndcapNeutrals

private

Definition at line 198 of file PFIsolationEstimator.h.

Referenced by isNeutralParticleVetoed(), and setRectangleDeltaPhiVetoEndcapNeutrals().

float PFIsolationEstimator::fRectangleDeltaPhiVetoEndcapPhotons

private

Definition at line 197 of file PFIsolationEstimator.h.

Referenced by isPhotonParticleVetoed(), and setRectangleDeltaPhiVetoEndcapPhotons().

float PFIsolationEstimator::fRingSize

private

Definition at line 212 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings(), getRingSize(), and setRingSize().

float PFIsolationEstimator::fVx

private

Definition at line 224 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings(), and isChargedParticleVetoed().

float PFIsolationEstimator::fVy

private

Definition at line 225 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings(), and isChargedParticleVetoed().

float PFIsolationEstimator::fVz

private

Definition at line 226 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings().

int PFIsolationEstimator::iMissHits

private

Definition at line 210 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings(), and isPhotonParticleVetoed().

int PFIsolationEstimator::iNumberOfRings

private

Definition at line 209 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings(), getNumbersOfRings(), initializeRings(), and setNumbersOfRings().

int PFIsolationEstimator::iParticleType

private

Definition at line 154 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed(), and setParticleType().

bool PFIsolationEstimator::pivotInBarrel

private

Definition at line 229 of file PFIsolationEstimator.h.

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

reco::SuperClusterRef PFIsolationEstimator::refSC

private

Definition at line 228 of file PFIsolationEstimator.h.

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

math::XYZVector PFIsolationEstimator::vtxWRTCandidate

private

Definition at line 231 of file PFIsolationEstimator.h.