#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	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	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::string	eidInputName_

const float	eidMinClusterEnergy_

const int	eidNClusters_

const int	eidNLayers_

const std::string	eidOutputNameEnergy_

const std::string	eidOutputNameId_

tensorflow::Session *	eidSession_

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_

Static Private Attributes
static const int	eidNFeatures_ = 3

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")),
       eidInputName_(conf.getParameter<std::string>("eid_input_name")),
       eidOutputNameEnergy_(conf.getParameter<std::string>("eid_output_name_energy")),
       eidOutputNameId_(conf.getParameter<std::string>("eid_output_name_id")),
       eidMinClusterEnergy_(conf.getParameter<double>("eid_min_cluster_energy")),
       eidNLayers_(conf.getParameter<int>("eid_n_layers")),
       eidNClusters_(conf.getParameter<int>("eid_n_clusters")),
       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 684 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, SiStripPI::max, allConversions_cfi::maxDelta, SiStripPI::min, HLT_2024v14_cff::minLayer, L1TMuonDQMOffline_cfi::nEtaBins, ecaldqm::binning::nPhiBins, electrons_cff::numberOfClusters, hltrates_dqm_sourceclient-live_cfg::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 518 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, SiStripPI::max, SiStripPI::min, HLT_2024v14_cff::minLayer, L1TMuonDQMOffline_cfi::nEtaBins, ecaldqm::binning::nPhiBins, electrons_cff::numberOfClusters, hltrates_dqm_sourceclient-live_cfg::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 109 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 52 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 hltrates_dqm_sourceclient-live_cfg::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 74 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, 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 PatternRecognitionbyCLUE3D::energyRegressionAndID	(	const std::vector< reco::CaloCluster > &	layerClusters,
		const tensorflow::Session *	eidSession,
		std::vector< Trackster > &	result
	)

Definition at line 378 of file PatternRecognitionbyCLUE3D.cc.

References a, funct::abs(), b, HLT_FULL_cff::batchSize, data, hcalRecHitTable_cff::energy, reco::CaloCluster::energy(), reco::CaloCluster::eta(), f, lowptgsfeleseed::features(), nano_mu_digi_cff::float, reco::CaloCluster::hitsAndFractions(), mps_fire::i, input, crabTemplate::inputList, createfilelist::int, dqmiolumiharvest::j, dqmdumpme::k, MainPageGenerator::l, hltEgammaHGCALIDVarsL1Seeded_cfi::layerClusters, jetsAK4_CHS_cff::outputNames, PatBasicFWLiteJetAnalyzer_Selector_cfg::outputs, reco::CaloCluster::phi(), tensorflow::run(), l1trig_cff::shape, jetUpdater_cfi::sort, bphysicsOniaDQM_cfi::vertex, ticl::Trackster::vertex_multiplicity(), AlignmentTracksFromVertexSelector_cfi::vertices, and ticl::Trackster::vertices().

                                                                                                 {
   // Energy regression and particle identification strategy:
   //
   // 1. Set default values for regressed energy and particle id for each trackster.
   // 2. Store indices of tracksters whose total sum of cluster energies is above the
   //    eidMinClusterEnergy_ (GeV) threshold. Inference is not applied for soft tracksters.
   // 3. When no trackster passes the selection, return.
   // 4. Create input and output tensors. The batch dimension is determined by the number of
   //    selected tracksters.
   // 5. Fill input tensors with layer cluster features. Per layer, clusters are ordered descending
   //    by energy. Given that tensor data is contiguous in memory, we can use pointer arithmetic to
   //    fill values, even with batching.
   // 6. Zero-fill features for empty clusters in each layer.
   // 7. Batched inference.
   // 8. Assign the regressed energy and id probabilities to each trackster.
   //
   // Indices used throughout this method:
   // i -> batch element / trackster
   // j -> layer
   // k -> cluster
   // l -> feature
 
   // set default values per trackster, determine if the cluster energy threshold is passed,
   // and store indices of hard tracksters
   std::vector<int> tracksterIndices;
   for (int i = 0; i < static_cast<int>(tracksters.size()); i++) {
     // calculate the cluster energy sum (2)
     // note: after the loop, sumClusterEnergy might be just above the threshold which is enough to
     // decide whether to run inference for the trackster or not
     float sumClusterEnergy = 0.;
     for (const unsigned int &vertex : tracksters[i].vertices()) {
       sumClusterEnergy += static_cast<float>(layerClusters[vertex].energy());
       // there might be many clusters, so try to stop early
       if (sumClusterEnergy >= eidMinClusterEnergy_) {
         // set default values (1)
         tracksters[i].setRegressedEnergy(0.f);
         tracksters[i].zeroProbabilities();
         tracksterIndices.push_back(i);
         break;
       }
     }
   }
 
   // do nothing when no trackster passes the selection (3)
   int batchSize = static_cast<int>(tracksterIndices.size());
   if (batchSize == 0) {
     return;
   }
 
   // create input and output tensors (4)
   tensorflow::TensorShape shape({batchSize, eidNLayers_, eidNClusters_, eidNFeatures_});
   tensorflow::Tensor input(tensorflow::DT_FLOAT, shape);
   tensorflow::NamedTensorList inputList = {{eidInputName_, input}};
 
   std::vector<tensorflow::Tensor> outputs;
   std::vector<std::string> outputNames;
   if (!eidOutputNameEnergy_.empty()) {
     outputNames.push_back(eidOutputNameEnergy_);
   }
   if (!eidOutputNameId_.empty()) {
     outputNames.push_back(eidOutputNameId_);
   }
 
   // fill input tensor (5)
   for (int i = 0; i < batchSize; i++) {
     const Trackster &trackster = tracksters[tracksterIndices[i]];
 
     // per layer, we only consider the first eidNClusters_ clusters in terms of energy, so in order
     // to avoid creating large / nested structures to do the sorting for an unknown number of total
     // clusters, create a sorted list of layer cluster indices to keep track of the filled clusters
     std::vector<int> clusterIndices(trackster.vertices().size());
     for (int k = 0; k < (int)trackster.vertices().size(); k++) {
       clusterIndices[k] = k;
     }
     sort(clusterIndices.begin(), clusterIndices.end(), [&layerClusters, &trackster](const int &a, const int &b) {
       return layerClusters[trackster.vertices(a)].energy() > layerClusters[trackster.vertices(b)].energy();
     });
 
     // keep track of the number of seen clusters per layer
     std::vector<int> seenClusters(eidNLayers_);
 
     // loop through clusters by descending energy
     for (const int &k : clusterIndices) {
       // get features per layer and cluster and store the values directly in the input tensor
       const reco::CaloCluster &cluster = layerClusters[trackster.vertices(k)];
       int j = rhtools_.getLayerWithOffset(cluster.hitsAndFractions()[0].first) - 1;
       if (j < eidNLayers_ && seenClusters[j] < eidNClusters_) {
         // get the pointer to the first feature value for the current batch, layer and cluster
         float *features = &input.tensor<float, 4>()(i, j, seenClusters[j], 0);
 
         // fill features
         *(features++) = float(cluster.energy() / float(trackster.vertex_multiplicity(k)));
         *(features++) = float(std::abs(cluster.eta()));
         *(features) = float(cluster.phi());
 
         // increment seen clusters
         seenClusters[j]++;
       }
     }
 
     // zero-fill features of empty clusters in each layer (6)
     for (int j = 0; j < eidNLayers_; j++) {
       for (int k = seenClusters[j]; k < eidNClusters_; k++) {
         float *features = &input.tensor<float, 4>()(i, j, k, 0);
         for (int l = 0; l < eidNFeatures_; l++) {
           *(features++) = 0.f;
         }
       }
     }
   }
 
   // run the inference (7)
   tensorflow::run(eidSession, inputList, outputNames, &outputs);
 
   // store regressed energy per trackster (8)
   if (!eidOutputNameEnergy_.empty()) {
     // get the pointer to the energy tensor, dimension is batch x 1
     float *energy = outputs[0].flat<float>().data();
 
     for (const int &i : tracksterIndices) {
       tracksters[i].setRegressedEnergy(*(energy++));
     }
   }
 
   // store id probabilities per trackster (8)
   if (!eidOutputNameId_.empty()) {
     // get the pointer to the id probability tensor, dimension is batch x id_probabilities.size()
     int probsIdx = eidOutputNameEnergy_.empty() ? 0 : 1;
     float *probs = outputs[probsIdx].flat<float>().data();
 
     for (const int &i : tracksterIndices) {
       tracksters[i].setProbabilities(probs);
       probs += tracksters[i].id_probabilities().size();
     }
   }
 }

◆ fillPSetDescription()

template<typename TILES >

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

static

Definition at line 863 of file PatternRecognitionbyCLUE3D.cc.

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

                                                                                              {
   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<std::string>("eid_input_name", "input");
   iDesc.add<std::string>("eid_output_name_energy", "output/regressed_energy");
   iDesc.add<std::string>("eid_output_name_id", "output/id_probabilities");
   iDesc.add<double>("eid_min_cluster_energy", 1.);
   iDesc.add<int>("eid_n_layers", 50);
   iDesc.add<int>("eid_n_clusters", 10);
   iDesc.add<bool>("computeLocalTime", false);
   iDesc.add<bool>("usePCACleaning", false)->setComment("Enable PCA cleaning alorithm");
 }

◆ findAndAssignTracksters()

template<typename TILES >

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

private

Definition at line 790 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 155 of file PatternRecognitionbyCLUE3D.cc.

References funct::abs(), ticl::Advanced, cms::cuda::assert(), ticl::assignPCAtoTracksters(), ticl::Trackster::charged_hadron, hcalRecHitTable_cff::detId, f, relativeConstraints::geom, edm::EventSetup::getData(), reco::CaloCluster::hgcal_em, mps_fire::i, input, createfilelist::int, SiStripPI::max, ticl::Trackster::neutral_hadron, 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());
   if (doPidCut_) {
     energyRegressionAndID(input.layerClusters, input.tfSession, result);
     result.erase(std::remove_if(std::begin(result),
                                 std::end(result),
                                 [&](auto const &v) {
                                   auto const &hadProb =
                                       v.id_probability(ticl::Trackster::ParticleType::charged_hadron) +
                                       v.id_probability(ticl::Trackster::ParticleType::neutral_hadron);
                                   return hadProb >= cutHadProb_;
                                 }),
                  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 96 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 117 of file PatternRecognitionbyCLUE3D.h.

◆ clusters_

template<typename TILES >

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

private

Definition at line 113 of file PatternRecognitionbyCLUE3D.h.

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

◆ computeLocalTime_

template<typename TILES >

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

private

Definition at line 143 of file PatternRecognitionbyCLUE3D.h.

◆ criticalDensity_

template<typename TILES >

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

private

Definition at line 118 of file PatternRecognitionbyCLUE3D.h.

◆ criticalEtaPhiDistance_

template<typename TILES >

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

private

Definition at line 129 of file PatternRecognitionbyCLUE3D.h.

◆ criticalSelfDensity_

template<typename TILES >

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

private

Definition at line 119 of file PatternRecognitionbyCLUE3D.h.

◆ criticalXYDistance_

template<typename TILES >

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

private

Definition at line 130 of file PatternRecognitionbyCLUE3D.h.

◆ criticalZDistanceLyr_

template<typename TILES >

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

private

Definition at line 131 of file PatternRecognitionbyCLUE3D.h.

◆ cutHadProb_

template<typename TILES >

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

private

Definition at line 135 of file PatternRecognitionbyCLUE3D.h.

◆ densityEtaPhiDistanceSqr_

template<typename TILES >

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

private

Definition at line 121 of file PatternRecognitionbyCLUE3D.h.

◆ densityOnSameLayer_

template<typename TILES >

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

private

Definition at line 124 of file PatternRecognitionbyCLUE3D.h.

◆ densitySiblingLayers_

template<typename TILES >

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

private

Definition at line 120 of file PatternRecognitionbyCLUE3D.h.

◆ densityXYDistanceSqr_

template<typename TILES >

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

private

Definition at line 122 of file PatternRecognitionbyCLUE3D.h.

◆ doPidCut_

template<typename TILES >

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

private

Definition at line 134 of file PatternRecognitionbyCLUE3D.h.

◆ eidInputName_

template<typename TILES >

const std::string ticl::PatternRecognitionbyCLUE3D< TILES >::eidInputName_

private

Definition at line 137 of file PatternRecognitionbyCLUE3D.h.

◆ eidMinClusterEnergy_

template<typename TILES >

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

private

Definition at line 140 of file PatternRecognitionbyCLUE3D.h.

◆ eidNClusters_

template<typename TILES >

const int ticl::PatternRecognitionbyCLUE3D< TILES >::eidNClusters_

private

Definition at line 142 of file PatternRecognitionbyCLUE3D.h.

◆ eidNFeatures_

template<typename TILES >

const int ticl::PatternRecognitionbyCLUE3D< TILES >::eidNFeatures_ = 3

staticprivate

Definition at line 149 of file PatternRecognitionbyCLUE3D.h.

◆ eidNLayers_

template<typename TILES >

const int ticl::PatternRecognitionbyCLUE3D< TILES >::eidNLayers_

private

Definition at line 141 of file PatternRecognitionbyCLUE3D.h.

◆ eidOutputNameEnergy_

template<typename TILES >

const std::string ticl::PatternRecognitionbyCLUE3D< TILES >::eidOutputNameEnergy_

private

Definition at line 138 of file PatternRecognitionbyCLUE3D.h.

◆ eidOutputNameId_

template<typename TILES >

const std::string ticl::PatternRecognitionbyCLUE3D< TILES >::eidOutputNameId_

private

Definition at line 139 of file PatternRecognitionbyCLUE3D.h.

◆ eidSession_

template<typename TILES >

tensorflow::Session* ticl::PatternRecognitionbyCLUE3D< TILES >::eidSession_

private

Definition at line 147 of file PatternRecognitionbyCLUE3D.h.

◆ filter_on_categories_

template<typename TILES >

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

private

Definition at line 136 of file PatternRecognitionbyCLUE3D.h.

◆ kernelDensityFactor_

template<typename TILES >

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

private

Definition at line 123 of file PatternRecognitionbyCLUE3D.h.

◆ layersPosZ_

template<typename TILES >

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

private

Definition at line 114 of file PatternRecognitionbyCLUE3D.h.

◆ minNumLayerCluster_

template<typename TILES >

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

private

Definition at line 133 of file PatternRecognitionbyCLUE3D.h.

◆ nearestHigherOnSameLayer_

template<typename TILES >

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

private

Definition at line 125 of file PatternRecognitionbyCLUE3D.h.

◆ outlierMultiplier_

template<typename TILES >

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

private

Definition at line 132 of file PatternRecognitionbyCLUE3D.h.

◆ rescaleDensityByZ_

template<typename TILES >

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

private

Definition at line 128 of file PatternRecognitionbyCLUE3D.h.

◆ rhtools_

template<typename TILES >

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

private

Definition at line 146 of file PatternRecognitionbyCLUE3D.h.

◆ tracksterSeedAlgoId_

template<typename TILES >

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

private

Definition at line 115 of file PatternRecognitionbyCLUE3D.h.

◆ useAbsoluteProjectiveScale_

template<typename TILES >

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

private

Definition at line 126 of file PatternRecognitionbyCLUE3D.h.

◆ useClusterDimensionXY_

template<typename TILES >

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

private

Definition at line 127 of file PatternRecognitionbyCLUE3D.h.

◆ usePCACleaning_

template<typename TILES >

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

private

Definition at line 144 of file PatternRecognitionbyCLUE3D.h.

Classes

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Static 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()

◆ findAndAssignTracksters()

◆ makeTracksters()

◆ reset()

Member Data Documentation

◆ caloGeomToken_

◆ clusters_

◆ computeLocalTime_

◆ criticalDensity_

◆ criticalEtaPhiDistance_

◆ criticalSelfDensity_

◆ criticalXYDistance_

◆ criticalZDistanceLyr_

◆ cutHadProb_

◆ densityEtaPhiDistanceSqr_

◆ densityOnSameLayer_

◆ densitySiblingLayers_

◆ densityXYDistanceSqr_

◆ doPidCut_

◆ eidInputName_

◆ eidMinClusterEnergy_

◆ eidNClusters_

◆ eidNFeatures_

◆ eidNLayers_

◆ eidOutputNameEnergy_

◆ eidOutputNameId_

◆ eidSession_

◆ filter_on_categories_

◆ kernelDensityFactor_

◆ layersPosZ_

◆ minNumLayerCluster_

◆ nearestHigherOnSameLayer_

◆ outlierMultiplier_

◆ rescaleDensityByZ_

◆ rhtools_

◆ tracksterSeedAlgoId_

◆ useAbsoluteProjectiveScale_

◆ useClusterDimensionXY_

◆ usePCACleaning_

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