#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_

std::vector< int >	filter_on_categories_

bool	filterByTracksterPID_

float	pid_threshold_

edm::Handle< std::vector< ticl::Trackster > >	trackstersH_

edm::EDGetTokenT< std::vector< ticl::Trackster > >	tracksterToken_

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 PFClusterFromHGCalMultiCluster.h.

Constructor & Destructor Documentation

◆ PFClusterFromHGCalMultiCluster() [1/2]

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

inline

Definition at line 11 of file PFClusterFromHGCalMultiCluster.h.

       : InitialClusteringStepBase(conf, sumes) {
     filterByTracksterPID_ = conf.getParameter<bool>("filterByTracksterPID");
     pid_threshold_ = conf.getParameter<double>("pid_threshold");
     filter_on_categories_ = conf.getParameter<std::vector<int> >("filter_on_categories");
  
     clusterToken_ =
         sumes.consumes<std::vector<reco::HGCalMultiCluster> >(conf.getParameter<edm::InputTag>("clusterSrc"));
     tracksterToken_ = sumes.consumes<std::vector<ticl::Trackster> >(conf.getParameter<edm::InputTag>("tracksterSrc"));
   }

References clusterToken_, edm::ConsumesCollector::consumes(), filter_on_categories_, filterByTracksterPID_, edm::ParameterSet::getParameter(), pid_threshold_, and tracksterToken_.

◆ ~PFClusterFromHGCalMultiCluster()

PFClusterFromHGCalMultiCluster::~PFClusterFromHGCalMultiCluster ( )

inlineoverride

Definition at line 22 of file PFClusterFromHGCalMultiCluster.h.

22 {}

◆ 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 13 of file PFClusterFromHGCalMultiCluster.cc.

                                                                                     {
   const auto& hgcalMultiClusters = *clusterH_;
   auto const& hits = *input;
  
   const auto& tracksters = *trackstersH_;
  
   // 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;
   }
  
   int iMultiClus = -1;
   for (const auto& mcl : hgcalMultiClusters) {
     iMultiClus++;
     // Skip empty multiclusters
     if (mcl.hitsAndFractions().empty()) {
       continue;
     }
     // Filter using trackster PID
     if (filterByTracksterPID_) {
       float probTotal = 0.0f;
       for (int cat : filter_on_categories_) {
         probTotal += tracksters[iMultiClus].id_probabilities(cat);
       }
       if (probTotal < pid_threshold_) {
         continue;
       }
     }
  
     DetId seed;
     double energy = 0.0, highest_energy = 0.0;
     output.emplace_back();
     reco::PFCluster& back = output.back();
     const auto& hitsAndFractions_mcl = mcl.hitsAndFractions();
  
     std::vector<std::pair<DetId, float> > hitsAndFractions;
     hitsAndFractions.insert(hitsAndFractions.end(), hitsAndFractions_mcl.begin(), hitsAndFractions_mcl.end());
  
     // Use the H&F of the clusters inside the multicluster if the latter's H&F are not stored
     if (hitsAndFractions.empty()) {
       for (const auto& cl : mcl) {
         const auto& hAndF_temp = cl->hitsAndFractions();
         hitsAndFractions.insert(hitsAndFractions.end(), hAndF_temp.begin(), hAndF_temp.end());
       }
     }
  
     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
  
     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)
 }

References reco::PFCluster::addRecHitFraction(), cms::cuda::assert(), eostools::cat(), GetRecoTauVFromDQM_MC_cff::cl, clusterH_, HCALHighEnergyHPDFilter_cfi::energy, f, filter_on_categories_, filterByTracksterPID_, hfClusterShapes_cfi::hits, reco::CaloCluster::hitsAndFractions(), mps_fire::i, input, InitialClusteringStepBase::makeRefhit(), convertSQLitetoXML_cfg::output, pid_threshold_, fileCollector::seed, reco::CaloCluster::setCorrectedEnergy(), reco::CaloCluster::setEnergy(), reco::CaloCluster::setSeed(), and trackstersH_.

◆ operator=()

PFClusterFromHGCalMultiCluster& PFClusterFromHGCalMultiCluster::operator= ( const PFClusterFromHGCalMultiCluster & )

delete

◆ updateEvent()

void PFClusterFromHGCalMultiCluster::updateEvent ( const edm::Event & ev )

finalvirtual

Reimplemented from InitialClusteringStepBase.

Definition at line 8 of file PFClusterFromHGCalMultiCluster.cc.

                                                                    {
   ev.getByToken(clusterToken_, clusterH_);
   ev.getByToken(tracksterToken_, trackstersH_);
 }