#include <InitialClusteringStepBase.h>

Inheritance diagram for InitialClusteringStepBase:

Public Member Functions
virtual void	buildClusters (const edm::Handle< reco::PFRecHitCollection > &, const std::vector< bool > &mask, const std::vector< bool > &seeds, reco::PFClusterCollection &)=0

	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 void	updateEvent (const edm::Event &)

virtual	~InitialClusteringStepBase ()=default

Protected Types
typedef std::tuple< std::vector< int >, std::vector< double >, std::vector< double > >	I3tuple

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

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

unsigned	_nClustersFound

unsigned	_nSeeds

std::unordered_map< int, I3tuple >	_thresholds

Private Types
typedef InitialClusteringStepBase	ICSB

Private Attributes
const std::string	_algoName

Detailed Description

Definition at line 24 of file InitialClusteringStepBase.h.

Member Typedef Documentation

◆ I3tuple

typedef std::tuple<std::vector<int>, std::vector<double>, std::vector<double> > InitialClusteringStepBase::I3tuple

protected

Definition at line 109 of file InitialClusteringStepBase.h.

◆ ICSB

typedef InitialClusteringStepBase InitialClusteringStepBase::ICSB

private

Definition at line 25 of file InitialClusteringStepBase.h.

Constructor & Destructor Documentation

◆ InitialClusteringStepBase() [1/2]

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

inline

Definition at line 28 of file InitialClusteringStepBase.h.

       : _nSeeds(0),
         _nClustersFound(0),
         _layerMap({{"PS2", (int)PFLayer::PS2},
                    {"PS1", (int)PFLayer::PS1},
                    {"ECAL_ENDCAP", (int)PFLayer::ECAL_ENDCAP},
                    {"ECAL_BARREL", (int)PFLayer::ECAL_BARREL},
                    {"NONE", (int)PFLayer::NONE},
                    {"HCAL_BARREL1", (int)PFLayer::HCAL_BARREL1},
                    {"HCAL_BARREL2_RING0", (int)PFLayer::HCAL_BARREL2},
                    {"HCAL_BARREL2_RING1", 100 * (int)PFLayer::HCAL_BARREL2},
                    {"HCAL_ENDCAP", (int)PFLayer::HCAL_ENDCAP},
                    {"HF_EM", (int)PFLayer::HF_EM},
                    {"HF_HAD", (int)PFLayer::HF_HAD},
                    {"HGCAL", (int)PFLayer::HGCAL}}),
         _algoName(conf.getParameter<std::string>("algoName")) {
     const std::vector<edm::ParameterSet>& thresholds = conf.getParameterSetVector("thresholdsByDetector");
     for (const auto& pset : thresholds) {
       const std::string& det = pset.getParameter<std::string>("detector");
  
       std::vector<int> depths;
       std::vector<double> thresh_E;
       std::vector<double> thresh_pT;
       std::vector<double> thresh_pT2;
  
       if (det == std::string("HCAL_BARREL1") || det == std::string("HCAL_ENDCAP")) {
         depths = pset.getParameter<std::vector<int> >("depths");
         thresh_E = pset.getParameter<std::vector<double> >("gatheringThreshold");
         thresh_pT = pset.getParameter<std::vector<double> >("gatheringThresholdPt");
         if (thresh_E.size() != depths.size() || thresh_pT.size() != depths.size()) {
           throw cms::Exception("InvalidGatheringThreshold")
               << "gatheringThresholds mismatch with the numbers of depths";
         }
       } else {
         depths.push_back(0);
         thresh_E.push_back(pset.getParameter<double>("gatheringThreshold"));
         thresh_pT.push_back(pset.getParameter<double>("gatheringThresholdPt"));
       }
  
       for (unsigned int i = 0; i < thresh_pT.size(); ++i) {
         thresh_pT2.push_back(thresh_pT[i] * thresh_pT[i]);
       }
  
       auto entry = _layerMap.find(det);
       if (entry == _layerMap.end()) {
         throw cms::Exception("InvalidDetectorLayer")
             << "Detector layer : " << det << " is not in the list of recognized"
             << " detector layers!";
       }
       _thresholds.emplace(_layerMap.find(det)->second, std::make_tuple(depths, thresh_E, thresh_pT2));
     }
   }

References PFLayer::ECAL_BARREL, PFLayer::ECAL_ENDCAP, PFLayer::HCAL_BARREL1, PFLayer::HCAL_BARREL2, PFLayer::HCAL_ENDCAP, PFLayer::HF_EM, PFLayer::HF_HAD, PFLayer::HGCAL, createfilelist::int, PFLayer::NONE, PFLayer::PS1, and PFLayer::PS2.

◆ ~InitialClusteringStepBase()

virtual InitialClusteringStepBase::~InitialClusteringStepBase ( )

virtualdefault

◆ InitialClusteringStepBase() [2/2]

InitialClusteringStepBase::InitialClusteringStepBase ( const ICSB & )

delete

Member Function Documentation

◆ buildClusters()

virtual void InitialClusteringStepBase::buildClusters	(	const edm::Handle< reco::PFRecHitCollection > &	,
		const std::vector< bool > &	mask,
		const std::vector< bool > &	seeds,
		reco::PFClusterCollection &
	)

pure virtual

Implemented in RealisticSimClusterMapper, PFClusterFromHGCalMultiCluster, GenericSimClusterMapper, Basic2DGenericTopoClusterizer, and Basic2DClusterForEachSeed.

◆ makeRefhit()

reco::PFRecHitRef InitialClusteringStepBase::makeRefhit	(	const edm::Handle< reco::PFRecHitCollection > &	h,
		const unsigned	i
	)		const

inlineprotected

Definition at line 103 of file InitialClusteringStepBase.h.

                                                                                                  {
     return reco::PFRecHitRef(h, i);
   }

References mps_fire::i.

Referenced by Basic2DClusterForEachSeed::buildClusters(), GenericSimClusterMapper::buildClusters(), PFClusterFromHGCalMultiCluster::buildClusters(), RealisticSimClusterMapper::buildClusters(), and Basic2DGenericTopoClusterizer::buildTopoCluster().

◆ operator<<()

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

inline

Definition at line 94 of file InitialClusteringStepBase.h.

                                               {
     o << "InitialClusteringStep with algo \"" << _algoName << "\" located " << _nSeeds << " seeds and built "
       << _nClustersFound << " clusters from those seeds. ";
     return o;
   }