PFPhotonIsolationCalculator Class Reference

#include <PFPhotonIsolationCalculator.h>

Public Member Functions
void	calculate (const reco::Photon *, const edm::Handle< reco::PFCandidateCollection > pfCandidateHandle, edm::Handle< reco::VertexCollection > &vertices, const edm::Event &e, const edm::EventSetup &es, reco::Photon::PflowIsolationVariables &phoisol03)
	PFPhotonIsolationCalculator ()
void	setup (const edm::ParameterSet &conf)
	~PFPhotonIsolationCalculator ()

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

Private Member Functions
reco::VertexRef	chargedHadronVertex (edm::Handle< reco::VertexCollection > verticies, const reco::PFCandidate &pfcand)
float	fGetIsolation (const reco::Photon *photon, const edm::Handle< reco::PFCandidateCollection > pfCandidateHandle, reco::VertexRef vtx, edm::Handle< reco::VertexCollection > vertices)
std::vector< float >	fGetIsolationInRings (const reco::Photon *photon, edm::Handle< reco::PFCandidateCollection > pfCandidateHandle, 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 ()
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)
float	isChargedParticleVetoed (const reco::PFCandidateRef pfIsoCand, reco::VertexRef vtx, edm::Handle< reco::VertexCollection > vertices)
float	isNeutralParticleVetoed (const reco::PFCandidate *pfIsoCand)
float	isNeutralParticleVetoed (const reco::PFCandidateRef pfIsoCand)
float	isPhotonParticleVetoed (const reco::PFCandidateRef 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)

Private Attributes
Bool_t	bApplyDzDxyVeto_
Bool_t	bApplyMissHitPhVeto_
Bool_t	bApplyPFPUVeto_
Bool_t	bApplyVeto_
Bool_t	bCheckClosestZVertex_
Bool_t	bDeltaRVetoBarrel_
Bool_t	bDeltaRVetoEndcap_
Bool_t	bRectangleVetoBarrel_
Bool_t	bRectangleVetoEndcap_
Bool_t	bUseCrystalSize_
float	fConeSize_
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

Detailed Description

Definition at line 35 of file PFPhotonIsolationCalculator.h.

Member Enumeration Documentation

enum PFPhotonIsolationCalculator::VetoType

private

Enumerator
kElectron
kPhoton

Definition at line 51 of file PFPhotonIsolationCalculator.h.

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

Constructor & Destructor Documentation

PFPhotonIsolationCalculator::PFPhotonIsolationCalculator

(

)

Definition at line 62 of file PFPhotonIsolationCalculator.cc.

                                                         {
  // Constructor.
}

PFPhotonIsolationCalculator::~PFPhotonIsolationCalculator

(

)

Definition at line 67 of file PFPhotonIsolationCalculator.cc.

{}

Member Function Documentation

void PFPhotonIsolationCalculator::calculate	(	const reco::Photon *	aPho,
		const edm::Handle< reco::PFCandidateCollection >	pfCandidateHandle,
		edm::Handle< reco::VertexCollection > &	vertices,
		const edm::Event &	e,
		const edm::EventSetup &	es,
		reco::Photon::PflowIsolationVariables &	phoisol03
	)

Definition at line 69 of file PFPhotonIsolationCalculator.cc.

References reco::Photon::PflowIsolationVariables::chargedHadronIso, fGetIsolation(), getIsolationCharged(), getIsolationNeutral(), getIsolationPhoton(), reco::Photon::PflowIsolationVariables::neutralHadronIso, reco::Photon::PflowIsolationVariables::photonIso, and badGlobalMuonTaggersAOD_cff::vtx.

                                                                                          {
  reco::VertexRef vtx(vertices, 0);
  this->fGetIsolation(&*aPho, pfCandidateHandle, vtx, vertices);
  phoisol03.chargedHadronIso = this->getIsolationCharged();
  phoisol03.neutralHadronIso = this->getIsolationNeutral();
  phoisol03.photonIso = this->getIsolationPhoton();
}

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

private

Definition at line 630 of file PFPhotonIsolationCalculator.cc.

References bCheckClosestZVertex_, PVValHelper::dz, edm::Handle< T >::product(), HLT_2018_cff::track, reco::PFCandidate::trackRef(), reco::PFCandidate::vertex(), pwdgSkimBPark_cfi::vertices, badGlobalMuonTaggersAOD_cff::vtx, and w.

Referenced by getIsolationInRingsChargedAll(), and isChargedParticleVetoed().

                                                                                                {
  //code copied from Florian's PFNoPU class (corrected removing the double loop....)

  auto const& track = pfcand.trackRef();

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

  float bestweight = 0;

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

  for (auto const& vtx : vertices) {
    float w = vtx.trackWeight(track);  // 0 if does not belong here
    //select the vertex for which the track has the highest weight
    if (w > bestweight) {  // should we break here?
      bestweight = w;
      iVertex = index;
      nFoundVertex++;
    }
    ++index;
  }

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

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

  return reco::VertexRef();
}

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

private

Definition at line 107 of file PFPhotonIsolationCalculator.cc.

References fGetIsolationInRings(), fIsolation_, and fIsolationInRings_.

Referenced by calculate(), and getIsolationInRingsChargedAll().

                                                                                           {
  fGetIsolationInRings(photon, pfCandidateHandle, vtx, vertices);
  fIsolation_ = fIsolationInRings_[0];
  return fIsolation_;
}

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

private

Definition at line 117 of file PFPhotonIsolationCalculator.cc.

References funct::abs(), fEta_, fIsolationInRings_, fIsolationInRingsCharged_, fIsolationInRingsChargedAll_, fIsolationInRingsNeutral_, fIsolationInRingsPhoton_, fPhi_, fRingSize_, fVx_, fVy_, fVz_, iMissHits_, createfilelist::int, iNumberOfRings_, isChargedParticleVetoed(), isNeutralParticleVetoed(), edm::Ref< C, T, F >::isNonnull(), isPhotonParticleVetoed(), pivotInBarrel, refSC, and reco::Photon::superCluster().

Referenced by fGetIsolation(), and getIsolationInRingsChargedAll().

                                              {
  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::fabs((refSC->position().eta())) < 1.479;

  for (unsigned iPF = 0; iPF < pfCandidateHandle->size(); iPF++) {
    reco::PFCandidateRef pfParticle(reco::PFCandidateRef(pfCandidateHandle, 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();

      float fDeltaR = isPhotonParticleVetoed(pfParticle);
      if (fDeltaR >= 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();
      float fDeltaR = isNeutralParticleVetoed(pfParticle);
      if (fDeltaR >= 0.) {
        isoBin = (int)(fDeltaR / fRingSize_);
        fIsolationInRingsNeutral_[isoBin] = fIsolationInRingsNeutral_[isoBin] + pfParticle->pt();
      }

      //}else if(abs(pfParticle.pdgId()) == 11 ||abs(pfParticle.pdgId()) == 13 || abs(pfParticle.pdgId()) == 211){
    } else if (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();
      float fDeltaR = isChargedParticleVetoed(pfParticle, vtx, vertices);
      if (fDeltaR >= 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 PFPhotonIsolationCalculator::getIsolationCharged ( )

inlineprivate

Definition at line 66 of file PFPhotonIsolationCalculator.h.

References fIsolationCharged_, and fIsolationInRingsCharged_.

Referenced by calculate().

                              {
    fIsolationCharged_ = fIsolationInRingsCharged_[0];
    return fIsolationCharged_;
  };

float PFPhotonIsolationCalculator::getIsolationChargedAll ( )

inlineprivate

Definition at line 70 of file PFPhotonIsolationCalculator.h.

References fIsolationChargedAll_.

{ return fIsolationChargedAll_; };

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

inlineprivate

Definition at line 74 of file PFPhotonIsolationCalculator.h.

References fIsolationInRingsCharged_.

{ return fIsolationInRingsCharged_; };

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

inlineprivate

Definition at line 75 of file PFPhotonIsolationCalculator.h.

References chargedHadronVertex(), fGetIsolation(), fGetIsolationInRings(), fIsolationInRingsChargedAll_, isChargedParticleVetoed(), isNeutralParticleVetoed(), isPhotonParticleVetoed(), matchPFObject(), pfDeepBoostedJetPreprocessParams_cfi::pfcand, muons2muons_cfi::photon, and badGlobalMuonTaggersAOD_cff::vtx.

{ return fIsolationInRingsChargedAll_; };

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

inlineprivate

Definition at line 73 of file PFPhotonIsolationCalculator.h.

References fIsolationInRingsNeutral_.

{ return fIsolationInRingsNeutral_; };

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

inlineprivate

Definition at line 72 of file PFPhotonIsolationCalculator.h.

References fIsolationInRingsPhoton_.

{ return fIsolationInRingsPhoton_; };

float PFPhotonIsolationCalculator::getIsolationNeutral ( )

inlineprivate

Definition at line 62 of file PFPhotonIsolationCalculator.h.

References fIsolationInRingsNeutral_, and fIsolationNeutral_.

Referenced by calculate().

                              {
    fIsolationNeutral_ = fIsolationInRingsNeutral_[0];
    return fIsolationNeutral_;
  };

float PFPhotonIsolationCalculator::getIsolationPhoton ( )

inlineprivate

Definition at line 58 of file PFPhotonIsolationCalculator.h.

References fIsolationInRingsPhoton_, and fIsolationPhoton_.

Referenced by calculate().

                             {
    fIsolationPhoton_ = fIsolationInRingsPhoton_[0];
    return fIsolationPhoton_;
  };

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

private

Definition at line 84 of file PFPhotonIsolationCalculator.cc.

References fConeSize_, fIsolationInRings_, fIsolationInRingsCharged_, fIsolationInRingsChargedAll_, fIsolationInRingsNeutral_, fIsolationInRingsPhoton_, and dqmMemoryStats::float.

Referenced by setup().

                                                                                     {
  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 PFPhotonIsolationCalculator::isChargedParticleVetoed ( const reco::PFCandidate *  pfIsoCand, edm::Handle< reco::VertexCollection >  vertices  )

private

Definition at line 426 of file PFPhotonIsolationCalculator.cc.

Referenced by fGetIsolationInRings(), and getIsolationInRingsChargedAll().

                                                                                                     {
  //need code to handle special conditions

  return -999;
}

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

private

Definition at line 434 of file PFPhotonIsolationCalculator.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_, 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::fabs(pfIsoCand->trackRef()->dz((*vtxMain).position()));
      if (dz > 0.2)
        return -999.;

      double dxy = pfIsoCand->trackRef()->dxy((*vtxMain).position());
      if (std::fabs(dxy) > 0.1)
        return -999.;

      /*
float dz = fabs(vtx->z() - fVtxMainZ);
if (dz > 1.)
        return -999.;
double dxy = ( -(vtx->x() - fVtxMainX)*pfIsoCand->py() + (vtx->y() - fVtxMainY)*pfIsoCand->px()) / pfIsoCand->pt();
if(fabs(dxy) > 0.2)
        return -999.;
*/
    } else {
      float dz = std::fabs(vtx->z() - fVtxMainZ);
      if (dz > 1.)
        return -999.;

      double dxy = (-(vtx->x() - fVx_) * pfIsoCand->py() + (vtx->y() - fVy_) * pfIsoCand->px()) / pfIsoCand->pt();
      if (std::fabs(dxy) > 0.1)
        return -999.;
    }
  }

  float fDeltaR = deltaR(pfIsoCand->eta(), pfIsoCand->phi(), fEta_, fPhi_);

  if (fDeltaR > fConeSize_)
    return -999.;

  float fDeltaPhi = deltaPhi(fPhi_, pfIsoCand->phi());
  float fDeltaEta = fEta_ - pfIsoCand->eta();

  // std::abscout << " 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;
}

float PFPhotonIsolationCalculator::isChargedParticleVetoed ( const reco::PFCandidateRef  pfIsoCand, reco::VertexRef  vtx, edm::Handle< reco::VertexCollection >  vertices  )

private

Definition at line 532 of file PFPhotonIsolationCalculator.cc.

References funct::abs(), bApplyDzDxyVeto_, bApplyPFPUVeto_, bApplyVeto_, bDeltaRVetoBarrel_, bDeltaRVetoEndcap_, bRectangleVetoBarrel_, bRectangleVetoEndcap_, chargedHadronVertex(), SiPixelRawToDigiRegional_cfi::deltaPhi, PbPb_ZMuSkimMuonDPG_cff::deltaR, PVValHelper::dxy, PVValHelper::dz, fConeSize_, fDeltaRVetoBarrelCharged_, fDeltaRVetoEndcapCharged_, fEta_, fPhi_, fRectangleDeltaEtaVetoBarrelCharged_, fRectangleDeltaEtaVetoEndcapCharged_, fRectangleDeltaPhiVetoBarrelCharged_, fRectangleDeltaPhiVetoEndcapCharged_, fVx_, fVy_, iParticleType_, edm::Ref< C, T, F >::isNull(), kPhoton, pivotInBarrel, 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::fabs(pfIsoCand->trackRef()->dz((*vtxMain).position()));
      if (dz > 0.2)
        return -999.;

      double dxy = pfIsoCand->trackRef()->dxy((*vtxMain).position());
      if (std::fabs(dxy) > 0.1)
        return -999.;

      /*
float dz = fabs(vtx->z() - fVtxMainZ);
if (dz > 1.)
        return -999.;
double dxy = ( -(vtx->x() - fVtxMainX)*pfIsoCand->py() + (vtx->y() - fVtxMainY)*pfIsoCand->px()) / pfIsoCand->pt();
if(fabs(dxy) > 0.2)
        return -999.;
*/
    } else {
      float dz = std::fabs(vtx->z() - fVtxMainZ);
      if (dz > 1.)
        return -999.;

      double dxy = (-(vtx->x() - fVx_) * pfIsoCand->py() + (vtx->y() - fVy_) * pfIsoCand->px()) / pfIsoCand->pt();
      if (std::fabs(dxy) > 0.1)
        return -999.;
    }
  }

  float fDeltaR = deltaR(pfIsoCand->eta(), pfIsoCand->phi(), fEta_, fPhi_);

  if (fDeltaR > fConeSize_)
    return -999.;

  float fDeltaPhi = deltaPhi(fPhi_, pfIsoCand->phi());
  float 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;
}

float PFPhotonIsolationCalculator::isNeutralParticleVetoed ( const reco::PFCandidate *  pfIsoCand )

private

Definition at line 326 of file PFPhotonIsolationCalculator.cc.

References funct::abs(), bApplyVeto_, bDeltaRVetoBarrel_, bDeltaRVetoEndcap_, bRectangleVetoBarrel_, bRectangleVetoEndcap_, SiPixelRawToDigiRegional_cfi::deltaPhi, PbPb_ZMuSkimMuonDPG_cff::deltaR, reco::LeafCandidate::eta(), fConeSize_, fDeltaRVetoBarrelNeutrals_, fDeltaRVetoEndcapNeutrals_, fEta_, fPhi_, fRectangleDeltaEtaVetoBarrelNeutrals_, fRectangleDeltaEtaVetoEndcapNeutrals_, fRectangleDeltaPhiVetoBarrelNeutrals_, fRectangleDeltaPhiVetoEndcapNeutrals_, reco::LeafCandidate::phi(), and pivotInBarrel.

Referenced by fGetIsolationInRings(), and getIsolationInRingsChargedAll().

                                                                                           {
  float fDeltaR = deltaR(fEta_, fPhi_, pfIsoCand->eta(), pfIsoCand->phi());

  if (fDeltaR > fConeSize_)
    return -999;

  float fDeltaPhi = deltaPhi(fPhi_, pfIsoCand->phi());
  float 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 PFPhotonIsolationCalculator::isNeutralParticleVetoed ( const reco::PFCandidateRef  pfIsoCand )

private

Definition at line 376 of file PFPhotonIsolationCalculator.cc.

References funct::abs(), bApplyVeto_, bDeltaRVetoBarrel_, bDeltaRVetoEndcap_, bRectangleVetoBarrel_, bRectangleVetoEndcap_, SiPixelRawToDigiRegional_cfi::deltaPhi, PbPb_ZMuSkimMuonDPG_cff::deltaR, fConeSize_, fDeltaRVetoBarrelNeutrals_, fDeltaRVetoEndcapNeutrals_, fEta_, fPhi_, fRectangleDeltaEtaVetoBarrelNeutrals_, fRectangleDeltaEtaVetoEndcapNeutrals_, fRectangleDeltaPhiVetoBarrelNeutrals_, fRectangleDeltaPhiVetoEndcapNeutrals_, and pivotInBarrel.

                                                                                             {
  float fDeltaR = deltaR(fEta_, fPhi_, pfIsoCand->eta(), pfIsoCand->phi());

  if (fDeltaR > fConeSize_)
    return -999;

  float fDeltaPhi = deltaPhi(fPhi_, pfIsoCand->phi());
  float 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 PFPhotonIsolationCalculator::isPhotonParticleVetoed ( const reco::PFCandidateRef  pfIsoCand )

private

Definition at line 267 of file PFPhotonIsolationCalculator.cc.

References funct::abs(), bApplyMissHitPhVeto_, bApplyVeto_, bDeltaRVetoBarrel_, bDeltaRVetoEndcap_, bRectangleVetoBarrel_, bRectangleVetoEndcap_, bUseCrystalSize_, SiPixelRawToDigiRegional_cfi::deltaPhi, PbPb_ZMuSkimMuonDPG_cff::deltaR, fConeSize_, fDeltaRVetoBarrelPhotons_, fDeltaRVetoEndcapPhotons_, fEta_, fNumberOfCrystalEndcapPhotons_, fPhi_, fRectangleDeltaEtaVetoBarrelPhotons_, fRectangleDeltaEtaVetoEndcapPhotons_, fRectangleDeltaPhiVetoBarrelPhotons_, fRectangleDeltaPhiVetoEndcapPhotons_, iMissHits_, edm::Ref< C, T, F >::isNonnull(), pivotInBarrel, refSC, and mathSSE::sqrt().

Referenced by fGetIsolationInRings(), and getIsolationInRingsChargedAll().

                                                                                            {
  float fDeltaR = deltaR(fEta_, fPhi_, pfIsoCand->eta(), pfIsoCand->phi());

  if (fDeltaR > fConeSize_)
    return -999.;

  float fDeltaPhi = deltaPhi(fPhi_, pfIsoCand->phi());
  float 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::fabs(refSC->position().z() / sqrt(refSC->position().perp2())) * fNumberOfCrystalEndcapPhotons_;
    }

    if (bDeltaRVetoEndcap_) {
      if (fDeltaR < fDeltaRVetoEndcapPhotons_)
        return -999.;
    }
    if (bRectangleVetoEndcap_) {
      if (std::abs(fDeltaEta) < fRectangleDeltaEtaVetoEndcapPhotons_ &&
          std::abs(fDeltaPhi) < fRectangleDeltaPhiVetoEndcapPhotons_) {
        return -999.;
      }
    }
  }

  return fDeltaR;
}

float PFPhotonIsolationCalculator::isPhotonParticleVetoed ( const reco::PFCandidate *  pfIsoCand )

private

Definition at line 208 of file PFPhotonIsolationCalculator.cc.

References funct::abs(), bApplyMissHitPhVeto_, bApplyVeto_, bDeltaRVetoBarrel_, bDeltaRVetoEndcap_, bRectangleVetoBarrel_, bRectangleVetoEndcap_, bUseCrystalSize_, SiPixelRawToDigiRegional_cfi::deltaPhi, PbPb_ZMuSkimMuonDPG_cff::deltaR, reco::LeafCandidate::eta(), fConeSize_, 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, mathSSE::sqrt(), and reco::PFCandidate::superClusterRef().

                                                                                          {
  float fDeltaR = deltaR(fEta_, fPhi_, pfIsoCand->eta(), pfIsoCand->phi());

  if (fDeltaR > fConeSize_)
    return -999.;

  float fDeltaPhi = deltaPhi(fPhi_, pfIsoCand->phi());
  float 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::fabs(refSC->position().z() / sqrt(refSC->position().perp2())) * fNumberOfCrystalEndcapPhotons_;
    }

    if (bDeltaRVetoEndcap_) {
      if (fDeltaR < fDeltaRVetoEndcapPhotons_)
        return -999.;
    }
    if (bRectangleVetoEndcap_) {
      if (std::abs(fDeltaEta) < fRectangleDeltaEtaVetoEndcapPhotons_ &&
          std::abs(fDeltaPhi) < fRectangleDeltaPhiVetoEndcapPhotons_) {
        return -999.;
      }
    }
  }

  return fDeltaR;
}

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

private

Definition at line 684 of file PFPhotonIsolationCalculator.cc.

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

Referenced by getIsolationInRingsChargedAll().

                                                                                            {
  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) || std::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 PFPhotonIsolationCalculator::matchPFObject ( const reco::GsfElectron *  photon, const reco::PFCandidateCollection *  pfParticlesColl  )

private

Definition at line 722 of file PFPhotonIsolationCalculator.cc.

References funct::abs(), PbPb_ZMuSkimMuonDPG_cff::deltaR, reco::LeafCandidate::eta(), 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) || std::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) || std::abs(pfParticle.pdgId()) == 11))) {
        if (pfParticle.pt() > fPt) {
          float fDeltaR = deltaR(pfParticle.eta(), pfParticle.phi(), electron->eta(), electron->phi());
          if (fDeltaR < 0.1) {
            iMatch = i;
            fPt = pfParticle.pt();
          }
        }
      }
      i++;
    }
  }

  return iMatch;
}

void PFPhotonIsolationCalculator::setup

(

const edm::ParameterSet &

conf

)

Definition at line 16 of file PFPhotonIsolationCalculator.cc.

References bApplyDzDxyVeto_, bApplyMissHitPhVeto_, bApplyPFPUVeto_, bApplyVeto_, bCheckClosestZVertex_, bDeltaRVetoBarrel_, bDeltaRVetoEndcap_, bRectangleVetoBarrel_, bRectangleVetoEndcap_, bUseCrystalSize_, fConeSize_, fDeltaRVetoBarrelCharged_, fDeltaRVetoBarrelNeutrals_, fDeltaRVetoBarrelPhotons_, fDeltaRVetoEndcapCharged_, fDeltaRVetoEndcapNeutrals_, fDeltaRVetoEndcapPhotons_, fNumberOfCrystalEndcapPhotons_, fRectangleDeltaEtaVetoBarrelCharged_, fRectangleDeltaEtaVetoBarrelNeutrals_, fRectangleDeltaEtaVetoBarrelPhotons_, fRectangleDeltaEtaVetoEndcapCharged_, fRectangleDeltaEtaVetoEndcapNeutrals_, fRectangleDeltaEtaVetoEndcapPhotons_, fRectangleDeltaPhiVetoBarrelCharged_, fRectangleDeltaPhiVetoBarrelNeutrals_, fRectangleDeltaPhiVetoBarrelPhotons_, fRectangleDeltaPhiVetoEndcapCharged_, fRectangleDeltaPhiVetoEndcapNeutrals_, fRectangleDeltaPhiVetoEndcapPhotons_, fRingSize_, edm::ParameterSet::getParameter(), initializeRings(), iNumberOfRings_, and iParticleType_.

                                                                   {
  iParticleType_ = conf.getParameter<int>("particleType");
  if (iParticleType_ == 1) {
    fConeSize_ = conf.getParameter<double>("coneDR");
    iNumberOfRings_ = conf.getParameter<int>("numberOfRings");
    fRingSize_ = conf.getParameter<double>("ringSize");
    //
    bApplyVeto_ = conf.getParameter<bool>("applyVeto");
    bApplyPFPUVeto_ = conf.getParameter<bool>("applyPFPUVeto");
    bApplyDzDxyVeto_ = conf.getParameter<bool>("applyDzDxyVeto");
    bApplyMissHitPhVeto_ = conf.getParameter<bool>("applyMissHitPhVeto");
    bDeltaRVetoBarrel_ = conf.getParameter<bool>("deltaRVetoBarrel");
    bDeltaRVetoEndcap_ = conf.getParameter<bool>("deltaRVetoEndcap");
    bRectangleVetoBarrel_ = conf.getParameter<bool>("rectangleVetoBarrel");
    bRectangleVetoEndcap_ = conf.getParameter<bool>("rectangleVetoEndcap");
    bUseCrystalSize_ = conf.getParameter<bool>("useCrystalSize");
    //
    fDeltaRVetoBarrelPhotons_ = conf.getParameter<double>("deltaRVetoBarrelPhotons");
    fDeltaRVetoBarrelNeutrals_ = conf.getParameter<double>("deltaRVetoBarrelNeutrals");
    fDeltaRVetoBarrelCharged_ = conf.getParameter<double>("deltaRVetoBarrelCharged");
    fDeltaRVetoEndcapPhotons_ = conf.getParameter<double>("deltaRVetoEndcapPhotons");
    fDeltaRVetoEndcapNeutrals_ = conf.getParameter<double>("deltaRVetoEndcapNeutrals");
    fDeltaRVetoEndcapCharged_ = conf.getParameter<double>("deltaRVetoEndcapCharged");
    fNumberOfCrystalEndcapPhotons_ = conf.getParameter<double>("numberOfCrystalEndcapPhotons");
    //
    fRectangleDeltaPhiVetoBarrelPhotons_ = conf.getParameter<double>("rectangleDeltaPhiVetoBarrelPhotons");
    fRectangleDeltaPhiVetoBarrelNeutrals_ = conf.getParameter<double>("rectangleDeltaPhiVetoBarrelNeutrals");
    fRectangleDeltaPhiVetoBarrelCharged_ = conf.getParameter<double>("rectangleDeltaPhiVetoBarrelCharged");
    fRectangleDeltaPhiVetoEndcapPhotons_ = conf.getParameter<double>("rectangleDeltaPhiVetoEndcapPhotons");
    fRectangleDeltaPhiVetoEndcapNeutrals_ = conf.getParameter<double>("rectangleDeltaPhiVetoEndcapNeutrals");
    fRectangleDeltaPhiVetoEndcapCharged_ = conf.getParameter<double>("rectangleDeltaPhiVetoEndcapCharged");
    //
    fRectangleDeltaEtaVetoBarrelPhotons_ = conf.getParameter<double>("rectangleDeltaEtaVetoBarrelPhotons");
    fRectangleDeltaEtaVetoBarrelNeutrals_ = conf.getParameter<double>("rectangleDeltaEtaVetoBarrelNeutrals");
    fRectangleDeltaEtaVetoBarrelCharged_ = conf.getParameter<double>("rectangleDeltaEtaVetoBarrelCharged");
    fRectangleDeltaEtaVetoEndcapPhotons_ = conf.getParameter<double>("rectangleDeltaEtaVetoEndcapPhotons");
    fRectangleDeltaEtaVetoEndcapNeutrals_ = conf.getParameter<double>("rectangleDeltaEtaVetoEndcapNeutrals");
    fRectangleDeltaEtaVetoEndcapCharged_ = conf.getParameter<double>("rectangleDeltaEtaVetoEndcapCharged");
    //
    bCheckClosestZVertex_ = conf.getParameter<bool>("checkClosestZVertex");
    initializeRings(iNumberOfRings_, fConeSize_);
  }
}

Member Data Documentation

Bool_t PFPhotonIsolationCalculator::bApplyDzDxyVeto_

private

Definition at line 124 of file PFPhotonIsolationCalculator.h.

Referenced by isChargedParticleVetoed(), and setup().

Bool_t PFPhotonIsolationCalculator::bApplyMissHitPhVeto_

private

Definition at line 126 of file PFPhotonIsolationCalculator.h.

Referenced by isPhotonParticleVetoed(), and setup().

Bool_t PFPhotonIsolationCalculator::bApplyPFPUVeto_

private

Definition at line 125 of file PFPhotonIsolationCalculator.h.

Referenced by isChargedParticleVetoed(), and setup().

Bool_t PFPhotonIsolationCalculator::bApplyVeto_

private

Definition at line 123 of file PFPhotonIsolationCalculator.h.

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

Bool_t PFPhotonIsolationCalculator::bCheckClosestZVertex_

private

Definition at line 121 of file PFPhotonIsolationCalculator.h.

Referenced by chargedHadronVertex(), and setup().

Bool_t PFPhotonIsolationCalculator::bDeltaRVetoBarrel_

private

Definition at line 129 of file PFPhotonIsolationCalculator.h.

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

Bool_t PFPhotonIsolationCalculator::bDeltaRVetoEndcap_

private

Definition at line 130 of file PFPhotonIsolationCalculator.h.

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

Bool_t PFPhotonIsolationCalculator::bRectangleVetoBarrel_

private

Definition at line 132 of file PFPhotonIsolationCalculator.h.

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

Bool_t PFPhotonIsolationCalculator::bRectangleVetoEndcap_

private

Definition at line 133 of file PFPhotonIsolationCalculator.h.

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

Bool_t PFPhotonIsolationCalculator::bUseCrystalSize_

private

Definition at line 127 of file PFPhotonIsolationCalculator.h.

Referenced by isPhotonParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fConeSize_

private

Definition at line 122 of file PFPhotonIsolationCalculator.h.

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

float PFPhotonIsolationCalculator::fDeltaRVetoBarrelCharged_

private

Definition at line 137 of file PFPhotonIsolationCalculator.h.

Referenced by isChargedParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fDeltaRVetoBarrelNeutrals_

private

Definition at line 136 of file PFPhotonIsolationCalculator.h.

Referenced by isNeutralParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fDeltaRVetoBarrelPhotons_

private

Definition at line 135 of file PFPhotonIsolationCalculator.h.

Referenced by isPhotonParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fDeltaRVetoEndcapCharged_

private

Definition at line 141 of file PFPhotonIsolationCalculator.h.

Referenced by isChargedParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fDeltaRVetoEndcapNeutrals_

private

Definition at line 140 of file PFPhotonIsolationCalculator.h.

Referenced by isNeutralParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fDeltaRVetoEndcapPhotons_

private

Definition at line 139 of file PFPhotonIsolationCalculator.h.

Referenced by isPhotonParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fEta_

private

Definition at line 169 of file PFPhotonIsolationCalculator.h.

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

float PFPhotonIsolationCalculator::fEtaSC_

private

Definition at line 171 of file PFPhotonIsolationCalculator.h.

Bool_t PFPhotonIsolationCalculator::fisInitialized_

private

Definition at line 108 of file PFPhotonIsolationCalculator.h.

float PFPhotonIsolationCalculator::fIsolation_

private

Definition at line 109 of file PFPhotonIsolationCalculator.h.

Referenced by fGetIsolation().

float PFPhotonIsolationCalculator::fIsolationCharged_

private

Definition at line 112 of file PFPhotonIsolationCalculator.h.

Referenced by getIsolationCharged().

float PFPhotonIsolationCalculator::fIsolationChargedAll_

private

Definition at line 113 of file PFPhotonIsolationCalculator.h.

Referenced by getIsolationChargedAll().

std::vector<float> PFPhotonIsolationCalculator::fIsolationInRings_

private

Definition at line 115 of file PFPhotonIsolationCalculator.h.

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

std::vector<float> PFPhotonIsolationCalculator::fIsolationInRingsCharged_

private

Definition at line 118 of file PFPhotonIsolationCalculator.h.

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

std::vector<float> PFPhotonIsolationCalculator::fIsolationInRingsChargedAll_

private

Definition at line 119 of file PFPhotonIsolationCalculator.h.

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

std::vector<float> PFPhotonIsolationCalculator::fIsolationInRingsNeutral_

private

Definition at line 117 of file PFPhotonIsolationCalculator.h.

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

std::vector<float> PFPhotonIsolationCalculator::fIsolationInRingsPhoton_

private

Definition at line 116 of file PFPhotonIsolationCalculator.h.

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

float PFPhotonIsolationCalculator::fIsolationNeutral_

private

Definition at line 111 of file PFPhotonIsolationCalculator.h.

Referenced by getIsolationNeutral().

float PFPhotonIsolationCalculator::fIsolationPhoton_

private

Definition at line 110 of file PFPhotonIsolationCalculator.h.

Referenced by getIsolationPhoton().

float PFPhotonIsolationCalculator::fNumberOfCrystalEndcapPhotons_

private

Definition at line 143 of file PFPhotonIsolationCalculator.h.

Referenced by isPhotonParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fPhi_

private

Definition at line 170 of file PFPhotonIsolationCalculator.h.

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

float PFPhotonIsolationCalculator::fPhiSC_

private

Definition at line 172 of file PFPhotonIsolationCalculator.h.

float PFPhotonIsolationCalculator::fPt_

private

Definition at line 174 of file PFPhotonIsolationCalculator.h.

float PFPhotonIsolationCalculator::fRectangleDeltaEtaVetoBarrelCharged_

private

Definition at line 155 of file PFPhotonIsolationCalculator.h.

Referenced by isChargedParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fRectangleDeltaEtaVetoBarrelNeutrals_

private

Definition at line 154 of file PFPhotonIsolationCalculator.h.

Referenced by isNeutralParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fRectangleDeltaEtaVetoBarrelPhotons_

private

Definition at line 153 of file PFPhotonIsolationCalculator.h.

Referenced by isPhotonParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fRectangleDeltaEtaVetoEndcapCharged_

private

Definition at line 159 of file PFPhotonIsolationCalculator.h.

Referenced by isChargedParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fRectangleDeltaEtaVetoEndcapNeutrals_

private

Definition at line 158 of file PFPhotonIsolationCalculator.h.

Referenced by isNeutralParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fRectangleDeltaEtaVetoEndcapPhotons_

private

Definition at line 157 of file PFPhotonIsolationCalculator.h.

Referenced by isPhotonParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fRectangleDeltaPhiVetoBarrelCharged_

private

Definition at line 147 of file PFPhotonIsolationCalculator.h.

Referenced by isChargedParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fRectangleDeltaPhiVetoBarrelNeutrals_

private

Definition at line 146 of file PFPhotonIsolationCalculator.h.

Referenced by isNeutralParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fRectangleDeltaPhiVetoBarrelPhotons_

private

Definition at line 145 of file PFPhotonIsolationCalculator.h.

Referenced by isPhotonParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fRectangleDeltaPhiVetoEndcapCharged_

private

Definition at line 151 of file PFPhotonIsolationCalculator.h.

Referenced by isChargedParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fRectangleDeltaPhiVetoEndcapNeutrals_

private

Definition at line 150 of file PFPhotonIsolationCalculator.h.

Referenced by isNeutralParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fRectangleDeltaPhiVetoEndcapPhotons_

private

Definition at line 149 of file PFPhotonIsolationCalculator.h.

Referenced by isPhotonParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fRingSize_

private

Definition at line 164 of file PFPhotonIsolationCalculator.h.

Referenced by fGetIsolationInRings(), and setup().

float PFPhotonIsolationCalculator::fVx_

private

Definition at line 175 of file PFPhotonIsolationCalculator.h.

Referenced by fGetIsolationInRings(), and isChargedParticleVetoed().

float PFPhotonIsolationCalculator::fVy_

private

Definition at line 176 of file PFPhotonIsolationCalculator.h.

Referenced by fGetIsolationInRings(), and isChargedParticleVetoed().

float PFPhotonIsolationCalculator::fVz_

private

Definition at line 177 of file PFPhotonIsolationCalculator.h.

Referenced by fGetIsolationInRings().

int PFPhotonIsolationCalculator::iMissHits_

private

Definition at line 162 of file PFPhotonIsolationCalculator.h.

Referenced by fGetIsolationInRings(), and isPhotonParticleVetoed().

int PFPhotonIsolationCalculator::iNumberOfRings_

private

Definition at line 161 of file PFPhotonIsolationCalculator.h.

Referenced by fGetIsolationInRings(), and setup().

int PFPhotonIsolationCalculator::iParticleType_

private

Definition at line 106 of file PFPhotonIsolationCalculator.h.

Referenced by isChargedParticleVetoed(), and setup().

bool PFPhotonIsolationCalculator::pivotInBarrel

private

Definition at line 180 of file PFPhotonIsolationCalculator.h.

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

reco::SuperClusterRef PFPhotonIsolationCalculator::refSC

private

Definition at line 179 of file PFPhotonIsolationCalculator.h.

Referenced by fGetIsolationInRings(), and isPhotonParticleVetoed().