#include <PatternRecognitionbyCLUE3D.h>

Inheritance diagram for ticl::PatternRecognitionbyCLUE3D< TILES >:

Classes
struct	ClustersOnLayer

Public Member Functions
void	energyRegressionAndID (const std::vector< reco::CaloCluster > &layerClusters, const tensorflow::Session *, std::vector< Trackster > &result)

void	filter (std::vector< Trackster > &output, const std::vector< Trackster > &inTracksters, const typename PatternRecognitionAlgoBaseT< TILES >::Inputs &input, std::unordered_map< int, std::vector< int >> &seedToTracksterAssociation) override

void	makeTracksters (const typename PatternRecognitionAlgoBaseT< TILES >::Inputs &input, std::vector< Trackster > &result, std::unordered_map< int, std::vector< int >> &seedToTracksterAssociation) override

	PatternRecognitionbyCLUE3D (const edm::ParameterSet &conf, edm::ConsumesCollector)

	~PatternRecognitionbyCLUE3D () override=default

Public Member Functions inherited from ticl::PatternRecognitionAlgoBaseT< TILES >
virtual void	filter (std::vector< Trackster > &output, const std::vector< Trackster > &inTracksters, const Inputs &input, std::unordered_map< int, std::vector< int >> &seedToTracksterAssociation)=0

virtual void	makeTracksters (const Inputs &input, std::vector< Trackster > &result, std::unordered_map< int, std::vector< int >> &seedToTracksterAssociation)=0

	PatternRecognitionAlgoBaseT (const edm::ParameterSet &conf, edm::ConsumesCollector)

virtual	~PatternRecognitionAlgoBaseT ()

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

Private Member Functions
void	calculateDistanceToHigher (const TILES &, const int layerId, const std::vector< std::pair< int, int >> &)

void	calculateLocalDensity (const TILES &, const int layerId, const std::vector< std::pair< int, int >> &)

void	dumpClusters (const TILES &tiles, const std::vector< std::pair< int, int >> &layerIdx2layerandSoa, const int) const

void	dumpTiles (const TILES &) const

void	dumpTracksters (const std::vector< std::pair< int, int >> &layerIdx2layerandSoa, const int, const std::vector< Trackster > &) const

int	findAndAssignTracksters (const TILES &, const std::vector< std::pair< int, int >> &)

void	reset ()

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

std::vector< ClustersOnLayer >	clusters_

const bool	computeLocalTime_

const std::vector< double >	criticalDensity_

const std::vector< double >	criticalEtaPhiDistance_

const std::vector< double >	criticalSelfDensity_

const std::vector< double >	criticalXYDistance_

const std::vector< int >	criticalZDistanceLyr_

const float	cutHadProb_

const std::vector< double >	densityEtaPhiDistanceSqr_

const bool	densityOnSameLayer_

const std::vector< int >	densitySiblingLayers_

const std::vector< double >	densityXYDistanceSqr_

const bool	doPidCut_

const std::vector< int >	filter_on_categories_

const std::vector< double >	kernelDensityFactor_

std::vector< float >	layersPosZ_

const std::vector< int >	minNumLayerCluster_

const bool	nearestHigherOnSameLayer_

const std::vector< double >	outlierMultiplier_

const bool	rescaleDensityByZ_

hgcal::RecHitTools	rhtools_

std::vector< int >	tracksterSeedAlgoId_

const bool	useAbsoluteProjectiveScale_

const bool	useClusterDimensionXY_

const bool	usePCACleaning_

Additional Inherited Members
Protected Attributes inherited from ticl::PatternRecognitionAlgoBaseT< TILES >
int	algo_verbosity_

Detailed Description

template<typename TILES>
class ticl::PatternRecognitionbyCLUE3D< TILES >

Definition at line 12 of file PatternRecognitionbyCLUE3D.h.

Constructor & Destructor Documentation

◆ PatternRecognitionbyCLUE3D()

template<typename TILES >

PatternRecognitionbyCLUE3D::PatternRecognitionbyCLUE3D	(	const edm::ParameterSet &	conf,
		edm::ConsumesCollector	iC
	)

Definition at line 21 of file PatternRecognitionbyCLUE3D.cc.

     : PatternRecognitionAlgoBaseT<TILES>(conf, iC),
       caloGeomToken_(iC.esConsumes<CaloGeometry, CaloGeometryRecord>()),
       criticalDensity_(conf.getParameter<std::vector<double>>("criticalDensity")),
       criticalSelfDensity_(conf.getParameter<std::vector<double>>("criticalSelfDensity")),
       densitySiblingLayers_(conf.getParameter<std::vector<int>>("densitySiblingLayers")),
       densityEtaPhiDistanceSqr_(conf.getParameter<std::vector<double>>("densityEtaPhiDistanceSqr")),
       densityXYDistanceSqr_(conf.getParameter<std::vector<double>>("densityXYDistanceSqr")),
       kernelDensityFactor_(conf.getParameter<std::vector<double>>("kernelDensityFactor")),
       densityOnSameLayer_(conf.getParameter<bool>("densityOnSameLayer")),
       nearestHigherOnSameLayer_(conf.getParameter<bool>("nearestHigherOnSameLayer")),
       useAbsoluteProjectiveScale_(conf.getParameter<bool>("useAbsoluteProjectiveScale")),
       useClusterDimensionXY_(conf.getParameter<bool>("useClusterDimensionXY")),
       rescaleDensityByZ_(conf.getParameter<bool>("rescaleDensityByZ")),
       criticalEtaPhiDistance_(conf.getParameter<std::vector<double>>("criticalEtaPhiDistance")),
       criticalXYDistance_(conf.getParameter<std::vector<double>>("criticalXYDistance")),
       criticalZDistanceLyr_(conf.getParameter<std::vector<int>>("criticalZDistanceLyr")),
       outlierMultiplier_(conf.getParameter<std::vector<double>>("outlierMultiplier")),
       minNumLayerCluster_(conf.getParameter<std::vector<int>>("minNumLayerCluster")),
       doPidCut_(conf.getParameter<bool>("doPidCut")),
       cutHadProb_(conf.getParameter<double>("cutHadProb")),
       computeLocalTime_(conf.getParameter<bool>("computeLocalTime")),
       usePCACleaning_(conf.getParameter<bool>("usePCACleaning")){};

◆ ~PatternRecognitionbyCLUE3D()

template<typename TILES >

ticl::PatternRecognitionbyCLUE3D< TILES >::~PatternRecognitionbyCLUE3D ( )

overridedefault

Member Function Documentation

◆ calculateDistanceToHigher()

template<typename TILES >

void PatternRecognitionbyCLUE3D::calculateDistanceToHigher	(	const TILES &	tiles,
		const int	layerId,
		const std::vector< std::pair< int, int >> &	layerIdx2layerandSoa
	)

private

Definition at line 547 of file PatternRecognitionbyCLUE3D.cc.

References funct::abs(), ticl::Advanced, hltPFPuppi_cfi::algoId, ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), HLT_2024v14_cff::delta_phi, reco::deltaPhi(), reco::deltaR2(), mps_fire::i, hcalRecHitTable_cff::ieta, hcalRecHitTable_cff::iphi, WZElectronSkims53X_cff::max, allConversions_cfi::maxDelta, SiStripPI::min, HLT_2024v14_cff::minLayer, L1TMuonDQMOffline_cfi::nEtaBins, ecaldqm::binning::nPhiBins, electrons_cff::numberOfClusters, HLT_IsoTrack_cff::offset, trackingPOGFilters_cfi::phiWindow, and mathSSE::sqrt().

                                                                                                      {
   constexpr int nEtaBin = TILES::constants_type_t::nEtaBins;
   constexpr int nPhiBin = TILES::constants_type_t::nPhiBins;
   auto &clustersOnLayer = clusters_[layerId];
   unsigned int numberOfClusters = clustersOnLayer.x.size();
 
   auto distanceSqr = [](float r0, float r1, float phi0, float phi1) -> float {
     auto delta_phi = reco::deltaPhi(phi0, phi1);
     return (r0 - r1) * (r0 - r1) + r1 * r1 * delta_phi * delta_phi;
   };
 
   for (unsigned int i = 0; i < numberOfClusters; i++) {
     if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
       edm::LogVerbatim("PatternRecognitionbyCLUE3D")
           << "Starting searching nearestHigher on " << layerId << " with rho: " << clustersOnLayer.rho[i]
           << " at eta, phi: " << tiles[layerId].etaBin(clustersOnLayer.eta[i]) << ", "
           << tiles[layerId].phiBin(clustersOnLayer.phi[i]);
     }
     // We need to partition the two sides of the HGCAL detector
     auto lastLayerPerSide = static_cast<int>(rhtools_.lastLayer(false));
     int minLayer = 0;
     int maxLayer = 2 * lastLayerPerSide - 1;
     auto algoId = clustersOnLayer.algoId[i];
     if (layerId < lastLayerPerSide) {
       minLayer = std::max(layerId - densitySiblingLayers_[algoId], minLayer);
       maxLayer = std::min(layerId + densitySiblingLayers_[algoId], lastLayerPerSide - 1);
     } else {
       minLayer = std::max(layerId - densitySiblingLayers_[algoId], lastLayerPerSide + 1);
       maxLayer = std::min(layerId + densitySiblingLayers_[algoId], maxLayer);
     }
     constexpr float maxDelta = std::numeric_limits<float>::max();
     float i_delta = maxDelta;
     std::pair<int, int> i_nearestHigher(-1, -1);
     std::pair<float, int> nearest_distances(maxDelta, std::numeric_limits<int>::max());
     for (int currentLayer = minLayer; currentLayer <= maxLayer; currentLayer++) {
       if (!nearestHigherOnSameLayer_ && (layerId == currentLayer))
         continue;
       const auto &tileOnLayer = tiles[currentLayer];
       int etaWindow = 1;
       int phiWindow = 1;
       int etaBinMin = std::max(tileOnLayer.etaBin(clustersOnLayer.eta[i]) - etaWindow, 0);
       int etaBinMax = std::min(tileOnLayer.etaBin(clustersOnLayer.eta[i]) + etaWindow, nEtaBin - 1);
       int phiBinMin = tileOnLayer.phiBin(clustersOnLayer.phi[i]) - phiWindow;
       int phiBinMax = tileOnLayer.phiBin(clustersOnLayer.phi[i]) + phiWindow;
       for (int ieta = etaBinMin; ieta <= etaBinMax; ++ieta) {
         auto offset = ieta * nPhiBin;
         for (int iphi_it = phiBinMin; iphi_it <= phiBinMax; ++iphi_it) {
           int iphi = ((iphi_it % nPhiBin + nPhiBin) % nPhiBin);
           if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
             edm::LogVerbatim("PatternRecognitionbyCLUE3D")
                 << "Searching nearestHigher on " << currentLayer << " eta, phi: " << ieta << ", " << iphi_it << " "
                 << iphi << " " << offset << " " << (offset + iphi);
           }
           for (auto otherClusterIdx : tileOnLayer[offset + iphi]) {
             auto const &layerandSoa = layerIdx2layerandSoa[otherClusterIdx];
             // Skip masked layer clusters
             if ((layerandSoa.first == -1) && (layerandSoa.second == -1))
               continue;
             auto const &clustersOnOtherLayer = clusters_[layerandSoa.first];
             auto dist = maxDelta;
             auto dist_transverse = maxDelta;
             int dist_layers = std::abs(layerandSoa.first - layerId);
             if (useAbsoluteProjectiveScale_) {
               dist_transverse = distanceSqr(clustersOnLayer.r_over_absz[i] * clustersOnLayer.z[i],
                                             clustersOnOtherLayer.r_over_absz[layerandSoa.second] * clustersOnLayer.z[i],
                                             clustersOnLayer.phi[i],
                                             clustersOnOtherLayer.phi[layerandSoa.second]);
               // Add Z-scale to the final distance
               dist = dist_transverse;
             } else {
               dist = reco::deltaR2(clustersOnLayer.eta[i],
                                    clustersOnLayer.phi[i],
                                    clustersOnOtherLayer.eta[layerandSoa.second],
                                    clustersOnOtherLayer.phi[layerandSoa.second]);
               dist_transverse = dist;
             }
             bool foundHigher = (clustersOnOtherLayer.rho[layerandSoa.second] > clustersOnLayer.rho[i]) ||
                                (clustersOnOtherLayer.rho[layerandSoa.second] == clustersOnLayer.rho[i] &&
                                 clustersOnOtherLayer.layerClusterOriginalIdx[layerandSoa.second] >
                                     clustersOnLayer.layerClusterOriginalIdx[i]);
             if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
               edm::LogVerbatim("PatternRecognitionbyCLUE3D")
                   << "Searching nearestHigher on " << currentLayer
                   << " with rho: " << clustersOnOtherLayer.rho[layerandSoa.second]
                   << " on layerIdxInSOA: " << layerandSoa.first << ", " << layerandSoa.second
                   << " with distance: " << sqrt(dist) << " foundHigher: " << foundHigher;
             }
             if (foundHigher && dist <= i_delta) {
               // update i_delta
               i_delta = dist;
               nearest_distances = std::make_pair(sqrt(dist_transverse), dist_layers);
               // update i_nearestHigher
               i_nearestHigher = layerandSoa;
             }
           }  // End of loop on clusters
         }  // End of loop on phi bins
       }  // End of loop on eta bins
     }  // End of loop on layers
 
     clustersOnLayer.delta[i] = nearest_distances;
     clustersOnLayer.nearestHigher[i] = i_nearestHigher;
   }  // End of loop on clusters
 }

◆ calculateLocalDensity()

template<typename TILES >

void PatternRecognitionbyCLUE3D::calculateLocalDensity	(	const TILES &	tiles,
		const int	layerId,
		const std::vector< std::pair< int, int >> &	layerIdx2layerandSoa
	)

private

Definition at line 381 of file PatternRecognitionbyCLUE3D.cc.

References funct::abs(), ticl::Advanced, hltPFPuppi_cfi::algoId, ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), HLT_2024v14_cff::delta_phi, reco::deltaPhi(), reco::deltaR2(), f, mps_fire::i, hcalRecHitTable_cff::ieta, ALPAKA_ACCELERATOR_NAMESPACE::caPixelDoublets::if(), hcalRecHitTable_cff::iphi, WZElectronSkims53X_cff::max, SiStripPI::min, HLT_2024v14_cff::minLayer, L1TMuonDQMOffline_cfi::nEtaBins, ecaldqm::binning::nPhiBins, electrons_cff::numberOfClusters, HLT_IsoTrack_cff::offset, trackingPOGFilters_cfi::phiWindow, mathSSE::sqrt(), testProducerWithPsetDescEmpty_cfi::y1, and testProducerWithPsetDescEmpty_cfi::y2.

                                                                                                      {
   constexpr int nEtaBin = TILES::constants_type_t::nEtaBins;
   constexpr int nPhiBin = TILES::constants_type_t::nPhiBins;
   auto &clustersOnLayer = clusters_[layerId];
   unsigned int numberOfClusters = clustersOnLayer.x.size();
 
   auto isReachable = [](float r0, float r1, float phi0, float phi1, float delta_sqr) -> bool {
     auto delta_phi = reco::deltaPhi(phi0, phi1);
     return (r0 - r1) * (r0 - r1) + r1 * r1 * delta_phi * delta_phi < delta_sqr;
   };
   auto distance_debug = [&](float x1, float x2, float y1, float y2) -> float {
     return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
   };
 
   for (unsigned int i = 0; i < numberOfClusters; i++) {
     auto algoId = clustersOnLayer.algoId[i];
     // We need to partition the two sides of the HGCAL detector
     auto lastLayerPerSide = static_cast<int>(rhtools_.lastLayer(false));
     int minLayer = 0;
     int maxLayer = 2 * lastLayerPerSide - 1;
     if (layerId < lastLayerPerSide) {
       minLayer = std::max(layerId - densitySiblingLayers_[algoId], minLayer);
       maxLayer = std::min(layerId + densitySiblingLayers_[algoId], lastLayerPerSide - 1);
     } else {
       minLayer = std::max(layerId - densitySiblingLayers_[algoId], lastLayerPerSide);
       maxLayer = std::min(layerId + densitySiblingLayers_[algoId], maxLayer);
     }
     float deltaLayersZ = std::abs(layersPosZ_[maxLayer % lastLayerPerSide] - layersPosZ_[minLayer % lastLayerPerSide]);
 
     for (int currentLayer = minLayer; currentLayer <= maxLayer; currentLayer++) {
       if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
         edm::LogVerbatim("PatternRecognitionbyCLUE3D") << "RefLayer: " << layerId << " SoaIDX: " << i;
         edm::LogVerbatim("PatternRecognitionbyCLUE3D") << "NextLayer: " << currentLayer;
       }
       const auto &tileOnLayer = tiles[currentLayer];
       bool onSameLayer = (currentLayer == layerId);
       if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
         edm::LogVerbatim("PatternRecognitionbyCLUE3D") << "onSameLayer: " << onSameLayer;
       }
       const int etaWindow = 2;
       const int phiWindow = 2;
       int etaBinMin = std::max(tileOnLayer.etaBin(clustersOnLayer.eta[i]) - etaWindow, 0);
       int etaBinMax = std::min(tileOnLayer.etaBin(clustersOnLayer.eta[i]) + etaWindow, nEtaBin - 1);
       int phiBinMin = tileOnLayer.phiBin(clustersOnLayer.phi[i]) - phiWindow;
       int phiBinMax = tileOnLayer.phiBin(clustersOnLayer.phi[i]) + phiWindow;
       if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
         edm::LogVerbatim("PatternRecognitionbyCLUE3D") << "eta: " << clustersOnLayer.eta[i];
         edm::LogVerbatim("PatternRecognitionbyCLUE3D") << "phi: " << clustersOnLayer.phi[i];
         edm::LogVerbatim("PatternRecognitionbyCLUE3D") << "etaBinMin: " << etaBinMin << ", etaBinMax: " << etaBinMax;
         edm::LogVerbatim("PatternRecognitionbyCLUE3D") << "phiBinMin: " << phiBinMin << ", phiBinMax: " << phiBinMax;
       }
       for (int ieta = etaBinMin; ieta <= etaBinMax; ++ieta) {
         auto offset = ieta * nPhiBin;
         if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
           edm::LogVerbatim("PatternRecognitionbyCLUE3D") << "offset: " << offset;
         }
         for (int iphi_it = phiBinMin; iphi_it <= phiBinMax; ++iphi_it) {
           int iphi = ((iphi_it % nPhiBin + nPhiBin) % nPhiBin);
           if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
             edm::LogVerbatim("PatternRecognitionbyCLUE3D") << "iphi: " << iphi;
             edm::LogVerbatim("PatternRecognitionbyCLUE3D")
                 << "Entries in tileBin: " << tileOnLayer[offset + iphi].size();
           }
           for (auto otherClusterIdx : tileOnLayer[offset + iphi]) {
             auto const &layerandSoa = layerIdx2layerandSoa[otherClusterIdx];
             // Skip masked layer clusters
             if ((layerandSoa.first == -1) && (layerandSoa.second == -1)) {
               if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
                 edm::LogVerbatim("PatternRecognitionbyCLUE3D") << "Skipping masked layerIdx " << otherClusterIdx;
               }
               continue;
             }
             auto const &clustersLayer = clusters_[layerandSoa.first];
             if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
               edm::LogVerbatim("PatternRecognitionbyCLUE3D")
                   << "OtherLayer: " << layerandSoa.first << " SoaIDX: " << layerandSoa.second;
               edm::LogVerbatim("PatternRecognitionbyCLUE3D") << "OtherEta: " << clustersLayer.eta[layerandSoa.second];
               edm::LogVerbatim("PatternRecognitionbyCLUE3D") << "OtherPhi: " << clustersLayer.phi[layerandSoa.second];
             }
 
             bool onSameCluster = clustersOnLayer.layerClusterOriginalIdx[i] == otherClusterIdx;
             if (onSameLayer && !densityOnSameLayer_ && !onSameCluster) {
               if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
                 edm::LogVerbatim("PatternRecognitionbyCLUE3D")
                     << "Skipping different cluster " << otherClusterIdx << "in the same layer " << currentLayer;
               }
               continue;
             }
 
             bool reachable = false;
             if (useAbsoluteProjectiveScale_) {
               if (useClusterDimensionXY_) {
                 reachable = isReachable(clustersOnLayer.r_over_absz[i] * clustersOnLayer.z[i],
                                         clustersLayer.r_over_absz[layerandSoa.second] * clustersOnLayer.z[i],
                                         clustersOnLayer.phi[i],
                                         clustersLayer.phi[layerandSoa.second],
                                         clustersOnLayer.radius[i] * clustersOnLayer.radius[i]);
               } else {
                 // Still differentiate between silicon and Scintillator.
                 // Scintillator has yet to be studied further.
                 if (clustersOnLayer.isSilicon[i]) {
                   reachable = isReachable(clustersOnLayer.r_over_absz[i] * clustersOnLayer.z[i],
                                           clustersLayer.r_over_absz[layerandSoa.second] * clustersOnLayer.z[i],
                                           clustersOnLayer.phi[i],
                                           clustersLayer.phi[layerandSoa.second],
                                           densityXYDistanceSqr_[algoId]);
                 } else {
                   reachable = isReachable(clustersOnLayer.r_over_absz[i] * clustersOnLayer.z[i],
                                           clustersLayer.r_over_absz[layerandSoa.second] * clustersOnLayer.z[i],
                                           clustersOnLayer.phi[i],
                                           clustersLayer.phi[layerandSoa.second],
                                           clustersOnLayer.radius[i] * clustersOnLayer.radius[i]);
                 }
               }
             } else {
               reachable = (reco::deltaR2(clustersOnLayer.eta[i],
                                          clustersOnLayer.phi[i],
                                          clustersLayer.eta[layerandSoa.second],
                                          clustersLayer.phi[layerandSoa.second]) < densityEtaPhiDistanceSqr_[algoId]);
             }
             if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
               edm::LogVerbatim("PatternRecognitionbyCLUE3D") << "Distance[eta,phi]: "
                                                              << reco::deltaR2(clustersOnLayer.eta[i],
                                                                               clustersOnLayer.phi[i],
                                                                               clustersLayer.eta[layerandSoa.second],
                                                                               clustersLayer.phi[layerandSoa.second]);
               auto dist = distance_debug(
                   clustersOnLayer.r_over_absz[i],
                   clustersLayer.r_over_absz[layerandSoa.second],
                   clustersOnLayer.r_over_absz[i] * std::abs(clustersOnLayer.phi[i]),
                   clustersLayer.r_over_absz[layerandSoa.second] * std::abs(clustersLayer.phi[layerandSoa.second]));
               edm::LogVerbatim("PatternRecognitionbyCLUE3D") << "Distance[cm]: " << (dist * clustersOnLayer.z[i]);
               edm::LogVerbatim("PatternRecognitionbyCLUE3D")
                   << "Energy Other:   " << clustersLayer.energy[layerandSoa.second];
               edm::LogVerbatim("PatternRecognitionbyCLUE3D") << "Cluster radius: " << clustersOnLayer.radius[i];
             }
             if (reachable) {
               float factor_same_layer_different_cluster = (onSameLayer && !densityOnSameLayer_) ? 0.f : 1.f;
               auto energyToAdd = (clustersOnLayer.layerClusterOriginalIdx[i] == otherClusterIdx
                                       ? 1.f
                                       : kernelDensityFactor_[algoId] * factor_same_layer_different_cluster) *
                                  clustersLayer.energy[layerandSoa.second];
               clustersOnLayer.rho[i] += energyToAdd;
               clustersOnLayer.z_extension[i] = deltaLayersZ;
               if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
                 edm::LogVerbatim("PatternRecognitionbyCLUE3D")
                     << "Adding " << energyToAdd << " partial " << clustersOnLayer.rho[i];
               }
             }
           }  // end of loop on possible compatible clusters
         }  // end of loop over phi-bin region
       }  // end of loop over eta-bin region
     }  // end of loop on the sibling layers
     if (rescaleDensityByZ_) {
       if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
         edm::LogVerbatim("PatternRecognitionbyCLUE3D")
             << "Rescaling original density: " << clustersOnLayer.rho[i] << " by Z: " << deltaLayersZ
             << " to final density/cm: " << clustersOnLayer.rho[i] / deltaLayersZ;
       }
       clustersOnLayer.rho[i] /= deltaLayersZ;
     }
   }  // end of loop over clusters on this layer
 }

◆ dumpClusters()

template<typename TILES >

void PatternRecognitionbyCLUE3D::dumpClusters	(	const TILES &	tiles,
		const std::vector< std::pair< int, int >> &	layerIdx2layerandSoa,
		const int	eventNumber
	)		const

private

Definition at line 102 of file PatternRecognitionbyCLUE3D.cc.

References ticl::Advanced, alignBH_cfg::fixed, EgammaValidation_cff::num, and findQualityFiles::v.

                                                                                   {
   if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
     edm::LogVerbatim("PatternRecognitionbyCLUE3D") << "[evt, lyr, Seed,      x,       y,       z, r/|z|,   eta,   phi, "
                                                       "etab,  phib, cells, enrgy, e/rho,   rho,   z_ext, "
                                                       "   dlt_tr,   dlt_lyr, "
                                                       " nestHL, nestHSoaIdx, radius, clIdx, lClOrigIdx, SOAidx";
   }
 
   for (unsigned int layer = 0; layer < clusters_.size(); layer++) {
     auto const &thisLayer = clusters_[layer];
     int num = 0;
     for (auto v : thisLayer.x) {
       if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
         edm::LogVerbatim("PatternRecognitionbyCLUE3D")
             << std::setw(4) << eventNumber << ", " << std::setw(3) << layer << ", " << std::setw(4)
             << thisLayer.isSeed[num] << ", " << std::setprecision(3) << std::fixed << v << ", " << thisLayer.y[num]
             << ", " << thisLayer.z[num] << ", " << thisLayer.r_over_absz[num] << ", " << thisLayer.eta[num] << ", "
             << thisLayer.phi[num] << ", " << std::setw(5) << tiles[layer].etaBin(thisLayer.eta[num]) << ", "
             << std::setw(5) << tiles[layer].phiBin(thisLayer.phi[num]) << ", " << std::setw(4) << thisLayer.cells[num]
             << ", " << std::setprecision(3) << thisLayer.energy[num] << ", "
             << (thisLayer.energy[num] / thisLayer.rho[num]) << ", " << thisLayer.rho[num] << ", "
             << thisLayer.z_extension[num] << ", " << std::scientific << thisLayer.delta[num].first << ", "
             << std::setw(10) << thisLayer.delta[num].second << ", " << std::setw(5)
             << thisLayer.nearestHigher[num].first << ", " << std::setw(10) << thisLayer.nearestHigher[num].second
             << ", " << std::defaultfloat << std::setprecision(3) << thisLayer.radius[num] << ", " << std::setw(5)
             << thisLayer.clusterIndex[num] << ", " << std::setw(4) << thisLayer.layerClusterOriginalIdx[num] << ", "
             << std::setw(4) << num << ", ClusterInfo";
       }
       ++num;
     }
   }
   for (unsigned int lcIdx = 0; lcIdx < layerIdx2layerandSoa.size(); lcIdx++) {
     auto const &layerandSoa = layerIdx2layerandSoa[lcIdx];
     // Skip masked layer clusters
     if ((layerandSoa.first == -1) && (layerandSoa.second == -1))
       continue;
     if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
       edm::LogVerbatim("PatternRecognitionbyCLUE3D")
           << "lcIdx: " << lcIdx << " on Layer: " << layerandSoa.first << " SOA: " << layerandSoa.second;
     }
   }
 }

◆ dumpTiles()

template<typename TILES >

void PatternRecognitionbyCLUE3D::dumpTiles ( const TILES & tiles ) const

private

Definition at line 45 of file PatternRecognitionbyCLUE3D.cc.

References ticl::Advanced, ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), relativeConstraints::empty, hcalRecHitTable_cff::ieta, hcalRecHitTable_cff::iphi, L1TMuonDQMOffline_cfi::nEtaBins, ecaldqm::binning::nPhiBins, and HLT_IsoTrack_cff::offset.

                                                                           {
   constexpr int nEtaBin = TILES::constants_type_t::nEtaBins;
   constexpr int nPhiBin = TILES::constants_type_t::nPhiBins;
   auto lastLayerPerSide = static_cast<int>(rhtools_.lastLayer(false));
   int maxLayer = 2 * lastLayerPerSide - 1;
   for (int layer = 0; layer <= maxLayer; layer++) {
     for (int ieta = 0; ieta < nEtaBin; ieta++) {
       auto offset = ieta * nPhiBin;
       for (int phi = 0; phi < nPhiBin; phi++) {
         int iphi = ((phi % nPhiBin + nPhiBin) % nPhiBin);
         if (!tiles[layer][offset + iphi].empty()) {
           if (this->algo_verbosity_ > VerbosityLevel::Advanced) {
             edm::LogVerbatim("PatternRecognitionbyCLUE3D") << "Layer: " << layer << " ieta: " << ieta << " phi: " << phi
                                                            << " " << tiles[layer][offset + iphi].size();
           }
         }
       }
     }
   }
 }

◆ dumpTracksters()

template<typename TILES >

void PatternRecognitionbyCLUE3D::dumpTracksters	(	const std::vector< std::pair< int, int >> &	layerIdx2layerandSoa,
		const int	eventNumber,
		const std::vector< Trackster > &	tracksters
	)		const

private

Definition at line 67 of file PatternRecognitionbyCLUE3D.cc.

References ticl::Advanced, ticl::Trackster::charged_hadron, ticl::Trackster::electron, ticl::Trackster::neutral_hadron, EgammaValidation_cff::num, ticl::Trackster::photon, AlCaHLTBitMon_QueryRunRegistry::string, submitPVValidationJobs::t, HitToTracksterAssociation_cfi::tracksters, and findQualityFiles::v.

                                                                                                      {
   if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
     edm::LogVerbatim("PatternRecognitionbyCLUE3D")
         << "[evt, tracksterId, cells, prob_photon, prob_ele, prob_chad, prob_nhad, layer_i, x_i, y_i, eta_i, phi_i, "
            "energy_i, radius_i, rho_i, z_extension, delta_tr, delta_lyr, isSeed_i";
   }
 
   int num = 0;
   const std::string sep(", ");
   for (auto const &t : tracksters) {
     for (auto v : t.vertices()) {
       auto [lyrIdx, soaIdx] = layerIdx2layerandSoa[v];
       auto const &thisLayer = clusters_[lyrIdx];
       if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
         edm::LogVerbatim("PatternRecognitionbyCLUE3D_NTP")
             << std::setw(4) << eventNumber << sep << std::setw(4) << num << sep << std::setw(4) << t.vertices().size()
             << sep << std::setw(8) << t.id_probability(ticl::Trackster::ParticleType::photon) << sep << std::setw(8)
             << t.id_probability(ticl::Trackster::ParticleType::electron) << sep << std::setw(8)
             << t.id_probability(ticl::Trackster::ParticleType::charged_hadron) << sep << std::setw(8)
             << t.id_probability(ticl::Trackster::ParticleType::neutral_hadron) << sep << std::setw(4) << lyrIdx << sep
             << std::setw(10) << thisLayer.x[soaIdx] << sep << std::setw(10) << thisLayer.y[soaIdx] << sep
             << std::setw(10) << thisLayer.eta[soaIdx] << sep << std::setw(10) << thisLayer.phi[soaIdx] << sep
             << std::setw(10) << thisLayer.energy[soaIdx] << sep << std::setw(10) << thisLayer.radius[soaIdx] << sep
             << std::setw(10) << thisLayer.rho[soaIdx] << sep << std::setw(10) << thisLayer.z_extension[soaIdx] << sep
             << std::setw(10) << thisLayer.delta[soaIdx].first << sep << std::setw(10) << thisLayer.delta[soaIdx].second
             << sep << std::setw(4) << thisLayer.isSeed[soaIdx];
       }
     }
     num++;
   }
 }

◆ energyRegressionAndID()

template<typename TILES >

void ticl::PatternRecognitionbyCLUE3D< TILES >::energyRegressionAndID	(	const std::vector< reco::CaloCluster > &	layerClusters,
		const tensorflow::Session *	,
		std::vector< Trackster > &	result
	)

◆ fillPSetDescription()

template<typename TILES >

void PatternRecognitionbyCLUE3D::fillPSetDescription ( edm::ParameterSetDescription & iDesc )

static

Definition at line 726 of file PatternRecognitionbyCLUE3D.cc.

References edm::ParameterSetDescription::add().

                                                                                              {
   iDesc.add<int>("algo_verbosity", 0);
   iDesc.add<std::vector<double>>("criticalDensity", {4, 4, 4})->setComment("in GeV");
   iDesc.add<std::vector<double>>("criticalSelfDensity", {0.15, 0.15, 0.15} /* roughly 1/(densitySiblingLayers+1) */)
       ->setComment("Minimum ratio of self_energy/local_density to become a seed.");
   iDesc.add<std::vector<int>>("densitySiblingLayers", {3, 3, 3})
       ->setComment(
           "inclusive, layers to consider while computing local density and searching for nearestHigher higher");
   iDesc.add<std::vector<double>>("densityEtaPhiDistanceSqr", {0.0008, 0.0008, 0.0008})
       ->setComment("in eta,phi space, distance to consider for local density");
   iDesc.add<std::vector<double>>("densityXYDistanceSqr", {3.24, 3.24, 3.24})
       ->setComment("in cm, distance on the transverse plane to consider for local density");
   iDesc.add<std::vector<double>>("kernelDensityFactor", {0.2, 0.2, 0.2})
       ->setComment("Kernel factor to be applied to other LC while computing the local density");
   iDesc.add<bool>("densityOnSameLayer", false);
   iDesc.add<bool>("nearestHigherOnSameLayer", false)
       ->setComment("Allow the nearestHigher to be located on the same layer");
   iDesc.add<bool>("useAbsoluteProjectiveScale", true)
       ->setComment("Express all cuts in terms of r/z*z_0{,phi} projective variables");
   iDesc.add<bool>("useClusterDimensionXY", false)
       ->setComment(
           "Boolean. If true use the estimated cluster radius to determine the cluster compatibility while computing "
           "the local density");
   iDesc.add<bool>("rescaleDensityByZ", false)
       ->setComment(
           "Rescale local density by the extension of the Z 'volume' explored. The transvere dimension is, at present, "
           "fixed and factored out.");
   iDesc.add<std::vector<double>>("criticalEtaPhiDistance", {0.025, 0.025, 0.025})
       ->setComment("Minimal distance in eta,phi space from nearestHigher to become a seed");
   iDesc.add<std::vector<double>>("criticalXYDistance", {1.8, 1.8, 1.8})
       ->setComment("Minimal distance in cm on the XY plane from nearestHigher to become a seed");
   iDesc.add<std::vector<int>>("criticalZDistanceLyr", {5, 5, 5})
       ->setComment("Minimal distance in layers along the Z axis from nearestHigher to become a seed");
   iDesc.add<std::vector<double>>("outlierMultiplier", {2, 2, 2})
       ->setComment("Minimal distance in transverse space from nearestHigher to become an outlier");
   iDesc.add<std::vector<int>>("minNumLayerCluster", {2, 2, 2})->setComment("Not Inclusive");
   iDesc.add<bool>("doPidCut", false);
   iDesc.add<double>("cutHadProb", 0.5);
   iDesc.add<bool>("computeLocalTime", false);
   iDesc.add<bool>("usePCACleaning", false)->setComment("Enable PCA cleaning alorithm");
 }

◆ filter()

template<typename TILES >

void PatternRecognitionbyCLUE3D::filter	(	std::vector< Trackster > &	output,
		const std::vector< Trackster > &	inTracksters,
		const typename PatternRecognitionAlgoBaseT< TILES >::Inputs &	input,
		std::unordered_map< int, std::vector< int >> &	seedToTracksterAssociation
	)

override

Definition at line 359 of file PatternRecognitionbyCLUE3D.cc.

References ticl::Trackster::charged_hadron, ticl::Trackster::neutral_hadron, and submitPVValidationJobs::t.

                                                                                                                   {
   auto isHAD = [this](const Trackster &t) -> bool {
     auto const hadProb = t.id_probability(ticl::Trackster::ParticleType::charged_hadron) +
                          t.id_probability(ticl::Trackster::ParticleType::neutral_hadron);
     return hadProb >= cutHadProb_;
   };
 
   if (doPidCut_) {
     for (auto const &t : inTracksters) {
       if (!isHAD(t)) {
         output.push_back(t);
       }
     }
   } else {
     output = inTracksters;
   }
 }

◆ findAndAssignTracksters()

template<typename TILES >

int PatternRecognitionbyCLUE3D::findAndAssignTracksters	(	const TILES &	tiles,
		const std::vector< std::pair< int, int >> &	layerIdx2layerandSoa
	)

private

Definition at line 653 of file PatternRecognitionbyCLUE3D.cc.

References ticl::Advanced, hltPFPuppi_cfi::algoId, mps_fire::i, and electrons_cff::numberOfClusters.

                                                                                   {
   unsigned int nTracksters = 0;
   std::vector<std::pair<int, int>> localStack;
   const auto &critical_transverse_distance =
       useAbsoluteProjectiveScale_ ? criticalXYDistance_ : criticalEtaPhiDistance_;
   // find cluster seeds and outlier
   for (unsigned int layer = 0; layer < 2 * rhtools_.lastLayer(); layer++) {
     auto &clustersOnLayer = clusters_[layer];
     unsigned int numberOfClusters = clustersOnLayer.x.size();
     for (unsigned int i = 0; i < numberOfClusters; i++) {
       // initialize clusterIndex
       clustersOnLayer.clusterIndex[i] = -1;
       auto algoId = clustersOnLayer.algoId[i];
       bool isSeed = (clustersOnLayer.delta[i].first > critical_transverse_distance[algoId] ||
                      clustersOnLayer.delta[i].second > criticalZDistanceLyr_[algoId]) &&
                     (clustersOnLayer.rho[i] >= criticalDensity_[algoId]) &&
                     (clustersOnLayer.energy[i] / clustersOnLayer.rho[i] > criticalSelfDensity_[algoId]);
       if (!clustersOnLayer.isSilicon[i]) {
         isSeed = (clustersOnLayer.delta[i].first > clustersOnLayer.radius[i] ||
                   clustersOnLayer.delta[i].second > criticalZDistanceLyr_[algoId]) &&
                  (clustersOnLayer.rho[i] >= criticalDensity_[algoId]) &&
                  (clustersOnLayer.energy[i] / clustersOnLayer.rho[i] > criticalSelfDensity_[algoId]);
       }
       bool isOutlier =
           (clustersOnLayer.delta[i].first > outlierMultiplier_[algoId] * critical_transverse_distance[algoId]) &&
           (clustersOnLayer.rho[i] < criticalDensity_[algoId]);
       if (isSeed) {
         if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
           edm::LogVerbatim("PatternRecognitionbyCLUE3D")
               << "Found seed on Layer " << layer << " SOAidx: " << i << " assigned ClusterIdx: " << nTracksters;
         }
         clustersOnLayer.clusterIndex[i] = nTracksters++;
         tracksterSeedAlgoId_.push_back(algoId);
         clustersOnLayer.isSeed[i] = true;
         localStack.emplace_back(layer, i);
       } else if (!isOutlier) {
         auto [lyrIdx, soaIdx] = clustersOnLayer.nearestHigher[i];
         if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
           edm::LogVerbatim("PatternRecognitionbyCLUE3D")
               << "Found follower on Layer " << layer << " SOAidx: " << i << " attached to cluster on layer: " << lyrIdx
               << " SOAidx: " << soaIdx;
         }
         if (lyrIdx >= 0)
           clusters_[lyrIdx].followers[soaIdx].emplace_back(layer, i);
       } else {
         if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
           edm::LogVerbatim("PatternRecognitionbyCLUE3D")
               << "Found Outlier on Layer " << layer << " SOAidx: " << i << " with rho: " << clustersOnLayer.rho[i]
               << " and delta: " << clustersOnLayer.delta[i].first << ", " << clustersOnLayer.delta[i].second;
         }
       }
     }
   }
 
   // Propagate cluster index
   while (!localStack.empty()) {
     auto [lyrIdx, soaIdx] = localStack.back();
     auto &thisSeed = clusters_[lyrIdx].followers[soaIdx];
     localStack.pop_back();
 
     // loop over followers
     for (auto [follower_lyrIdx, follower_soaIdx] : thisSeed) {
       // pass id to a follower
       clusters_[follower_lyrIdx].clusterIndex[follower_soaIdx] = clusters_[lyrIdx].clusterIndex[soaIdx];
       // push this follower to localStack
       localStack.emplace_back(follower_lyrIdx, follower_soaIdx);
     }
   }
   return nTracksters;
 }

◆ makeTracksters()

template<typename TILES >

void PatternRecognitionbyCLUE3D::makeTracksters	(	const typename PatternRecognitionAlgoBaseT< TILES >::Inputs &	input,
		std::vector< Trackster > &	result,
		std::unordered_map< int, std::vector< int >> &	seedToTracksterAssociation
	)

override

Definition at line 148 of file PatternRecognitionbyCLUE3D.cc.

References funct::abs(), ticl::Advanced, cms::cuda::assert(), ticl::assignPCAtoTracksters(), hcalRecHitTable_cff::detId, f, relativeConstraints::geom, edm::EventSetup::getData(), reco::CaloCluster::hgcal_em, mps_fire::i, input, createfilelist::int, WZElectronSkims53X_cff::max, point, reset(), mps_fire::result, mathSSE::sqrt(), makeMuonMisalignmentScenario::sum_x, makeMuonMisalignmentScenario::sum_y, submitPVValidationJobs::t, findQualityFiles::v, and x.

                                                                        {
   // Protect from events with no seeding regions
   if (input.regions.empty())
     return;
 
   const int eventNumber = input.ev.eventAuxiliary().event();
   if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
     edm::LogVerbatim("PatternRecognitionbyCLUE3D") << "New Event";
   }
 
   edm::EventSetup const &es = input.es;
   const CaloGeometry &geom = es.getData(caloGeomToken_);
   rhtools_.setGeometry(geom);
 
   // Assume identical Z-positioning between positive and negative sides.
   // Also, layers inside the HGCAL geometry start from 1.
   for (unsigned int i = 0; i < rhtools_.lastLayer(); ++i) {
     layersPosZ_.push_back(rhtools_.getPositionLayer(i + 1).z());
     if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
       edm::LogVerbatim("PatternRecognitionbyCLUE3D") << "Layer " << i << " located at Z: " << layersPosZ_.back();
     }
   }
 
   clusters_.clear();
   tracksterSeedAlgoId_.clear();
 
   clusters_.resize(2 * rhtools_.lastLayer(false));
   std::vector<std::pair<int, int>> layerIdx2layerandSoa;  //used everywhere also to propagate cluster masking
 
   layerIdx2layerandSoa.reserve(input.layerClusters.size());
   unsigned int layerIdx = 0;
   for (auto const &lc : input.layerClusters) {
     if (input.mask[layerIdx] == 0.) {
       if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
         edm::LogVerbatim("PatternRecognitionbyCLUE3D") << "Skipping masked cluster: " << layerIdx;
       }
       layerIdx2layerandSoa.emplace_back(-1, -1);
       layerIdx++;
       continue;
     }
     const auto firstHitDetId = lc.hitsAndFractions()[0].first;
     int layer = rhtools_.getLayerWithOffset(firstHitDetId) - 1 +
                 rhtools_.lastLayer(false) * ((rhtools_.zside(firstHitDetId) + 1) >> 1);
     assert(layer >= 0);
     auto detId = lc.hitsAndFractions()[0].first;
     int layerClusterIndexInLayer = clusters_[layer].x.size();
     layerIdx2layerandSoa.emplace_back(layer, layerClusterIndexInLayer);
     float sum_x = 0.;
     float sum_y = 0.;
     float sum_sqr_x = 0.;
     float sum_sqr_y = 0.;
     float ref_x = lc.x();
     float ref_y = lc.y();
     float invClsize = 1. / lc.hitsAndFractions().size();
     for (auto const &hitsAndFractions : lc.hitsAndFractions()) {
       auto const &point = rhtools_.getPosition(hitsAndFractions.first);
       sum_x += point.x() - ref_x;
       sum_sqr_x += (point.x() - ref_x) * (point.x() - ref_x);
       sum_y += point.y() - ref_y;
       sum_sqr_y += (point.y() - ref_y) * (point.y() - ref_y);
     }
     // The variance of X for X uniform in circle of radius R is R^2/4,
     // therefore we multiply the sqrt(var) by 2 to have a rough estimate of the
     // radius. On the other hand, while averaging the x and y radius, we would
     // end up dividing by 2. Hence we omit the value here and in the average
     // below, too.
     float radius_x = sqrt((sum_sqr_x - (sum_x * sum_x) * invClsize) * invClsize);
     float radius_y = sqrt((sum_sqr_y - (sum_y * sum_y) * invClsize) * invClsize);
     if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
       edm::LogVerbatim("PatternRecognitionbyCLUE3D")
           << "cluster rx: " << std::setw(5) << radius_x << ", ry: " << std::setw(5) << radius_y
           << ", r:  " << std::setw(5) << (radius_x + radius_y) << ", cells: " << std::setw(4)
           << lc.hitsAndFractions().size();
     }
 
     // The case of single cell layer clusters has to be handled differently.
 
     if (invClsize == 1.) {
       // Silicon case
       if (rhtools_.isSilicon(detId)) {
         radius_x = radius_y = rhtools_.getRadiusToSide(detId);
         if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
           edm::LogVerbatim("PatternRecognitionbyCLUE3D") << "Single cell cluster in silicon, rx: " << std::setw(5)
                                                          << radius_x << ", ry: " << std::setw(5) << radius_y;
         }
       } else {
         auto const &point = rhtools_.getPosition(detId);
         auto const &eta_phi_window = rhtools_.getScintDEtaDPhi(detId);
         radius_x = radius_y = point.perp() * eta_phi_window.second;
         if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
           edm::LogVerbatim("PatternRecognitionbyCLUE3D")
               << "Single cell cluster in scintillator. rx: " << std::setw(5) << radius_x << ", ry: " << std::setw(5)
               << radius_y << ", eta-span: " << std::setw(5) << eta_phi_window.first << ", phi-span: " << std::setw(5)
               << eta_phi_window.second;
         }
       }
     }
 
     // Maybe check if these vectors can be reserved beforehands
     clusters_[layer].x.emplace_back(lc.x());
     clusters_[layer].y.emplace_back(lc.y());
     clusters_[layer].z.emplace_back(lc.z());
     clusters_[layer].r_over_absz.emplace_back(sqrt(lc.x() * lc.x() + lc.y() * lc.y()) / std::abs(lc.z()));
     clusters_[layer].radius.emplace_back(radius_x + radius_y);
     clusters_[layer].eta.emplace_back(lc.eta());
     clusters_[layer].phi.emplace_back(lc.phi());
     clusters_[layer].cells.push_back(lc.hitsAndFractions().size());
     clusters_[layer].algoId.push_back(lc.algo() - reco::CaloCluster::hgcal_em);
     clusters_[layer].isSilicon.push_back(rhtools_.isSilicon(detId));
     clusters_[layer].energy.emplace_back(lc.energy());
     clusters_[layer].isSeed.push_back(false);
     clusters_[layer].clusterIndex.emplace_back(-1);
     clusters_[layer].layerClusterOriginalIdx.emplace_back(layerIdx++);
     clusters_[layer].nearestHigher.emplace_back(-1, -1);
     clusters_[layer].rho.emplace_back(0.f);
     clusters_[layer].z_extension.emplace_back(0.f);
     clusters_[layer].delta.emplace_back(
         std::make_pair(std::numeric_limits<float>::max(), std::numeric_limits<int>::max()));
   }
   for (unsigned int layer = 0; layer < clusters_.size(); layer++) {
     clusters_[layer].followers.resize(clusters_[layer].x.size());
   }
 
   auto lastLayerPerSide = static_cast<int>(rhtools_.lastLayer(false));
   int maxLayer = 2 * lastLayerPerSide - 1;
   std::vector<int> numberOfClustersPerLayer(maxLayer, 0);
   for (int i = 0; i <= maxLayer; i++) {
     calculateLocalDensity(input.tiles, i, layerIdx2layerandSoa);
   }
   for (int i = 0; i <= maxLayer; i++) {
     calculateDistanceToHigher(input.tiles, i, layerIdx2layerandSoa);
   }
 
   auto nTracksters = findAndAssignTracksters(input.tiles, layerIdx2layerandSoa);
   if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
     edm::LogVerbatim("PatternRecognitionbyCLUE3D") << "Reconstructed " << nTracksters << " tracksters" << std::endl;
     dumpClusters(input.tiles, layerIdx2layerandSoa, eventNumber);
   }
 
   // Build Trackster
   result.resize(nTracksters);
 
   for (unsigned int layer = 0; layer < clusters_.size(); ++layer) {
     const auto &thisLayer = clusters_[layer];
     if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
       edm::LogVerbatim("PatternRecognitionbyCLUE3D") << "Examining Layer: " << layer;
     }
     for (unsigned int lc = 0; lc < thisLayer.x.size(); ++lc) {
       if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
         edm::LogVerbatim("PatternRecognitionbyCLUE3D") << "Trackster " << thisLayer.clusterIndex[lc];
       }
       if (thisLayer.clusterIndex[lc] >= 0) {
         if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
           edm::LogVerbatim("PatternRecognitionbyCLUE3D") << " adding lcIdx: " << thisLayer.layerClusterOriginalIdx[lc];
         }
         result[thisLayer.clusterIndex[lc]].vertices().push_back(thisLayer.layerClusterOriginalIdx[lc]);
         result[thisLayer.clusterIndex[lc]].vertex_multiplicity().push_back(1);
         // loop over followers
         for (auto [follower_lyrIdx, follower_soaIdx] : thisLayer.followers[lc]) {
           std::array<unsigned int, 2> edge = {
               {(unsigned int)thisLayer.layerClusterOriginalIdx[lc],
                (unsigned int)clusters_[follower_lyrIdx].layerClusterOriginalIdx[follower_soaIdx]}};
           result[thisLayer.clusterIndex[lc]].edges().push_back(edge);
         }
       }
     }
   }
   size_t tracksterIndex = 0;
   result.erase(std::remove_if(std::begin(result),
                               std::end(result),
                               [&](auto const &v) {
                                 return static_cast<int>(v.vertices().size()) <
                                        minNumLayerCluster_[tracksterSeedAlgoId_[tracksterIndex++]];
                               }),
                result.end());
 
   result.shrink_to_fit();
 
   ticl::assignPCAtoTracksters(result,
                               input.layerClusters,
                               input.layerClustersTime,
                               rhtools_.getPositionLayer(rhtools_.lastLayerEE(false), false).z(),
                               rhtools_,
                               computeLocalTime_,
                               true,  // energy weighting
                               usePCACleaning_);
 
   if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
     for (auto const &t : result) {
       edm::LogVerbatim("PatternRecognitionbyCLUE3D") << "Barycenter: " << t.barycenter();
       edm::LogVerbatim("PatternRecognitionbyCLUE3D") << "LCs: " << t.vertices().size();
       edm::LogVerbatim("PatternRecognitionbyCLUE3D") << "Energy: " << t.raw_energy();
       edm::LogVerbatim("PatternRecognitionbyCLUE3D") << "Regressed: " << t.regressed_energy();
     }
   }
 
   // Dump Tracksters information
   if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
     dumpTracksters(layerIdx2layerandSoa, eventNumber, result);
   }
 
   // Reset internal clusters_ structure of array for next event
   reset();
   if (PatternRecognitionAlgoBaseT<TILES>::algo_verbosity_ > VerbosityLevel::Advanced) {
     edm::LogVerbatim("PatternRecognitionbyCLUE3D") << std::endl;
   }
 }

◆ reset()

template<typename TILES >

void ticl::PatternRecognitionbyCLUE3D< TILES >::reset ( void )

inlineprivate

Definition at line 101 of file PatternRecognitionbyCLUE3D.h.

References DummyCfis::c, and ticl::PatternRecognitionbyCLUE3D< TILES >::clusters_.

                  {
       for (auto& c : clusters_) {
         c.clear();
         c.shrink_to_fit();
       }
     }

Member Data Documentation

◆ caloGeomToken_

template<typename TILES >

edm::ESGetToken<CaloGeometry, CaloGeometryRecord> ticl::PatternRecognitionbyCLUE3D< TILES >::caloGeomToken_

private

Definition at line 122 of file PatternRecognitionbyCLUE3D.h.

◆ clusters_

template<typename TILES >

std::vector<ClustersOnLayer> ticl::PatternRecognitionbyCLUE3D< TILES >::clusters_

private

Definition at line 118 of file PatternRecognitionbyCLUE3D.h.

Referenced by ticl::PatternRecognitionbyCLUE3D< TILES >::reset().

◆ computeLocalTime_

template<typename TILES >

const bool ticl::PatternRecognitionbyCLUE3D< TILES >::computeLocalTime_

private

Definition at line 142 of file PatternRecognitionbyCLUE3D.h.

◆ criticalDensity_

template<typename TILES >

const std::vector<double> ticl::PatternRecognitionbyCLUE3D< TILES >::criticalDensity_

private

Definition at line 123 of file PatternRecognitionbyCLUE3D.h.

◆ criticalEtaPhiDistance_

template<typename TILES >

const std::vector<double> ticl::PatternRecognitionbyCLUE3D< TILES >::criticalEtaPhiDistance_

private

Definition at line 134 of file PatternRecognitionbyCLUE3D.h.

◆ criticalSelfDensity_

template<typename TILES >

const std::vector<double> ticl::PatternRecognitionbyCLUE3D< TILES >::criticalSelfDensity_

private

Definition at line 124 of file PatternRecognitionbyCLUE3D.h.

◆ criticalXYDistance_

template<typename TILES >

const std::vector<double> ticl::PatternRecognitionbyCLUE3D< TILES >::criticalXYDistance_

private

Definition at line 135 of file PatternRecognitionbyCLUE3D.h.

◆ criticalZDistanceLyr_

template<typename TILES >

const std::vector<int> ticl::PatternRecognitionbyCLUE3D< TILES >::criticalZDistanceLyr_

private

Definition at line 136 of file PatternRecognitionbyCLUE3D.h.

◆ cutHadProb_

template<typename TILES >

const float ticl::PatternRecognitionbyCLUE3D< TILES >::cutHadProb_

private

Definition at line 140 of file PatternRecognitionbyCLUE3D.h.

◆ densityEtaPhiDistanceSqr_

template<typename TILES >

const std::vector<double> ticl::PatternRecognitionbyCLUE3D< TILES >::densityEtaPhiDistanceSqr_

private

Definition at line 126 of file PatternRecognitionbyCLUE3D.h.

◆ densityOnSameLayer_

template<typename TILES >

const bool ticl::PatternRecognitionbyCLUE3D< TILES >::densityOnSameLayer_

private

Definition at line 129 of file PatternRecognitionbyCLUE3D.h.

◆ densitySiblingLayers_

template<typename TILES >

const std::vector<int> ticl::PatternRecognitionbyCLUE3D< TILES >::densitySiblingLayers_

private

Definition at line 125 of file PatternRecognitionbyCLUE3D.h.

◆ densityXYDistanceSqr_

template<typename TILES >

const std::vector<double> ticl::PatternRecognitionbyCLUE3D< TILES >::densityXYDistanceSqr_

private

Definition at line 127 of file PatternRecognitionbyCLUE3D.h.

◆ doPidCut_

template<typename TILES >

const bool ticl::PatternRecognitionbyCLUE3D< TILES >::doPidCut_

private

Definition at line 139 of file PatternRecognitionbyCLUE3D.h.

◆ filter_on_categories_

template<typename TILES >

const std::vector<int> ticl::PatternRecognitionbyCLUE3D< TILES >::filter_on_categories_

private

Definition at line 141 of file PatternRecognitionbyCLUE3D.h.

◆ kernelDensityFactor_

template<typename TILES >

const std::vector<double> ticl::PatternRecognitionbyCLUE3D< TILES >::kernelDensityFactor_

private

Definition at line 128 of file PatternRecognitionbyCLUE3D.h.

◆ layersPosZ_

template<typename TILES >

std::vector<float> ticl::PatternRecognitionbyCLUE3D< TILES >::layersPosZ_

private

Definition at line 119 of file PatternRecognitionbyCLUE3D.h.

◆ minNumLayerCluster_

template<typename TILES >

const std::vector<int> ticl::PatternRecognitionbyCLUE3D< TILES >::minNumLayerCluster_

private

Definition at line 138 of file PatternRecognitionbyCLUE3D.h.

◆ nearestHigherOnSameLayer_

template<typename TILES >

const bool ticl::PatternRecognitionbyCLUE3D< TILES >::nearestHigherOnSameLayer_

private

Definition at line 130 of file PatternRecognitionbyCLUE3D.h.

◆ outlierMultiplier_

template<typename TILES >

const std::vector<double> ticl::PatternRecognitionbyCLUE3D< TILES >::outlierMultiplier_

private

Definition at line 137 of file PatternRecognitionbyCLUE3D.h.

◆ rescaleDensityByZ_

template<typename TILES >

const bool ticl::PatternRecognitionbyCLUE3D< TILES >::rescaleDensityByZ_

private

Definition at line 133 of file PatternRecognitionbyCLUE3D.h.

◆ rhtools_

template<typename TILES >

hgcal::RecHitTools ticl::PatternRecognitionbyCLUE3D< TILES >::rhtools_

private

Definition at line 145 of file PatternRecognitionbyCLUE3D.h.

◆ tracksterSeedAlgoId_

template<typename TILES >

std::vector<int> ticl::PatternRecognitionbyCLUE3D< TILES >::tracksterSeedAlgoId_

private

Definition at line 120 of file PatternRecognitionbyCLUE3D.h.

◆ useAbsoluteProjectiveScale_

template<typename TILES >

const bool ticl::PatternRecognitionbyCLUE3D< TILES >::useAbsoluteProjectiveScale_

private

Definition at line 131 of file PatternRecognitionbyCLUE3D.h.

◆ useClusterDimensionXY_

template<typename TILES >

const bool ticl::PatternRecognitionbyCLUE3D< TILES >::useClusterDimensionXY_

private

Definition at line 132 of file PatternRecognitionbyCLUE3D.h.

◆ usePCACleaning_

template<typename TILES >

const bool ticl::PatternRecognitionbyCLUE3D< TILES >::usePCACleaning_

private

Definition at line 143 of file PatternRecognitionbyCLUE3D.h.

Classes

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

template<typename TILES> class ticl::PatternRecognitionbyCLUE3D< TILES >

Constructor & Destructor Documentation

◆ PatternRecognitionbyCLUE3D()

◆ ~PatternRecognitionbyCLUE3D()

Member Function Documentation

◆ calculateDistanceToHigher()

◆ calculateLocalDensity()

◆ dumpClusters()

◆ dumpTiles()

◆ dumpTracksters()

◆ energyRegressionAndID()

◆ fillPSetDescription()

◆ filter()

◆ findAndAssignTracksters()

◆ makeTracksters()

◆ reset()

Member Data Documentation

◆ caloGeomToken_

◆ clusters_

◆ computeLocalTime_

◆ criticalDensity_

◆ criticalEtaPhiDistance_

◆ criticalSelfDensity_

◆ criticalXYDistance_

◆ criticalZDistanceLyr_

◆ cutHadProb_

◆ densityEtaPhiDistanceSqr_

◆ densityOnSameLayer_

◆ densitySiblingLayers_

◆ densityXYDistanceSqr_

◆ doPidCut_

◆ filter_on_categories_

◆ kernelDensityFactor_

◆ layersPosZ_

◆ minNumLayerCluster_

◆ nearestHigherOnSameLayer_

◆ outlierMultiplier_

◆ rescaleDensityByZ_

◆ rhtools_

◆ tracksterSeedAlgoId_

◆ useAbsoluteProjectiveScale_

◆ useClusterDimensionXY_

◆ usePCACleaning_

template<typename TILES>
class ticl::PatternRecognitionbyCLUE3D< TILES >