#include <HGCal3DClustering.h>

Classes
struct	ClusterRef

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

Public Member Functions
	clusterTools (nullptr)

void	getEvent (const edm::Event &ev)

void	getEventSetup (const edm::EventSetup &es)

	HGCal3DClustering ()

	HGCal3DClustering (const edm::ParameterSet &conf, edm::ConsumesCollector &sumes, const std::vector< double > &radii_in, uint32_t min_clusters)

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

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

	minClusters (0)

Private Types
typedef KDTreeNodeInfo < ClusterRef >	KDNode

typedef KDTreeLinkerAlgo < ClusterRef >	KDTree

Private Member Functions
void	layerIntersection (std::array< double, 3 > &to, const std::array< double, 3 > &from) const

void	organizeByLayer (const reco::HGCalMultiCluster::ClusterCollection &)

void	reset ()

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

std::unique_ptr < hgcal::ClusterTools >	clusterTools

std::vector< size_t >	es

unsigned int	maxlayer

std::vector< std::array< float, 2 > >	maxpos

uint32_t	minClusters

std::vector< std::array< float, 2 > >	minpos

std::vector< std::vector < KDNode > >	points

std::vector< double >	radii

hgcal::RecHitTools	rhtools_

std::vector< float >	zees

Detailed Description

Definition at line 16 of file HGCal3DClustering.h.

Member Typedef Documentation

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

Definition at line 52 of file HGCal3DClustering.h.

typedef KDTreeNodeInfo<ClusterRef> HGCal3DClustering::KDNode

private

Definition at line 86 of file HGCal3DClustering.h.

typedef KDTreeLinkerAlgo<ClusterRef> HGCal3DClustering::KDTree

private

Definition at line 85 of file HGCal3DClustering.h.

Constructor & Destructor Documentation

HGCal3DClustering::HGCal3DClustering ( )

inline

Definition at line 18 of file HGCal3DClustering.h.

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

HGCal3DClustering::minClusters

uint32_t minClusters

Definition: HGCal3DClustering.h:77

HGCal3DClustering::radii

std::vector< double > radii

Definition: HGCal3DClustering.h:76

HGCal3DClustering::clusterTools

std::unique_ptr< hgcal::ClusterTools > clusterTools

Definition: HGCal3DClustering.h:92

HGCal3DClustering::HGCal3DClustering	(	const edm::ParameterSet &	conf,
		edm::ConsumesCollector &	sumes,
		const std::vector< double > &	radii_in,
		uint32_t	min_clusters
	)

inline

Definition at line 20 of file HGCal3DClustering.h.

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

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

inline

Definition at line 30 of file HGCal3DClustering.h.

       : HGCal3DClustering(conf,
                           sumes,
                           conf.getParameter<std::vector<double>>("multiclusterRadii"),
                           conf.getParameter<unsigned>("minClusters")) {}

Member Function Documentation

HGCal3DClustering::clusterTools ( nullptr )

inline

Definition at line 18 of file HGCal3DClustering.h.

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

HGCal3DClustering::minClusters

uint32_t minClusters

Definition: HGCal3DClustering.h:77

HGCal3DClustering::radii

std::vector< double > radii

Definition: HGCal3DClustering.h:76

HGCal3DClustering::clusterTools

std::unique_ptr< hgcal::ClusterTools > clusterTools

Definition: HGCal3DClustering.h:92

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

inline

Definition at line 36 of file HGCal3DClustering.h.

References clusterTools.

36 { clusterTools->getEvent(ev); }

HGCal3DClustering::clusterTools

std::unique_ptr< hgcal::ClusterTools > clusterTools

Definition: HGCal3DClustering.h:92

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

inline

Definition at line 37 of file HGCal3DClustering.h.

References caloGeomToken_, clusterTools, relativeConstraints::geom, edm::EventSetup::getData(), hgcal::RecHitTools::lastLayerBH(), maxlayer, maxpos, minpos, points, rhtools_, hgcal::RecHitTools::setGeometry(), and zees.

                                               {
     clusterTools->getEventSetup(es);
     const CaloGeometry& geom = es.getData(caloGeomToken_);
     rhtools_.setGeometry(geom);
     maxlayer = rhtools_.lastLayerBH();
     points.clear();
     minpos.clear();
     maxpos.clear();
     zees.clear();
     points.resize(2 * (maxlayer + 1));
     minpos.resize(2 * (maxlayer + 1), {{0.0f, 0.0f}});
     maxpos.resize(2 * (maxlayer + 1), {{0.0f, 0.0f}});
     zees.resize(2 * (maxlayer + 1), 0.);
   }

void HGCal3DClustering::layerIntersection	(	std::array< double, 3 > &	to,
		const std::array< double, 3 > &	from
	)		const

private

Definition at line 119 of file HGCal3DClustering.cc.

Referenced by makeClusters().

                                                                                                         {
   if (from[2] != 0) {
     to[0] = from[0] / from[2] * to[2];
     to[1] = from[1] / from[2] * to[2];
   } else {
     to[0] = 0;
     to[1] = 0;
   }
 }

std::vector< reco::HGCalMultiCluster > HGCal3DClustering::makeClusters ( const reco::HGCalMultiCluster::ClusterCollection & thecls )

Definition at line 48 of file HGCal3DClustering.cc.

References funct::abs(), clusterTools, es, hgcal::RecHitTools::firstLayerBH(), newFWLiteAna::found, mps_fire::i, dqmiolumiharvest::j, isotrackApplyRegressor::k, hgcal::RecHitTools::lastLayerEE(), phase1PixelTopology::layer, layerIntersection(), maxlayer, maxpos, minClusters, minpos, organizeByLayer(), points, position, reco::HGCalMultiCluster::push_back(), radii, CosmicsPD_Skims::radius, reset(), rhtools_, reco::HGCalMultiCluster::size(), groupFilesInBlocks::temp, z, and zees.

                                                           {
   reset();
   organizeByLayer(thecls);
   std::vector<reco::HGCalMultiCluster> thePreClusters;
 
   std::vector<KDTree> hit_kdtree(2 * (maxlayer + 1));
   for (unsigned int i = 0; i <= 2 * maxlayer + 1; ++i) {
     KDTreeBox bounds(minpos[i][0], maxpos[i][0], minpos[i][1], maxpos[i][1]);
     hit_kdtree[i].build(points[i], bounds);
   }
   std::vector<int> vused(es.size(), 0);
   unsigned int used = 0;
 
   unsigned int es_size = es.size();
   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;
       // Starting from cluster es[i] at from[0] - from[1] - from[2]
       std::array<double, 3> from{{thecls[es[i]]->x(), thecls[es[i]]->y(), thecls[es[i]]->z()}};
       unsigned int firstlayer = int(thecls[es[i]]->z() > 0) * (maxlayer + 1);
       unsigned int lastlayer = firstlayer + maxlayer + 1;
       for (unsigned int j = firstlayer; j < lastlayer; ++j) {
         if (zees[j] == 0.) {
           // layer j not yet ever reached?
           continue;
         }
         std::array<double, 3> to{{0., 0., zees[j]}};
         layerIntersection(to, from);
         unsigned int layer =
             j > maxlayer ? (j - (maxlayer + 1)) : j;  //maps back from index used for KD trees to actual layer
         float radius = radii[2];
         if (layer <= rhtools_.lastLayerEE())
           radius = radii[0];
         else if (layer < rhtools_.firstLayerBH())
           radius = radii[1];
         float radius2 = radius * radius;
         KDTreeBox search_box(
             float(to[0]) - radius, float(to[0]) + radius, float(to[1]) - radius, float(to[1]) + radius);
         std::vector<ClusterRef> found;
         // at layer j in box float(to[0])+/-radius - float(to[1])+/-radius
         hit_kdtree[j].search(search_box, found);
         // found found.size() clusters within box
         for (unsigned int k = 0; k < found.size(); k++) {
           if (vused[found[k].ind] == 0 && distReal2(thecls[es[found[k].ind]], to) < radius2) {
             temp.push_back(thecls[es[found[k].ind]]);
             vused[found[k].ind] = vused[i];
             ++used;
           }
         }
       }
       if (temp.size() > minClusters) {
         math::XYZPoint position = clusterTools->getMultiClusterPosition(temp);
         if (std::abs(position.z()) <= 0.)
           continue;
         // only store multiclusters that pass the energy threshold in getMultiClusterPosition
         // giving them a position inside the HGCal
         thePreClusters.push_back(temp);
         auto &back = thePreClusters.back();
         back.setPosition(position);
         back.setEnergy(clusterTools->getMultiClusterEnergy(back));
       }
     }
   }
 
   return thePreClusters;
 }

HGCal3DClustering::minClusters ( 0 )

void HGCal3DClustering::organizeByLayer ( const reco::HGCalMultiCluster::ClusterCollection & thecls )

private

Definition at line 21 of file HGCal3DClustering.cc.

References relativeConstraints::empty, es, first, hgcal::RecHitTools::getLayerWithOffset(), mps_fire::i, phase1PixelTopology::layer, SiStripPI::max, maxlayer, maxpos, SiStripPI::min, minpos, points, rhtools_, hgcal_clustering::sorted_indices(), x, y, z, and zees.

Referenced by makeClusters().

                                                                                             {
   es = sorted_indices(thecls);
   unsigned int es_size = es.size();
   for (unsigned int i = 0; i < es_size; ++i) {
     int layer = rhtools_.getLayerWithOffset(thecls[es[i]]->hitsAndFractions()[0].first);
     layer += int(thecls[es[i]]->z() > 0) * (maxlayer + 1);
     float x = thecls[es[i]]->x();
     float y = thecls[es[i]]->y();
     float z = thecls[es[i]]->z();
     points[layer].emplace_back(ClusterRef(i, z), x, y);
     if (zees[layer] == 0.) {
       // At least one cluster for layer at z
       zees[layer] = z;
     }
     if (points[layer].empty()) {
       minpos[layer][0] = x;
       minpos[layer][1] = y;
       maxpos[layer][0] = x;
       maxpos[layer][1] = y;
     } else {
       minpos[layer][0] = std::min(x, minpos[layer][0]);
       minpos[layer][1] = std::min(y, minpos[layer][1]);
       maxpos[layer][0] = std::max(x, maxpos[layer][0]);
       maxpos[layer][1] = std::max(y, maxpos[layer][1]);
     }
   }
 }

void HGCal3DClustering::reset ( void )

inlineprivate

Definition at line 58 of file HGCal3DClustering.h.

References PVValHelper::fill(), mps_fire::i, maxpos, minpos, points, edm::swap(), and zees.

Referenced by makeClusters().

                {
     for (auto& it : points) {
       it.clear();
       std::vector<KDNode>().swap(it);
     }
     std::fill(zees.begin(), zees.end(), 0.);
     for (unsigned int i = 0; i < minpos.size(); i++) {
       minpos[i][0] = 0.;
       minpos[i][1] = 0.;
       maxpos[i][0] = 0.;
       maxpos[i][1] = 0.;
     }
   }