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

References SimDataFormats::CaloAnalysis::cp, mps_fire::i, edm::Ptr< T >::isAvailable(), edm::Ptr< T >::isNonnull(), dqmiodumpmetadata::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 59 of file IsolationComputer.cc.

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

void heppy::IsolationComputer::clearVetos

(

)

clear all vetos

Definition at line 56 of file IsolationComputer.cc.

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

References funct::abs(), SimDataFormats::CaloAnalysis::cp, reco::deltaR2(), HGC3DClusterGenMatchSelector_cfi::dR, reco::Candidate::eta(), Exception, f, spr::find(), mps_fire::i, edm::Ptr< T >::isAvailable(), edm::Ptr< T >::isNonnull(), dqm-mbProfile::log, dqmiodumpmetadata::n, reco::Candidate::numberOfSourceCandidatePtrs(), reco::Candidate::sourceCandidatePtr(), mathSSE::sqrt(), MessageLogger_cff::threshold, boostedElectronIsolation_cff::vetos, 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 100 of file IsolationComputer.cc.

References funct::abs(), SimDataFormats::CaloAnalysis::cp, reco::deltaR2(), HGC3DClusterGenMatchSelector_cfi::dR, reco::Candidate::eta(), spr::find(), mps_fire::i, edm::Ptr< T >::isAvailable(), edm::Ptr< T >::isNonnull(), dqmiodumpmetadata::n, reco::Candidate::numberOfSourceCandidatePtrs(), reco::Candidate::sourceCandidatePtr(), MessageLogger_cff::threshold, and boostedElectronIsolation_cff::vetos.

                                                           {
  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 70 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 80 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 85 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 90 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 95 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 65 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 14 of file IsolationComputer.cc.

References funct::abs(), Vispa.Plugins.EdmBrowser.EdmDataAccessor::all(), ntuplemaker::fill, and AlCaHLTBitMon_ParallelJobs::p.

                                                                      {
  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 85 of file IsolationComputer.h.

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

protected

Definition at line 88 of file IsolationComputer.h.

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

protected

Definition at line 88 of file IsolationComputer.h.

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

protected

Definition at line 88 of file IsolationComputer.h.

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

protected

Definition at line 90 of file IsolationComputer.h.

float heppy::IsolationComputer::weightCone_

protected

Definition at line 86 of file IsolationComputer.h.

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

mutableprotected

Definition at line 89 of file IsolationComputer.h.