#include <HGCalIsoCalculator.h>

Public Member Functions
const float	getIso (const unsigned int ring) const

	HGCalIsoCalculator ()

void	produceHGCalIso (const reco::CaloClusterPtr &seedCluster)

void	setDeltaR (const float dr)

void	setMinDeltaR (const float dr)

void	setNLayers (unsigned int nLayers)

void	setNRings (const size_t nrings)

void	setRecHits (edm::Handle< HGCRecHitCollection > hitsEE, edm::Handle< HGCRecHitCollection > hitsFH, edm::Handle< HGCRecHitCollection > hitsBH)
	fill - once per event More...

void	setRecHitTools (const hgcal::RecHitTools *recHitTools)

	~HGCalIsoCalculator ()

Private Attributes
bool	debug_

float	dr2_

std::vector< std::pair< float, float > >	hitEtaPhiCache_

std::vector< float >	isoringdeposits_

float	mindr2_

unsigned int	nlayers_

edm::Handle< HGCRecHitCollection >	recHitsBH_

edm::Handle< HGCRecHitCollection >	recHitsEE_

edm::Handle< HGCRecHitCollection >	recHitsFH_

const hgcal::RecHitTools *	rechittools_

std::vector< unsigned int >	ringasso_

Detailed Description

Definition at line 46 of file HGCalIsoCalculator.h.

Constructor & Destructor Documentation

◆ HGCalIsoCalculator()

HGCalIsoCalculator::HGCalIsoCalculator ( )

Definition at line 11 of file HGCalIsoCalculator.cc.

     : dr2_(0.15 * 0.15), mindr2_(0), rechittools_(nullptr), debug_(false), nlayers_(30) {
   setNRings(5);
 }

References setNRings().

◆ ~HGCalIsoCalculator()

HGCalIsoCalculator::~HGCalIsoCalculator ( )

Definition at line 16 of file HGCalIsoCalculator.cc.

16 {}

Member Function Documentation

◆ getIso()

const float HGCalIsoCalculator::getIso ( const unsigned int ring ) const

Definition at line 114 of file HGCalIsoCalculator.cc.

                                                                     {
   if (ring >= isoringdeposits_.size())
     throw cms::Exception("HGCalIsoCalculator::getIso: ring index out of range");
   return isoringdeposits_[ring];
 }

References isoringdeposits_, and relativeConstraints::ring.

Referenced by HGCalEgammaIDHelper::getIsolationRing().

◆ produceHGCalIso()

void HGCalIsoCalculator::produceHGCalIso ( const reco::CaloClusterPtr & seedCluster )

Definition at line 48 of file HGCalIsoCalculator.cc.

                                                                        {
   if (!rechittools_)
     throw cms::Exception("HGCalIsoCalculator::produceHGCalIso: rechittools not set");
  
   for (auto& r : isoringdeposits_)
     r = 0;
  
   // make local temporaries to pass to the lambda
   // avoids recomputing every iteration
   const float seedEta = seed->eta();
   const float seedPhi = seed->phi();
   const std::vector<std::pair<DetId, float>>& seedHitsAndFractions = seed->hitsAndFractions();
  
   auto checkAndFill = [this, &seedEta, &seedPhi, &seedHitsAndFractions](const HGCRecHit& hit,
                                                                         std::pair<float, float> etaphiVal) {
     float deltar2 = reco::deltaR2(etaphiVal.first, etaphiVal.second, seedEta, seedPhi);
     if (deltar2 > dr2_ || deltar2 < mindr2_)
       return;
  
     unsigned int layer = rechittools_->getLayerWithOffset(hit.id());
     if (layer >= nlayers_)
       return;
  
     //do not consider hits associated to the photon cluster
     if (std::none_of(seedHitsAndFractions.begin(), seedHitsAndFractions.end(), [&hit](const auto& seedhit) {
           return hit.id() == seedhit.first;
         })) {
       const unsigned int ring = ringasso_.at(layer);
       isoringdeposits_.at(ring) += hit.energy();
     }
   };
  
   // The cache order is EE,FH,BH, so we should loop over them the same here
   auto itEtaPhiCache = hitEtaPhiCache_.cbegin();
   for (const auto& hit : *recHitsEE_) {
     checkAndFill(hit, *itEtaPhiCache);
     itEtaPhiCache++;
   }
   for (const auto& hit : *recHitsFH_) {
     checkAndFill(hit, *itEtaPhiCache);
     itEtaPhiCache++;
   }
   for (const auto& hit : *recHitsBH_) {
     checkAndFill(hit, *itEtaPhiCache);
     itEtaPhiCache++;
   }
 }

References reco::deltaR2(), dr2_, Exception, hgcal::RecHitTools::getLayerWithOffset(), hitEtaPhiCache_, hit::id, isoringdeposits_, phase1PixelTopology::layer, mindr2_, nlayers_, alignCSCRings::r, recHitsBH_, recHitsEE_, recHitsFH_, rechittools_, relativeConstraints::ring, ringasso_, and fileCollector::seed.

Referenced by HGCalEgammaIDHelper::computeHGCAL().

◆ setDeltaR()

void HGCalIsoCalculator::setDeltaR ( const float dr )

inline

Definition at line 52 of file HGCalIsoCalculator.h.

52 { dr2_ = dr * dr; }

References flavorHistoryFilter_cfi::dr, and dr2_.

Referenced by HGCalEgammaIDHelper::HGCalEgammaIDHelper().

◆ setMinDeltaR()

void HGCalIsoCalculator::setMinDeltaR ( const float dr )

inline

Definition at line 54 of file HGCalIsoCalculator.h.

54 { mindr2_ = dr * dr; }

References flavorHistoryFilter_cfi::dr, and mindr2_.

Referenced by HGCalEgammaIDHelper::HGCalEgammaIDHelper().

◆ setNLayers()

void HGCalIsoCalculator::setNLayers ( unsigned int nLayers )

inline

Definition at line 60 of file HGCalIsoCalculator.h.

60 { nlayers_ = nLayers; }

References MuonTCMETValueMapProducer_cff::nLayers, and nlayers_.

◆ setNRings()

void HGCalIsoCalculator::setNRings ( const size_t nrings )

Definition at line 96 of file HGCalIsoCalculator.cc.

                                                       {
   if (nrings > nlayers_)
     throw std::logic_error("PhotonHGCalIsoCalculator::setNRings: max number of rings reached");
  
   ringasso_.clear();
   isoringdeposits_.clear();
   unsigned int separator = nlayers_ / nrings;
   size_t counter = 0;
   for (size_t i = 0; i < nlayers_ + 1; i++) {
     ringasso_.push_back(counter);
     //the last ring might be larger.
     if (i && !(i % separator) && (int)counter < (int)nrings - 1) {
       counter++;
     }
   }
   isoringdeposits_.resize(nrings, 0);
 }

References mps_fire::i, isoringdeposits_, nlayers_, ringasso_, and mps_merge::separator.

Referenced by HGCalEgammaIDHelper::HGCalEgammaIDHelper(), and HGCalIsoCalculator().

◆ setRecHits()

void HGCalIsoCalculator::setRecHits	(	edm::Handle< HGCRecHitCollection >	hitsEE,
		edm::Handle< HGCRecHitCollection >	hitsFH,
		edm::Handle< HGCRecHitCollection >	hitsBH
	)

fill - once per event

Definition at line 18 of file HGCalIsoCalculator.cc.

                                                                            {
   recHitsEE_ = hitsEE;
   recHitsFH_ = hitsFH;
   recHitsBH_ = hitsBH;
  
   if (!rechittools_)
     throw cms::Exception("HGCalIsoCalculator::produceHGCalIso: rechittools not set");
  
   hitEtaPhiCache_.clear();
   hitEtaPhiCache_.reserve(recHitsEE_->size() + recHitsFH_->size() + recHitsBH_->size());
  
   // Since HGCal is not projective and the rechits don't cache any
   // eta,phi, we make our own here
   auto makeEtaPhiPair = [this](const auto& hit) {
     const GlobalPoint position = rechittools_->getPosition(hit.id());
     float eta = rechittools_->getEta(position, 0);  //assume vertex at z=0
     float phi = rechittools_->getPhi(position);
     return std::make_pair(eta, phi);
   };
  
   for (const auto& hit : *recHitsEE_)
     hitEtaPhiCache_.push_back(makeEtaPhiPair(hit));
   for (const auto& hit : *recHitsFH_)
     hitEtaPhiCache_.push_back(makeEtaPhiPair(hit));
   for (const auto& hit : *recHitsBH_)
     hitEtaPhiCache_.push_back(makeEtaPhiPair(hit));
 }