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 edm::ParameterSet &conf, edm::ConsumesCollector &cc)

	GenericSimClusterMapper (const B2DGT &)=delete

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 &cc)

	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.cc.

Member Typedef Documentation

◆ B2DGT

typedef GenericSimClusterMapper GenericSimClusterMapper::B2DGT

private

Definition at line 10 of file GenericSimClusterMapper.cc.

Constructor & Destructor Documentation

◆ GenericSimClusterMapper() [1/2]

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

inline

Definition at line 13 of file GenericSimClusterMapper.cc.

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

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

◆ ~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 49 of file GenericSimClusterMapper.cc.

References _simClusterH, reco::PFCluster::addRecHitFraction(), HCALHighEnergyHPDFilter_cfi::energy, f, hfClusterShapes_cfi::hits, reco::CaloCluster::hitsAndFractions(), mps_fire::i, input, InitialClusteringStepBase::makeRefhit(), convertSQLitetoXML_cfg::output, fileCollector::seed, reco::CaloCluster::setCorrectedEnergy(), reco::CaloCluster::setEnergy(), and reco::CaloCluster::setSeed().

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