ticl Namespace Reference

Classes
class	CacheBase
class	ClusterFilterBase
class	ClusterFilterByAlgo
class	ClusterFilterByAlgoAndSize
class	ClusterFilterByAlgoAndSizeAndLayerRange
class	ClusterFilterBySize
class	LinkingAlgoBase
class	LinkingAlgoByDirectionGeometric
class	PatternRecognitionAlgoBaseT
class	PatternRecognitionbyCA
class	PatternRecognitionbyCLUE3D
class	PatternRecognitionbyFastJet
class	PatternRecognitionbyMultiClusters
class	SeedingRegionAlgoBase
class	SeedingRegionByHF
class	SeedingRegionByL1
class	SeedingRegionByTracks
class	SeedingRegionGlobal
struct	TileConstants
struct	TileConstantsHFNose
class	Trackster
class	TracksterMomentumPluginBase
class	TracksterP4FromEnergySum
class	TracksterP4FromTrackAndPCA
class	TracksterRecoTrackPlugin
class	TrackstersCache
class	TracksterTrackPluginBase

Typedefs
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 math::XYZVectorF	Vector

Enumerations
enum	VerbosityLevel {   None = 0, Basic, Advanced, Expert,   Guru }

Functions
void	assignPCAtoTracksters (std::vector< Trackster > &, const std::vector< reco::CaloCluster > &, const edm::ValueMap< std::pair< float, float >> &, double, bool energyWeight=true)
Trackster::ParticleType	tracksterParticleTypeFromPdgId (int pdgId, int charge)

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

Typedef Documentation

TICLClusterFilterMask

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

Definition at line 32 of file Common.h.

TICLLayerTile

using ticl::TICLLayerTile = typedef TICLLayerTileT<TileConstants>

Definition at line 80 of file TICLLayerTile.h.

TICLLayerTileHFNose

using ticl::TICLLayerTileHFNose = typedef TICLLayerTileT<TileConstantsHFNose>

Definition at line 84 of file TICLLayerTile.h.

Tiles

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

Definition at line 81 of file TICLLayerTile.h.

TilesHFNose

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

Definition at line 85 of file TICLLayerTile.h.

TracksterCollection

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

Definition at line 199 of file Trackster.h.

TracksterTiles

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

Definition at line 82 of file TICLLayerTile.h.

TracksterTilesHFNose

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

Definition at line 86 of file TICLLayerTile.h.

Vector

typedef math::XYZVectorF ticl::Vector

Definition at line 14 of file commons.h.

Enumeration Type Documentation

VerbosityLevel

enum ticl::VerbosityLevel

Enumerator
None
Basic
Advanced
Expert
Guru

Definition at line 43 of file commons.h.

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

Function Documentation

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,
		bool	energyWeight = true
	)

Definition at line 12 of file TrackstersPCA.cc.

References funct::abs(), ticl::Trackster::ascending, HltBtagPostValidation_cff::c, f, dqmdumpme::first, hgcalsimclustertime::ComputeClusterTime::fixSizeHighestDensity(), HLT_2024v14_cff::fraction, mps_fire::i, dqmiolumiharvest::j, hltEgammaHGCALIDVarsL1Seeded_cfi::layerClusters, LogDebug, N, point, funct::pow(), edm::second(), Success, mps_merge::weight, x, and detailsBasic3DVector::y.

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

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

  for (auto &trackster : tracksters) {
    Eigen::Vector3d point;
    point << 0., 0., 0.;
    Eigen::Vector3d barycenter;
    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();
    float weight = 1.f / N;
    float weights2_sum = 0.f;
    Eigen::Vector3d sigmas;
    sigmas << 0., 0., 0.;
    Eigen::Vector3d sigmasEigen;
    sigmasEigen << 0., 0., 0.;
    Eigen::Matrix3d covM = Eigen::Matrix3d::Zero();

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

    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];

      // 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. / pow(timeE, 2));
        }
      }
    }
    if (energyWeight && trackster.raw_energy())
      barycenter /= trackster.raw_energy();

    hgcalsimclustertime::ComputeClusterTime timeEstimator;
    std::pair<float, float> timeTrackster = timeEstimator.fixSizeHighestDensity(times, timeErrors);

    // Compute the Covariance Matrix and the sum of the squared weights, used
    // to compute the correct normalization.
    // The barycenter has to be known.
    for (size_t i = 0; i < N; ++i) {
      fillPoint(layerClusters[trackster.vertices(i)]);
      if (energyWeight && trackster.raw_energy())
        weight =
            (layerClusters[trackster.vertices(i)].energy() / trackster.vertex_multiplicity(i)) / trackster.raw_energy();
      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] - barycenter[x]) * (point[y] - barycenter[y]);
          covM(y, x) = covM(x, y);
        }
    }
    covM *= 1. / (1. - weights2_sum);

    // Perform the actual decomposition
    Eigen::SelfAdjointEigenSolver<Eigen::Matrix3d>::RealVectorType eigenvalues_fromEigen;
    Eigen::SelfAdjointEigenSolver<Eigen::Matrix3d>::EigenvectorsType eigenvectors_fromEigen;
    Eigen::SelfAdjointEigenSolver<Eigen::Matrix3d> 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.
    for (size_t i = 0; i < N; ++i) {
      fillPoint(layerClusters[trackster.vertices(i)]);
      sigmas += weight * (point - barycenter).cwiseAbs2();
      Eigen::Vector3d point_transformed = eigenvectors_fromEigen * (point - barycenter);
      if (energyWeight && trackster.raw_energy())
        weight =
            (layerClusters[trackster.vertices(i)].energy() / trackster.vertex_multiplicity(i)) / trackster.raw_energy();
      sigmasEigen += weight * (point_transformed.cwiseAbs2());
    }
    sigmas /= (1. - weights2_sum);
    sigmasEigen /= (1. - weights2_sum);

    // Add trackster attributes
    trackster.setBarycenter(ticl::Trackster::Vector(barycenter));
    trackster.setTimeAndError(timeTrackster.first, timeTrackster.second);
    trackster.fillPCAVariables(
        eigenvalues_fromEigen, eigenvectors_fromEigen, sigmas, sigmasEigen, 3, ticl::Trackster::PCAOrdering::ascending);

    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;
    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;
  }
}

tracksterParticleTypeFromPdgId()

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

inline

Definition at line 16 of file commons.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(), 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 12 of file commons.h.

Referenced by TrackstersMergeProducerV3::produce(), and TrackstersMergeProducer::produce().

mpion2

constexpr float ticl::mpion2 = mpion * mpion

Definition at line 13 of file commons.h.

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