HGCal3DClustering Class Reference

#include <HGCal3DClustering.h>

Classes
struct	ClusterRef

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

Public Member Functions
void	getEvent (const edm::Event &ev)
void	getEventSetup (const edm::EventSetup &es)
	HGCal3DClustering ()
	HGCal3DClustering (const edm::ParameterSet &conf, edm::ConsumesCollector &sumes)
	HGCal3DClustering (const edm::ParameterSet &conf, edm::ConsumesCollector &sumes, const std::vector< double > &radii_in, uint32_t min_clusters)
std::vector< reco::HGCalMultiCluster >	makeClusters (const reco::HGCalMultiCluster::ClusterCollection &)

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
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 17 of file HGCal3DClustering.h.

Member Typedef Documentation

ClusterCollection

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

Definition at line 51 of file HGCal3DClustering.h.

KDNode

typedef KDTreeNodeInfo<ClusterRef> HGCal3DClustering::KDNode

private

Definition at line 85 of file HGCal3DClustering.h.

KDTree

typedef KDTreeLinkerAlgo<ClusterRef> HGCal3DClustering::KDTree

private

Definition at line 84 of file HGCal3DClustering.h.

Constructor & Destructor Documentation

HGCal3DClustering() [1/3]

HGCal3DClustering::HGCal3DClustering ( )

inline

Definition at line 19 of file HGCal3DClustering.h.

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

HGCal3DClustering() [2/3]

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

inline

Definition at line 21 of file HGCal3DClustering.h.

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

HGCal3DClustering() [3/3]

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

getEvent()

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

inline

Definition at line 36 of file HGCal3DClustering.h.

{ clusterTools->getEvent(ev); }

References clusterTools, and ev.

getEventSetup()

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

inline

Definition at line 37 of file HGCal3DClustering.h.

                                              {
    clusterTools->getEventSetup(es);
    rhtools_.getEventSetup(es);
    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.);
  }

References clusterTools, es, hgcal::RecHitTools::getEventSetup(), hgcal::RecHitTools::lastLayerBH(), maxlayer, maxpos, minpos, points, rhtools_, and zees.

layerIntersection()

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

private

Definition at line 119 of file HGCal3DClustering.cc.

                                                                                                        {
  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;
  }
}

Referenced by makeClusters().

makeClusters()

std::vector< reco::HGCalMultiCluster > HGCal3DClustering::makeClusters

(

const reco::HGCalMultiCluster::ClusterCollection &

thecls

)

Definition at line 48 of file HGCal3DClustering.cc.

                                                          {
  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;
}

References funct::abs(), clusterTools, es, hgcal::RecHitTools::firstLayerBH(), newFWLiteAna::found, mps_fire::i, createfilelist::int, dqmiolumiharvest::j, dqmdumpme::k, hgcal::RecHitTools::lastLayerEE(), layerIntersection(), maxlayer, maxpos, minClusters, minpos, organizeByLayer(), points, position, radii, CosmicsPD_Skims::radius, reset(), rhtools_, groupFilesInBlocks::temp, z, and zees.

organizeByLayer()

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

private

Definition at line 21 of file HGCal3DClustering.cc.

                                                                                            {
  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]);
    }
  }
}

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

Referenced by makeClusters().

reset()

void HGCal3DClustering::reset ( void  )

inlineprivate

Definition at line 57 of file HGCal3DClustering.h.

               {
    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.;
    }
  }

References ntuplemaker::fill, mps_fire::i, maxpos, minpos, points, and zees.

Referenced by makeClusters().

Member Data Documentation

clusterTools

std::unique_ptr<hgcal::ClusterTools> HGCal3DClustering::clusterTools

private

instance of tools to simplify cluster access.

Definition at line 91 of file HGCal3DClustering.h.

Referenced by getEvent(), getEventSetup(), and makeClusters().

es

std::vector<size_t> HGCal3DClustering::es

private

vector to contain sorted indices of all clusters.

Definition at line 89 of file HGCal3DClustering.h.

Referenced by getEventSetup(), makeClusters(), and organizeByLayer().

maxlayer

unsigned int HGCal3DClustering::maxlayer

private

Definition at line 73 of file HGCal3DClustering.h.

Referenced by getEventSetup(), makeClusters(), and organizeByLayer().

maxpos

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

private

Definition at line 88 of file HGCal3DClustering.h.

Referenced by getEventSetup(), makeClusters(), organizeByLayer(), and reset().

minClusters

uint32_t HGCal3DClustering::minClusters

private

Definition at line 76 of file HGCal3DClustering.h.

Referenced by makeClusters().

minpos

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

private

Definition at line 87 of file HGCal3DClustering.h.

Referenced by getEventSetup(), makeClusters(), organizeByLayer(), and reset().

points

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

private

Definition at line 86 of file HGCal3DClustering.h.

Referenced by getEventSetup(), makeClusters(), organizeByLayer(), and reset().

radii

std::vector<double> HGCal3DClustering::radii

private

Definition at line 75 of file HGCal3DClustering.h.

Referenced by makeClusters().

rhtools_

hgcal::RecHitTools HGCal3DClustering::rhtools_

private

instance of tools to access RecHit information.

Definition at line 92 of file HGCal3DClustering.h.

Referenced by getEventSetup(), makeClusters(), and organizeByLayer().

zees

std::vector<float> HGCal3DClustering::zees

private

vector to contain z position of each layer.

Definition at line 90 of file HGCal3DClustering.h.

Referenced by getEventSetup(), makeClusters(), organizeByLayer(), and reset().