CMS 3D CMS Logo
Classes | Typedefs | Functions
ticl Namespace Reference

Classes

class  CacheBase
 
class  ClusterFilterBase
 
class  ClusterFilterByAlgo
 
class  ClusterFilterByAlgoAndSize
 
class  ClusterFilterByAlgoAndSizeAndLayerRange
 
class  ClusterFilterBySize
 
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 > > HgcalClusterFilterMask
 
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 >
 

Functions

static void addTrackster (const int &index, const std::vector< std::pair< edm::Ref< reco::CaloClusterCollection >, std::pair< float, float >>> &lcVec, const std::vector< float > &inputClusterMask, const float &fractionCut_, const float &energy, const int &pdgId, const int &charge, const edm::ProductID &seed, const Trackster::IterationIndex iter, std::vector< float > &output_mask, std::vector< Trackster > &result)
 
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)
 

Typedef Documentation

◆ HgcalClusterFilterMask

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

Definition at line 32 of file Common.h.

◆ TICLLayerTile

using ticl::TICLLayerTile = typedef TICLLayerTileT<TileConstants>

Definition at line 69 of file TICLLayerTile.h.

◆ TICLLayerTileHFNose

using ticl::TICLLayerTileHFNose = typedef TICLLayerTileT<TileConstantsHFNose>

Definition at line 73 of file TICLLayerTile.h.

◆ Tiles

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

Definition at line 70 of file TICLLayerTile.h.

◆ TilesHFNose

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

Definition at line 74 of file TICLLayerTile.h.

◆ TracksterCollection

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

Definition at line 203 of file Trackster.h.

◆ TracksterTiles

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

Definition at line 71 of file TICLLayerTile.h.

◆ TracksterTilesHFNose

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

Definition at line 75 of file TICLLayerTile.h.

Function Documentation

◆ addTrackster()

static void ticl::addTrackster ( const int &  index,
const std::vector< std::pair< edm::Ref< reco::CaloClusterCollection >, std::pair< float, float >>> &  lcVec,
const std::vector< float > &  inputClusterMask,
const float &  fractionCut_,
const float &  energy,
const int &  pdgId,
const int &  charge,
const edm::ProductID &  seed,
const Trackster::IterationIndex  iter,
std::vector< float > &  output_mask,
std::vector< Trackster > &  result 
)
static

Definition at line 36 of file commons.h.

References ALCARECOTkAlJpsiMuMu_cff::charge, HCALHighEnergyHPDFilter_cfi::energy, f, HLT_2022v12_cff::fraction, EgammaValidation_cff::pdgId, mps_fire::result, fileCollector::seed, ticl::Trackster::setIdProbability(), ticl::Trackster::setIteration(), ticl::Trackster::setRegressedEnergy(), ticl::Trackster::setSeed(), tracksterParticleTypeFromPdgId(), ticl::Trackster::vertex_multiplicity(), ticl::Trackster::vertices(), and ticl::Trackster::zeroProbabilities().

Referenced by SimTrackstersProducer::produce().

47  {
48  if (lcVec.empty())
49  return;
50 
51  Trackster tmpTrackster;
52  tmpTrackster.zeroProbabilities();
53  tmpTrackster.vertices().reserve(lcVec.size());
54  tmpTrackster.vertex_multiplicity().reserve(lcVec.size());
55  for (auto const& [lc, energyScorePair] : lcVec) {
56  if (inputClusterMask[lc.index()] > 0) {
57  double fraction = energyScorePair.first / lc->energy();
58  if (fraction < fractionCut_)
59  continue;
60  tmpTrackster.vertices().push_back(lc.index());
61  output_mask[lc.index()] -= fraction;
62  tmpTrackster.vertex_multiplicity().push_back(1. / fraction);
63  }
64  }
65 
66  tmpTrackster.setIdProbability(tracksterParticleTypeFromPdgId(pdgId, charge), 1.f);
67  tmpTrackster.setRegressedEnergy(energy);
68  tmpTrackster.setIteration(iter);
69  tmpTrackster.setSeed(seed, index);
70  result.emplace_back(tmpTrackster);
71  }
mps_fire.result
result
Definition: mps_fire.py:311
EgammaValidation_cff.pdgId
pdgId
Definition: EgammaValidation_cff.py:117
HLT_2022v12_cff.fraction
fraction
Definition: HLT_2022v12_cff.py:37619
ticl::tracksterParticleTypeFromPdgId
Trackster::ParticleType tracksterParticleTypeFromPdgId(int pdgId, int charge)
Definition: commons.h:10
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
ALCARECOTkAlJpsiMuMu_cff.charge
charge
Definition: ALCARECOTkAlJpsiMuMu_cff.py:47
HCALHighEnergyHPDFilter_cfi.energy
energy
Definition: HCALHighEnergyHPDFilter_cfi.py:5

◆ 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, c, f, first, hgcalsimclustertime::ComputeClusterTime::fixSizeHighestDensity(), HLT_2022v12_cff::fraction, mps_fire::i, dqmiolumiharvest::j, hltEgammaHGCALIDVarsL1Seeded_cfi::layerClusters, LogDebug, N, point, funct::pow(), edm::second(), mps_merge::weight, x, and detailsBasic3DVector::y.

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

16  {
17  LogDebug("TrackstersPCA_Eigen") << "------- Eigen -------" << std::endl;
18 
19  for (auto &trackster : tracksters) {
20  Eigen::Vector3d point;
21  point << 0., 0., 0.;
22  Eigen::Vector3d barycenter;
23  barycenter << 0., 0., 0.;
24 
25  auto fillPoint = [&](const reco::CaloCluster &c, const float weight = 1.f) {
26  point[0] = weight * c.x();
27  point[1] = weight * c.y();
28  point[2] = weight * c.z();
29  };
30 
31  // Initialize this trackster with default, dummy values
32  trackster.setRawEnergy(0.f);
33  trackster.setRawEmEnergy(0.f);
34  trackster.setRawPt(0.f);
35  trackster.setRawEmPt(0.f);
36 
37  size_t N = trackster.vertices().size();
38  float weight = 1.f / N;
39  float weights2_sum = 0.f;
40  Eigen::Vector3d sigmas;
41  sigmas << 0., 0., 0.;
42  Eigen::Vector3d sigmasEigen;
43  sigmasEigen << 0., 0., 0.;
44  Eigen::Matrix3d covM = Eigen::Matrix3d::Zero();
45 
46  std::vector<float> times;
47  std::vector<float> timeErrors;
48  std::set<uint32_t> usedLC;
49 
50  for (size_t i = 0; i < N; ++i) {
51  auto fraction = 1.f / trackster.vertex_multiplicity(i);
52  trackster.addToRawEnergy(layerClusters[trackster.vertices(i)].energy() * fraction);
53  if (std::abs(layerClusters[trackster.vertices(i)].z()) <= z_limit_em)
54  trackster.addToRawEmEnergy(layerClusters[trackster.vertices(i)].energy() * fraction);
55 
56  // Compute the weighted barycenter.
57  if (energyWeight)
58  weight = layerClusters[trackster.vertices(i)].energy() * fraction;
59  fillPoint(layerClusters[trackster.vertices(i)], weight);
60  for (size_t j = 0; j < 3; ++j)
61  barycenter[j] += point[j];
62 
63  // Add timing from layerClusters not already used
64  if ((usedLC.insert(trackster.vertices(i))).second) {
65  float timeE = layerClustersTime.get(trackster.vertices(i)).second;
66  if (timeE > 0.f) {
67  times.push_back(layerClustersTime.get(trackster.vertices(i)).first);
68  timeErrors.push_back(1. / pow(timeE, 2));
69  }
70  }
71  }
72  if (energyWeight && trackster.raw_energy())
73  barycenter /= trackster.raw_energy();
74 
75  hgcalsimclustertime::ComputeClusterTime timeEstimator;
76  std::pair<float, float> timeTrackster = timeEstimator.fixSizeHighestDensity(times, timeErrors);
77 
78  // Compute the Covariance Matrix and the sum of the squared weights, used
79  // to compute the correct normalization.
80  // The barycenter has to be known.
81  for (size_t i = 0; i < N; ++i) {
82  fillPoint(layerClusters[trackster.vertices(i)]);
83  if (energyWeight && trackster.raw_energy())
84  weight =
85  (layerClusters[trackster.vertices(i)].energy() / trackster.vertex_multiplicity(i)) / trackster.raw_energy();
86  weights2_sum += weight * weight;
87  for (size_t x = 0; x < 3; ++x)
88  for (size_t y = 0; y <= x; ++y) {
89  covM(x, y) += weight * (point[x] - barycenter[x]) * (point[y] - barycenter[y]);
90  covM(y, x) = covM(x, y);
91  }
92  }
93  covM *= 1. / (1. - weights2_sum);
94 
95  // Perform the actual decomposition
96  Eigen::SelfAdjointEigenSolver<Eigen::Matrix3d>::RealVectorType eigenvalues_fromEigen;
97  Eigen::SelfAdjointEigenSolver<Eigen::Matrix3d>::EigenvectorsType eigenvectors_fromEigen;
98  Eigen::SelfAdjointEigenSolver<Eigen::Matrix3d> eigensolver(covM);
99  if (eigensolver.info() != Eigen::Success) {
100  eigenvalues_fromEigen = eigenvalues_fromEigen.Zero();
101  eigenvectors_fromEigen = eigenvectors_fromEigen.Zero();
102  } else {
103  eigenvalues_fromEigen = eigensolver.eigenvalues();
104  eigenvectors_fromEigen = eigensolver.eigenvectors();
105  }
106 
107  // Compute the spread in the both spaces.
108  for (size_t i = 0; i < N; ++i) {
109  fillPoint(layerClusters[trackster.vertices(i)]);
110  sigmas += weight * (point - barycenter).cwiseAbs2();
111  Eigen::Vector3d point_transformed = eigenvectors_fromEigen * (point - barycenter);
112  if (energyWeight && trackster.raw_energy())
113  weight =
114  (layerClusters[trackster.vertices(i)].energy() / trackster.vertex_multiplicity(i)) / trackster.raw_energy();
115  sigmasEigen += weight * (point_transformed.cwiseAbs2());
116  }
117  sigmas /= (1. - weights2_sum);
118  sigmasEigen /= (1. - weights2_sum);
119 
120  // Add trackster attributes
121  trackster.setBarycenter(ticl::Trackster::Vector(barycenter));
122  trackster.setTimeAndError(timeTrackster.first, timeTrackster.second);
123  trackster.fillPCAVariables(
124  eigenvalues_fromEigen, eigenvectors_fromEigen, sigmas, sigmasEigen, 3, ticl::Trackster::PCAOrdering::ascending);
125 
126  LogDebug("TrackstersPCA") << "Use energy weighting: " << energyWeight << std::endl;
127  LogDebug("TrackstersPCA") << "\nTrackster characteristics: " << std::endl;
128  LogDebug("TrackstersPCA") << "Size: " << N << std::endl;
129  LogDebug("TrackstersPCA") << "Energy: " << trackster.raw_energy() << std::endl;
130  LogDebug("TrackstersPCA") << "raw_pt: " << trackster.raw_pt() << std::endl;
131  LogDebug("TrackstersPCA") << "Means: " << barycenter[0] << ", " << barycenter[1] << ", " << barycenter[2]
132  << std::endl;
133  LogDebug("TrackstersPCA") << "Time: " << trackster.time() << " +/- " << trackster.timeError() << std::endl;
134  LogDebug("TrackstersPCA") << "EigenValues from Eigen/Tr(cov): " << eigenvalues_fromEigen[2] / covM.trace() << ", "
135  << eigenvalues_fromEigen[1] / covM.trace() << ", "
136  << eigenvalues_fromEigen[0] / covM.trace() << std::endl;
137  LogDebug("TrackstersPCA") << "EigenValues from Eigen: " << eigenvalues_fromEigen[2] << ", "
138  << eigenvalues_fromEigen[1] << ", " << eigenvalues_fromEigen[0] << std::endl;
139  LogDebug("TrackstersPCA") << "EigenVector 3 from Eigen: " << eigenvectors_fromEigen(0, 2) << ", "
140  << eigenvectors_fromEigen(1, 2) << ", " << eigenvectors_fromEigen(2, 2) << std::endl;
141  LogDebug("TrackstersPCA") << "EigenVector 2 from Eigen: " << eigenvectors_fromEigen(0, 1) << ", "
142  << eigenvectors_fromEigen(1, 1) << ", " << eigenvectors_fromEigen(2, 1) << std::endl;
143  LogDebug("TrackstersPCA") << "EigenVector 1 from Eigen: " << eigenvectors_fromEigen(0, 0) << ", "
144  << eigenvectors_fromEigen(1, 0) << ", " << eigenvectors_fromEigen(2, 0) << std::endl;
145  LogDebug("TrackstersPCA") << "Original sigmas: " << sigmas[0] << ", " << sigmas[1] << ", " << sigmas[2]
146  << std::endl;
147  LogDebug("TrackstersPCA") << "SigmasEigen in PCA space: " << sigmasEigen[2] << ", " << sigmasEigen[1] << ", "
148  << sigmasEigen[0] << std::endl;
149  LogDebug("TrackstersPCA") << "covM: \n" << covM << std::endl;
150  }
151 }
ticl::Trackster::Vector
math::XYZVector Vector
Definition: Trackster.h:21
mps_fire.i
i
Definition: mps_fire.py:428
edm::ValueMap::get
const_reference_type get(ProductID id, size_t idx) const
Definition: ValueMap.h:144
hltEgammaHGCALIDVarsL1Seeded_cfi.layerClusters
layerClusters
Definition: hltEgammaHGCALIDVarsL1Seeded_cfi.py:5
weight
Definition: weight.py:1
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:222
hgcalsimclustertime::ComputeClusterTime::fixSizeHighestDensity
std::pair< float, float > fixSizeHighestDensity(std::vector< float > &time, std::vector< float > weight=std::vector< float >(), unsigned int minNhits=3, float deltaT=0.210, float timeWidthBy=0.5)
Definition: ComputeClusterTime.cc:66
HLT_2022v12_cff.fraction
fraction
Definition: HLT_2022v12_cff.py:37619
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
N
#define N
Definition: blowfish.cc:9
x
float x
Definition: beamSpotDipStandalone.cc:55
riemannFit::Matrix3d
Eigen::Matrix3d Matrix3d
Definition: FitResult.h:18
mps_merge.weight
weight
Definition: mps_merge.py:88
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:29
point
*vegas h *****************************************************used in the default bin number in original ***version of VEGAS is ***a higher bin number might help to derive a more precise ***grade subtle point
Definition: invegas.h:5
riemannFit::Vector3d
Eigen::Vector3d Vector3d
Definition: FitResult.h:14
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:233

◆ tracksterParticleTypeFromPdgId()

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

Definition at line 10 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 addTrackster().

10  {
11  if (pdgId == 111) {
12  return Trackster::ParticleType::neutral_pion;
13  } else {
14  pdgId = std::abs(pdgId);
15  if (pdgId == 22) {
16  return Trackster::ParticleType::photon;
17  } else if (pdgId == 11) {
18  return Trackster::ParticleType::electron;
19  } else if (pdgId == 13) {
20  return Trackster::ParticleType::muon;
21  } else {
22  bool isHadron = (pdgId > 100 and pdgId < 900) or (pdgId > 1000 and pdgId < 9000);
23  if (isHadron) {
24  if (charge != 0) {
25  return Trackster::ParticleType::charged_hadron;
26  } else {
27  return Trackster::ParticleType::neutral_hadron;
28  }
29  } else {
30  return Trackster::ParticleType::unknown;
31  }
32  }
33  }
34  }
EgammaValidation_cff.pdgId
pdgId
Definition: EgammaValidation_cff.py:117
HLT_2022v12_cff.muon
muon
Definition: HLT_2022v12_cff.py:9242
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
ALCARECOTkAlJpsiMuMu_cff.charge
charge
Definition: ALCARECOTkAlJpsiMuMu_cff.py:47
displacedMuons_cfi.photon
photon
Definition: displacedMuons_cfi.py:25
HPSPFTauProducerPuppi_cfi.electron
electron
Definition: HPSPFTauProducerPuppi_cfi.py:13
Generated for CMSSW Reference Manual by doxygen 1.8.14