#include <IsolationComputer.h>

Public Types
enum	SelfVetoPolicy { selfVetoNone = 0, selfVetoAll = 1, selfVetoFirst = 2 }
	Self-veto policy. More...

Public Member Functions
void	addVetos (const reco::Candidate &cand)
	veto footprint from this candidate, for the isolation of all candidates and also for calculation of neutral weights (if used) More...

float	chargedAbsIso (const reco::Candidate &cand, float dR, float innerR=0, float threshold=0, SelfVetoPolicy selfVeto=selfVetoAll) const
	Isolation from charged from the PV. More...

void	clearVetos ()
	clear all vetos More...

	IsolationComputer (float weightCone=-1)
	Create the calculator; optionally specify a cone for computing deltaBeta weights. More...

float	neutralAbsIsoRaw (const reco::Candidate &cand, float dR, float innerR=0, float threshold=0, SelfVetoPolicy selfVeto=selfVetoAll) const
	Isolation from all neutrals (uncorrected) More...

float	neutralAbsIsoWeighted (const reco::Candidate &cand, float dR, float innerR=0, float threshold=0, SelfVetoPolicy selfVeto=selfVetoAll) const
	Isolation from all neutrals (with weights) More...

float	neutralHadAbsIsoRaw (const reco::Candidate &cand, float dR, float innerR=0, float threshold=0, SelfVetoPolicy selfVeto=selfVetoAll) const
	Isolation from neutral hadrons (uncorrected) More...

float	neutralHadAbsIsoWeighted (const reco::Candidate &cand, float dR, float innerR=0, float threshold=0, SelfVetoPolicy selfVeto=selfVetoAll) const
	Isolation from neutral hadrons (with weights) More...

float	photonAbsIsoRaw (const reco::Candidate &cand, float dR, float innerR=0, float threshold=0, SelfVetoPolicy selfVeto=selfVetoAll) const
	Isolation from photons (uncorrected) More...

float	photonAbsIsoWeighted (const reco::Candidate &cand, float dR, float innerR=0, float threshold=0, SelfVetoPolicy selfVeto=selfVetoAll) const
	Isolation from photons (with weights) More...

float	puAbsIso (const reco::Candidate &cand, float dR, float innerR=0, float threshold=0, SelfVetoPolicy selfVeto=selfVetoAll) const
	Isolation from charged from PU. More...

void	setPackedCandidates (const std::vector< pat::PackedCandidate > &all, int fromPV_thresh=1, float dz_thresh=9999., float dxy_thresh=9999., bool also_leptons=false)
	Initialize with the list of packed candidates (note: clears also all vetos) More...

Protected Member Functions
float	isoSumNeutralsWeighted (const reco::Candidate &cand, float dR, float innerR, float threshold, SelfVetoPolicy selfVeto, int pdgId=-1) const

float	isoSumRaw (const std::vector< const pat::PackedCandidate * > &cands, const reco::Candidate &cand, float dR, float innerR, float threshold, SelfVetoPolicy selfVeto, int pdgId=-1) const

Protected Attributes
const std::vector< pat::PackedCandidate > *	allcands_

std::vector< const pat::PackedCandidate * >	charged_

std::vector< const pat::PackedCandidate * >	neutral_

std::vector< const pat::PackedCandidate * >	pileup_

std::vector< const reco::Candidate * >	vetos_

float	weightCone_

std::vector< float >	weights_

Detailed Description

Definition at line 8 of file IsolationComputer.h.

Member Enumeration Documentation

◆ SelfVetoPolicy

enum heppy::IsolationComputer::SelfVetoPolicy

Self-veto policy.

Enumerator
selfVetoNone
selfVetoAll
selfVetoFirst

Definition at line 14 of file IsolationComputer.h.

14 { selfVetoNone = 0, selfVetoAll = 1, selfVetoFirst = 2 };

Constructor & Destructor Documentation

◆ IsolationComputer()

heppy::IsolationComputer::IsolationComputer ( float weightCone = -1 )

inline

Create the calculator; optionally specify a cone for computing deltaBeta weights.

Definition at line 11 of file IsolationComputer.h.

11 : weightCone_(weightCone) {}

Member Function Documentation

◆ addVetos()

void heppy::IsolationComputer::addVetos ( const reco::Candidate & cand )

veto footprint from this candidate, for the isolation of all candidates and also for calculation of neutral weights (if used)

veto footprint from this candidate

Definition at line 47 of file IsolationComputer.cc.

                                                                {
   for (unsigned int i = 0, n = cand.numberOfSourceCandidatePtrs(); i < n; ++i) {
     const reco::CandidatePtr &cp = cand.sourceCandidatePtr(i);
     if (cp.isNonnull() && cp.isAvailable())
       vetos_.push_back(&*cp);
   }
 }

References CommonMethods::cp(), mps_fire::i, and dqmiodumpmetadata::n.

◆ chargedAbsIso()

float heppy::IsolationComputer::chargedAbsIso	(	const reco::Candidate &	cand,
		float	dR,
		float	innerR = `0`,
		float	threshold = `0`,
		SelfVetoPolicy	selfVeto = `selfVetoAll`
	)		const

Isolation from charged from the PV.

Definition at line 59 of file IsolationComputer.cc.

                                                                                                        {
   return isoSumRaw(charged_, cand, dR, innerR, threshold, selfVeto);
 }

References HGC3DClusterGenMatchSelector_cfi::dR, and remoteMonitoring_LED_IterMethod_cfg::threshold.

◆ clearVetos()

void heppy::IsolationComputer::clearVetos ( )

clear all vetos

Definition at line 56 of file IsolationComputer.cc.

56 { vetos_.clear(); }

Referenced by setPackedCandidates().

◆ isoSumNeutralsWeighted()

float heppy::IsolationComputer::isoSumNeutralsWeighted	(	const reco::Candidate &	cand,
		float	dR,
		float	innerR,
		float	threshold,
		SelfVetoPolicy	selfVeto,
		int	pdgId = `-1`
	)		const

protected

Definition at line 147 of file IsolationComputer.cc.

                                                                                                                   {
   if (weightCone_ <= 0)
     throw cms::Exception("LogicError", "you must set a valid weight cone to use this method");
   float dR2 = dR * dR, innerR2 = innerR * innerR, weightCone2 = weightCone_ * weightCone_;
  
   std::vector<const reco::Candidate *> vetos(vetos_);
   for (unsigned int i = 0, n = cand.numberOfSourceCandidatePtrs(); i < n; ++i) {
     if (selfVeto == selfVetoNone)
       break;
     const reco::CandidatePtr &cp = cand.sourceCandidatePtr(i);
     if (cp.isNonnull() && cp.isAvailable()) {
       vetos.push_back(&*cp);
       if (selfVeto == selfVetoFirst)
         break;
     }
   }
  
   typedef std::vector<const pat::PackedCandidate *>::const_iterator IT;
   IT charged_begin = std::lower_bound(charged_.begin(), charged_.end(), cand.eta() - dR - weightCone_, ByEta());
   IT charged_end = std::upper_bound(charged_begin, charged_.end(), cand.eta() + dR + weightCone_, ByEta());
   IT pileup_begin = std::lower_bound(pileup_.begin(), pileup_.end(), cand.eta() - dR - weightCone_, ByEta());
   IT pileup_end = std::upper_bound(pileup_begin, pileup_.end(), cand.eta() + dR + weightCone_, ByEta());
   IT neutral_begin = std::lower_bound(neutral_.begin(), neutral_.end(), cand.eta() - dR, ByEta());
   IT neutral_end = std::upper_bound(neutral_begin, neutral_.end(), cand.eta() + dR, ByEta());
  
   double isosum = 0.0;
   for (IT ineutral = neutral_begin; ineutral < neutral_end; ++ineutral) {
     // pdgId
     if (pdgId > 0 && abs((*ineutral)->pdgId()) != pdgId)
       continue;
     // threshold
     if (threshold > 0 && (*ineutral)->pt() < threshold)
       continue;
     // cone
     float mydr2 = reco::deltaR2(**ineutral, cand);
     if (mydr2 >= dR2 || mydr2 < innerR2)
       continue;
     // veto
     if (std::find(vetos.begin(), vetos.end(), *ineutral) != vetos.end()) {
       continue;
     }
     // weight
     float &w = weights_[ineutral - neutral_.begin()];
     if (w == -1.f) {
       double sumc = 0, sump = 0.0;
       for (IT icharged = charged_begin; icharged < charged_end; ++icharged) {
         float hisdr2 = std::max<float>(reco::deltaR2(**icharged, **ineutral), 0.01f);
         if (hisdr2 > weightCone2)
           continue;
         if (std::find(vetos_.begin(), vetos_.end(), *icharged) != vetos_.end()) {
           continue;
         }
         sumc += std::log((*icharged)->pt() / std::sqrt(hisdr2));
       }
       for (IT ipileup = pileup_begin; ipileup < pileup_end; ++ipileup) {
         float hisdr2 = std::max<float>(reco::deltaR2(**ipileup, **ineutral), 0.01f);
         if (hisdr2 > weightCone2)
           continue;
         if (std::find(vetos_.begin(), vetos_.end(), *ipileup) != vetos_.end()) {
           continue;
         }
         sumc += std::log((*ipileup)->pt() / std::sqrt(hisdr2));
       }
       w = (sump == 0 ? 1 : sumc / (sump + sumc));
     }
     // add to sum
     isosum += w * (*ineutral)->pt();
   }
   return isosum;
 }

References funct::abs(), CommonMethods::cp(), reco::deltaR2(), HGC3DClusterGenMatchSelector_cfi::dR, Exception, f, spr::find(), mps_fire::i, dqm-mbProfile::log, cuda_std::lower_bound(), dqmiodumpmetadata::n, EgammaValidation_cff::pdgId, mathSSE::sqrt(), remoteMonitoring_LED_IterMethod_cfg::threshold, cuda_std::upper_bound(), boostedElectronIsolation_cff::vetos, and w.

◆ isoSumRaw()

float heppy::IsolationComputer::isoSumRaw	(	const std::vector< const pat::PackedCandidate * > &	cands,
		const reco::Candidate &	cand,
		float	dR,
		float	innerR,
		float	threshold,
		SelfVetoPolicy	selfVeto,
		int	pdgId = `-1`
	)		const

protected

Definition at line 100 of file IsolationComputer.cc.

                                                            {
   float dR2 = dR * dR, innerR2 = innerR * innerR;
  
   std::vector<const reco::Candidate *> vetos(vetos_);
   for (unsigned int i = 0, n = cand.numberOfSourceCandidatePtrs(); i < n; ++i) {
     if (selfVeto == selfVetoNone)
       break;
     const reco::CandidatePtr &cp = cand.sourceCandidatePtr(i);
     if (cp.isNonnull() && cp.isAvailable()) {
       vetos.push_back(&*cp);
       if (selfVeto == selfVetoFirst)
         break;
     }
   }
  
   typedef std::vector<const pat::PackedCandidate *>::const_iterator IT;
   IT candsbegin = std::lower_bound(cands.begin(), cands.end(), cand.eta() - dR, ByEta());
   IT candsend = std::upper_bound(candsbegin, cands.end(), cand.eta() + dR, ByEta());
  
   double isosum = 0;
   for (IT icharged = candsbegin; icharged < candsend; ++icharged) {
     // pdgId
     if (pdgId > 0 && abs((*icharged)->pdgId()) != pdgId)
       continue;
     // threshold
     if (threshold > 0 && (*icharged)->pt() < threshold)
       continue;
     // cone
     float mydr2 = reco::deltaR2(**icharged, cand);
     if (mydr2 >= dR2 || mydr2 < innerR2)
       continue;
     // veto
     if (std::find(vetos.begin(), vetos.end(), *icharged) != vetos.end()) {
       continue;
     }
     // add to sum
     isosum += (*icharged)->pt();
   }
   return isosum;
 }

References funct::abs(), HLT_2018_cff::cands, CommonMethods::cp(), reco::deltaR2(), HGC3DClusterGenMatchSelector_cfi::dR, spr::find(), mps_fire::i, cuda_std::lower_bound(), dqmiodumpmetadata::n, EgammaValidation_cff::pdgId, remoteMonitoring_LED_IterMethod_cfg::threshold, cuda_std::upper_bound(), and boostedElectronIsolation_cff::vetos.

◆ neutralAbsIsoRaw()

float heppy::IsolationComputer::neutralAbsIsoRaw	(	const reco::Candidate &	cand,
		float	dR,
		float	innerR = `0`,
		float	threshold = `0`,
		SelfVetoPolicy	selfVeto = `selfVetoAll`
	)		const

Isolation from all neutrals (uncorrected)

Definition at line 70 of file IsolationComputer.cc.

                                                                                                        {
   return isoSumRaw(neutral_, cand, dR, innerR, threshold, selfVeto);
 }

References HGC3DClusterGenMatchSelector_cfi::dR, and remoteMonitoring_LED_IterMethod_cfg::threshold.

◆ neutralAbsIsoWeighted()

float heppy::IsolationComputer::neutralAbsIsoWeighted	(	const reco::Candidate &	cand,
		float	dR,
		float	innerR = `0`,
		float	threshold = `0`,
		SelfVetoPolicy	selfVeto = `selfVetoAll`
	)		const

Isolation from all neutrals (with weights)

Definition at line 75 of file IsolationComputer.cc.

                                                                                                        {
   return isoSumNeutralsWeighted(cand, dR, innerR, threshold, selfVeto);
 }

References HGC3DClusterGenMatchSelector_cfi::dR, and remoteMonitoring_LED_IterMethod_cfg::threshold.

◆ neutralHadAbsIsoRaw()

float heppy::IsolationComputer::neutralHadAbsIsoRaw	(	const reco::Candidate &	cand,
		float	dR,
		float	innerR = `0`,
		float	threshold = `0`,
		SelfVetoPolicy	selfVeto = `selfVetoAll`
	)		const

Isolation from neutral hadrons (uncorrected)

Definition at line 80 of file IsolationComputer.cc.

                                                                                                        {
   return isoSumRaw(neutral_, cand, dR, innerR, threshold, selfVeto, 130);
 }

References HGC3DClusterGenMatchSelector_cfi::dR, and remoteMonitoring_LED_IterMethod_cfg::threshold.

◆ neutralHadAbsIsoWeighted()

float heppy::IsolationComputer::neutralHadAbsIsoWeighted	(	const reco::Candidate &	cand,
		float	dR,
		float	innerR = `0`,
		float	threshold = `0`,
		SelfVetoPolicy	selfVeto = `selfVetoAll`
	)		const

Isolation from neutral hadrons (with weights)

Definition at line 85 of file IsolationComputer.cc.

                                                                                                        {
   return isoSumNeutralsWeighted(cand, dR, innerR, threshold, selfVeto, 130);
 }

References HGC3DClusterGenMatchSelector_cfi::dR, and remoteMonitoring_LED_IterMethod_cfg::threshold.

◆ photonAbsIsoRaw()

float heppy::IsolationComputer::photonAbsIsoRaw	(	const reco::Candidate &	cand,
		float	dR,
		float	innerR = `0`,
		float	threshold = `0`,
		SelfVetoPolicy	selfVeto = `selfVetoAll`
	)		const

Isolation from photons (uncorrected)

Definition at line 90 of file IsolationComputer.cc.

                                                                                                        {
   return isoSumRaw(neutral_, cand, dR, innerR, threshold, selfVeto, 22);
 }

References HGC3DClusterGenMatchSelector_cfi::dR, and remoteMonitoring_LED_IterMethod_cfg::threshold.

◆ photonAbsIsoWeighted()

float heppy::IsolationComputer::photonAbsIsoWeighted	(	const reco::Candidate &	cand,
		float	dR,
		float	innerR = `0`,
		float	threshold = `0`,
		SelfVetoPolicy	selfVeto = `selfVetoAll`
	)		const

Isolation from photons (with weights)

Definition at line 95 of file IsolationComputer.cc.

                                                                                                        {
   return isoSumNeutralsWeighted(cand, dR, innerR, threshold, selfVeto, 22);
 }

References HGC3DClusterGenMatchSelector_cfi::dR, and remoteMonitoring_LED_IterMethod_cfg::threshold.

◆ puAbsIso()

float heppy::IsolationComputer::puAbsIso	(	const reco::Candidate &	cand,
		float	dR,
		float	innerR = `0`,
		float	threshold = `0`,
		SelfVetoPolicy	selfVeto = `selfVetoAll`
	)		const

Isolation from charged from PU.

Definition at line 65 of file IsolationComputer.cc.

                                                                                                        {
   return isoSumRaw(pileup_, cand, dR, innerR, threshold, selfVeto);
 }

References HGC3DClusterGenMatchSelector_cfi::dR, and remoteMonitoring_LED_IterMethod_cfg::threshold.

◆ setPackedCandidates()

void heppy::IsolationComputer::setPackedCandidates	(	const std::vector< pat::PackedCandidate > &	all,
		int	fromPV_thresh = `1`,
		float	dz_thresh = `9999.`,
		float	dxy_thresh = `9999.`,
		bool	also_leptons = `false`
	)

Initialize with the list of packed candidates (note: clears also all vetos)

Definition at line 14 of file IsolationComputer.cc.

                                                                       {
   allcands_ = &all;
   charged_.clear();
   neutral_.clear();
   pileup_.clear();
  
   for (const pat::PackedCandidate &p : all) {
     if (p.charge() == 0) {
       neutral_.push_back(&p);
     } else {
       if ((abs(p.pdgId()) == 211) || (also_leptons && ((abs(p.pdgId()) == 11) || (abs(p.pdgId()) == 13)))) {
         if (p.fromPV() > fromPV_thresh && fabs(p.dz()) < dz_thresh && fabs(p.dxy()) < dxy_thresh) {
           charged_.push_back(&p);
         } else {
           pileup_.push_back(&p);
         }
       }
     }
   }
   if (weightCone_ > 0)
     weights_.resize(neutral_.size());
   std::fill(weights_.begin(), weights_.end(), -1.f);
   std::sort(charged_.begin(), charged_.end(), ByEta());
   std::sort(neutral_.begin(), neutral_.end(), ByEta());
   std::sort(pileup_.begin(), pileup_.end(), ByEta());
   clearVetos();
 }

References funct::abs(), python.cmstools::all(), allcands_, charged_, clearVetos(), ntuplemaker::fill, neutral_, AlCaHLTBitMon_ParallelJobs::p, pileup_, weightCone_, and weights_.

Member Data Documentation

◆ allcands_

const std::vector<pat::PackedCandidate>* heppy::IsolationComputer::allcands_

protected

Definition at line 85 of file IsolationComputer.h.

Referenced by setPackedCandidates().

◆ charged_

std::vector<const pat::PackedCandidate *> heppy::IsolationComputer::charged_

protected

Definition at line 88 of file IsolationComputer.h.

Referenced by setPackedCandidates().

◆ neutral_

std::vector<const pat::PackedCandidate *> heppy::IsolationComputer::neutral_

protected

Definition at line 88 of file IsolationComputer.h.

Referenced by setPackedCandidates().

◆ pileup_

std::vector<const pat::PackedCandidate *> heppy::IsolationComputer::pileup_

protected

Definition at line 88 of file IsolationComputer.h.

Referenced by setPackedCandidates().

◆ vetos_

std::vector<const reco::Candidate *> heppy::IsolationComputer::vetos_

protected

Definition at line 90 of file IsolationComputer.h.

◆ weightCone_

float heppy::IsolationComputer::weightCone_

protected

Definition at line 86 of file IsolationComputer.h.

Referenced by setPackedCandidates().

◆ weights_

std::vector<float> heppy::IsolationComputer::weights_

mutableprotected

Definition at line 89 of file IsolationComputer.h.

Referenced by setPackedCandidates().

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Member Enumeration Documentation

◆ SelfVetoPolicy

Constructor & Destructor Documentation

◆ IsolationComputer()

Member Function Documentation

◆ addVetos()

◆ chargedAbsIso()

◆ clearVetos()

◆ isoSumNeutralsWeighted()

◆ isoSumRaw()

◆ neutralAbsIsoRaw()

◆ neutralAbsIsoWeighted()

◆ neutralHadAbsIsoRaw()

◆ neutralHadAbsIsoWeighted()

◆ photonAbsIsoRaw()

◆ photonAbsIsoWeighted()

◆ puAbsIso()

◆ setPackedCandidates()

Member Data Documentation

◆ allcands_

◆ charged_

◆ neutral_

◆ pileup_

◆ vetos_

◆ weightCone_

◆ weights_