#include <PFClusterFromHGCalMultiCluster.h>

Inheritance diagram for PFClusterFromHGCalMultiCluster:

Public Member Functions
void	buildClusters (const edm::Handle< reco::PFRecHitCollection > &, const std::vector< bool > &, const std::vector< bool > &, reco::PFClusterCollection &) override

PFClusterFromHGCalMultiCluster &	operator= (const PFClusterFromHGCalMultiCluster &)=delete

	PFClusterFromHGCalMultiCluster (const edm::ParameterSet &conf, edm::ConsumesCollector &sumes)

	PFClusterFromHGCalMultiCluster (const PFClusterFromHGCalMultiCluster &)=delete

void	updateEvent (const edm::Event &) final

	~PFClusterFromHGCalMultiCluster () override

Public Member Functions inherited from InitialClusteringStepBase
	InitialClusteringStepBase (const edm::ParameterSet &conf, edm::ConsumesCollector &sumes)

	InitialClusteringStepBase (const ICSB &)=delete

std::ostream &	operator<< (std::ostream &o) const

ICSB &	operator= (const ICSB &)=delete

void	reset ()

virtual void	update (const edm::EventSetup &)

virtual	~InitialClusteringStepBase ()=default

Private Attributes
edm::Handle< std::vector< reco::HGCalMultiCluster > >	clusterH_

edm::EDGetTokenT< std::vector< reco::HGCalMultiCluster > >	clusterToken_

Additional Inherited Members
Protected Types inherited from InitialClusteringStepBase
typedef std::tuple< std::vector< int >, std::vector< double >, std::vector< double > >	I3tuple

Protected Member Functions inherited from InitialClusteringStepBase
reco::PFRecHitRef	makeRefhit (const edm::Handle< reco::PFRecHitCollection > &h, const unsigned i) const

Protected Attributes inherited from InitialClusteringStepBase
const std::unordered_map< std::string, int >	_layerMap

unsigned	_nClustersFound

unsigned	_nSeeds

std::unordered_map< int, I3tuple >	_thresholds

Detailed Description

Definition at line 8 of file PFClusterFromHGCalMultiCluster.h.

Constructor & Destructor Documentation

◆ PFClusterFromHGCalMultiCluster() [1/2]

PFClusterFromHGCalMultiCluster::PFClusterFromHGCalMultiCluster	(	const edm::ParameterSet &	conf,
		edm::ConsumesCollector &	sumes
	)

inline

Definition at line 10 of file PFClusterFromHGCalMultiCluster.h.

       : InitialClusteringStepBase(conf, sumes) {
     clusterToken_ =
         sumes.consumes<std::vector<reco::HGCalMultiCluster> >(conf.getParameter<edm::InputTag>("clusterSrc"));
   }

References clusterToken_, edm::ConsumesCollector::consumes(), and edm::ParameterSet::getParameter().

◆ ~PFClusterFromHGCalMultiCluster()

PFClusterFromHGCalMultiCluster::~PFClusterFromHGCalMultiCluster ( )

inlineoverride

Definition at line 15 of file PFClusterFromHGCalMultiCluster.h.

15 {}

◆ PFClusterFromHGCalMultiCluster() [2/2]

PFClusterFromHGCalMultiCluster::PFClusterFromHGCalMultiCluster ( const PFClusterFromHGCalMultiCluster & )

delete

Member Function Documentation

◆ buildClusters()

void PFClusterFromHGCalMultiCluster::buildClusters	(	const edm::Handle< reco::PFRecHitCollection > &	input,
		const std::vector< bool > &	rechitMask,
		const std::vector< bool > &	seedable,
		reco::PFClusterCollection &	output
	)

overridevirtual

Implements InitialClusteringStepBase.

Definition at line 10 of file PFClusterFromHGCalMultiCluster.cc.

                                                                                     {
   const auto& hgcalMultiClusters = *clusterH_;
   auto const& hits = *input;
  
   // for quick indexing back to hit energy
   std::unordered_map<uint32_t, size_t> detIdToIndex(hits.size());
   for (uint32_t i = 0; i < hits.size(); ++i) {
     detIdToIndex[hits[i].detId()] = i;
   }
  
   for (const auto& mcl : hgcalMultiClusters) {
     DetId seed;
     double energy = 0.0, highest_energy = 0.0;
     output.emplace_back();
     reco::PFCluster& back = output.back();
     for (const auto& cl : mcl) {
       const auto& hitsAndFractions = cl->hitsAndFractions();
       for (const auto& hAndF : hitsAndFractions) {
         auto itr = detIdToIndex.find(hAndF.first);
         if (itr == detIdToIndex.end()) {
           continue;  // hit wasn't saved in reco
         }
         auto ref = makeRefhit(input, itr->second);
         assert(ref->detId() == hAndF.first.rawId());
         const double hit_energy = hAndF.second * ref->energy();
         energy += hit_energy;
         back.addRecHitFraction(reco::PFRecHitFraction(ref, hAndF.second));
         // TODO: the following logic to identify the seed of a cluster
         // could be appropriate for the Run2 Ecal Calorimetric
         // detector, but could be wrong for the HGCal one. This has to
         // be reviewd.
         if (hit_energy > highest_energy || highest_energy == 0.0) {
           highest_energy = hit_energy;
           seed = ref->detId();
         }
       }  // end of hitsAndFractions
     }    // end of loop over clusters (2D/layer)
     if (energy <= 1) {
       output.pop_back();
       continue;
     }
     if (!back.hitsAndFractions().empty()) {
       back.setSeed(seed);
       back.setEnergy(energy);
       back.setCorrectedEnergy(energy);
     } else {
       back.setSeed(0);
       back.setEnergy(0.f);
     }
   }  // end of loop over hgcalMulticlusters (3D)
 }