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 51 of file PFIsolationEstimator.h.

Member Enumeration Documentation

VetoType

enum PFIsolationEstimator::VetoType

Enumerator
kElectron
kPhoton

Definition at line 56 of file PFIsolationEstimator.h.

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

Constructor & Destructor Documentation

PFIsolationEstimator()

PFIsolationEstimator::PFIsolationEstimator

(

)

Definition at line 24 of file PFIsolationEstimator.cc.

                                           : fisInitialized(kFALSE) {
  // Constructor.
}

~PFIsolationEstimator()

PFIsolationEstimator::~PFIsolationEstimator

(

)

Definition at line 29 of file PFIsolationEstimator.cc.

{}

Member Function Documentation

chargedHadronVertex()

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

Definition at line 639 of file PFIsolationEstimator.cc.

References funct::abs(), checkClosestZVertex, PVValHelper::dz, gpuVertexFinder::iv, pfDeepBoostedJetPreprocessParams_cfi::pfcand, edm::Handle< T >::product(), AlignmentTracksFromVertexSelector_cfi::vertices, extraflags_cff::vtx, 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 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();
}

fGetIsolation() [1/3]

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

Definition at line 178 of file PFIsolationEstimator.cc.

References fGetIsolationInRings(), fIsolation, fIsolationInRings, refSC, AlignmentTracksFromVertexSelector_cfi::vertices, and extraflags_cff::vtx.

Referenced by PhotonIsoProducer::filter().

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

  return fIsolation;
}

fGetIsolation() [2/3]

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

Definition at line 249 of file PFIsolationEstimator.cc.

References fGetIsolationInRings(), fIsolation, fIsolationInRings, displacedMuons_cfi::photon, AlignmentTracksFromVertexSelector_cfi::vertices, and extraflags_cff::vtx.

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

  return fIsolation;
}

fGetIsolation() [3/3]

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

Definition at line 349 of file PFIsolationEstimator.cc.

References HPSPFTauProducerPuppi_cfi::electron, fGetIsolationInRings(), fIsolation, fIsolationInRings, AlignmentTracksFromVertexSelector_cfi::vertices, and extraflags_cff::vtx.

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

  return fIsolation;
}

fGetIsolationInRings() [1/3]

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

Definition at line 190 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(), AlignmentTracksFromVertexSelector_cfi::vertices, extraflags_cff::vtx, 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 = 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;
}

fGetIsolationInRings() [2/3]

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

Definition at line 260 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(), displacedMuons_cfi::photon, pivotInBarrel, reco::LeafCandidate::pt(), refSC, reco::PFCandidate::superClusterRef(), AlignmentTracksFromVertexSelector_cfi::vertices, extraflags_cff::vtx, 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;
}

fGetIsolationInRings() [3/3]

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

Definition at line 360 of file PFIsolationEstimator.cc.

References funct::abs(), HPSPFTauProducerPuppi_cfi::electron, fDeltaR, fEta, fIsolationInRings, fIsolationInRingsCharged, fIsolationInRingsChargedAll, fIsolationInRingsNeutral, fIsolationInRingsPhoton, fPhi, fPt, fRingSize, fVx, fVy, fVz, iMissHits, createfilelist::int, iNumberOfRings, isChargedParticleVetoed(), isNeutralParticleVetoed(), isPhotonParticleVetoed(), reco::HitPattern::MISSING_INNER_HITS, reco::LeafCandidate::pdgId(), pivotInBarrel, reco::LeafCandidate::pt(), refSC, AlignmentTracksFromVertexSelector_cfi::vertices, and extraflags_cff::vtx.

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

getIsolationCharged()

float PFIsolationEstimator::getIsolationCharged ( )

inline

Definition at line 152 of file PFIsolationEstimator.h.

References fIsolationCharged, and fIsolationInRingsCharged.

Referenced by PhotonIsoProducer::filter().

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

getIsolationChargedAll()

float PFIsolationEstimator::getIsolationChargedAll ( )

inline

Definition at line 156 of file PFIsolationEstimator.h.

References fIsolationChargedAll.

{ return fIsolationChargedAll; };

getIsolationInRingsCharged()

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

inline

Definition at line 160 of file PFIsolationEstimator.h.

References fIsolationInRingsCharged.

{ return fIsolationInRingsCharged; };

getIsolationInRingsChargedAll()

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

inline

Definition at line 161 of file PFIsolationEstimator.h.

References fIsolationInRingsChargedAll.

{ return fIsolationInRingsChargedAll; };

getIsolationInRingsNeutral()

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

inline

Definition at line 159 of file PFIsolationEstimator.h.

References fIsolationInRingsNeutral.

{ return fIsolationInRingsNeutral; };

getIsolationInRingsPhoton()

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

inline

Definition at line 158 of file PFIsolationEstimator.h.

References fIsolationInRingsPhoton.

{ return fIsolationInRingsPhoton; };

getIsolationNeutral()

float PFIsolationEstimator::getIsolationNeutral ( )

inline

Definition at line 148 of file PFIsolationEstimator.h.

References fIsolationInRingsNeutral, and fIsolationNeutral.

Referenced by PhotonIsoProducer::filter().

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

getIsolationPhoton()

float PFIsolationEstimator::getIsolationPhoton ( )

inline

Definition at line 144 of file PFIsolationEstimator.h.

References fIsolationInRingsPhoton, and fIsolationPhoton.

Referenced by PhotonIsoProducer::filter().

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

getNumbersOfRings()

int PFIsolationEstimator::getNumbersOfRings ( )

inline

Definition at line 166 of file PFIsolationEstimator.h.

References iNumberOfRings.

{ return iNumberOfRings; };

getRingSize()

float PFIsolationEstimator::getRingSize ( )

inline

Definition at line 167 of file PFIsolationEstimator.h.

References fRingSize.

{ return fRingSize; };

initialize()

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

private

Definition at line 32 of file PFIsolationEstimator.cc.

References bApplyVeto, checkClosestZVertex, iParticleType, 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.);
  }
}

initializeElectronIsolation()

void PFIsolationEstimator::initializeElectronIsolation

(

Bool_t

bApplyVeto

)

Definition at line 119 of file PFIsolationEstimator.cc.

References bApplyVeto, 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;
}

initializeElectronIsolationInRings()

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

Definition at line 140 of file PFIsolationEstimator.cc.

References bApplyVeto, fRingSize, initialize(), initializeRings(), iNumberOfRings, and kElectron.

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

initializePhotonIsolation()

void PFIsolationEstimator::initializePhotonIsolation

(

Bool_t

bApplyVeto

)

Definition at line 134 of file PFIsolationEstimator.cc.

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

Referenced by PhotonIsoProducer::PhotonIsoProducer().

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

initializePhotonIsolationInRings()

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

Definition at line 146 of file PFIsolationEstimator.cc.

References bApplyVeto, fRingSize, initialize(), initializeRings(), iNumberOfRings, and kPhoton.

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

initializeRings()

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

Definition at line 152 of file PFIsolationEstimator.cc.

References fConeSize, fIsolationInRings, fIsolationInRingsCharged, fIsolationInRingsChargedAll, fIsolationInRingsNeutral, fIsolationInRingsPhoton, dqmMemoryStats::float, fRingSize, 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;
}

isChargedParticleVetoed() [1/2]

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

Definition at line 530 of file PFIsolationEstimator.cc.

Referenced by fGetIsolationInRings().

                                                                                              {
  //need code to handle special conditions

  return -999;
}

isChargedParticleVetoed() [2/2]

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

Definition at line 538 of file PFIsolationEstimator.cc.

References funct::abs(), bApplyDzDxyVeto, bApplyPFPUVeto, bApplyVeto, bDeltaRVetoBarrel, bDeltaRVetoEndcap, bRectangleVetoBarrel, bRectangleVetoEndcap, chargedHadronVertex(), SiPixelRawToDigiRegional_cfi::deltaPhi, PbPb_ZMuSkimMuonDPG_cff::deltaR, PVValHelper::dxy, PVValHelper::dz, reco::LeafCandidate::eta(), fConeSize, fDeltaEta, fDeltaPhi, fDeltaR, fDeltaRVetoBarrelCharged, fDeltaRVetoEndcapCharged, fEta, fPhi, fRectangleDeltaEtaVetoBarrelCharged, fRectangleDeltaEtaVetoEndcapCharged, fRectangleDeltaPhiVetoBarrelCharged, fRectangleDeltaPhiVetoEndcapCharged, fVx, fVy, iParticleType, kPhoton, reco::LeafCandidate::phi(), pivotInBarrel, reco::LeafCandidate::pt(), reco::LeafCandidate::px(), reco::LeafCandidate::py(), reco::PFCandidate::trackRef(), AlignmentTracksFromVertexSelector_cfi::vertices, and extraflags_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;
}

isInitialized()

Bool_t PFIsolationEstimator::isInitialized ( ) const

inline

Definition at line 66 of file PFIsolationEstimator.h.

References fisInitialized.

{ return fisInitialized; }

isNeutralParticleVetoed()

float PFIsolationEstimator::isNeutralParticleVetoed

(

const reco::PFCandidate *

pfIsoCand

)

Definition at line 480 of file PFIsolationEstimator.cc.

References funct::abs(), bApplyVeto, bDeltaRVetoBarrel, bDeltaRVetoEndcap, bRectangleVetoBarrel, bRectangleVetoEndcap, SiPixelRawToDigiRegional_cfi::deltaPhi, PbPb_ZMuSkimMuonDPG_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().

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

isPhotonParticleVetoed()

float PFIsolationEstimator::isPhotonParticleVetoed

(

const reco::PFCandidate *

pfIsoCand

)

Definition at line 422 of file PFIsolationEstimator.cc.

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

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

matchPFObject() [1/2]

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

Definition at line 703 of file PFIsolationEstimator.cc.

References mps_fire::i, reco::LeafCandidate::pdgId(), displacedMuons_cfi::photon, 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;
}

matchPFObject() [2/2]

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

Definition at line 741 of file PFIsolationEstimator.cc.

References PbPb_ZMuSkimMuonDPG_cff::deltaR, HPSPFTauProducerPuppi_cfi::electron, reco::LeafCandidate::eta(), fDeltaR, fPt, mps_fire::i, reco::LeafCandidate::pdgId(), reco::LeafCandidate::phi(), reco::LeafCandidate::pt(), 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;
}

setApplyDzDxyVeto()

void PFIsolationEstimator::setApplyDzDxyVeto ( Bool_t  bValue = kTRUE )

inline

Definition at line 104 of file PFIsolationEstimator.h.

References bApplyDzDxyVeto.

Referenced by initialize().

{ bApplyDzDxyVeto = bValue; };

setApplyMissHitPhVeto()

void PFIsolationEstimator::setApplyMissHitPhVeto ( Bool_t  bValue = kFALSE )

inline

Definition at line 105 of file PFIsolationEstimator.h.

References bApplyMissHitPhVeto.

Referenced by initialize().

{ bApplyMissHitPhVeto = bValue; };

setApplyPFPUVeto()

void PFIsolationEstimator::setApplyPFPUVeto ( Bool_t  bValue = kFALSE )

inline

Definition at line 103 of file PFIsolationEstimator.h.

References bApplyPFPUVeto.

Referenced by initialize().

{ bApplyPFPUVeto = bValue; };

setApplyVeto()

void PFIsolationEstimator::setApplyVeto ( Bool_t  bValue = kTRUE )

inline

Definition at line 102 of file PFIsolationEstimator.h.

References bApplyVeto.

Referenced by initialize().

{ bApplyVeto = bValue; };

setConeSize()

void PFIsolationEstimator::setConeSize ( float  fValue = 0.4 )

inline

Definition at line 97 of file PFIsolationEstimator.h.

References fConeSize.

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

{ fConeSize = fValue; };

setDeltaRVetoBarrel()

void PFIsolationEstimator::setDeltaRVetoBarrel ( Bool_t  bValue = kTRUE )

inline

Definition at line 106 of file PFIsolationEstimator.h.

References bDeltaRVetoBarrel.

Referenced by initialize().

{ bDeltaRVetoBarrel = bValue; };

setDeltaRVetoBarrelCharged()

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

inline

Definition at line 116 of file PFIsolationEstimator.h.

References fDeltaRVetoBarrelCharged.

Referenced by initialize().

{ fDeltaRVetoBarrelCharged = fValue; };

setDeltaRVetoBarrelNeutrals()

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

inline

Definition at line 115 of file PFIsolationEstimator.h.

References fDeltaRVetoBarrelNeutrals.

Referenced by initialize().

{ fDeltaRVetoBarrelNeutrals = fValue; };

setDeltaRVetoBarrelPhotons()

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

inline

Definition at line 114 of file PFIsolationEstimator.h.

References fDeltaRVetoBarrelPhotons.

Referenced by initialize().

{ fDeltaRVetoBarrelPhotons = fValue; };

setDeltaRVetoEndcap()

void PFIsolationEstimator::setDeltaRVetoEndcap ( Bool_t  bValue = kTRUE )

inline

Definition at line 107 of file PFIsolationEstimator.h.

References bDeltaRVetoEndcap.

Referenced by initialize().

{ bDeltaRVetoEndcap = bValue; };

setDeltaRVetoEndcapCharged()

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

inline

Definition at line 119 of file PFIsolationEstimator.h.

References fDeltaRVetoEndcapCharged.

Referenced by initialize().

{ fDeltaRVetoEndcapCharged = fValue; };

setDeltaRVetoEndcapNeutrals()

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

inline

Definition at line 118 of file PFIsolationEstimator.h.

References fDeltaRVetoEndcapNeutrals.

Referenced by initialize().

{ fDeltaRVetoEndcapNeutrals = fValue; };

setDeltaRVetoEndcapPhotons()

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

inline

Definition at line 117 of file PFIsolationEstimator.h.

References fDeltaRVetoEndcapPhotons.

Referenced by initialize().

{ fDeltaRVetoEndcapPhotons = fValue; };

setNumberOfCrystalEndcapPhotons()

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

inline

Definition at line 120 of file PFIsolationEstimator.h.

References fNumberOfCrystalEndcapPhotons.

Referenced by initialize().

{ fNumberOfCrystalEndcapPhotons = fValue; };

setNumbersOfRings()

void PFIsolationEstimator::setNumbersOfRings ( int  iValue = 1 )

inline

Definition at line 163 of file PFIsolationEstimator.h.

References iNumberOfRings.

Referenced by initializeRings().

{ iNumberOfRings = iValue; };

setParticleType()

void PFIsolationEstimator::setParticleType ( int  iValue )

inline

Definition at line 99 of file PFIsolationEstimator.h.

References iParticleType.

Referenced by initialize().

{ iParticleType = iValue; };

setRectangleDeltaEtaVetoBarrelCharged()

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

inline

Definition at line 131 of file PFIsolationEstimator.h.

References fRectangleDeltaEtaVetoBarrelCharged.

Referenced by initialize().

{ fRectangleDeltaEtaVetoBarrelCharged = fValue; };

setRectangleDeltaEtaVetoBarrelNeutrals()

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

inline

Definition at line 130 of file PFIsolationEstimator.h.

References fRectangleDeltaEtaVetoBarrelNeutrals.

Referenced by initialize().

{ fRectangleDeltaEtaVetoBarrelNeutrals = fValue; };

setRectangleDeltaEtaVetoBarrelPhotons()

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

inline

Definition at line 129 of file PFIsolationEstimator.h.

References fRectangleDeltaEtaVetoBarrelPhotons.

Referenced by initialize().

{ fRectangleDeltaEtaVetoBarrelPhotons = fValue; };

setRectangleDeltaEtaVetoEndcapCharged()

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

inline

Definition at line 134 of file PFIsolationEstimator.h.

References fRectangleDeltaEtaVetoEndcapCharged.

Referenced by initialize().

{ fRectangleDeltaEtaVetoEndcapCharged = fValue; };

setRectangleDeltaEtaVetoEndcapNeutrals()

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

inline

Definition at line 133 of file PFIsolationEstimator.h.

References fRectangleDeltaEtaVetoEndcapNeutrals.

Referenced by initialize().

{ fRectangleDeltaEtaVetoEndcapNeutrals = fValue; };

setRectangleDeltaEtaVetoEndcapPhotons()

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

inline

Definition at line 132 of file PFIsolationEstimator.h.

References fRectangleDeltaEtaVetoEndcapPhotons.

Referenced by initialize().

{ fRectangleDeltaEtaVetoEndcapPhotons = fValue; };

setRectangleDeltaPhiVetoBarrelCharged()

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

inline

Definition at line 124 of file PFIsolationEstimator.h.

References fRectangleDeltaPhiVetoBarrelCharged.

Referenced by initialize().

{ fRectangleDeltaPhiVetoBarrelCharged = fValue; };

setRectangleDeltaPhiVetoBarrelNeutrals()

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

inline

Definition at line 123 of file PFIsolationEstimator.h.

References fRectangleDeltaPhiVetoBarrelNeutrals.

Referenced by initialize().

{ fRectangleDeltaPhiVetoBarrelNeutrals = fValue; };

setRectangleDeltaPhiVetoBarrelPhotons()

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

inline

Definition at line 122 of file PFIsolationEstimator.h.

References fRectangleDeltaPhiVetoBarrelPhotons.

Referenced by initialize().

{ fRectangleDeltaPhiVetoBarrelPhotons = fValue; };

setRectangleDeltaPhiVetoEndcapCharged()

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

inline

Definition at line 127 of file PFIsolationEstimator.h.

References fRectangleDeltaPhiVetoEndcapCharged.

Referenced by initialize().

{ fRectangleDeltaPhiVetoEndcapCharged = fValue; };

setRectangleDeltaPhiVetoEndcapNeutrals()

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

inline

Definition at line 126 of file PFIsolationEstimator.h.

References fRectangleDeltaPhiVetoEndcapNeutrals.

Referenced by initialize().

{ fRectangleDeltaPhiVetoEndcapNeutrals = fValue; };

setRectangleDeltaPhiVetoEndcapPhotons()

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

inline

Definition at line 125 of file PFIsolationEstimator.h.

References fRectangleDeltaPhiVetoEndcapPhotons.

Referenced by initialize().

{ fRectangleDeltaPhiVetoEndcapPhotons = fValue; };

setRectangleVetoBarrel()

void PFIsolationEstimator::setRectangleVetoBarrel ( Bool_t  bValue = kTRUE )

inline

Definition at line 108 of file PFIsolationEstimator.h.

References bRectangleVetoBarrel.

Referenced by initialize().

{ bRectangleVetoBarrel = bValue; };

setRectangleVetoEndcap()

void PFIsolationEstimator::setRectangleVetoEndcap ( Bool_t  bValue = kTRUE )

inline

Definition at line 109 of file PFIsolationEstimator.h.

References bRectangleVetoEndcap.

Referenced by initialize().

{ bRectangleVetoEndcap = bValue; };

setRingSize()

void PFIsolationEstimator::setRingSize ( float  fValue = 0.4 )

inline

Definition at line 164 of file PFIsolationEstimator.h.

References fRingSize.

Referenced by initializeRings().

{ fRingSize = fValue; };

setUseCrystalSize()

void PFIsolationEstimator::setUseCrystalSize ( Bool_t  bValue = kFALSE )

inline

Definition at line 111 of file PFIsolationEstimator.h.

References bUseCrystalSize.

Referenced by initialize().

{ bUseCrystalSize = bValue; };

Member Data Documentation

bApplyDzDxyVeto

Bool_t PFIsolationEstimator::bApplyDzDxyVeto

private

Definition at line 191 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed(), and setApplyDzDxyVeto().

bApplyMissHitPhVeto

Bool_t PFIsolationEstimator::bApplyMissHitPhVeto

private

Definition at line 193 of file PFIsolationEstimator.h.

Referenced by isPhotonParticleVetoed(), and setApplyMissHitPhVeto().

bApplyPFPUVeto

Bool_t PFIsolationEstimator::bApplyPFPUVeto

private

Definition at line 192 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed(), and setApplyPFPUVeto().

bApplyVeto

Bool_t PFIsolationEstimator::bApplyVeto

private

Definition at line 190 of file PFIsolationEstimator.h.

Referenced by initialize(), initializeElectronIsolation(), initializeElectronIsolationInRings(), initializePhotonIsolation(), initializePhotonIsolationInRings(), isChargedParticleVetoed(), isNeutralParticleVetoed(), isPhotonParticleVetoed(), and setApplyVeto().

bDeltaRVetoBarrel

Bool_t PFIsolationEstimator::bDeltaRVetoBarrel

private

Definition at line 196 of file PFIsolationEstimator.h.

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

bDeltaRVetoEndcap

Bool_t PFIsolationEstimator::bDeltaRVetoEndcap

private

Definition at line 197 of file PFIsolationEstimator.h.

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

bRectangleVetoBarrel

Bool_t PFIsolationEstimator::bRectangleVetoBarrel

private

Definition at line 199 of file PFIsolationEstimator.h.

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

bRectangleVetoEndcap

Bool_t PFIsolationEstimator::bRectangleVetoEndcap

private

Definition at line 200 of file PFIsolationEstimator.h.

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

bUseCrystalSize

Bool_t PFIsolationEstimator::bUseCrystalSize

private

Definition at line 194 of file PFIsolationEstimator.h.

Referenced by isPhotonParticleVetoed(), and setUseCrystalSize().

checkClosestZVertex

Bool_t PFIsolationEstimator::checkClosestZVertex

private

Definition at line 188 of file PFIsolationEstimator.h.

Referenced by chargedHadronVertex(), and initialize().

fConeSize

float PFIsolationEstimator::fConeSize

private

Definition at line 189 of file PFIsolationEstimator.h.

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

fDeltaEta

float PFIsolationEstimator::fDeltaEta

private

Definition at line 234 of file PFIsolationEstimator.h.

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

fDeltaPhi

float PFIsolationEstimator::fDeltaPhi

private

Definition at line 235 of file PFIsolationEstimator.h.

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

fDeltaR

float PFIsolationEstimator::fDeltaR

private

Definition at line 233 of file PFIsolationEstimator.h.

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

fDeltaRVetoBarrelCharged

float PFIsolationEstimator::fDeltaRVetoBarrelCharged

private

Definition at line 204 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed(), and setDeltaRVetoBarrelCharged().

fDeltaRVetoBarrelNeutrals

float PFIsolationEstimator::fDeltaRVetoBarrelNeutrals

private

Definition at line 203 of file PFIsolationEstimator.h.

Referenced by isNeutralParticleVetoed(), and setDeltaRVetoBarrelNeutrals().

fDeltaRVetoBarrelPhotons

float PFIsolationEstimator::fDeltaRVetoBarrelPhotons

private

Definition at line 202 of file PFIsolationEstimator.h.

Referenced by isPhotonParticleVetoed(), and setDeltaRVetoBarrelPhotons().

fDeltaRVetoEndcapCharged

float PFIsolationEstimator::fDeltaRVetoEndcapCharged

private

Definition at line 208 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed(), and setDeltaRVetoEndcapCharged().

fDeltaRVetoEndcapNeutrals

float PFIsolationEstimator::fDeltaRVetoEndcapNeutrals

private

Definition at line 207 of file PFIsolationEstimator.h.

Referenced by isNeutralParticleVetoed(), and setDeltaRVetoEndcapNeutrals().

fDeltaRVetoEndcapPhotons

float PFIsolationEstimator::fDeltaRVetoEndcapPhotons

private

Definition at line 206 of file PFIsolationEstimator.h.

Referenced by isPhotonParticleVetoed(), and setDeltaRVetoEndcapPhotons().

fEta

float PFIsolationEstimator::fEta

private

Definition at line 237 of file PFIsolationEstimator.h.

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

fEtaSC

float PFIsolationEstimator::fEtaSC

private

Definition at line 239 of file PFIsolationEstimator.h.

fisInitialized

Bool_t PFIsolationEstimator::fisInitialized

private

Definition at line 175 of file PFIsolationEstimator.h.

Referenced by isInitialized().

fIsolation

float PFIsolationEstimator::fIsolation

private

Definition at line 176 of file PFIsolationEstimator.h.

Referenced by fGetIsolation().

fIsolationCharged

float PFIsolationEstimator::fIsolationCharged

private

Definition at line 179 of file PFIsolationEstimator.h.

Referenced by getIsolationCharged().

fIsolationChargedAll

float PFIsolationEstimator::fIsolationChargedAll

private

Definition at line 180 of file PFIsolationEstimator.h.

Referenced by getIsolationChargedAll().

fIsolationInRings

std::vector<float> PFIsolationEstimator::fIsolationInRings

private

Definition at line 182 of file PFIsolationEstimator.h.

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

fIsolationInRingsCharged

std::vector<float> PFIsolationEstimator::fIsolationInRingsCharged

private

Definition at line 185 of file PFIsolationEstimator.h.

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

fIsolationInRingsChargedAll

std::vector<float> PFIsolationEstimator::fIsolationInRingsChargedAll

private

Definition at line 186 of file PFIsolationEstimator.h.

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

fIsolationInRingsNeutral

std::vector<float> PFIsolationEstimator::fIsolationInRingsNeutral

private

Definition at line 184 of file PFIsolationEstimator.h.

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

fIsolationInRingsPhoton

std::vector<float> PFIsolationEstimator::fIsolationInRingsPhoton

private

Definition at line 183 of file PFIsolationEstimator.h.

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

fIsolationNeutral

float PFIsolationEstimator::fIsolationNeutral

private

Definition at line 178 of file PFIsolationEstimator.h.

Referenced by getIsolationNeutral().

fIsolationPhoton

float PFIsolationEstimator::fIsolationPhoton

private

Definition at line 177 of file PFIsolationEstimator.h.

Referenced by getIsolationPhoton().

fNumberOfCrystalEndcapPhotons

float PFIsolationEstimator::fNumberOfCrystalEndcapPhotons

private

Definition at line 210 of file PFIsolationEstimator.h.

Referenced by isPhotonParticleVetoed(), and setNumberOfCrystalEndcapPhotons().

fPhi

float PFIsolationEstimator::fPhi

private

Definition at line 238 of file PFIsolationEstimator.h.

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

fPhiSC

float PFIsolationEstimator::fPhiSC

private

Definition at line 240 of file PFIsolationEstimator.h.

fPt

float PFIsolationEstimator::fPt

private

Definition at line 242 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings(), and matchPFObject().

fRectangleDeltaEtaVetoBarrelCharged

float PFIsolationEstimator::fRectangleDeltaEtaVetoBarrelCharged

private

Definition at line 222 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed(), and setRectangleDeltaEtaVetoBarrelCharged().

fRectangleDeltaEtaVetoBarrelNeutrals

float PFIsolationEstimator::fRectangleDeltaEtaVetoBarrelNeutrals

private

Definition at line 221 of file PFIsolationEstimator.h.

Referenced by isNeutralParticleVetoed(), and setRectangleDeltaEtaVetoBarrelNeutrals().

fRectangleDeltaEtaVetoBarrelPhotons

float PFIsolationEstimator::fRectangleDeltaEtaVetoBarrelPhotons

private

Definition at line 220 of file PFIsolationEstimator.h.

Referenced by isPhotonParticleVetoed(), and setRectangleDeltaEtaVetoBarrelPhotons().

fRectangleDeltaEtaVetoEndcapCharged

float PFIsolationEstimator::fRectangleDeltaEtaVetoEndcapCharged

private

Definition at line 226 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed(), and setRectangleDeltaEtaVetoEndcapCharged().

fRectangleDeltaEtaVetoEndcapNeutrals

float PFIsolationEstimator::fRectangleDeltaEtaVetoEndcapNeutrals

private

Definition at line 225 of file PFIsolationEstimator.h.

Referenced by isNeutralParticleVetoed(), and setRectangleDeltaEtaVetoEndcapNeutrals().

fRectangleDeltaEtaVetoEndcapPhotons

float PFIsolationEstimator::fRectangleDeltaEtaVetoEndcapPhotons

private

Definition at line 224 of file PFIsolationEstimator.h.

Referenced by isPhotonParticleVetoed(), and setRectangleDeltaEtaVetoEndcapPhotons().

fRectangleDeltaPhiVetoBarrelCharged

float PFIsolationEstimator::fRectangleDeltaPhiVetoBarrelCharged

private

Definition at line 214 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed(), and setRectangleDeltaPhiVetoBarrelCharged().

fRectangleDeltaPhiVetoBarrelNeutrals

float PFIsolationEstimator::fRectangleDeltaPhiVetoBarrelNeutrals

private

Definition at line 213 of file PFIsolationEstimator.h.

Referenced by isNeutralParticleVetoed(), and setRectangleDeltaPhiVetoBarrelNeutrals().

fRectangleDeltaPhiVetoBarrelPhotons

float PFIsolationEstimator::fRectangleDeltaPhiVetoBarrelPhotons

private

Definition at line 212 of file PFIsolationEstimator.h.

Referenced by isPhotonParticleVetoed(), and setRectangleDeltaPhiVetoBarrelPhotons().

fRectangleDeltaPhiVetoEndcapCharged

float PFIsolationEstimator::fRectangleDeltaPhiVetoEndcapCharged

private

Definition at line 218 of file PFIsolationEstimator.h.

Referenced by isChargedParticleVetoed(), and setRectangleDeltaPhiVetoEndcapCharged().

fRectangleDeltaPhiVetoEndcapNeutrals

float PFIsolationEstimator::fRectangleDeltaPhiVetoEndcapNeutrals

private

Definition at line 217 of file PFIsolationEstimator.h.

Referenced by isNeutralParticleVetoed(), and setRectangleDeltaPhiVetoEndcapNeutrals().

fRectangleDeltaPhiVetoEndcapPhotons

float PFIsolationEstimator::fRectangleDeltaPhiVetoEndcapPhotons

private

Definition at line 216 of file PFIsolationEstimator.h.

Referenced by isPhotonParticleVetoed(), and setRectangleDeltaPhiVetoEndcapPhotons().

fRingSize

float PFIsolationEstimator::fRingSize

private

Definition at line 231 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings(), getRingSize(), initializeElectronIsolationInRings(), initializePhotonIsolationInRings(), initializeRings(), and setRingSize().

fVx

float PFIsolationEstimator::fVx

private

Definition at line 243 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings(), and isChargedParticleVetoed().

fVy

float PFIsolationEstimator::fVy

private

Definition at line 244 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings(), and isChargedParticleVetoed().

fVz

float PFIsolationEstimator::fVz

private

Definition at line 245 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings().

iMissHits

int PFIsolationEstimator::iMissHits

private

Definition at line 229 of file PFIsolationEstimator.h.

Referenced by fGetIsolationInRings(), and isPhotonParticleVetoed().

iNumberOfRings

int PFIsolationEstimator::iNumberOfRings

private

Definition at line 228 of file PFIsolationEstimator.h.

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

iParticleType

int PFIsolationEstimator::iParticleType

private

Definition at line 173 of file PFIsolationEstimator.h.

Referenced by initialize(), isChargedParticleVetoed(), and setParticleType().

pivotInBarrel

bool PFIsolationEstimator::pivotInBarrel

private

Definition at line 248 of file PFIsolationEstimator.h.

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

refSC

reco::SuperClusterRef PFIsolationEstimator::refSC

private

Definition at line 247 of file PFIsolationEstimator.h.

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

vtxWRTCandidate

math::XYZVector PFIsolationEstimator::vtxWRTCandidate

private

Definition at line 250 of file PFIsolationEstimator.h.