#include <HGCalCLUEAlgo.h>

Inheritance diagram for HGCalCLUEAlgoT< TILE, STRATEGY >:

Classes
struct	CellsOnLayer

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

void	getEventSetupPerAlgorithm (const edm::EventSetup &es) override

	HGCalCLUEAlgoT (const edm::ParameterSet &ps)

void	makeClusters () override

void	populate (const HGCRecHitCollection &hits) override

void	reset () override

	~HGCalCLUEAlgoT () override

Public Member Functions inherited from HGCalClusteringAlgoBase
virtual hgcal_clustering::Density	getDensity ()

void	getEventSetup (const edm::EventSetup &es, hgcal::RecHitTools rhtools)

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

void	setAlgoId (reco::CaloCluster::AlgoId algo, bool isNose=false)

void	setVerbosity (VerbosityLevel the_verbosity)

virtual	~HGCalClusteringAlgoBase ()

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

Private Member Functions
void	calculateDistanceToHigher (const TILE &lt, const unsigned int layerId, float delta)

void	calculateLocalDensity (const TILE &lt, const unsigned int layerId, float delta)

void	calculateLocalDensity (const TILE &lt, const unsigned int layerId, float delta, HGCalSiliconStrategy strategy)

void	calculateLocalDensity (const TILE &lt, const unsigned int layerId, float delta, HGCalScintillatorStrategy strategy)

float	distance (const TILE &lt, int cell1, int cell2, int layerId) const

float	distance2 (const TILE &lt, int cell1, int cell2, int layerId) const

int	findAndAssignClusters (const unsigned int layerId, float delta)

void	prepareDataStructures (const unsigned int layerId)

Private Attributes
std::vector< CellsOnLayer >	cells_

std::vector< double >	dEdXweights_

int	deltasi_index_regemfac_

bool	dependSensor_

double	ecut_

double	fcPerEle_

std::vector< double >	fcPerMip_

bool	initialized_

double	kappa_

unsigned	maxNumberOfThickIndices_

double	noiseMip_

std::vector< double >	nonAgedNoises_

std::vector< int >	numberOfClustersPerLayer_

float	outlierDeltaFactor_ = 2.f

double	positionDeltaRho2_

double	sciThicknessCorrection_

std::vector< double >	thicknessCorrection_

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

std::vector< double >	thresholdW0_

bool	use2x2_

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

std::vector< double >	vecDeltas_

Additional Inherited Members
Public Attributes inherited from HGCalClusteringAlgoBase
unsigned int	firstLayerBH_

bool	isNose_

unsigned int	lastLayerEE_

unsigned int	lastLayerFH_

unsigned int	maxlayer_

int	scintMaxIphi_

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

edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	caloGeomToken_

std::vector< reco::BasicCluster >	clusters_v_

hgcal::RecHitTools	rhtools_

VerbosityLevel	verbosity_

Detailed Description

template<typename TILE, typename STRATEGY>
class HGCalCLUEAlgoT< TILE, STRATEGY >

Definition at line 35 of file HGCalCLUEAlgo.h.

Member Typedef Documentation

◆ Point

template<typename TILE , typename STRATEGY >

typedef math::XYZPoint HGCalCLUEAlgoT< TILE, STRATEGY >::Point

point in the space

Definition at line 128 of file HGCalCLUEAlgo.h.

Constructor & Destructor Documentation

◆ HGCalCLUEAlgoT()

template<typename TILE , typename STRATEGY >

HGCalCLUEAlgoT< TILE, STRATEGY >::HGCalCLUEAlgoT ( const edm::ParameterSet & ps )

inline

Definition at line 37 of file HGCalCLUEAlgo.h.

References edm::ParameterSet::getParameter(), and AlCaHLTBitMon_QueryRunRegistry::string.

       : HGCalClusteringAlgoBase(
             (HGCalClusteringAlgoBase::VerbosityLevel)ps.getUntrackedParameter<unsigned int>("verbosity", 3),
             reco::CaloCluster::undefined),
         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")),
         sciThicknessCorrection_(ps.getParameter<double>("sciThicknessCorrection")),
         deltasi_index_regemfac_(ps.getParameter<int>("deltasi_index_regemfac")),
         maxNumberOfThickIndices_(ps.getParameter<unsigned>("maxNumberOfThickIndices")),
         fcPerMip_(ps.getParameter<std::vector<double>>("fcPerMip")),
         fcPerEle_(ps.getParameter<double>("fcPerEle")),
         nonAgedNoises_(ps.getParameter<std::vector<double>>("noises")),
         noiseMip_(ps.getParameter<edm::ParameterSet>("noiseMip").getParameter<double>("noise_MIP")),
         thresholdW0_(ps.getParameter<std::vector<double>>("thresholdW0")),
         positionDeltaRho2_(ps.getParameter<double>("positionDeltaRho2")),
         use2x2_(ps.getParameter<bool>("use2x2")),
         initialized_(false) {
 #if DEBUG_CLUSTERS_ALPAKA
     moduleType_ = ps.getParameter<std::string>("type");
 #endif
   }

◆ ~HGCalCLUEAlgoT()

template<typename TILE , typename STRATEGY >

HGCalCLUEAlgoT< TILE, STRATEGY >::~HGCalCLUEAlgoT ( )

inlineoverride

Definition at line 63 of file HGCalCLUEAlgo.h.

63 {}

Member Function Documentation

◆ calculateDistanceToHigher()

template<typename TILE , typename STRATEGY >

void HGCalCLUEAlgoT< T, STRATEGY >::calculateDistanceToHigher	(	const TILE &	lt,
		const unsigned int	layerId,
		float	delta
	)

private

Definition at line 347 of file HGCalCLUEAlgo.cc.

References ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), dumpMFGeometry_cfg::delta, mps_fire::i, dqmiolumiharvest::j, LogDebug, WZElectronSkims53X_cff::max, allConversions_cfi::maxDelta, isotrackApplyRegressor::range, and mathSSE::sqrt().

                                                                                                                 {
   auto& cellsOnLayer = cells_[layerId];
   unsigned int numberOfCells = cellsOnLayer.detid.size();
 
   for (unsigned int i = 0; i < numberOfCells; i++) {
     // initialize delta and nearest higher for i
     float maxDelta = std::numeric_limits<float>::max();
     float i_delta = maxDelta;
     int i_nearestHigher = -1;
     float rho_max = 0.f;
     auto range = outlierDeltaFactor_ * delta;
     std::array<int, 4> search_box = lt.searchBox(cellsOnLayer.dim1[i] - range,
                                                  cellsOnLayer.dim1[i] + range,
                                                  cellsOnLayer.dim2[i] - range,
                                                  cellsOnLayer.dim2[i] + range);
     // loop over all bins in the search box
     for (int dim1Bin = search_box[0]; dim1Bin < search_box[1] + 1; ++dim1Bin) {
       for (int dim2Bin = search_box[2]; dim2Bin < search_box[3] + 1; ++dim2Bin) {
         // get the id of this bin
         size_t binId = lt.getGlobalBinByBin(dim1Bin, dim2Bin);
         if constexpr (std::is_same_v<STRATEGY, HGCalScintillatorStrategy>)
           binId = lt.getGlobalBinByBin(dim1Bin, (dim2Bin % T::type::nRows));
         // get the size of this bin
         size_t binSize = lt[binId].size();
 
         // loop over all hits in this bin
         for (unsigned int j = 0; j < binSize; j++) {
           unsigned int otherId = lt[binId][j];
           float dist = distance2(lt, i, otherId, layerId);
           bool foundHigher =
               (cellsOnLayer.rho[otherId] > cellsOnLayer.rho[i]) ||
               (cellsOnLayer.rho[otherId] == cellsOnLayer.rho[i] && cellsOnLayer.detid[otherId] > cellsOnLayer.detid[i]);
           if (!foundHigher) {
             continue;
           }
           if ((dist < i_delta) || ((dist == i_delta) && (cellsOnLayer.rho[otherId] > rho_max)) ||
               ((dist == i_delta) && (cellsOnLayer.rho[otherId] == rho_max) &&
                (cellsOnLayer.detid[otherId] > cellsOnLayer.detid[i]))) {
             rho_max = cellsOnLayer.rho[otherId];
             i_delta = dist;
             i_nearestHigher = otherId;
           }
         }
       }
     }
     bool foundNearestHigherInSearchBox = (i_delta != maxDelta);
     if (foundNearestHigherInSearchBox) {
       cellsOnLayer.delta[i] = std::sqrt(i_delta);
       cellsOnLayer.nearestHigher[i] = i_nearestHigher;
     } else {
       // otherwise delta is guaranteed to be larger outlierDeltaFactor_*delta_c
       // we can safely maximize delta to be maxDelta
       cellsOnLayer.delta[i] = maxDelta;
       cellsOnLayer.nearestHigher[i] = -1;
     }
 
     LogDebug("HGCalCLUEAlgo") << "Debugging calculateDistanceToHigher: \n"
                               << "  cell: " << i << " eta: " << cellsOnLayer.dim1[i] << " phi: " << cellsOnLayer.dim2[i]
                               << " energy: " << cellsOnLayer.weight[i] << " density: " << cellsOnLayer.rho[i]
                               << " nearest higher: " << cellsOnLayer.nearestHigher[i]
                               << " distance: " << cellsOnLayer.delta[i] << "\n";
   }
 }

◆ calculateLocalDensity() [1/3]

template<typename TILE , typename STRATEGY >

void HGCalCLUEAlgoT< TILE, STRATEGY >::calculateLocalDensity	(	const TILE &	lt,
		const unsigned int	layerId,
		float	delta
	)

private

◆ calculateLocalDensity() [2/3]

template<typename TILE , typename STRATEGY >

void HGCalCLUEAlgoT< TILE, STRATEGY >::calculateLocalDensity	(	const TILE &	lt,
		const unsigned int	layerId,
		float	delta,
		HGCalSiliconStrategy	strategy
	)

private

◆ calculateLocalDensity() [3/3]

template<typename TILE , typename STRATEGY >

void HGCalCLUEAlgoT< TILE, STRATEGY >::calculateLocalDensity	(	const TILE &	lt,
		const unsigned int	layerId,
		float	delta,
		HGCalScintillatorStrategy	strategy
	)

private

◆ computeThreshold()

template<typename T , typename STRATEGY >

void HGCalCLUEAlgoT< T, STRATEGY >::computeThreshold ( )

Definition at line 457 of file HGCalCLUEAlgo.cc.

References LogDebug.

                                                    {
   // 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 in CE_E , the next 3 indices will address
   // the thicknesses of the Silicon detectors in CE_H, while the last one, number 6 (the
   // seventh) 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;
 
   dummy.resize(maxNumberOfThickIndices_ + !isNose_, 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;
       LogDebug("HGCalCLUEAlgo") << "ilayer: " << ilayer << " nonAgedNoises: " << nonAgedNoises_[ithick]
                                 << " fcPerEle: " << fcPerEle_ << " fcPerMip: " << fcPerMip_[ithick]
                                 << " noiseMip: " << fcPerEle_ * nonAgedNoises_[ithick] / fcPerMip_[ithick]
                                 << " sigmaNoise: " << sigmaNoise << "\n";
     }
 
     if (!isNose_) {
       float scintillators_sigmaNoise = 0.001f * noiseMip_ * dEdXweights_[ilayer] / sciThicknessCorrection_;
       thresholds_[ilayer - 1][maxNumberOfThickIndices_] = ecut_ * scintillators_sigmaNoise;
       v_sigmaNoise_[ilayer - 1][maxNumberOfThickIndices_] = scintillators_sigmaNoise;
       LogDebug("HGCalCLUEAlgo") << "ilayer: " << ilayer << " noiseMip: " << noiseMip_
                                 << " scintillators_sigmaNoise: " << scintillators_sigmaNoise << "\n";
     }
   }
 }

◆ distance()

template<typename TILE , typename STRATEGY >

float HGCalCLUEAlgoT< TILE, STRATEGY >::distance	(	const TILE &	lt,
		int	cell1,
		int	cell2,
		int	layerId
	)		const

inlineprivate

Definition at line 222 of file HGCalCLUEAlgo.h.

References hgcalTopologyTester_cfi::cell1, hgcalTopologyTester_cfi::cell2, HGCalCLUEAlgoT< TILE, STRATEGY >::cells_, and mathSSE::sqrt().

                                                                                  {  // 2-d distance on the layer (x-y)
     return std::sqrt(lt.distance2(cells_[layerId].dim1[cell1],
                                   cells_[layerId].dim2[cell1],
                                   cells_[layerId].dim1[cell2],
                                   cells_[layerId].dim2[cell2]));
   }

◆ distance2()

template<typename TILE , typename STRATEGY >

float HGCalCLUEAlgoT< TILE, STRATEGY >::distance2	(	const TILE &	lt,
		int	cell1,
		int	cell2,
		int	layerId
	)		const

inlineprivate

Definition at line 215 of file HGCalCLUEAlgo.h.

References hgcalTopologyTester_cfi::cell1, hgcalTopologyTester_cfi::cell2, and HGCalCLUEAlgoT< TILE, STRATEGY >::cells_.

                                                                                   {  // 2-d distance on the layer (x-y)
     return (lt.distance2(cells_[layerId].dim1[cell1],
                          cells_[layerId].dim2[cell1],
                          cells_[layerId].dim1[cell2],
                          cells_[layerId].dim2[cell2]));
   }

◆ fillPSetDescription()

template<typename TILE , typename STRATEGY >

static void HGCalCLUEAlgoT< TILE, STRATEGY >::fillPSetDescription ( edm::ParameterSetDescription & iDesc )

inlinestatic

Definition at line 92 of file HGCalCLUEAlgo.h.

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

                                                                      {
     iDesc.add<std::vector<double>>("thresholdW0", {2.9, 2.9, 2.9});
     iDesc.add<double>("positionDeltaRho2", 1.69);
     iDesc.add<std::vector<double>>("deltac",
                                    {
                                        1.3,
                                        1.3,
                                        1.3,
                                        0.0315,  // for scintillator
                                    });
     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<double>("sciThicknessCorrection", 0.9);
     iDesc.add<int>("deltasi_index_regemfac", 3);
     iDesc.add<unsigned>("maxNumberOfThickIndices", 6);
     iDesc.add<std::vector<double>>("fcPerMip", {});
     iDesc.add<double>("fcPerEle", 0.0);
     iDesc.add<std::vector<double>>("noises", {});
     edm::ParameterSetDescription descNestedNoiseMIP;
     descNestedNoiseMIP.add<bool>("scaleByDose", false);
     descNestedNoiseMIP.add<unsigned int>("scaleByDoseAlgo", 0);
     descNestedNoiseMIP.add<double>("scaleByDoseFactor", 1.);
     descNestedNoiseMIP.add<std::string>("doseMap", "");
     descNestedNoiseMIP.add<std::string>("sipmMap", "");
     descNestedNoiseMIP.add<double>("referenceIdark", -1);
     descNestedNoiseMIP.add<double>("referenceXtalk", -1);
     descNestedNoiseMIP.add<double>("noise_MIP", 1. / 100.);
     iDesc.add<edm::ParameterSetDescription>("noiseMip", descNestedNoiseMIP);
     iDesc.add<bool>("use2x2", true);  // use 2x2 or 3x3 scenario for scint density calculation
   }

◆ findAndAssignClusters()

template<typename T , typename STRATEGY >

int HGCalCLUEAlgoT< T, STRATEGY >::findAndAssignClusters	(	const unsigned int	layerId,
		float	delta
	)

private

Definition at line 412 of file HGCalCLUEAlgo.cc.

References dumpMFGeometry_cfg::delta, mps_fire::i, and dqmiolumiharvest::j.

                                                                                               {
   // 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;
   auto& cellsOnLayer = cells_[layerId];
   unsigned int numberOfCells = cellsOnLayer.detid.size();
   std::vector<int> localStack;
   // find cluster seeds and outlier
   for (unsigned int i = 0; i < numberOfCells; i++) {
     float rho_c = kappa_ * cellsOnLayer.sigmaNoise[i];
     // initialize clusterIndex
     cellsOnLayer.clusterIndex[i] = -1;
     bool isSeed = (cellsOnLayer.delta[i] > delta) && (cellsOnLayer.rho[i] >= rho_c);
     bool isOutlier = (cellsOnLayer.delta[i] > outlierDeltaFactor_ * delta) && (cellsOnLayer.rho[i] < rho_c);
     if (isSeed) {
       cellsOnLayer.clusterIndex[i] = nClustersOnLayer;
       cellsOnLayer.isSeed[i] = true;
       nClustersOnLayer++;
       localStack.push_back(i);
 
     } else if (!isOutlier) {
       cellsOnLayer.followers[cellsOnLayer.nearestHigher[i]].push_back(i);
     }
   }
 
   // need to pass clusterIndex to their followers
   while (!localStack.empty()) {
     int endStack = localStack.back();
     auto& thisSeed = cellsOnLayer.followers[endStack];
     localStack.pop_back();
 
     // loop over followers
     for (int j : thisSeed) {
       // pass id to a follower
       cellsOnLayer.clusterIndex[j] = cellsOnLayer.clusterIndex[endStack];
       // push this follower to localStack
       localStack.push_back(j);
     }
   }
   return nClustersOnLayer;
 }

◆ getClusters()

template<typename T , typename STRATEGY >

std::vector< reco::BasicCluster > HGCalCLUEAlgoT< T, STRATEGY >::getClusters ( bool )

overridevirtual

Implements HGCalClusteringAlgoBase.

Definition at line 137 of file HGCalCLUEAlgo.cc.

References haddnano::cl, ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), d1, reco::CaloID::DET_HGCAL_ENDCAP, HBHEDarkening_cff::energy, mps_fire::i, CrabHelper::log, WZElectronSkims53X_cff::max, SiStripPI::min, upgradeWorkflowComponents::offsets, position, and x.

                                                                          {
   std::vector<int> offsets(numberOfClustersPerLayer_.size(), 0);
 
   int maxClustersOnLayer = numberOfClustersPerLayer_[0];
 
   for (unsigned layerId = 1; layerId < offsets.size(); ++layerId) {
     offsets[layerId] = offsets[layerId - 1] + numberOfClustersPerLayer_[layerId - 1];
 
     maxClustersOnLayer = std::max(maxClustersOnLayer, numberOfClustersPerLayer_[layerId]);
   }
 
   auto totalNumberOfClusters = offsets.back() + numberOfClustersPerLayer_.back();
   clusters_v_.resize(totalNumberOfClusters);
   std::vector<std::vector<int>> cellsIdInCluster;
   cellsIdInCluster.reserve(maxClustersOnLayer);
 
   for (unsigned int layerId = 0; layerId < 2 * maxlayer_ + 2; ++layerId) {
     cellsIdInCluster.resize(numberOfClustersPerLayer_[layerId]);
     auto& cellsOnLayer = cells_[layerId];
     unsigned int numberOfCells = cellsOnLayer.detid.size();
     auto firstClusterIdx = offsets[layerId];
 
     for (unsigned int i = 0; i < numberOfCells; ++i) {
       auto clusterIndex = cellsOnLayer.clusterIndex[i];
       if (clusterIndex != -1)
         cellsIdInCluster[clusterIndex].push_back(i);
     }
 
     std::vector<std::pair<DetId, float>> thisCluster;
 
     for (auto& cl : cellsIdInCluster) {
       float maxEnergyValue = std::numeric_limits<float>::min();
       int maxEnergyCellIndex = -1;
       DetId maxEnergyDetId;
       float energy = 0.f;
       int seedDetId = -1;
       float x = 0.f;
       float y = 0.f;
       float z = cellsOnLayer.layerDim3;
       // TODO Felice: maybe use the seed for the position calculation
       for (auto cellIdx : cl) {
         energy += cellsOnLayer.weight[cellIdx];
         if (cellsOnLayer.weight[cellIdx] > maxEnergyValue) {
           maxEnergyValue = cellsOnLayer.weight[cellIdx];
           maxEnergyCellIndex = cellIdx;
           maxEnergyDetId = cellsOnLayer.detid[cellIdx];
         }
         thisCluster.emplace_back(cellsOnLayer.detid[cellIdx], 1.f);
         if (cellsOnLayer.isSeed[cellIdx]) {
           seedDetId = cellsOnLayer.detid[cellIdx];
         }
       }
 
       float total_weight_log = 0.f;
       float total_weight = energy;
 
       if constexpr (std::is_same_v<STRATEGY, HGCalSiliconStrategy>) {
         auto thick = rhtools_.getSiThickIndex(maxEnergyDetId);
         for (auto cellIdx : cl) {
           const float d1 = cellsOnLayer.dim1[cellIdx] - cellsOnLayer.dim1[maxEnergyCellIndex];
           const float d2 = cellsOnLayer.dim2[cellIdx] - cellsOnLayer.dim2[maxEnergyCellIndex];
           if ((d1 * d1 + d2 * d2) < positionDeltaRho2_) {
             float Wi = std::max(thresholdW0_[thick] + std::log(cellsOnLayer.weight[cellIdx] / energy), 0.);
             x += cellsOnLayer.dim1[cellIdx] * Wi;
             y += cellsOnLayer.dim2[cellIdx] * Wi;
             total_weight_log += Wi;
           }
         }
       } else {
         for (auto cellIdx : cl) {
           auto position = rhtools_.getPosition(cellsOnLayer.detid[cellIdx]);
           x += position.x() * cellsOnLayer.weight[cellIdx];
           y += position.y() * cellsOnLayer.weight[cellIdx];
         }
       }
 
       if constexpr (std::is_same_v<STRATEGY, HGCalSiliconStrategy>) {
         total_weight = total_weight_log;
       }
 
       if (total_weight != 0.) {
         float inv_tot_weight = 1.f / total_weight;
         x *= inv_tot_weight;
         y *= inv_tot_weight;
       } else {
         x = cellsOnLayer.dim1[maxEnergyCellIndex];
         y = cellsOnLayer.dim2[maxEnergyCellIndex];
       }
       math::XYZPoint position = math::XYZPoint(x, y, z);
 
       auto globalClusterIndex = cellsOnLayer.clusterIndex[cl[0]] + firstClusterIdx;
 
       clusters_v_[globalClusterIndex] =
           reco::BasicCluster(energy, position, reco::CaloID::DET_HGCAL_ENDCAP, thisCluster, algoId_);
       clusters_v_[globalClusterIndex].setSeed(seedDetId);
       thisCluster.clear();
     }
 
     cellsIdInCluster.clear();
   }
   return clusters_v_;
 }

◆ getEventSetupPerAlgorithm()

template<typename T , typename STRATEGY >

void HGCalCLUEAlgoT< T, STRATEGY >::getEventSetupPerAlgorithm ( const edm::EventSetup & es )

overridevirtual

Reimplemented from HGCalClusteringAlgoBase.

Definition at line 20 of file HGCalCLUEAlgo.cc.

                                                                                    {
   cells_.clear();
   numberOfClustersPerLayer_.clear();
   cells_.resize(2 * (maxlayer_ + 1));
   numberOfClustersPerLayer_.resize(2 * (maxlayer_ + 1), 0);
 }

◆ makeClusters()

template<typename T , typename STRATEGY >

void HGCalCLUEAlgoT< T, STRATEGY >::makeClusters ( )

overridevirtual

Implements HGCalClusteringAlgoBase.

Definition at line 98 of file HGCalCLUEAlgo.cc.

References ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), dumpMFGeometry_cfg::delta, hitfit::delta_r(), hgcalUtils::DumpLegacySoA::dumpInfos(), mps_fire::i, and LogDebug.

                                                {
   // 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) {
       prepareDataStructures(i);
       T lt;
       lt.clear();
       lt.fill(cells_[i].dim1, cells_[i].dim2);
 
       float delta;
       if constexpr (std::is_same_v<STRATEGY, HGCalSiliconStrategy>) {
         // maximum search distance (critical distance) for local density calculation
         float delta_c;
         if (i % maxlayer_ < lastLayerEE_)
           delta_c = vecDeltas_[0];
         else if (i % maxlayer_ < (firstLayerBH_ - 1))
           delta_c = vecDeltas_[1];
         else
           delta_c = vecDeltas_[2];
         delta = delta_c;
       } else {
         float delta_r = vecDeltas_[3];
         delta = delta_r;
       }
       LogDebug("HGCalCLUEAlgo") << "maxlayer: " << maxlayer_ << " lastLayerEE: " << lastLayerEE_
                                 << " firstLayerBH: " << firstLayerBH_ << "\n";
 
       calculateLocalDensity(lt, i, delta);
       calculateDistanceToHigher(lt, i, delta);
       numberOfClustersPerLayer_[i] = findAndAssignClusters(i, delta);
     });
   });
 #if DEBUG_CLUSTERS_ALPAKA
   hgcalUtils::DumpLegacySoA dumperLegacySoA;
   dumperLegacySoA.dumpInfos(cells_, moduleType_);
 #endif
 }

◆ populate()

template<typename T , typename STRATEGY >

void HGCalCLUEAlgoT< T, STRATEGY >::populate ( const HGCRecHitCollection & hits )

overridevirtual

Implements HGCalClusteringAlgoBase.

Definition at line 28 of file HGCalCLUEAlgo.cc.

References ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), ALCARECOPPSCalTrackBasedSel_cff::detid, CaloRecHit::detid(), CaloRecHit::energy(), DetId::HGCalHSi, HGCHEF, hfClusterShapes_cfi::hits, mps_fire::i, infinity, HLT_IsoTrack_cff::offset, and position.

                                                                           {
   // 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();
   }
 
   for (unsigned int i = 0; i < hits.size(); ++i) {
     const HGCRecHit& hgrh = hits[i];
     DetId detid = hgrh.detid();
     unsigned int layerOnSide = (rhtools_.getLayerWithOffset(detid) - 1);
 
     // set sigmaNoise default value 1 to use kappa value directly in case of
     // sensor-independent thresholds
     float sigmaNoise = 1.f;
     if (dependSensor_) {
       int thickness_index = rhtools_.getSiThickIndex(detid);
       if (thickness_index == -1)
         thickness_index = maxNumberOfThickIndices_;
 
       double storedThreshold = thresholds_[layerOnSide][thickness_index];
       if (detid.det() == DetId::HGCalHSi || detid.subdetId() == HGCHEF) {
         storedThreshold = thresholds_[layerOnSide][thickness_index + deltasi_index_regemfac_];
       }
       sigmaNoise = v_sigmaNoise_[layerOnSide][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;
     const GlobalPoint position(rhtools_.getPosition(detid));
     int offset = ((rhtools_.zside(detid) + 1) >> 1) * maxlayer_;
     int layer = layerOnSide + offset;
     // setting the layer position only once per layer
     if (cells_[layer].layerDim3 == std::numeric_limits<float>::infinity())
       cells_[layer].layerDim3 = position.z();
 
     cells_[layer].detid.emplace_back(detid);
     if constexpr (std::is_same_v<STRATEGY, HGCalScintillatorStrategy>) {
       cells_[layer].dim1.emplace_back(position.eta());
       cells_[layer].dim2.emplace_back(position.phi());
     }  // else, isSilicon == true and eta phi values will not be used
     else {
       cells_[layer].dim1.emplace_back(position.x());
       cells_[layer].dim2.emplace_back(position.y());
     }
     cells_[layer].weight.emplace_back(hgrh.energy());
     cells_[layer].sigmaNoise.emplace_back(sigmaNoise);
   }
 }

◆ prepareDataStructures()

template<typename T , typename STRATEGY >

void HGCalCLUEAlgoT< T, STRATEGY >::prepareDataStructures ( const unsigned int layerId )

private

Definition at line 83 of file HGCalCLUEAlgo.cc.

References f, and MainPageGenerator::l.

                                                                       {
   auto cellsSize = cells_[l].detid.size();
   cells_[l].rho.resize(cellsSize, 0.f);
   cells_[l].delta.resize(cellsSize, 9999999);
   cells_[l].nearestHigher.resize(cellsSize, -1);
   cells_[l].clusterIndex.resize(cellsSize, -1);
   cells_[l].followers.resize(cellsSize);
   cells_[l].isSeed.resize(cellsSize, false);
 }

◆ reset()

template<typename TILE , typename STRATEGY >

void HGCalCLUEAlgoT< TILE, STRATEGY >::reset ( void )

inlineoverridevirtual

Implements HGCalClusteringAlgoBase.

Definition at line 77 of file HGCalCLUEAlgo.h.

References hgcalTBTopologyTester_cfi::cells, HGCalCLUEAlgoT< TILE, STRATEGY >::cells_, haddnano::cl, HGCalClusteringAlgoBase::clusters_v_, and HGCalCLUEAlgoT< TILE, STRATEGY >::numberOfClustersPerLayer_.

                         {
     clusters_v_.clear();
     clusters_v_.shrink_to_fit();
     for (auto& cl : numberOfClustersPerLayer_) {
       cl = 0;
     }
 
     for (auto& cells : cells_) {
       cells.clear();
       cells.shrink_to_fit();
     }
   }

Member Data Documentation

◆ cells_

template<typename TILE , typename STRATEGY >

std::vector<CellsOnLayer> HGCalCLUEAlgoT< TILE, STRATEGY >::cells_

private

Definition at line 207 of file HGCalCLUEAlgo.h.

Referenced by HGCalCLUEAlgoT< TILE, STRATEGY >::distance(), HGCalCLUEAlgoT< TILE, STRATEGY >::distance2(), and HGCalCLUEAlgoT< TILE, STRATEGY >::reset().

◆ dEdXweights_

template<typename TILE , typename STRATEGY >

std::vector<double> HGCalCLUEAlgoT< TILE, STRATEGY >::dEdXweights_

private

Definition at line 141 of file HGCalCLUEAlgo.h.

◆ deltasi_index_regemfac_

template<typename TILE , typename STRATEGY >

int HGCalCLUEAlgoT< TILE, STRATEGY >::deltasi_index_regemfac_

private

Definition at line 144 of file HGCalCLUEAlgo.h.

◆ dependSensor_

template<typename TILE , typename STRATEGY >

bool HGCalCLUEAlgoT< TILE, STRATEGY >::dependSensor_

private

Definition at line 140 of file HGCalCLUEAlgo.h.

◆ ecut_

template<typename TILE , typename STRATEGY >

double HGCalCLUEAlgoT< TILE, STRATEGY >::ecut_

private

Definition at line 136 of file HGCalCLUEAlgo.h.

◆ fcPerEle_

template<typename TILE , typename STRATEGY >

double HGCalCLUEAlgoT< TILE, STRATEGY >::fcPerEle_

private

Definition at line 147 of file HGCalCLUEAlgo.h.

◆ fcPerMip_

template<typename TILE , typename STRATEGY >

std::vector<double> HGCalCLUEAlgoT< TILE, STRATEGY >::fcPerMip_

private

Definition at line 146 of file HGCalCLUEAlgo.h.

◆ initialized_

template<typename TILE , typename STRATEGY >

bool HGCalCLUEAlgoT< TILE, STRATEGY >::initialized_

private

Definition at line 158 of file HGCalCLUEAlgo.h.

◆ kappa_

template<typename TILE , typename STRATEGY >

double HGCalCLUEAlgoT< TILE, STRATEGY >::kappa_

private

Definition at line 133 of file HGCalCLUEAlgo.h.

◆ maxNumberOfThickIndices_

template<typename TILE , typename STRATEGY >

unsigned HGCalCLUEAlgoT< TILE, STRATEGY >::maxNumberOfThickIndices_

private

Definition at line 145 of file HGCalCLUEAlgo.h.

◆ noiseMip_

template<typename TILE , typename STRATEGY >

double HGCalCLUEAlgoT< TILE, STRATEGY >::noiseMip_

private

Definition at line 149 of file HGCalCLUEAlgo.h.

◆ nonAgedNoises_

template<typename TILE , typename STRATEGY >

std::vector<double> HGCalCLUEAlgoT< TILE, STRATEGY >::nonAgedNoises_

private

Definition at line 148 of file HGCalCLUEAlgo.h.

◆ numberOfClustersPerLayer_

template<typename TILE , typename STRATEGY >

std::vector<int> HGCalCLUEAlgoT< TILE, STRATEGY >::numberOfClustersPerLayer_

private

Definition at line 209 of file HGCalCLUEAlgo.h.

Referenced by HGCalCLUEAlgoT< TILE, STRATEGY >::reset().

◆ outlierDeltaFactor_

template<typename TILE , typename STRATEGY >

float HGCalCLUEAlgoT< TILE, STRATEGY >::outlierDeltaFactor_ = 2.f

private

Definition at line 160 of file HGCalCLUEAlgo.h.

◆ positionDeltaRho2_

template<typename TILE , typename STRATEGY >

double HGCalCLUEAlgoT< TILE, STRATEGY >::positionDeltaRho2_

private

Definition at line 153 of file HGCalCLUEAlgo.h.

◆ sciThicknessCorrection_

template<typename TILE , typename STRATEGY >

double HGCalCLUEAlgoT< TILE, STRATEGY >::sciThicknessCorrection_

private

Definition at line 143 of file HGCalCLUEAlgo.h.

◆ thicknessCorrection_

template<typename TILE , typename STRATEGY >

std::vector<double> HGCalCLUEAlgoT< TILE, STRATEGY >::thicknessCorrection_

private

Definition at line 142 of file HGCalCLUEAlgo.h.

◆ thresholds_

template<typename TILE , typename STRATEGY >

std::vector<std::vector<double> > HGCalCLUEAlgoT< TILE, STRATEGY >::thresholds_

private

Definition at line 150 of file HGCalCLUEAlgo.h.

◆ thresholdW0_

template<typename TILE , typename STRATEGY >

std::vector<double> HGCalCLUEAlgoT< TILE, STRATEGY >::thresholdW0_

private

Definition at line 152 of file HGCalCLUEAlgo.h.

◆ use2x2_

template<typename TILE , typename STRATEGY >

bool HGCalCLUEAlgoT< TILE, STRATEGY >::use2x2_

private

Definition at line 155 of file HGCalCLUEAlgo.h.

◆ v_sigmaNoise_

template<typename TILE , typename STRATEGY >

std::vector<std::vector<double> > HGCalCLUEAlgoT< TILE, STRATEGY >::v_sigmaNoise_

private

Definition at line 151 of file HGCalCLUEAlgo.h.

◆ vecDeltas_

template<typename TILE , typename STRATEGY >

std::vector<double> HGCalCLUEAlgoT< TILE, STRATEGY >::vecDeltas_

private

Definition at line 132 of file HGCalCLUEAlgo.h.

Classes

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

template<typename TILE, typename STRATEGY> class HGCalCLUEAlgoT< TILE, STRATEGY >

Member Typedef Documentation

◆ Point

Constructor & Destructor Documentation

◆ HGCalCLUEAlgoT()

◆ ~HGCalCLUEAlgoT()

Member Function Documentation

◆ calculateDistanceToHigher()

◆ calculateLocalDensity() [1/3]

◆ calculateLocalDensity() [2/3]

◆ calculateLocalDensity() [3/3]

◆ computeThreshold()

◆ distance()

◆ distance2()

◆ fillPSetDescription()

◆ findAndAssignClusters()

◆ getClusters()

◆ getEventSetupPerAlgorithm()

◆ makeClusters()

◆ populate()

◆ prepareDataStructures()

◆ reset()

Member Data Documentation

◆ cells_

◆ dEdXweights_

◆ deltasi_index_regemfac_

◆ dependSensor_

◆ ecut_

◆ fcPerEle_

◆ fcPerMip_

◆ initialized_

◆ kappa_

◆ maxNumberOfThickIndices_

◆ noiseMip_

◆ nonAgedNoises_

◆ numberOfClustersPerLayer_

◆ outlierDeltaFactor_

◆ positionDeltaRho2_

◆ sciThicknessCorrection_

◆ thicknessCorrection_

◆ thresholds_

◆ thresholdW0_

◆ use2x2_

◆ v_sigmaNoise_

◆ vecDeltas_

template<typename TILE, typename STRATEGY>
class HGCalCLUEAlgoT< TILE, STRATEGY >