#include <GenericSimClusterMapper.h>

Inheritance diagram for GenericSimClusterMapper:

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

	GenericSimClusterMapper (const B2DGT &)=delete

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

B2DGT &	operator= (const B2DGT &)=delete

void	updateEvent (const edm::Event &) final

	~GenericSimClusterMapper () override=default

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 Types
typedef GenericSimClusterMapper	B2DGT

Private Attributes
edm::Handle< SimClusterCollection >	_simClusterH

edm::EDGetTokenT< SimClusterCollection >	_simClusterToken

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 9 of file GenericSimClusterMapper.h.

Member Typedef Documentation

◆ B2DGT

typedef GenericSimClusterMapper GenericSimClusterMapper::B2DGT

private

Definition at line 10 of file GenericSimClusterMapper.h.

Constructor & Destructor Documentation

◆ GenericSimClusterMapper() [1/2]

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

inline

Definition at line 13 of file GenericSimClusterMapper.h.

       : InitialClusteringStepBase(conf, sumes) {
     _simClusterToken = sumes.consumes<SimClusterCollection>(conf.getParameter<edm::InputTag>("simClusterSrc"));
   }

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

◆ ~GenericSimClusterMapper()

GenericSimClusterMapper::~GenericSimClusterMapper ( )

overridedefault

◆ GenericSimClusterMapper() [2/2]

GenericSimClusterMapper::GenericSimClusterMapper ( const B2DGT & )

delete

Member Function Documentation

◆ buildClusters()

void GenericSimClusterMapper::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 23 of file GenericSimClusterMapper.cc.

                                                                              {
   const SimClusterCollection& simClusters = *_simClusterH;
   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;
     auto ref = makeRefhit(input, i);
   }
  
   for (const auto& sc : simClusters) {
     output.emplace_back();
     reco::PFCluster& back = output.back();
     edm::Ref<std::vector<reco::PFRecHit> > seed;
     double energy = 0.0, highest_energy = 0.0;
     auto hitsAndFractions = sc.hits_and_fractions();
     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);
       const double hit_energy = hAndF.second * ref->energy();
       energy += hit_energy;
       back.addRecHitFraction(reco::PFRecHitFraction(ref, hAndF.second));
       if (hit_energy > highest_energy || highest_energy == 0.0) {
         highest_energy = hit_energy;
         seed = ref;
       }
     }
     if (!back.hitsAndFractions().empty()) {
       back.setSeed(seed->detId());
       back.setEnergy(energy);
       back.setCorrectedEnergy(energy);
     } else {
       back.setSeed(-1);
       back.setEnergy(0.f);
     }
   }
 }