Inheritance diagram for PFClusterFromHGCalTrackster:

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

PFClusterFromHGCalTrackster &	operator= (const PFClusterFromHGCalTrackster &)=delete

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

	PFClusterFromHGCalTrackster (const PFClusterFromHGCalTrackster &)=delete

void	updateEvent (const edm::Event &) final

	~PFClusterFromHGCalTrackster () override

Public Member Functions inherited from InitialClusteringStepBase
	_algoName (conf.getParameter< std::string >("algoName"))

	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 Attributes
edm::Handle < reco::CaloClusterCollection >	clusterH_

edm::EDGetTokenT < reco::CaloClusterCollection >	clusterToken_

std::vector< int >	filter_on_categories_

std::vector< int >	filter_on_iterations_

bool	filterByTracksterIteration_

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 8 of file PFClusterFromHGCalTrackster.cc.

Constructor & Destructor Documentation

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

inline

Definition at line 10 of file PFClusterFromHGCalTrackster.cc.

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

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

PFClusterFromHGCalTrackster::~PFClusterFromHGCalTrackster ( )

inlineoverride

Definition at line 22 of file PFClusterFromHGCalTrackster.cc.

22 {}

PFClusterFromHGCalTrackster::PFClusterFromHGCalTrackster ( const PFClusterFromHGCalTrackster & )

delete

Member Function Documentation

void PFClusterFromHGCalTrackster::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 54 of file PFClusterFromHGCalTrackster.cc.

References reco::PFCluster::addRecHitFraction(), cms::cuda::assert(), SplitLinear::begin, eostools::cat(), clusterH_, HLT_FULL_cff::clusters, dataset::end, relval_parameters_module::energy, validate-o2o-wbm::f, filter_on_categories_, filter_on_iterations_, filterByTracksterIteration_, filterByTracksterPID_, spr::find(), HLT_FULL_cff::fraction, reco::CaloCluster::hitsAndFractions(), mps_fire::i, input, InitialClusteringStepBase::makeRefhit(), pid_threshold_, fileCollector::seed, reco::CaloCluster::setCorrectedEnergy(), reco::CaloCluster::setEnergy(), reco::CaloCluster::setSeed(), and trackstersH_.

                                                                                  {
   auto const& hits = *input;
 
   const auto& tracksters = *trackstersH_;
   const auto& clusters = *clusterH_;
 
   // 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& tst : tracksters) {
     // Skip empty tracksters
     if (tst.vertices().empty()) {
       continue;
     }
     // Filter using trackster PID
     if (filterByTracksterPID_) {
       float probTotal = 0.0f;
       for (int cat : filter_on_categories_) {
         probTotal += tst.id_probabilities(cat);
       }
       if (probTotal < pid_threshold_) {
         continue;
       }
     }
 
     if (filterByTracksterIteration_ &&
         std::find(filter_on_iterations_.begin(), filter_on_iterations_.end(), tst.ticlIteration()) ==
             filter_on_iterations_.end()) {
       continue;
     }
 
     DetId seed;
     double energy = 0.0, highest_energy = 0.0;
     output.emplace_back();
     reco::PFCluster& back = output.back();
 
     std::vector<std::pair<DetId, float> > hitsAndFractions;
     int iLC = 0;
     std::for_each(std::begin(tst.vertices()), std::end(tst.vertices()), [&](unsigned int lcId) {
       const auto fraction = 1.f / tst.vertex_multiplicity(iLC++);
       for (const auto& cell : clusters[lcId].hitsAndFractions()) {
         hitsAndFractions.emplace_back(cell.first, cell.second * fraction);
       }
     });
 
     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 hgcalTracksters (3D)
 }

PFClusterFromHGCalTrackster& PFClusterFromHGCalTrackster::operator= ( const PFClusterFromHGCalTrackster & )

delete

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

finalvirtual

Reimplemented from InitialClusteringStepBase.

Definition at line 49 of file PFClusterFromHGCalTrackster.cc.

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