#include <HGCalCLUEAlgo.h>

Inheritance diagram for HGCalCLUEAlgo:

Classes
struct	Hexel

Public Types
typedef math::XYZPoint	Point
	point in the space More...

Public Types inherited from HGCalClusteringAlgoBase
enum	VerbosityLevel { pDEBUG = 0, pWARNING = 1, pINFO = 2, pERROR = 3 }

Public Member Functions
void	computeThreshold ()

std::vector< reco::BasicCluster >	getClusters (bool) override

Density	getDensity () override

	HGCalCLUEAlgo (const edm::ParameterSet &ps)

void	makeClusters () override

void	populate (const HGCRecHitCollection &hits) override

void	reset () override

	~HGCalCLUEAlgo () override

Public Member Functions inherited from HGCalClusteringAlgoBase
void	getEventSetup (const edm::EventSetup &es)

	HGCalClusteringAlgoBase (VerbosityLevel v, reco::CaloCluster::AlgoId algo)

void	setAlgoId (reco::CaloCluster::AlgoId algo)

void	setVerbosity (VerbosityLevel the_verbosity)

virtual	~HGCalClusteringAlgoBase ()

Static Public Member Functions
static void	fillPSetDescription (edm::ParameterSetDescription &iDesc)

Private Types
typedef KDTreeNodeInfoT< Hexel, 2 >	KDNode

typedef KDTreeLinkerAlgo< Hexel, 2 >	KDTree

Private Member Functions
double	calculateDistanceToHigher (std::vector< KDNode > &) const

double	calculateLocalDensity (std::vector< KDNode > &, KDTree &, const unsigned int) const

math::XYZPoint	calculatePosition (const std::vector< KDNode > &) const

double	distance (const Hexel &pt1, const Hexel &pt2) const

double	distance2 (const Hexel &pt1, const Hexel &pt2) const

int	findAndAssignClusters (std::vector< KDNode > &, KDTree &, double, KDTreeBox &, const unsigned int, std::vector< std::vector< KDNode > > &) const

void	setDensity (const std::vector< KDNode > &nd)

std::vector< size_t >	sort_by_delta (const std::vector< KDNode > &v) const

Private Attributes
std::vector< double >	dEdXweights_

Density	density_

bool	dependSensor_

double	ecut_

double	fcPerEle_

std::vector< double >	fcPerMip_

bool	initialized_

double	kappa_

std::vector< std::vector< std::vector< KDNode > > >	layerClustersPerLayer_

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

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

double	noiseMip_

std::vector< double >	nonAgedNoises_

std::vector< std::vector< KDNode > >	points_

std::vector< double >	positionDeltaRho_c_

std::vector< double >	thicknessCorrection_

std::vector< std::vector< double > >	thresholds_

std::vector< double >	thresholdW0_

std::vector< std::vector< double > >	v_sigmaNoise_

std::vector< double >	vecDeltas_

Additional Inherited Members
Static Public Attributes inherited from HGCalClusteringAlgoBase
static const unsigned int	lastLayerEE = 28

static const unsigned int	lastLayerFH = 40

static const unsigned int	maxlayer = 52

Protected Attributes inherited from HGCalClusteringAlgoBase
reco::CaloCluster::AlgoId	algoId_

std::vector< reco::BasicCluster >	clusters_v_

hgcal::RecHitTools	rhtools_

VerbosityLevel	verbosity_

Detailed Description

Definition at line 31 of file HGCalCLUEAlgo.h.

Member Typedef Documentation

typedef KDTreeNodeInfoT<Hexel, 2> HGCalCLUEAlgo::KDNode

private

Definition at line 206 of file HGCalCLUEAlgo.h.

typedef KDTreeLinkerAlgo<Hexel, 2> HGCalCLUEAlgo::KDTree

private

Definition at line 205 of file HGCalCLUEAlgo.h.

typedef math::XYZPoint HGCalCLUEAlgo::Point

point in the space

Definition at line 120 of file HGCalCLUEAlgo.h.

Constructor & Destructor Documentation

HGCalCLUEAlgo::HGCalCLUEAlgo ( const edm::ParameterSet & ps )

inline

Definition at line 34 of file HGCalCLUEAlgo.h.

References HGCalClusteringAlgoBase::maxlayer, and maxpos_.

   : HGCalClusteringAlgoBase(
       (HGCalClusteringAlgoBase::VerbosityLevel)ps.getUntrackedParameter<unsigned int>("verbosity",3),
       reco::CaloCluster::undefined),
      thresholdW0_(ps.getParameter<std::vector<double> >("thresholdW0")),
      positionDeltaRho_c_(ps.getParameter<std::vector<double> >("positionDeltaRho_c")),
      vecDeltas_(ps.getParameter<std::vector<double> >("deltac")),
      kappa_(ps.getParameter<double>("kappa")),
      ecut_(ps.getParameter<double>("ecut")),
      dependSensor_(ps.getParameter<bool>("dependSensor")),
      dEdXweights_(ps.getParameter<std::vector<double> >("dEdXweights")),
      thicknessCorrection_(ps.getParameter<std::vector<double> >("thicknessCorrection")),
      fcPerMip_(ps.getParameter<std::vector<double> >("fcPerMip")),
      fcPerEle_(ps.getParameter<double>("fcPerEle")),
      nonAgedNoises_(ps.getParameter<edm::ParameterSet>("noises").getParameter<std::vector<double> >("values")),
      noiseMip_(ps.getParameter<edm::ParameterSet>("noiseMip").getParameter<double>("value")),
      initialized_(false),
      points_(2*(maxlayer+1)),
      minpos_(2*(maxlayer+1),{ {0.0f,0.0f} }),
      maxpos_(2*(maxlayer+1),{ {0.0f,0.0f} }) {}

HGCalCLUEAlgo::~HGCalCLUEAlgo ( )

inlineoverride

Definition at line 55 of file HGCalCLUEAlgo.h.

References getClusters(), hfClusterShapes_cfi::hits, makeClusters(), and populate().

55 {}

Member Function Documentation

double HGCalCLUEAlgo::calculateDistanceToHigher ( std::vector< KDNode > & nd ) const

private

Definition at line 240 of file HGCalCLUEAlgo.cc.

References data, mps_fire::i, hgcal_clustering::sorted_indices(), mathSSE::sqrt(), and tmp.

Referenced by distance().

                                                                            {
   // sort vector of Hexels by decreasing local density
   std::vector<size_t> &&rs = sorted_indices(nd);
 
   double maxdensity = 0.0;
   int nearestHigher = -1;
 
   if (!rs.empty())
     maxdensity = nd[rs[0]].data.rho;
   else
     return maxdensity;  // there are no hits
   double dist2 = 0.;
   // start by setting delta for the highest density hit to
   // the most distant hit - this is a convention
 
   for (const auto &j : nd) {
     double tmp = distance2(nd[rs[0]].data, j.data);
     if (tmp > dist2) dist2 = tmp;
   }
   nd[rs[0]].data.delta = std::sqrt(dist2);
   nd[rs[0]].data.nearestHigher = nearestHigher;
 
   // now we save the largest distance as a starting point
   const double max_dist2 = dist2;
   const unsigned int nd_size = nd.size();
 
   for (unsigned int oi = 1; oi < nd_size; ++oi) {  // start from second-highest density
     dist2 = max_dist2;
     unsigned int i = rs[oi];
     // we only need to check up to oi since hits
     // are ordered by decreasing density
     // and all points coming BEFORE oi are guaranteed to have higher rho
     // and the ones AFTER to have lower rho
     for (unsigned int oj = 0; oj < oi; ++oj) {
       unsigned int j = rs[oj];
       double tmp = distance2(nd[i].data, nd[j].data);
       if (tmp <= dist2) {  // this "<=" instead of "<" addresses the (rare) case
                            // when there are only two hits
         dist2 = tmp;
         nearestHigher = j;
       }
     }
     nd[i].data.delta = std::sqrt(dist2);
     nd[i].data.nearestHigher = nearestHigher;  // this uses the original unsorted hitlist
   }
   return maxdensity;
 }

double HGCalCLUEAlgo::calculateLocalDensity	(	std::vector< KDNode > &	nd,
		KDTree &	lp,
		const unsigned int	layer
	)		const

private

Definition at line 210 of file HGCalCLUEAlgo.cc.

References data, SoftLeptonByDistance_cfi::distance, runEdmFileComparison::found, mps_fire::i, SiStripPI::max, and KDTreeLinkerAlgo< DATA >::search().

Referenced by distance().

                                                                             {
   double maxdensity = 0.;
   float delta_c;  // maximum search distance (critical distance) for local
                   // density calculation
   if (layer <= lastLayerEE)
     delta_c = vecDeltas_[0];
   else if (layer <= lastLayerFH)
     delta_c = vecDeltas_[1];
   else
     delta_c = vecDeltas_[2];
 
   // for each node calculate local density rho and store it
   for (unsigned int i = 0; i < nd.size(); ++i) {
     // speec up search by looking within +/- delta_c window only
     KDTreeBox search_box(nd[i].dims[0] - delta_c, nd[i].dims[0] + delta_c, nd[i].dims[1] - delta_c,
                          nd[i].dims[1] + delta_c);
     std::vector<KDNode> found;
     lp.search(search_box, found);
     const unsigned int found_size = found.size();
     for (unsigned int j = 0; j < found_size; j++) {
       if (distance(nd[i].data, found[j].data) < delta_c) {
         nd[i].data.rho += (nd[i].data.detid == found[j].data.detid ? 1. : 0.5) * found[j].data.weight;
         maxdensity = std::max(maxdensity, nd[i].data.rho);
       }
     }  // end loop found
   }    // end loop nodes
   return maxdensity;
 }

math::XYZPoint HGCalCLUEAlgo::calculatePosition ( const std::vector< KDNode > & v ) const

private

Definition at line 145 of file HGCalCLUEAlgo.cc.

References data, mps_fire::i, training_settings::idx, cmsBatch::log, and SiStripPI::max.

Referenced by distance().

                                                                               {
   float total_weight = 0.f;
   float x = 0.f;
   float y = 0.f;
 
   unsigned int v_size = v.size();
   unsigned int maxEnergyIndex = 0;
   float maxEnergyValue = 0;
 
   // loop over hits in cluster candidate
   // determining the maximum energy hit
   for (unsigned int i = 0; i < v_size; i++) {
     if (v[i].data.weight > maxEnergyValue) {
       maxEnergyValue = v[i].data.weight;
       maxEnergyIndex = i;
     }
   }
 
   // Si cell or Scintillator. Used to set approach and parameters
   int thick = rhtools_.getSiThickIndex(v[maxEnergyIndex].data.detid);
 
   // for hits within positionDeltaRho_c_ from maximum energy hit
   // build up weight for energy-weighted position
   // and save corresponding hits indices
   std::vector<unsigned int> innerIndices;
   for (unsigned int i = 0; i < v_size; i++) {
     if (thick == -1 || distance2(v[i].data, v[maxEnergyIndex].data) < positionDeltaRho_c_[thick]) {
       innerIndices.push_back(i);
 
       float rhEnergy = v[i].data.weight;
       total_weight += rhEnergy;
       // just fill x, y for scintillator
       // for Si it is overwritten later anyway
       if (thick == -1) {
         x += v[i].data.x * rhEnergy;
         y += v[i].data.y * rhEnergy;
       }
     }
   }
   // just loop on reduced vector of interesting indices
   // to compute log weighting
   if (thick != -1 && total_weight != 0.) {  // Silicon case
     float total_weight_log = 0.f;
     float x_log = 0.f;
     float y_log = 0.f;
     for (auto idx : innerIndices) {
       float rhEnergy = v[idx].data.weight;
       if (rhEnergy == 0.) continue;
       float Wi = std::max(thresholdW0_[thick] + std::log(rhEnergy / total_weight), 0.);
       x_log += v[idx].data.x * Wi;
       y_log += v[idx].data.y * Wi;
       total_weight_log += Wi;
     }
     total_weight = total_weight_log;
     x = x_log;
     y = y_log;
   }
 
   if (total_weight != 0.) {
     auto inv_tot_weight = 1. / total_weight;
     return math::XYZPoint(x * inv_tot_weight, y * inv_tot_weight, v[maxEnergyIndex].data.z);
   }
   return math::XYZPoint(0, 0, 0);
 }

void HGCalCLUEAlgo::computeThreshold ( )

Definition at line 369 of file HGCalCLUEAlgo.cc.

Referenced by reset().

                                      {
   // To support the TDR geometry and also the post-TDR one (v9 onwards), we
   // need to change the logic of the vectors containing signal to noise and
   // thresholds. The first 3 indices will keep on addressing the different
   // thicknesses of the Silicon detectors, while the last one, number 3 (the
   // fourth) will address the Scintillators. This change will support both
   // geometries at the same time.
 
   if (initialized_) return;  // only need to calculate thresholds once
 
   initialized_ = true;
 
   std::vector<double> dummy;
   const unsigned maxNumberOfThickIndices = 3;
   dummy.resize(maxNumberOfThickIndices + 1, 0);  // +1 to accomodate for the Scintillators
   thresholds_.resize(maxlayer, dummy);
   v_sigmaNoise_.resize(maxlayer, dummy);
 
   for (unsigned ilayer = 1; ilayer <= maxlayer; ++ilayer) {
     for (unsigned ithick = 0; ithick < maxNumberOfThickIndices; ++ithick) {
       float sigmaNoise = 0.001f * fcPerEle_ * nonAgedNoises_[ithick] * dEdXweights_[ilayer] /
                          (fcPerMip_[ithick] * thicknessCorrection_[ithick]);
       thresholds_[ilayer - 1][ithick] = sigmaNoise * ecut_;
       v_sigmaNoise_[ilayer - 1][ithick] = sigmaNoise;
     }
     float scintillators_sigmaNoise = 0.001f * noiseMip_ * dEdXweights_[ilayer];
     thresholds_[ilayer - 1][maxNumberOfThickIndices] = ecut_ * scintillators_sigmaNoise;
     v_sigmaNoise_[ilayer - 1][maxNumberOfThickIndices] = scintillators_sigmaNoise;
   }
 }

double HGCalCLUEAlgo::distance	(	const Hexel &	pt1,
		const Hexel &	pt2
	)		const

inlineprivate

Definition at line 231 of file HGCalCLUEAlgo.h.

References calculateDistanceToHigher(), calculateLocalDensity(), calculatePosition(), distance2(), findAndAssignClusters(), setDensity(), and mathSSE::sqrt().

                                                  {  // 2-d distance on the layer (x-y)
     return std::sqrt(distance2(pt1, pt2));
   }

double HGCalCLUEAlgo::distance2	(	const Hexel &	pt1,
		const Hexel &	pt2
	)		const

inlineprivate

Definition at line 226 of file HGCalCLUEAlgo.h.

References PVValHelper::dx, PVValHelper::dy, HGCalCLUEAlgo::Hexel::x, and HGCalCLUEAlgo::Hexel::y.

Referenced by distance().

                                                                     {  // distance squared
     const double dx = pt1.x - pt2.x;
     const double dy = pt1.y - pt2.y;
     return (dx * dx + dy * dy);
   }  // distance squaredq

static void HGCalCLUEAlgo::fillPSetDescription ( edm::ParameterSetDescription & iDesc )

inlinestatic

Definition at line 87 of file HGCalCLUEAlgo.h.

References edm::ParameterSetDescription::add(), and edm::ParameterSetDescription::addUntracked().

                                                                      {
     iDesc.add<std::vector<double>>("thresholdW0", {
         2.9,
         2.9,
         2.9
         });
     iDesc.add<std::vector<double>>("positionDeltaRho_c", {
         1.3,
         1.3,
         1.3
         });
     iDesc.add<std::vector<double>>("deltac", {
         1.3,
         1.3,
         5.0,
         });
     iDesc.add<bool>("dependSensor", true);
     iDesc.add<double>("ecut", 3.0);
     iDesc.add<double>("kappa", 9.0);
     iDesc.addUntracked<unsigned int>("verbosity", 3);
     iDesc.add<std::vector<double>>("dEdXweights",{});
     iDesc.add<std::vector<double>>("thicknessCorrection",{});
     iDesc.add<std::vector<double>>("fcPerMip",{});
     iDesc.add<double>("fcPerEle",0.0);
     edm::ParameterSetDescription descNestedNoises;
     descNestedNoises.add<std::vector<double> >("values", {});
     iDesc.add<edm::ParameterSetDescription>("noises", descNestedNoises);
     edm::ParameterSetDescription descNestedNoiseMIP;
     descNestedNoiseMIP.add<double>("value", 0 );
     iDesc.add<edm::ParameterSetDescription>("noiseMip", descNestedNoiseMIP);
   }

int HGCalCLUEAlgo::findAndAssignClusters	(	std::vector< KDNode > &	,
		KDTree &	,
		double	,
		KDTreeBox &	,
		const unsigned int	,
		std::vector< std::vector< KDNode > > &
	)		const

private

Definition at line 287 of file HGCalCLUEAlgo.cc.

References data, mps_fire::i, LogDebug, and hgcal_clustering::sorted_indices().

Referenced by distance().

                                                                                               {
   // this is called once per layer and endcap...
   // so when filling the cluster temporary vector of Hexels we resize each time
   // by the number  of clusters found. This is always equal to the number of
   // cluster centers...
 
   unsigned int nClustersOnLayer = 0;
   float delta_c;  // critical distance
   if (layer <= lastLayerEE)
     delta_c = vecDeltas_[0];
   else if (layer <= lastLayerFH)
     delta_c = vecDeltas_[1];
   else
     delta_c = vecDeltas_[2];
 
   std::vector<size_t> rs = sorted_indices(nd);  // indices sorted by decreasing rho
   std::vector<size_t> ds = sort_by_delta(nd);   // sort in decreasing distance to higher
 
   const unsigned int nd_size = nd.size();
   for (unsigned int i = 0; i < nd_size; ++i) {
     if (nd[ds[i]].data.delta < delta_c) break;  // no more cluster centers to be looked at
     if (dependSensor_) {
       float rho_c = kappa_ * nd[ds[i]].data.sigmaNoise;
       if (nd[ds[i]].data.rho < rho_c) continue;  // set equal to kappa times noise threshold
 
     } else if (nd[ds[i]].data.rho * kappa_ < maxdensity)
       continue;
 
     nd[ds[i]].data.clusterIndex = nClustersOnLayer;
     if (verbosity_ < pINFO) {
       LogDebug("HGCalCLUEAlgo")
         << "Adding new cluster with index " << nClustersOnLayer
         << "Cluster center is hit " << ds[i] << std::endl;
     }
     nClustersOnLayer++;
   }
 
   // at this point nClustersOnLayer is equal to the number of cluster centers -
   // if it is zero we are  done
   if (nClustersOnLayer == 0) return nClustersOnLayer;
 
   // assign remaining points to clusters, using the nearestHigher set from
   // previous step (always set except
   // for top density hit that is skipped...)
   for (unsigned int oi = 1; oi < nd_size; ++oi) {
     unsigned int i = rs[oi];
     int ci = nd[i].data.clusterIndex;
     if (ci == -1 && nd[i].data.delta < 2. * delta_c) {
       nd[i].data.clusterIndex = nd[nd[i].data.nearestHigher].data.clusterIndex;
     }
   }
 
   // make room in the temporary cluster vector for the additional clusterIndex
   // clusters
   // from this layer
   if (verbosity_ < pINFO) {
     LogDebug("HGCalCLUEAlgo")
       << "resizing cluster vector by " << nClustersOnLayer << std::endl;
   }
   clustersOnLayer.resize(nClustersOnLayer);
 
   // Fill the cluster vector
   for (unsigned int i = 0; i < nd_size; ++i) {
     int ci = nd[i].data.clusterIndex;
     if (ci != -1) {
       clustersOnLayer[ci].push_back(nd[i]);
       if (verbosity_ < pINFO) {
         LogDebug("HGCalCLUEAlgo")
           << "Pushing hit " << i << " into cluster with index " << ci << std::endl;
       }
     }
   }
 
   // prepare the offset for the next layer if there is one
   if (verbosity_ < pINFO) {
     LogDebug("HGCalCLUEAlgo") << "moving cluster offset by " << nClustersOnLayer << std::endl;
   }
   return nClustersOnLayer;
 }

std::vector< reco::BasicCluster > HGCalCLUEAlgo::getClusters ( bool )

overridevirtual

Implements HGCalClusteringAlgoBase.

Definition at line 109 of file HGCalCLUEAlgo.cc.

References AlignmentPI::calculatePosition(), haddnano::cl, data, reco::CaloID::DET_HGCAL_ENDCAP, LogDebug, hgcal_clustering::max_index(), and position.

Referenced by ~HGCalCLUEAlgo().

                                                            {
   reco::CaloID caloID = reco::CaloID::DET_HGCAL_ENDCAP;
   std::vector<std::pair<DetId, float>> thisCluster;
   for (const auto &clsOnLayer : layerClustersPerLayer_) {
     int index = 0;
     for (const auto &cl : clsOnLayer) {
       double energy = 0;
       Point position;
       // Will save the maximum density hit of the cluster
       size_t rsmax = max_index(cl);
       position = calculatePosition(cl);  // energy-weighted position
       for (const auto &it : cl) {
         energy += it.data.weight;
         thisCluster.emplace_back(it.data.detid, 1.f);
       }
       if (verbosity_ < pINFO) {
         LogDebug("HGCalCLUEAlgo")
           << "******** NEW CLUSTER (HGCIA) ********"
           << "Index          " << index
           << "No. of cells = " << cl.size()
           << "     Energy     = " << energy
           << "     Phi        = " << position.phi()
           << "     Eta        = " << position.eta()
           << "*****************************" << std::endl;
       }
       clusters_v_.emplace_back(energy, position, caloID, thisCluster, algoId_);
       if (!clusters_v_.empty()) {
         clusters_v_.back().setSeed(cl[rsmax].data.detid);
       }
       thisCluster.clear();
       index++;
     }
   }
   return clusters_v_;
 }

Density HGCalCLUEAlgo::getDensity ( )

overridevirtual

Implements HGCalClusteringAlgoBase.

Definition at line 408 of file HGCalCLUEAlgo.cc.

Referenced by reset().

                                   {
   return density_;
 }

void HGCalCLUEAlgo::makeClusters ( )

overridevirtual

Implements HGCalClusteringAlgoBase.

Definition at line 82 of file HGCalCLUEAlgo.cc.

References KDTreeLinkerAlgo< DATA >::build(), mps_fire::i, and AlCaHLTBitMon_ParallelJobs::p.

Referenced by ~HGCalCLUEAlgo().

                                  {
   layerClustersPerLayer_.resize(2 * maxlayer + 2);
   // assign all hits in each layer to a cluster core
   tbb::this_task_arena::isolate([&] {
     tbb::parallel_for(size_t(0), size_t(2 * maxlayer + 2), [&](size_t i) {
       KDTreeBox bounds(minpos_[i][0], maxpos_[i][0], minpos_[i][1], maxpos_[i][1]);
       KDTree hit_kdtree;
       hit_kdtree.build(points_[i], bounds);
 
       unsigned int actualLayer = i > maxlayer
                                      ? (i - (maxlayer + 1))
                                      : i;  // maps back from index used for KD trees to actual layer
 
       double maxdensity = calculateLocalDensity(points_[i], hit_kdtree,
                                                 actualLayer);  // also stores rho (energy
                                                                // density) for each point (node)
       // calculate distance to nearest point with higher density storing
       // distance (delta) and point's index
       calculateDistanceToHigher(points_[i]);
       findAndAssignClusters(points_[i], hit_kdtree, maxdensity, bounds, actualLayer,
                             layerClustersPerLayer_[i]);
     });
   });
   //Now that we have the density per point we can store it
   for(auto const& p: points_) { setDensity(p); }
 }

void HGCalCLUEAlgo::populate ( const HGCRecHitCollection & hits )

overridevirtual

Implements HGCalClusteringAlgoBase.

Definition at line 17 of file HGCalCLUEAlgo.cc.

References CaloRecHit::detid(), CaloRecHit::energy(), mps_fire::i, createfilelist::int, SiStripPI::max, min(), position, and edm::SortedCollection< T, SORT >::size().

Referenced by ~HGCalCLUEAlgo().

                                                             {
   // loop over all hits and create the Hexel structure, skip energies below ecut
 
   if (dependSensor_) {
     // for each layer and wafer calculate the thresholds (sigmaNoise and energy)
     // once
     computeThreshold();
   }
 
   std::vector<bool> firstHit(2 * (maxlayer + 1), true);
   for (unsigned int i = 0; i < hits.size(); ++i) {
     const HGCRecHit &hgrh = hits[i];
     DetId detid = hgrh.detid();
     unsigned int layer = rhtools_.getLayerWithOffset(detid);
     float thickness = 0.f;
     // set sigmaNoise default value 1 to use kappa value directly in case of
     // sensor-independent thresholds
     float sigmaNoise = 1.f;
     if (dependSensor_) {
       thickness = rhtools_.getSiThickness(detid);
       int thickness_index = rhtools_.getSiThickIndex(detid);
       if (thickness_index == -1) thickness_index = 3;
       double storedThreshold = thresholds_[layer - 1][thickness_index];
       sigmaNoise = v_sigmaNoise_[layer - 1][thickness_index];
 
       if (hgrh.energy() < storedThreshold)
         continue;  // this sets the ZS threshold at ecut times the sigma noise
                    // for the sensor
     }
     if (!dependSensor_ && hgrh.energy() < ecut_) continue;
 
     // map layers from positive endcap (z) to layer + maxlayer+1 to prevent
     // mixing up hits from different sides
     layer += int(rhtools_.zside(detid) > 0) * (maxlayer + 1);
 
     // determine whether this is a half-hexagon
     bool isHalf = rhtools_.isHalfCell(detid);
     const GlobalPoint position(rhtools_.getPosition(detid));
 
     // here's were the KDNode is passed its dims arguments - note that these are
     // *copied* from the Hexel
     points_[layer].emplace_back(Hexel(hgrh, detid, isHalf, sigmaNoise, thickness, &rhtools_),
                                 position.x(), position.y());
 
     // for each layer, store the minimum and maximum x and y coordinates for the
     // KDTreeBox boundaries
     if (firstHit[layer]) {
       minpos_[layer][0] = position.x();
       minpos_[layer][1] = position.y();
       maxpos_[layer][0] = position.x();
       maxpos_[layer][1] = position.y();
       firstHit[layer] = false;
     } else {
       minpos_[layer][0] = std::min((float)position.x(), minpos_[layer][0]);
       minpos_[layer][1] = std::min((float)position.y(), minpos_[layer][1]);
       maxpos_[layer][0] = std::max((float)position.x(), maxpos_[layer][0]);
       maxpos_[layer][1] = std::max((float)position.y(), maxpos_[layer][1]);
     }
   }  // end loop hits
 }

void HGCalCLUEAlgo::reset ( void )

inlineoverridevirtual

Implements HGCalClusteringAlgoBase.

Definition at line 68 of file HGCalCLUEAlgo.h.

References HGCalClusteringAlgoBase::clusters_v_, computeThreshold(), getDensity(), mps_fire::i, layerClustersPerLayer_, maxpos_, minpos_, points_, and edm::swap().

                         {
     clusters_v_.clear();
     layerClustersPerLayer_.clear();
     for (auto &it : points_) {
       it.clear();
       std::vector<KDNode>().swap(it);
     }
     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.;
     }
   }

void HGCalCLUEAlgo::setDensity ( const std::vector< KDNode > & nd )

private

Definition at line 400 of file HGCalCLUEAlgo.cc.

References mps_fire::i.

Referenced by distance().

                                                          {
 
   // for each node store the computer local density
   for (auto &i : nd){
     density_[ i.data.detid ] =  i.data.rho ;
   }
 }

std::vector<size_t> HGCalCLUEAlgo::sort_by_delta ( const std::vector< KDNode > & v ) const

inlineprivate

Definition at line 210 of file HGCalCLUEAlgo.h.

References begin, end, training_settings::idx, jetUpdater_cfi::sort, and findQualityFiles::v.

                                                                     {
     std::vector<size_t> idx(v.size());
     std::iota(std::begin(idx), std::end(idx), 0);
     sort(idx.begin(), idx.end(),
          [&v](size_t i1, size_t i2) { return v[i1].data.delta > v[i2].data.delta; });
     return idx;
   }

Member Data Documentation

std::vector<double> HGCalCLUEAlgo::dEdXweights_

private

Definition at line 140 of file HGCalCLUEAlgo.h.

Density HGCalCLUEAlgo::density_

private

Definition at line 135 of file HGCalCLUEAlgo.h.

bool HGCalCLUEAlgo::dependSensor_

private

Definition at line 139 of file HGCalCLUEAlgo.h.

double HGCalCLUEAlgo::ecut_

private

Definition at line 132 of file HGCalCLUEAlgo.h.

double HGCalCLUEAlgo::fcPerEle_

private

Definition at line 143 of file HGCalCLUEAlgo.h.

std::vector<double> HGCalCLUEAlgo::fcPerMip_

private

Definition at line 142 of file HGCalCLUEAlgo.h.

bool HGCalCLUEAlgo::initialized_

private

Definition at line 150 of file HGCalCLUEAlgo.h.

double HGCalCLUEAlgo::kappa_

private

Definition at line 129 of file HGCalCLUEAlgo.h.

std::vector<std::vector<std::vector<KDNode> > > HGCalCLUEAlgo::layerClustersPerLayer_

private

Definition at line 208 of file HGCalCLUEAlgo.h.

Referenced by reset().

std::vector<std::array<float, 2> > HGCalCLUEAlgo::maxpos_

private

Definition at line 223 of file HGCalCLUEAlgo.h.

Referenced by HGCalCLUEAlgo(), and reset().

std::vector<std::array<float, 2> > HGCalCLUEAlgo::minpos_

private

Definition at line 222 of file HGCalCLUEAlgo.h.

Referenced by reset().

double HGCalCLUEAlgo::noiseMip_

private

Definition at line 145 of file HGCalCLUEAlgo.h.

std::vector<double> HGCalCLUEAlgo::nonAgedNoises_

private

Definition at line 144 of file HGCalCLUEAlgo.h.

std::vector<std::vector<KDNode> > HGCalCLUEAlgo::points_

private

Definition at line 218 of file HGCalCLUEAlgo.h.

Referenced by reset().

std::vector<double> HGCalCLUEAlgo::positionDeltaRho_c_

private

Definition at line 125 of file HGCalCLUEAlgo.h.

std::vector<double> HGCalCLUEAlgo::thicknessCorrection_

private

Definition at line 141 of file HGCalCLUEAlgo.h.

std::vector<std::vector<double> > HGCalCLUEAlgo::thresholds_

private

Definition at line 146 of file HGCalCLUEAlgo.h.

std::vector<double> HGCalCLUEAlgo::thresholdW0_

private

Definition at line 124 of file HGCalCLUEAlgo.h.

std::vector<std::vector<double> > HGCalCLUEAlgo::v_sigmaNoise_

private

Definition at line 147 of file HGCalCLUEAlgo.h.

std::vector<double> HGCalCLUEAlgo::vecDeltas_

private

Definition at line 128 of file HGCalCLUEAlgo.h.

Classes

Public Types

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation