#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

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

protected

Definition at line 112 of file InitialClusteringStepBase.h.

typedef InitialClusteringStepBase InitialClusteringStepBase::ICSB

private

Definition at line 25 of file InitialClusteringStepBase.h.

Constructor & Destructor Documentation

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

inline

Definition at line 27 of file InitialClusteringStepBase.h.

References particleFlowClusterHBHE_cfi::depths, PFLayer::ECAL_BARREL, PFLayer::ECAL_ENDCAP, mps_splice::entry, Exception, PFLayer::HCAL_BARREL1, PFLayer::HCAL_BARREL2, PFLayer::HCAL_ENDCAP, PFLayer::HF_EM, PFLayer::HF_HAD, PFLayer::HGCAL, mps_fire::i, createfilelist::int, PFLayer::NONE, PFLayer::PS1, PFLayer::PS2, muonDTDigis_cfi::pset, AlCaHLTBitMon_QueryRunRegistry::string, and particleFlowZeroSuppressionECAL_cff::thresholds.

                                              :    
     _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));
   }
   }

virtual InitialClusteringStepBase::~InitialClusteringStepBase ( )

virtualdefault

InitialClusteringStepBase::InitialClusteringStepBase ( const ICSB & )

delete

Member Function Documentation

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, and Basic2DGenericTopoClusterizer.

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

inlineprotected

Definition at line 105 of file InitialClusteringStepBase.h.

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

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

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

inline

Definition at line 95 of file InitialClusteringStepBase.h.

References connectstrParser::o.

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