heppy::IsolationComputer Class Reference

#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

enum heppy::IsolationComputer::SelfVetoPolicy

Self-veto policy.

Enumerator
selfVetoNone
selfVetoAll
selfVetoFirst

Definition at line 14 of file IsolationComputer.h.

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

Constructor & Destructor Documentation

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.

: weightCone_(weightCone) {}

Member Function Documentation

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 49 of file IsolationComputer.cc.

References CommonMethods::cp(), i, edm::Ptr< T >::isAvailable(), edm::Ptr< T >::isNonnull(), gen::n, reco::Candidate::numberOfSourceCandidatePtrs(), and reco::Candidate::sourceCandidatePtr().

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

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 62 of file IsolationComputer.cc.

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

void heppy::IsolationComputer::clearVetos

(

)

clear all vetos

Definition at line 57 of file IsolationComputer.cc.

Referenced by setPackedCandidates().

                                        {
    vetos_.clear();
}

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

protected

Definition at line 132 of file IsolationComputer.cc.

References funct::abs(), CommonMethods::cp(), reco::deltaR2(), PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, reco::Candidate::eta(), Exception, f, spr::find(), i, edm::Ptr< T >::isAvailable(), edm::Ptr< T >::isNonnull(), cmsBatch::log, gen::n, reco::Candidate::numberOfSourceCandidatePtrs(), reco::Candidate::sourceCandidatePtr(), mathSSE::sqrt(), dtDQMClient_cfg::threshold, and w.

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

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 95 of file IsolationComputer.cc.

References funct::abs(), CommonMethods::cp(), reco::deltaR2(), PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, reco::Candidate::eta(), spr::find(), i, edm::Ptr< T >::isAvailable(), edm::Ptr< T >::isNonnull(), gen::n, reco::Candidate::numberOfSourceCandidatePtrs(), reco::Candidate::sourceCandidatePtr(), and dtDQMClient_cfg::threshold.

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

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 71 of file IsolationComputer.cc.

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

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

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 79 of file IsolationComputer.cc.

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

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 83 of file IsolationComputer.cc.

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

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 87 of file IsolationComputer.cc.

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

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 91 of file IsolationComputer.cc.

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

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 67 of file IsolationComputer.cc.

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

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 18 of file IsolationComputer.cc.

References funct::abs(), cond::ecalcond::all, allcands_, charged_, clearVetos(), lumiContext::fill, neutral_, AlCaHLTBitMon_ParallelJobs::p, pileup_, python.multivaluedict::sort(), weightCone_, and weights_.

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

Member Data Documentation

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

protected

Definition at line 51 of file IsolationComputer.h.

Referenced by setPackedCandidates().

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

protected

Definition at line 54 of file IsolationComputer.h.

Referenced by setPackedCandidates().

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

protected

Definition at line 54 of file IsolationComputer.h.

Referenced by setPackedCandidates().

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

protected

Definition at line 54 of file IsolationComputer.h.

Referenced by setPackedCandidates().

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

protected

Definition at line 56 of file IsolationComputer.h.

float heppy::IsolationComputer::weightCone_

protected

Definition at line 52 of file IsolationComputer.h.

Referenced by setPackedCandidates().

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

mutableprotected

Definition at line 55 of file IsolationComputer.h.

Referenced by setPackedCandidates().