#include <HGCalDepthPreClusterer.h>

Public Types
typedef std::vector< reco::BasicCluster >	ClusterCollection

Public Member Functions
void	getEvent (const edm::Event &ev)

void	getEventSetup (const edm::EventSetup &es)

	HGCalDepthPreClusterer ()

	HGCalDepthPreClusterer (const edm::ParameterSet &conf, edm::ConsumesCollector &sumes, std::vector< float > radii_in, uint32_t min_clusters, bool real_space_cone)

std::vector< reco::HGCalMultiCluster >	makePreClusters (const reco::HGCalMultiCluster::ClusterCollection &) const

Private Attributes
edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	caloGeomToken_

std::unique_ptr< hgcal::ClusterTools >	clusterTools

uint32_t	minClusters

std::vector< float >	radii

bool	realSpaceCone

hgcal::RecHitTools	rhtools_

Detailed Description

Definition at line 13 of file HGCalDepthPreClusterer.h.

Member Typedef Documentation

◆ ClusterCollection

typedef std::vector<reco::BasicCluster> HGCalDepthPreClusterer::ClusterCollection

Definition at line 43 of file HGCalDepthPreClusterer.h.

Constructor & Destructor Documentation

◆ HGCalDepthPreClusterer() [1/2]

HGCalDepthPreClusterer::HGCalDepthPreClusterer ( )

inline

Definition at line 15 of file HGCalDepthPreClusterer.h.

       : radii({
             0.,
             0.,
             0.,
         }),
         minClusters(0),
         realSpaceCone(false),
         clusterTools(nullptr) {}

◆ HGCalDepthPreClusterer() [2/2]

HGCalDepthPreClusterer::HGCalDepthPreClusterer	(	const edm::ParameterSet &	conf,
		edm::ConsumesCollector &	sumes,
		std::vector< float >	radii_in,
		uint32_t	min_clusters,
		bool	real_space_cone
	)

inline

Definition at line 25 of file HGCalDepthPreClusterer.h.

       : radii(radii_in),
         minClusters(min_clusters),
         realSpaceCone(real_space_cone),
         clusterTools(std::make_unique<hgcal::ClusterTools>(conf, sumes)),
         caloGeomToken_(sumes.esConsumes<CaloGeometry, CaloGeometryRecord>()) {}

Member Function Documentation

◆ getEvent()

void HGCalDepthPreClusterer::getEvent ( const edm::Event & ev )

inline

Definition at line 36 of file HGCalDepthPreClusterer.h.

36 { clusterTools->getEvent(ev); }

References clusterTools, and ev.

◆ getEventSetup()

void HGCalDepthPreClusterer::getEventSetup ( const edm::EventSetup & es )

inline

Definition at line 37 of file HGCalDepthPreClusterer.h.

                                               {
     clusterTools->getEventSetup(es);
     edm::ESHandle<CaloGeometry> geom = es.getHandle(caloGeomToken_);
     rhtools_.setGeometry(*geom);
   }

References caloGeomToken_, clusterTools, relativeConstraints::geom, edm::EventSetup::getHandle(), rhtools_, and hgcal::RecHitTools::setGeometry().

◆ makePreClusters()

std::vector< reco::HGCalMultiCluster > HGCalDepthPreClusterer::makePreClusters ( const reco::HGCalMultiCluster::ClusterCollection & thecls ) const

Definition at line 33 of file HGCalDepthPreClusterer.cc.

                                                                 {
   std::vector<reco::HGCalMultiCluster> thePreClusters;
   std::vector<size_t> es = sorted_indices(thecls);
   std::vector<int> vused(es.size(), 0);
   unsigned int used = 0;
  
   for (unsigned int i = 0; i < es.size(); ++i) {
     if (vused[i] == 0) {
       reco::HGCalMultiCluster temp;
       temp.push_back(thecls[es[i]]);
       vused[i] = (thecls[es[i]]->z() > 0) ? 1 : -1;
       ++used;
       for (unsigned int j = i + 1; j < es.size(); ++j) {
         if (vused[j] == 0) {
           float distanceCheck = 9999.;
           if (realSpaceCone)
             distanceCheck = distAxisCluster2(thecls[es[i]], thecls[es[j]]);
           else
             distanceCheck = dist2(thecls[es[i]], thecls[es[j]]);
           DetId detid = thecls[es[j]]->hitsAndFractions()[0].first();
           unsigned int layer = clusterTools->getLayer(detid);
           float radius = radii[2];
           if (layer <= rhtools_.lastLayerEE())
             radius = radii[0];
           else if (layer < rhtools_.firstLayerBH())
             radius = radii[1];
           float radius2 = radius * radius;
           if (distanceCheck<radius2 &&int(thecls[es[j]]->z() * vused[i])> 0) {
             temp.push_back(thecls[es[j]]);
             vused[j] = vused[i];
             ++used;
           }
         }
       }
       if (temp.size() > minClusters) {
         thePreClusters.push_back(temp);
         auto &back = thePreClusters.back();
         back.setPosition(clusterTools->getMultiClusterPosition(back));
         back.setEnergy(clusterTools->getMultiClusterEnergy(back));
       }
     }
   }
  
   return thePreClusters;
 }