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 40 of file PFPhotonIsolationCalculator.h.

Member Enumeration Documentation

enum PFPhotonIsolationCalculator::VetoType

private

Enumerator
kElectron
kPhoton

Definition at line 66 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 76 of file PFPhotonIsolationCalculator.cc.

                                                         {
  // Constructor.
}

PFPhotonIsolationCalculator::~PFPhotonIsolationCalculator

(

)

Definition at line 83 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 89 of file PFPhotonIsolationCalculator.cc.

References reco::Photon::PflowIsolationVariables::chargedHadronIso, fGetIsolation(), getIsolationCharged(), getIsolationNeutral(), getIsolationPhoton(), reco::Photon::PflowIsolationVariables::neutralHadronIso, reco::Photon::PflowIsolationVariables::photonIso, and extraflags_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 685 of file PFPhotonIsolationCalculator.cc.

References bCheckClosestZVertex_, PVValHelper::dz, edm::Handle< T >::product(), HiIsolationCommonParameters_cff::track, reco::PFCandidate::trackRef(), reco::PFCandidate::vertex(), electrons_cff::vertices, extraflags_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 139 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 149 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 77 of file PFPhotonIsolationCalculator.h.

References fIsolationCharged_, and fIsolationInRingsCharged_.

Referenced by calculate().

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

float PFPhotonIsolationCalculator::getIsolationChargedAll ( )

inlineprivate

Definition at line 78 of file PFPhotonIsolationCalculator.h.

References fIsolationChargedAll_.

{ return fIsolationChargedAll_; };

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

inlineprivate

Definition at line 82 of file PFPhotonIsolationCalculator.h.

References fIsolationInRingsCharged_.

{ return fIsolationInRingsCharged_; };

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

inlineprivate

Definition at line 83 of file PFPhotonIsolationCalculator.h.

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

{ return fIsolationInRingsChargedAll_; };

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

inlineprivate

Definition at line 81 of file PFPhotonIsolationCalculator.h.

References fIsolationInRingsNeutral_.

{ return fIsolationInRingsNeutral_; };

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

inlineprivate

Definition at line 80 of file PFPhotonIsolationCalculator.h.

References fIsolationInRingsPhoton_.

{ return fIsolationInRingsPhoton_; };

float PFPhotonIsolationCalculator::getIsolationNeutral ( )

inlineprivate

Definition at line 76 of file PFPhotonIsolationCalculator.h.

References fIsolationInRingsNeutral_, and fIsolationNeutral_.

Referenced by calculate().

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

float PFPhotonIsolationCalculator::getIsolationPhoton ( )

inlineprivate

Definition at line 75 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 110 of file PFPhotonIsolationCalculator.cc.

References fConeSize_, fIsolationInRings_, fIsolationInRingsCharged_, fIsolationInRingsChargedAll_, fIsolationInRingsNeutral_, fIsolationInRingsPhoton_, and objects.autophobj::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 467 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 474 of file PFPhotonIsolationCalculator.cc.

References funct::abs(), bApplyDzDxyVeto_, bApplyPFPUVeto_, bApplyVeto_, bDeltaRVetoBarrel_, bDeltaRVetoEndcap_, bRectangleVetoBarrel_, bRectangleVetoEndcap_, chargedHadronVertex(), hiPixelPairStep_cff::deltaPhi, boostedElectronIsolation_cff::deltaR, PVValHelper::dxy, PVValHelper::dz, reco::LeafCandidate::eta(), fConeSize_, 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 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::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 579 of file PFPhotonIsolationCalculator.cc.

References funct::abs(), bApplyDzDxyVeto_, bApplyPFPUVeto_, bApplyVeto_, bDeltaRVetoBarrel_, bDeltaRVetoEndcap_, bRectangleVetoBarrel_, bRectangleVetoEndcap_, chargedHadronVertex(), hiPixelPairStep_cff::deltaPhi, boostedElectronIsolation_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 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::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 365 of file PFPhotonIsolationCalculator.cc.

References funct::abs(), bApplyVeto_, bDeltaRVetoBarrel_, bDeltaRVetoEndcap_, bRectangleVetoBarrel_, bRectangleVetoEndcap_, hiPixelPairStep_cff::deltaPhi, boostedElectronIsolation_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 415 of file PFPhotonIsolationCalculator.cc.

References funct::abs(), bApplyVeto_, bDeltaRVetoBarrel_, bDeltaRVetoEndcap_, bRectangleVetoBarrel_, bRectangleVetoEndcap_, hiPixelPairStep_cff::deltaPhi, boostedElectronIsolation_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 306 of file PFPhotonIsolationCalculator.cc.

References funct::abs(), bApplyMissHitPhVeto_, bApplyVeto_, bDeltaRVetoBarrel_, bDeltaRVetoEndcap_, bRectangleVetoBarrel_, bRectangleVetoEndcap_, bUseCrystalSize_, hiPixelPairStep_cff::deltaPhi, boostedElectronIsolation_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 246 of file PFPhotonIsolationCalculator.cc.

References funct::abs(), bApplyMissHitPhVeto_, bApplyVeto_, bDeltaRVetoBarrel_, bDeltaRVetoEndcap_, bRectangleVetoBarrel_, bRectangleVetoEndcap_, bUseCrystalSize_, hiPixelPairStep_cff::deltaPhi, boostedElectronIsolation_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 746 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 791 of file PFPhotonIsolationCalculator.cc.

References funct::abs(), boostedElectronIsolation_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 20 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 126 of file PFPhotonIsolationCalculator.h.

Referenced by isChargedParticleVetoed(), and setup().

Bool_t PFPhotonIsolationCalculator::bApplyMissHitPhVeto_

private

Definition at line 128 of file PFPhotonIsolationCalculator.h.

Referenced by isPhotonParticleVetoed(), and setup().

Bool_t PFPhotonIsolationCalculator::bApplyPFPUVeto_

private

Definition at line 127 of file PFPhotonIsolationCalculator.h.

Referenced by isChargedParticleVetoed(), and setup().

Bool_t PFPhotonIsolationCalculator::bApplyVeto_

private

Definition at line 125 of file PFPhotonIsolationCalculator.h.

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

Bool_t PFPhotonIsolationCalculator::bCheckClosestZVertex_

private

Definition at line 123 of file PFPhotonIsolationCalculator.h.

Referenced by chargedHadronVertex(), and setup().

Bool_t PFPhotonIsolationCalculator::bDeltaRVetoBarrel_

private

Definition at line 131 of file PFPhotonIsolationCalculator.h.

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

Bool_t PFPhotonIsolationCalculator::bDeltaRVetoEndcap_

private

Definition at line 132 of file PFPhotonIsolationCalculator.h.

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

Bool_t PFPhotonIsolationCalculator::bRectangleVetoBarrel_

private

Definition at line 134 of file PFPhotonIsolationCalculator.h.

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

Bool_t PFPhotonIsolationCalculator::bRectangleVetoEndcap_

private

Definition at line 135 of file PFPhotonIsolationCalculator.h.

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

Bool_t PFPhotonIsolationCalculator::bUseCrystalSize_

private

Definition at line 129 of file PFPhotonIsolationCalculator.h.

Referenced by isPhotonParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fConeSize_

private

Definition at line 124 of file PFPhotonIsolationCalculator.h.

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

float PFPhotonIsolationCalculator::fDeltaRVetoBarrelCharged_

private

Definition at line 139 of file PFPhotonIsolationCalculator.h.

Referenced by isChargedParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fDeltaRVetoBarrelNeutrals_

private

Definition at line 138 of file PFPhotonIsolationCalculator.h.

Referenced by isNeutralParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fDeltaRVetoBarrelPhotons_

private

Definition at line 137 of file PFPhotonIsolationCalculator.h.

Referenced by isPhotonParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fDeltaRVetoEndcapCharged_

private

Definition at line 143 of file PFPhotonIsolationCalculator.h.

Referenced by isChargedParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fDeltaRVetoEndcapNeutrals_

private

Definition at line 142 of file PFPhotonIsolationCalculator.h.

Referenced by isNeutralParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fDeltaRVetoEndcapPhotons_

private

Definition at line 141 of file PFPhotonIsolationCalculator.h.

Referenced by isPhotonParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fEta_

private

Definition at line 171 of file PFPhotonIsolationCalculator.h.

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

float PFPhotonIsolationCalculator::fEtaSC_

private

Definition at line 173 of file PFPhotonIsolationCalculator.h.

Bool_t PFPhotonIsolationCalculator::fisInitialized_

private

Definition at line 110 of file PFPhotonIsolationCalculator.h.

float PFPhotonIsolationCalculator::fIsolation_

private

Definition at line 111 of file PFPhotonIsolationCalculator.h.

Referenced by fGetIsolation().

float PFPhotonIsolationCalculator::fIsolationCharged_

private

Definition at line 114 of file PFPhotonIsolationCalculator.h.

Referenced by getIsolationCharged().

float PFPhotonIsolationCalculator::fIsolationChargedAll_

private

Definition at line 115 of file PFPhotonIsolationCalculator.h.

Referenced by getIsolationChargedAll().

std::vector<float > PFPhotonIsolationCalculator::fIsolationInRings_

private

Definition at line 117 of file PFPhotonIsolationCalculator.h.

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

std::vector<float > PFPhotonIsolationCalculator::fIsolationInRingsCharged_

private

Definition at line 120 of file PFPhotonIsolationCalculator.h.

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

std::vector<float > PFPhotonIsolationCalculator::fIsolationInRingsChargedAll_

private

Definition at line 121 of file PFPhotonIsolationCalculator.h.

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

std::vector<float > PFPhotonIsolationCalculator::fIsolationInRingsNeutral_

private

Definition at line 119 of file PFPhotonIsolationCalculator.h.

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

std::vector<float > PFPhotonIsolationCalculator::fIsolationInRingsPhoton_

private

Definition at line 118 of file PFPhotonIsolationCalculator.h.

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

float PFPhotonIsolationCalculator::fIsolationNeutral_

private

Definition at line 113 of file PFPhotonIsolationCalculator.h.

Referenced by getIsolationNeutral().

float PFPhotonIsolationCalculator::fIsolationPhoton_

private

Definition at line 112 of file PFPhotonIsolationCalculator.h.

Referenced by getIsolationPhoton().

float PFPhotonIsolationCalculator::fNumberOfCrystalEndcapPhotons_

private

Definition at line 145 of file PFPhotonIsolationCalculator.h.

Referenced by isPhotonParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fPhi_

private

Definition at line 172 of file PFPhotonIsolationCalculator.h.

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

float PFPhotonIsolationCalculator::fPhiSC_

private

Definition at line 174 of file PFPhotonIsolationCalculator.h.

float PFPhotonIsolationCalculator::fPt_

private

Definition at line 176 of file PFPhotonIsolationCalculator.h.

float PFPhotonIsolationCalculator::fRectangleDeltaEtaVetoBarrelCharged_

private

Definition at line 157 of file PFPhotonIsolationCalculator.h.

Referenced by isChargedParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fRectangleDeltaEtaVetoBarrelNeutrals_

private

Definition at line 156 of file PFPhotonIsolationCalculator.h.

Referenced by isNeutralParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fRectangleDeltaEtaVetoBarrelPhotons_

private

Definition at line 155 of file PFPhotonIsolationCalculator.h.

Referenced by isPhotonParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fRectangleDeltaEtaVetoEndcapCharged_

private

Definition at line 161 of file PFPhotonIsolationCalculator.h.

Referenced by isChargedParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fRectangleDeltaEtaVetoEndcapNeutrals_

private

Definition at line 160 of file PFPhotonIsolationCalculator.h.

Referenced by isNeutralParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fRectangleDeltaEtaVetoEndcapPhotons_

private

Definition at line 159 of file PFPhotonIsolationCalculator.h.

Referenced by isPhotonParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fRectangleDeltaPhiVetoBarrelCharged_

private

Definition at line 149 of file PFPhotonIsolationCalculator.h.

Referenced by isChargedParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fRectangleDeltaPhiVetoBarrelNeutrals_

private

Definition at line 148 of file PFPhotonIsolationCalculator.h.

Referenced by isNeutralParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fRectangleDeltaPhiVetoBarrelPhotons_

private

Definition at line 147 of file PFPhotonIsolationCalculator.h.

Referenced by isPhotonParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fRectangleDeltaPhiVetoEndcapCharged_

private

Definition at line 153 of file PFPhotonIsolationCalculator.h.

Referenced by isChargedParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fRectangleDeltaPhiVetoEndcapNeutrals_

private

Definition at line 152 of file PFPhotonIsolationCalculator.h.

Referenced by isNeutralParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fRectangleDeltaPhiVetoEndcapPhotons_

private

Definition at line 151 of file PFPhotonIsolationCalculator.h.

Referenced by isPhotonParticleVetoed(), and setup().

float PFPhotonIsolationCalculator::fRingSize_

private

Definition at line 166 of file PFPhotonIsolationCalculator.h.

Referenced by fGetIsolationInRings(), and setup().

float PFPhotonIsolationCalculator::fVx_

private

Definition at line 177 of file PFPhotonIsolationCalculator.h.

Referenced by fGetIsolationInRings(), and isChargedParticleVetoed().

float PFPhotonIsolationCalculator::fVy_

private

Definition at line 178 of file PFPhotonIsolationCalculator.h.

Referenced by fGetIsolationInRings(), and isChargedParticleVetoed().

float PFPhotonIsolationCalculator::fVz_

private

Definition at line 179 of file PFPhotonIsolationCalculator.h.

Referenced by fGetIsolationInRings().

int PFPhotonIsolationCalculator::iMissHits_

private

Definition at line 164 of file PFPhotonIsolationCalculator.h.

Referenced by fGetIsolationInRings(), and isPhotonParticleVetoed().

int PFPhotonIsolationCalculator::iNumberOfRings_

private

Definition at line 163 of file PFPhotonIsolationCalculator.h.

Referenced by fGetIsolationInRings(), and setup().

int PFPhotonIsolationCalculator::iParticleType_

private

Definition at line 108 of file PFPhotonIsolationCalculator.h.

Referenced by isChargedParticleVetoed(), and setup().

bool PFPhotonIsolationCalculator::pivotInBarrel

private

Definition at line 182 of file PFPhotonIsolationCalculator.h.

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

reco::SuperClusterRef PFPhotonIsolationCalculator::refSC

private

Definition at line 181 of file PFPhotonIsolationCalculator.h.

Referenced by fGetIsolationInRings(), and isPhotonParticleVetoed().