ticl Namespace Reference

Classes
class	AbstractSuperclusteringDNNInput
class	CacheBase
struct	caloParticleOnLayer
class	ClusterFilterBase
class	ClusterFilterByAlgo
class	ClusterFilterByAlgoAndSize
class	ClusterFilterByAlgoAndSizeAndLayerRange
class	ClusterFilterBySize
struct	detIdInfoInCluster
struct	detIdInfoInTrackster
class	GeneralInterpretationAlgo
class	LayerClusterToCaloParticleAssociator
class	LayerClusterToCaloParticleAssociatorBaseImpl
class	LayerClusterToSimClusterAssociator
class	LayerClusterToSimClusterAssociatorBaseImpl
class	LayerClusterToSimTracksterAssociator
class	LayerClusterToSimTracksterAssociatorBaseImpl
struct	lcInfoInTrackster
class	LinkingAlgoBase
class	LinkingAlgoByDirectionGeometric
class	Node
class	PatternRecognitionAlgoBaseT
class	PatternRecognitionbyCA
class	PatternRecognitionbyCLUE3D
class	PatternRecognitionbyFastJet
class	PatternRecognitionbyPassthrough
class	SeedingRegionAlgoBase
class	SeedingRegionByHF
class	SeedingRegionByL1
class	SeedingRegionByTracks
class	SeedingRegionGlobal
struct	simClusterOnBLayer
struct	simClusterOnCLayer
struct	simTracksterOnLayer
class	SuperclusteringDNNInputV1
class	SuperclusteringDNNInputV2
class	TICLInterpretationAlgoBase
struct	TileConstants
struct	TileConstantsHFNose
class	Trackster
class	TracksterLinkingAlgoBase
class	TracksterLinkingbyFastJet
class	TracksterLinkingbySkeletons
class	TracksterLinkingbySuperClusteringDNN
class	TracksterLinkingbySuperClusteringMustache
class	TracksterLinkingPassthrough
class	TracksterMomentumPluginBase
class	TracksterP4FromEnergySum
class	TracksterP4FromTrackAndPCA
class	TracksterRecoTrackPlugin
class	TrackstersCache
class	TracksterToSimClusterAssociator
class	TracksterToSimClusterAssociatorBaseImpl
class	TracksterToSimTracksterAssociator
class	TracksterToSimTracksterAssociatorBaseImpl
class	TracksterToSimTracksterHitLCAssociator
class	TracksterToSimTracksterHitLCAssociatorBaseImpl
class	TracksterTrackPluginBase

Typedefs
typedef std::tuple< layerClusterToCaloParticle, caloParticleToLayerCluster >	association
typedef std::tuple< sharedEnergyAndScore_t, sharedEnergyAndScore_t >	association_t
typedef std::vector< std::vector< ticl::caloParticleOnLayer > >	caloParticleToLayerCluster
typedef std::vector< std::vector< std::pair< unsigned int, float > > >	layerClusterToCaloParticle
typedef std::vector< std::vector< std::pair< unsigned int, float > > >	layerClusterToSimCluster
typedef edm::AssociationMap< edm::OneToManyWithQualityGeneric< reco::CaloClusterCollection, CaloParticleCollection, float > >	RecoToSimCollection
typedef edm::AssociationMap< edm::OneToManyWithQualityGeneric< ticl::TracksterCollection, ticl::TracksterCollection, std::pair< float, float > > >	RecoToSimCollectionSimTracksters
typedef edm::AssociationMap< edm::OneToManyWithQualityGeneric< ticl::TracksterCollection, SimClusterCollection, float > >	RecoToSimCollectionTracksters
typedef edm::AssociationMap< edm::OneToManyWithQualityGeneric< reco::CaloClusterCollection, SimClusterCollection, float > >	RecoToSimCollectionWithSimClusters
typedef edm::AssociationMap< edm::OneToManyWithQualityGeneric< reco::CaloClusterCollection, ticl::TracksterCollection, float > >	RecoToSimTracksterCollection
typedef std::vector< std::vector< std::pair< float, float > > >	sharedEnergyAndScore_t
typedef std::vector< std::vector< ticl::simClusterOnCLayer > >	simClusterToLayerCluster
typedef std::vector< ticl::simClusterOnBLayer >	simClusterToTrackster
typedef edm::AssociationMap< edm::OneToManyWithQualityGeneric< CaloParticleCollection, reco::CaloClusterCollection, std::pair< float, float > > >	SimToRecoCollection
typedef edm::AssociationMap< edm::OneToManyWithQualityGeneric< ticl::TracksterCollection, ticl::TracksterCollection, std::pair< float, float > > >	SimToRecoCollectionSimTracksters
typedef edm::AssociationMap< edm::OneToManyWithQualityGeneric< SimClusterCollection, ticl::TracksterCollection, std::pair< float, float > > >	SimToRecoCollectionTracksters
typedef edm::AssociationMap< edm::OneToManyWithQualityGeneric< SimClusterCollection, reco::CaloClusterCollection, std::pair< float, float > > >	SimToRecoCollectionWithSimClusters
typedef edm::AssociationMap< edm::OneToManyWithQualityGeneric< ticl::TracksterCollection, reco::CaloClusterCollection, std::pair< float, float > > >	SimTracksterToRecoCollection
typedef std::vector< ticl::simTracksterOnLayer >	simTracksterToTrackster
typedef std::vector< std::pair< unsigned int, float > >	TICLClusterFilterMask
using	TICLLayerTile = TICLLayerTileT< TileConstants >
using	TICLLayerTileHFNose = TICLLayerTileT< TileConstantsHFNose >
using	Tiles = std::array< TICLLayerTile, TileConstants::nLayers >
using	TilesHFNose = std::array< TICLLayerTileHFNose, TileConstantsHFNose::nLayers >
typedef std::vector< Trackster >	TracksterCollection
using	TracksterTiles = std::array< TICLLayerTile, TileConstants::iterations >
using	TracksterTilesHFNose = std::array< TICLLayerTileHFNose, TileConstantsHFNose::iterations >
typedef std::vector< std::vector< std::pair< unsigned int, float > > >	tracksterToSimCluster
typedef std::vector< std::vector< std::pair< unsigned int, std::pair< float, float > > > >	tracksterToSimTrackster
typedef math::XYZVectorF	Vector

Enumerations
enum	validationType { Linking = 0, PatternRecognition, PatternRecognition_CP }
enum	VerbosityLevel {   None = 0, Basic, Advanced, Expert,   Guru }

Functions
template<class Vector1 , class Vector2 >
float	Angle2D (const Vector1 &v1, const Vector2 &v2)
void	assignPCAtoTracksters (std::vector< Trackster > &tracksters, const std::vector< reco::CaloCluster > &layerClusters, const edm::ValueMap< std::pair< float, float >> &layerClustersTime, double z_limit_em, hgcal::RecHitTools const &rhTools, bool computeLocalTime=false, bool energyWeight=true, bool clean=false, int minLayer=10, int maxLayer=10)
std::pair< float, float >	computeLocalTracksterTime (const Trackster &trackster, const std::vector< reco::CaloCluster > &layerClusters, const edm::ValueMap< std::pair< float, float >> &layerClustersTime, const Eigen::Vector3f &barycenter, size_t N)
std::pair< float, float >	computeTracksterTime (const Trackster &trackster, const edm::ValueMap< std::pair< float, float >> &layerClustersTime, size_t N)
template<class Vector1 , class Vector2 >
float	CosTheta2D (const Vector1 &v1, const Vector2 &v2)
unsigned	getLayerFromLC (const reco::CaloCluster &LC, const hgcal::RecHitTools &rhtools)
std::unique_ptr< AbstractSuperclusteringDNNInput >	makeSuperclusteringDNNInputFromString (std::string dnnVersion)
std::vector< std::vector< unsigned > >	sortByLayer (const Trackster &ts, const std::vector< reco::CaloCluster > &layerClusters, const hgcal::RecHitTools &rhtools)
Trackster::ParticleType	tracksterParticleTypeFromPdgId (int pdgId, int charge)

Variables
constexpr double	mpion = 0.13957
constexpr float	mpion2 = mpion * mpion

Detailed Description

Computation of input features for superclustering DNN. Used by plugins/TracksterLinkingBySuperClustering.cc and plugins/SuperclusteringSampleDumper.cc

Typedef Documentation

association

typedef std::tuple< tracksterToSimTrackster, simTracksterToTrackster > ticl::association

Definition at line 64 of file LCToCPAssociatorByEnergyScoreImpl.h.

association_t

typedef std::tuple<sharedEnergyAndScore_t, sharedEnergyAndScore_t> ticl::association_t

Definition at line 20 of file TracksterToSimTracksterHitLCAssociatorBaseImpl.h.

caloParticleToLayerCluster

typedef std::vector<std::vector<ticl::caloParticleOnLayer> > ticl::caloParticleToLayerCluster

Definition at line 60 of file LCToCPAssociatorByEnergyScoreImpl.h.

layerClusterToCaloParticle

typedef std::vector<std::vector<std::pair<unsigned int, float> > > ticl::layerClusterToCaloParticle

Definition at line 57 of file LCToCPAssociatorByEnergyScoreImpl.h.

layerClusterToSimCluster

typedef std::vector<std::vector<std::pair<unsigned int, float> > > ticl::layerClusterToSimCluster

Definition at line 54 of file LCToSCAssociatorByEnergyScoreImpl.h.

RecoToSimCollection

typedef edm::AssociationMap< edm::OneToManyWithQualityGeneric<reco::CaloClusterCollection, CaloParticleCollection, float> > ticl::RecoToSimCollection

Definition at line 26 of file LayerClusterToCaloParticleAssociatorBaseImpl.h.

RecoToSimCollectionSimTracksters

typedef SimToRecoCollectionSimTracksters ticl::RecoToSimCollectionSimTracksters

Definition at line 27 of file TracksterToSimTracksterAssociatorBaseImpl.h.

RecoToSimCollectionTracksters

typedef edm::AssociationMap<edm::OneToManyWithQualityGeneric<ticl::TracksterCollection, SimClusterCollection, float> > ticl::RecoToSimCollectionTracksters

Definition at line 26 of file TracksterToSimClusterAssociatorBaseImpl.h.

RecoToSimCollectionWithSimClusters

typedef edm::AssociationMap<edm::OneToManyWithQualityGeneric<reco::CaloClusterCollection, SimClusterCollection, float> > ticl::RecoToSimCollectionWithSimClusters

Definition at line 25 of file LayerClusterToSimClusterAssociatorBaseImpl.h.

RecoToSimTracksterCollection

typedef edm::AssociationMap< edm::OneToManyWithQualityGeneric<reco::CaloClusterCollection, ticl::TracksterCollection, float> > ticl::RecoToSimTracksterCollection

Definition at line 30 of file LayerClusterToSimTracksterAssociatorBaseImpl.h.

sharedEnergyAndScore_t

typedef std::vector<std::vector<std::pair<float, float> > > ticl::sharedEnergyAndScore_t

Definition at line 17 of file TracksterToSimTracksterHitLCAssociatorBaseImpl.h.

simClusterToLayerCluster

typedef std::vector<std::vector<ticl::simClusterOnCLayer> > ticl::simClusterToLayerCluster

Definition at line 57 of file LCToSCAssociatorByEnergyScoreImpl.h.

simClusterToTrackster

typedef std::vector<ticl::simClusterOnBLayer> ticl::simClusterToTrackster

Definition at line 36 of file TSToSCAssociatorByEnergyScoreImpl.h.

SimToRecoCollection

typedef edm::AssociationMap< edm::OneToManyWithQualityGeneric<CaloParticleCollection, reco::CaloClusterCollection, std::pair<float, float> > > ticl::SimToRecoCollection

Definition at line 23 of file LayerClusterToCaloParticleAssociatorBaseImpl.h.

SimToRecoCollectionSimTracksters

typedef edm::AssociationMap< edm::OneToManyWithQualityGeneric< ticl::TracksterCollection, ticl::TracksterCollection, std::pair< float, float > > > ticl::SimToRecoCollectionSimTracksters

Definition at line 24 of file TracksterToSimTracksterAssociatorBaseImpl.h.

SimToRecoCollectionTracksters

typedef edm::AssociationMap< edm::OneToManyWithQualityGeneric<SimClusterCollection, ticl::TracksterCollection, std::pair<float, float> > > ticl::SimToRecoCollectionTracksters

Definition at line 24 of file TracksterToSimClusterAssociatorBaseImpl.h.

SimToRecoCollectionWithSimClusters

typedef edm::AssociationMap< edm::OneToManyWithQualityGeneric<SimClusterCollection, reco::CaloClusterCollection, std::pair<float, float> > > ticl::SimToRecoCollectionWithSimClusters

Definition at line 23 of file LayerClusterToSimClusterAssociatorBaseImpl.h.

SimTracksterToRecoCollection

typedef edm::AssociationMap< edm::OneToManyWithQualityGeneric<ticl::TracksterCollection, reco::CaloClusterCollection, std::pair<float, float> > > ticl::SimTracksterToRecoCollection

Definition at line 27 of file LayerClusterToSimTracksterAssociatorBaseImpl.h.

simTracksterToTrackster

typedef std::vector<ticl::simTracksterOnLayer> ticl::simTracksterToTrackster

Definition at line 62 of file TSToSimTSAssociatorByEnergyScoreImpl.h.

TICLClusterFilterMask

typedef std::vector<std::pair<unsigned int, float> > ticl::TICLClusterFilterMask

Definition at line 34 of file Common.h.

TICLLayerTile

using ticl::TICLLayerTile = typedef TICLLayerTileT<TileConstants>

Definition at line 78 of file TICLLayerTile.h.

TICLLayerTileHFNose

using ticl::TICLLayerTileHFNose = typedef TICLLayerTileT<TileConstantsHFNose>

Definition at line 82 of file TICLLayerTile.h.

Tiles

using ticl::Tiles = typedef std::array<TICLLayerTile, TileConstants::nLayers>

Definition at line 79 of file TICLLayerTile.h.

TilesHFNose

using ticl::TilesHFNose = typedef std::array<TICLLayerTileHFNose, TileConstantsHFNose::nLayers>

Definition at line 83 of file TICLLayerTile.h.

TracksterCollection

typedef std::vector<Trackster> ticl::TracksterCollection

Definition at line 254 of file Trackster.h.

TracksterTiles

using ticl::TracksterTiles = typedef std::array<TICLLayerTile, TileConstants::iterations>

Definition at line 80 of file TICLLayerTile.h.

TracksterTilesHFNose

using ticl::TracksterTilesHFNose = typedef std::array<TICLLayerTileHFNose, TileConstantsHFNose::iterations>

Definition at line 84 of file TICLLayerTile.h.

tracksterToSimCluster

typedef std::vector<std::vector<std::pair<unsigned int, float> > > ticl::tracksterToSimCluster

Definition at line 35 of file TSToSCAssociatorByEnergyScoreImpl.h.

tracksterToSimTrackster

typedef std::vector<std::vector<std::pair<unsigned int, std::pair<float, float> > > > ticl::tracksterToSimTrackster

Definition at line 59 of file TSToSimTSAssociatorByEnergyScoreImpl.h.

Vector

typedef math::XYZVectorF ticl::Vector

Definition at line 42 of file Common.h.

Enumeration Type Documentation

validationType

enum ticl::validationType

Enumerator
Linking
PatternRecognition
PatternRecognition_CP

Definition at line 15 of file TracksterToSimTracksterHitLCAssociatorBaseImpl.h.

{ Linking = 0, PatternRecognition, PatternRecognition_CP };

VerbosityLevel

enum ticl::VerbosityLevel

Enumerator
None
Basic
Advanced
Expert
Guru

Definition at line 71 of file Common.h.

{ None = 0, Basic, Advanced, Expert, Guru };

Function Documentation

Angle2D()

template<class Vector1 , class Vector2 >

float ticl::Angle2D ( const Vector1 &  v1, const Vector2 &  v2  )

inline

Definition at line 59 of file SuperclusteringDNNInputs.cc.

References CosTheta2D().

Referenced by ticl::SuperclusteringDNNInputV2::computeVector().

                                                             {
    return static_cast<float>(std::acos(CosTheta2D(v1, v2)));
  }

assignPCAtoTracksters()

void ticl::assignPCAtoTracksters	(	std::vector< Trackster > &	tracksters,
		const std::vector< reco::CaloCluster > &	layerClusters,
		const edm::ValueMap< std::pair< float, float >> &	layerClustersTime,
		double	z_limit_em,
		hgcal::RecHitTools const &	rhTools,
		bool	computeLocalTime = false,
		bool	energyWeight = true,
		bool	clean = false,
		int	minLayer = 10,
		int	maxLayer = 10
	)

Computes the trackster raw energy, barycenter, timing, PCA. PCA is computed using layer cluster positions (and energies if energyWeight=True) In case clean=True: Only the most energetic layer cluster on each layer is considered, and only layers in range around the most energetic layer cluster

Parameters

z_limit_em	Limit between EM and HAD section (in absolute value)
energyWeight	Compute energy-weighted barycenter and PCA
clean	Use the PCA cleaning algorithm.
minLayer	Number of layers to consider for cleaned PCA behind the most energetic LC
maxLayer	Number of layers to consider for cleaned PCA after the most energetic LC

< Number of layer clusters in trackster

Definition at line 14 of file TrackstersPCA.cc.

References funct::abs(), ticl::Trackster::ascending, DummyCfis::c, clean(), hltHGCalUncalibRecHit_cfi::computeLocalTime, computeLocalTracksterTime(), computeTracksterTime(), HLT_2024v14_cff::distance, f, HLT_2024v14_cff::fraction, getLayerFromLC(), mps_fire::i, dqmiolumiharvest::j, hgcal::RecHitTools::lastLayer(), hltEgammaHGCALIDVarsL1Seeded_cfi::layerClusters, LogDebug, HLT_2024v14_cff::minLayer, N, point, sortByLayer(), Success, mps_merge::weight, x, and detailsBasic3DVector::y.

Referenced by ticl::PatternRecognitionbyCLUE3D< TILES >::makeTracksters(), ticl::PatternRecognitionbyPassthrough< TILES >::makeTracksters(), ticl::PatternRecognitionbyCA< TILES >::makeTracksters(), ticl::PatternRecognitionbyFastJet< TILES >::makeTracksters(), TracksterLinksProducer::produce(), TrackstersMergeProducer::produce(), SimTrackstersProducer::produce(), and TICLCandidateProducer::produce().

                                               {
  LogDebug("TrackstersPCA_Eigen") << "------- Eigen -------" << std::endl;

  for (auto &trackster : tracksters) {
    LogDebug("TrackstersPCA_Eigen") << "start testing teackster with size:" << trackster.vertices().size() << std::endl;

    Eigen::Vector3f point;
    point << 0., 0., 0.;
    Eigen::Vector3f barycenter;
    barycenter << 0., 0., 0.;
    Eigen::Vector3f filtered_barycenter;
    filtered_barycenter << 0., 0., 0.;

    auto fillPoint = [&](const reco::CaloCluster &c, const float weight = 1.f) {
      point[0] = weight * c.x();
      point[1] = weight * c.y();
      point[2] = weight * c.z();
    };

    // Initialize this trackster with default, dummy values
    trackster.setRawEnergy(0.f);
    trackster.setRawEmEnergy(0.f);
    trackster.setRawPt(0.f);
    trackster.setRawEmPt(0.f);

    size_t N = trackster.vertices().size();  
    if (N == 0)
      continue;
    float weight = 1.f / N;
    float weights2_sum = 0.f;

    std::vector<float> layerClusterEnergies;

    for (size_t i = 0; i < N; ++i) {
      auto fraction = 1.f / trackster.vertex_multiplicity(i);
      trackster.addToRawEnergy(layerClusters[trackster.vertices(i)].energy() * fraction);
      if (std::abs(layerClusters[trackster.vertices(i)].z()) <= z_limit_em)
        trackster.addToRawEmEnergy(layerClusters[trackster.vertices(i)].energy() * fraction);

      // Compute the weighted barycenter.
      if (energyWeight)
        weight = layerClusters[trackster.vertices(i)].energy() * fraction;
      fillPoint(layerClusters[trackster.vertices(i)], weight);
      for (size_t j = 0; j < 3; ++j)
        barycenter[j] += point[j];

      layerClusterEnergies.push_back(layerClusters[trackster.vertices(i)].energy());
    }
    float raw_energy = trackster.raw_energy();
    float inv_raw_energy = 1.f / raw_energy;
    if (energyWeight)
      barycenter *= inv_raw_energy;
    trackster.setBarycenter(ticl::Trackster::Vector(barycenter));

    LogDebug("TrackstersPCA_Eigen") << "cleaning is  :" << clean << std::endl;

    std::vector<unsigned> filtered_idx;  // indices of layer clusters to consider for cleaned PCA
    float filtered_energy = 0;
    float inv_filtered_energy = 0;
    if (clean) {
      // Filter layerclusters for the cleaned PCA
      auto maxE_vertex = std::distance(layerClusterEnergies.begin(),
                                       std::max_element(layerClusterEnergies.begin(), layerClusterEnergies.end()));
      auto maxE_layer = getLayerFromLC(layerClusters[trackster.vertices(maxE_vertex)], rhtools);

      auto vertices_by_layer = sortByLayer(trackster, layerClusters, rhtools);

      for (unsigned i = 1; i <= rhtools.lastLayer(); ++i) {
        auto vertices_in_layer = vertices_by_layer[i];
        if (vertices_in_layer.empty())
          continue;

        std::vector<float> energies_in_layer;
        for (auto vrt : vertices_in_layer)
          energies_in_layer.push_back(layerClusters[trackster.vertices(vrt)].energy());

        unsigned maxEid_inLayer = std::distance(energies_in_layer.begin(),
                                                std::max_element(energies_in_layer.begin(), energies_in_layer.end()));

        // layer based filtering of what goes into the PCA
        if ((int)i >= (int)maxE_layer - minLayer && (int)i <= (int)maxE_layer + maxLayer) {
          auto filtered_vert = vertices_in_layer[maxEid_inLayer];
          filtered_idx.push_back(filtered_vert);

          const auto &maxE_LC = layerClusters[trackster.vertices(filtered_vert)];
          fillPoint(maxE_LC, maxE_LC.energy() * (1.f / trackster.vertex_multiplicity(filtered_vert)));
          for (size_t j = 0; j < 3; ++j)
            filtered_barycenter[j] += point[j];
          filtered_energy += maxE_LC.energy();
        }
      }
      inv_filtered_energy = 1. / filtered_energy;
      filtered_barycenter *= inv_filtered_energy;
    }
    LogDebug("TrackstersPCA_Eigen") << "min, max " << minLayer << "  " << maxLayer << std::endl;

    std::pair<float, float> timeTrackster;
    if (computeLocalTime)
      timeTrackster = ticl::computeLocalTracksterTime(trackster, layerClusters, layerClustersTime, barycenter, N);
    else
      timeTrackster = ticl::computeTracksterTime(trackster, layerClustersTime, N);

    trackster.setTimeAndError(timeTrackster.first, timeTrackster.second);
    LogDebug("TrackstersPCA") << "Use energy weighting: " << energyWeight << std::endl;
    LogDebug("TrackstersPCA") << "\nTrackster characteristics: " << std::endl;
    LogDebug("TrackstersPCA") << "Size: " << N << std::endl;
    LogDebug("TrackstersPCA") << "Energy: " << trackster.raw_energy() << std::endl;
    LogDebug("TrackstersPCA") << "raw_pt: " << trackster.raw_pt() << std::endl;
    LogDebug("TrackstersPCA") << "Means:          " << barycenter[0] << ", " << barycenter[1] << ", " << barycenter[2]
                              << std::endl;
    LogDebug("TrackstersPCA") << "Time:          " << trackster.time() << " +/- " << trackster.timeError() << std::endl;

    if (N > 2) {
      Eigen::Vector3f sigmas;
      sigmas << 0., 0., 0.;
      Eigen::Vector3f sigmasEigen;
      sigmasEigen << 0., 0., 0.;
      Eigen::Matrix3f covM = Eigen::Matrix3f::Zero();
      // Compute the Covariance Matrix and the sum of the squared weights, used
      // to compute the correct normalization.
      // The barycenter has to be known.

      auto calc_covM = [&](size_t i) {
        fillPoint(layerClusters[trackster.vertices(i)]);
        if (energyWeight && trackster.raw_energy()) {
          weight = (layerClusters[trackster.vertices(i)].energy() / trackster.vertex_multiplicity(i)) *
                   (clean ? inv_filtered_energy : inv_raw_energy);
          if (trackster.vertex_multiplicity(i) > 1)
            LogDebug("TrackstersPCA_Eigen")
                << "trackster.vertex_multiplicity(i)   :" << trackster.vertex_multiplicity(i);
        }
        weights2_sum += weight * weight;
        for (size_t x = 0; x < 3; ++x) {
          for (size_t y = 0; y <= x; ++y) {
            covM(x, y) += weight * (point[x] - (clean ? filtered_barycenter[x] : barycenter[x])) *
                          (point[y] - (clean ? filtered_barycenter[y] : barycenter[y]));
            covM(y, x) = covM(x, y);
          }
        }
      };
      if (clean) {
        for (size_t i : filtered_idx) {
          calc_covM(i);
        }
      } else {
        for (size_t i = 0; i < N; ++i) {
          calc_covM(i);
        }
      }

      covM *= 1.f / (1.f - weights2_sum);

      // Perform the actual decomposition
      Eigen::SelfAdjointEigenSolver<Eigen::Matrix3f>::RealVectorType eigenvalues_fromEigen;
      Eigen::SelfAdjointEigenSolver<Eigen::Matrix3f>::EigenvectorsType eigenvectors_fromEigen;
      Eigen::SelfAdjointEigenSolver<Eigen::Matrix3f> eigensolver(covM);
      if (eigensolver.info() != Eigen::Success) {
        eigenvalues_fromEigen = eigenvalues_fromEigen.Zero();
        eigenvectors_fromEigen = eigenvectors_fromEigen.Zero();
      } else {
        eigenvalues_fromEigen = eigensolver.eigenvalues();
        eigenvectors_fromEigen = eigensolver.eigenvectors();
      }

      // Compute the spread in the both spaces.
      auto calc_spread = [&](size_t i) {
        fillPoint(layerClusters[trackster.vertices(i)]);
        sigmas += weight * (point - (clean ? filtered_barycenter : barycenter)).cwiseAbs2();
        Eigen::Vector3f point_transformed =
            eigenvectors_fromEigen * (point - (clean ? filtered_barycenter : barycenter));
        if (energyWeight && raw_energy)
          weight = (layerClusters[trackster.vertices(i)].energy() / trackster.vertex_multiplicity(i)) *
                   (clean ? inv_filtered_energy : inv_raw_energy);
        sigmasEigen += weight * (point_transformed.cwiseAbs2());
      };

      if (clean) {
        for (size_t i : filtered_idx) {
          calc_spread(i);
        }
      } else {
        for (size_t i = 0; i < N; ++i) {
          calc_spread(i);
        }
      }

      sigmas /= (1.f - weights2_sum);
      sigmasEigen /= (1.f - weights2_sum);

      trackster.fillPCAVariables(eigenvalues_fromEigen,
                                 eigenvectors_fromEigen,
                                 sigmas,
                                 sigmasEigen,
                                 3,
                                 ticl::Trackster::PCAOrdering::ascending);

      LogDebug("TrackstersPCA") << "EigenValues from Eigen/Tr(cov): " << eigenvalues_fromEigen[2] / covM.trace() << ", "
                                << eigenvalues_fromEigen[1] / covM.trace() << ", "
                                << eigenvalues_fromEigen[0] / covM.trace() << std::endl;
      LogDebug("TrackstersPCA") << "EigenValues from Eigen:         " << eigenvalues_fromEigen[2] << ", "
                                << eigenvalues_fromEigen[1] << ", " << eigenvalues_fromEigen[0] << std::endl;
      LogDebug("TrackstersPCA") << "EigenVector 3 from Eigen: " << eigenvectors_fromEigen(0, 2) << ", "
                                << eigenvectors_fromEigen(1, 2) << ", " << eigenvectors_fromEigen(2, 2) << std::endl;
      LogDebug("TrackstersPCA") << "EigenVector 2 from Eigen: " << eigenvectors_fromEigen(0, 1) << ", "
                                << eigenvectors_fromEigen(1, 1) << ", " << eigenvectors_fromEigen(2, 1) << std::endl;
      LogDebug("TrackstersPCA") << "EigenVector 1 from Eigen: " << eigenvectors_fromEigen(0, 0) << ", "
                                << eigenvectors_fromEigen(1, 0) << ", " << eigenvectors_fromEigen(2, 0) << std::endl;
      LogDebug("TrackstersPCA") << "Original sigmas:          " << sigmas[0] << ", " << sigmas[1] << ", " << sigmas[2]
                                << std::endl;
      LogDebug("TrackstersPCA") << "SigmasEigen in PCA space: " << sigmasEigen[2] << ", " << sigmasEigen[1] << ", "
                                << sigmasEigen[0] << std::endl;
      LogDebug("TrackstersPCA") << "covM:     \n" << covM << std::endl;
    }
  }
}

computeLocalTracksterTime()

std::pair< float, float > ticl::computeLocalTracksterTime	(	const Trackster &	trackster,
		const std::vector< reco::CaloCluster > &	layerClusters,
		const edm::ValueMap< std::pair< float, float >> &	layerClustersTime,
		const Eigen::Vector3f &	barycenter,
		size_t	N
	)

Definition at line 239 of file TrackstersPCA.cc.

References funct::abs(), DummyCfis::c, ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), HLT_2024v14_cff::distance, f, dqmdumpme::first, mps_fire::i, hltEgammaHGCALIDVarsL1Seeded_cfi::layerClusters, N, point, funct::pow(), edm::second(), mathSSE::sqrt(), hcalRecHitTable_cff::time, ticl::Trackster::vertices(), x, detailsBasic3DVector::y, and detailsBasic3DVector::z.

Referenced by assignPCAtoTracksters().

                                                                  {
  float tracksterTime = 0.;
  float tracksterTimeErr = 0.;
  std::set<uint32_t> usedLC;

  auto project_lc_to_pca = [](const std::vector<double> &point, const std::vector<double> &segment_end) {
    double dot_product = 0.0;
    double segment_dot = 0.0;

    for (int i = 0; i < 3; ++i) {
      dot_product += point[i] * segment_end[i];
      segment_dot += segment_end[i] * segment_end[i];
    }

    double projection = 0.0;
    if (segment_dot != 0.0) {
      projection = dot_product / segment_dot;
    }

    std::vector<double> closest_point(3);
    for (int i = 0; i < 3; ++i) {
      closest_point[i] = projection * segment_end[i];
    }

    double distance = 0.0;
    for (int i = 0; i < 3; ++i) {
      distance += std::pow(point[i] - closest_point[i], 2);
    }

    return std::sqrt(distance);
  };

  constexpr double c = 29.9792458;  // cm/ns
  for (size_t i = 0; i < N; ++i) {
    // Add timing from layerClusters not already used
    if ((usedLC.insert(trackster.vertices(i))).second) {
      float timeE = layerClustersTime.get(trackster.vertices(i)).second;
      if (timeE > 0.f) {
        float time = layerClustersTime.get(trackster.vertices(i)).first;
        timeE = 1.f / pow(timeE, 2);
        float x = layerClusters[trackster.vertices(i)].x();
        float y = layerClusters[trackster.vertices(i)].y();
        float z = layerClusters[trackster.vertices(i)].z();

        if (project_lc_to_pca({x, y, z}, {barycenter[0], barycenter[1], barycenter[2]}) < 3) {  // set MR to 3
          float deltaT = 1.f / c *
                         std::sqrt(((barycenter[2] / z - 1.f) * x) * ((barycenter[2] / z - 1.f) * x) +
                                   ((barycenter[2] / z - 1.f) * y) * ((barycenter[2] / z - 1.f) * y) +
                                   (barycenter[2] - z) * (barycenter[2] - z));
          time = std::abs(barycenter[2]) < std::abs(z) ? time - deltaT : time + deltaT;

          tracksterTime += time * timeE;
          tracksterTimeErr += timeE;
        }
      }
    }
  }
  if (tracksterTimeErr > 0.f)
    return {tracksterTime / tracksterTimeErr, 1.f / std::sqrt(tracksterTimeErr)};
  else
    return {-99.f, -1.f};
}

computeTracksterTime()

std::pair< float, float > ticl::computeTracksterTime	(	const Trackster &	trackster,
		const edm::ValueMap< std::pair< float, float >> &	layerClustersTime,
		size_t	N
	)

Definition at line 306 of file TrackstersPCA.cc.

References f, dqmdumpme::first, hgcalsimclustertime::ComputeClusterTime::fixSizeHighestDensity(), mps_fire::i, N, funct::pow(), edm::second(), and ticl::Trackster::vertices().

Referenced by assignPCAtoTracksters().

                                                             {
  std::vector<float> times;
  std::vector<float> timeErrors;
  std::set<uint32_t> usedLC;

  for (size_t i = 0; i < N; ++i) {
    // Add timing from layerClusters not already used
    if ((usedLC.insert(trackster.vertices(i))).second) {
      float timeE = layerClustersTime.get(trackster.vertices(i)).second;
      if (timeE > 0.f) {
        times.push_back(layerClustersTime.get(trackster.vertices(i)).first);
        timeErrors.push_back(1.f / pow(timeE, 2));
      }
    }
  }

  hgcalsimclustertime::ComputeClusterTime timeEstimator;
  return timeEstimator.fixSizeHighestDensity(times, timeErrors);
}

CosTheta2D()

template<class Vector1 , class Vector2 >

float ticl::CosTheta2D	(	const Vector1 &	v1,
		const Vector2 &	v2
	)

Definition at line 40 of file SuperclusteringDNNInputs.cc.

References mathSSE::sqrt().

Referenced by Angle2D().

                                                         {
    float arg;
    float v1_r2 = v1.X() * v1.X() + v1.Y() * v1.Y();
    float v2_r2 = v2.X() * v2.X() + v2.Y() * v2.Y();
    float ptot2 = v1_r2 * v2_r2;
    if (ptot2 <= 0) {
      arg = 0.0;
    } else {
      float pdot = v1.X() * v2.X() + v1.Y() * v2.Y();
      using std::sqrt;
      arg = pdot / sqrt(ptot2);
      if (arg > 1.0)
        arg = 1.0;
      if (arg < -1.0)
        arg = -1.0;
    }
    return arg;
  }

getLayerFromLC()

unsigned ticl::getLayerFromLC ( const reco::CaloCluster &  LC, const hgcal::RecHitTools &  rhtools  )

inline

Definition at line 40 of file TrackstersPCA.h.

References dqmdumpme::first, hgcal::RecHitTools::getLayerWithOffset(), and reco::CaloCluster::hitsAndFractions().

Referenced by assignPCAtoTracksters(), and sortByLayer().

                                                                                             {
    std::vector<std::pair<DetId, float>> thisclusterHits = LC.hitsAndFractions();
    auto layer = rhtools.getLayerWithOffset(thisclusterHits[0].first);
    return layer;
  }

makeSuperclusteringDNNInputFromString()

std::unique_ptr< AbstractSuperclusteringDNNInput > ticl::makeSuperclusteringDNNInputFromString

(

std::string

dnnVersion

)

Definition at line 108 of file SuperclusteringDNNInputs.cc.

References cms::cuda::assert().

                                                                                                                  {
    if (dnnInputVersion == "v1")
      return std::make_unique<SuperclusteringDNNInputV1>();
    else if (dnnInputVersion == "v2")
      return std::make_unique<SuperclusteringDNNInputV2>();
    assert(false);
  }

sortByLayer()

std::vector<std::vector<unsigned> > ticl::sortByLayer ( const Trackster &  ts, const std::vector< reco::CaloCluster > &  layerClusters, const hgcal::RecHitTools &  rhtools  )

inline

Definition at line 47 of file TrackstersPCA.h.

References getLayerFromLC(), mps_fire::i, hgcal::RecHitTools::lastLayer(), hltEgammaHGCALIDVarsL1Seeded_cfi::layerClusters, N, mps_fire::result, and ticl::Trackster::vertices().

Referenced by assignPCAtoTracksters().

                                                                                         {
    size_t N = ts.vertices().size();

    std::vector<std::vector<unsigned>> result;
    result.resize(rhtools.lastLayer() + 1);

    for (unsigned i = 0; i < N; ++i) {
      const auto &thisLC = layerClusters[ts.vertices(i)];
      auto layer = getLayerFromLC(thisLC, rhtools);
      result[layer].push_back(i);
    }
    return result;
  }

tracksterParticleTypeFromPdgId()

Trackster::ParticleType ticl::tracksterParticleTypeFromPdgId ( int  pdgId, int  charge  )

inline

Definition at line 44 of file Common.h.

References funct::abs(), ALCARECOTkAlJpsiMuMu_cff::charge, ticl::Trackster::charged_hadron, ticl::Trackster::electron, ticl::Trackster::muon, ticl::Trackster::neutral_hadron, ticl::Trackster::neutral_pion, EgammaValidation_cff::pdgId, ticl::Trackster::photon, and ticl::Trackster::unknown.

Referenced by SimTrackstersProducer::addTrackster(), TICLCandidateValidator::fillCandidateHistos(), and SimTrackstersProducer::produce().

                                                                                     {
    if (pdgId == 111) {
      return Trackster::ParticleType::neutral_pion;
    } else {
      pdgId = std::abs(pdgId);
      if (pdgId == 22) {
        return Trackster::ParticleType::photon;
      } else if (pdgId == 11) {
        return Trackster::ParticleType::electron;
      } else if (pdgId == 13) {
        return Trackster::ParticleType::muon;
      } else {
        bool isHadron = (pdgId > 100 and pdgId < 900) or (pdgId > 1000 and pdgId < 9000);
        if (isHadron) {
          if (charge != 0) {
            return Trackster::ParticleType::charged_hadron;
          } else {
            return Trackster::ParticleType::neutral_hadron;
          }
        } else {
          return Trackster::ParticleType::unknown;
        }
      }
    }
  }

Variable Documentation

mpion

constexpr double ticl::mpion = 0.13957

Definition at line 40 of file Common.h.

Referenced by TrackstersMergeProducer::produce().

mpion2

constexpr float ticl::mpion2 = mpion * mpion

Definition at line 41 of file Common.h.

Referenced by filterTracks(), ticl::LinkingAlgoByDirectionGeometric::linkTracksters(), TICLCandidateFromTrackstersProducer::produce(), SimPFProducer::produce(), TrackstersMergeProducer::produce(), and ticl::TracksterP4FromTrackAndPCA::setP4().