CMS 3D CMS Logo
List of all members | Classes | Public Types | Public Member Functions | Private Member Functions | Private Attributes
HGVHistoProducerAlgo Class Reference

#include <HGVHistoProducerAlgo.h>

Classes

struct  caloParticleOnLayer
 
struct  detIdInfoInCluster
 
struct  detIdInfoInTrackster
 

Public Types

typedef dqm::legacy::DQMStore DQMStore
 
using Histograms = HGVHistoProducerAlgoHistograms
 
typedef dqm::legacy::MonitorElement MonitorElement
 
enum  validationType { Linking = 0, PatternRecognition, PatternRecognition_CP }
 

Public Member Functions

void bookCaloParticleHistos (DQMStore::IBooker &ibook, Histograms &histograms, int pdgid, unsigned int layers)
 
void bookClusterHistos_CellLevel (DQMStore::IBooker &ibook, Histograms &histograms, unsigned int layers, std::vector< int > thicknesses)
 
void bookClusterHistos_ClusterLevel (DQMStore::IBooker &ibook, Histograms &histograms, unsigned int layers, std::vector< int > thicknesses, std::string pathtomatbudfile)
 
void bookClusterHistos_LCtoCP_association (DQMStore::IBooker &ibook, Histograms &histograms, unsigned int layers)
 
void bookInfo (DQMStore::IBooker &ibook, Histograms &histograms)
 
void bookSimClusterAssociationHistos (DQMStore::IBooker &ibook, Histograms &histograms, unsigned int layers, std::vector< int > thicknesses)
 
void bookSimClusterHistos (DQMStore::IBooker &ibook, Histograms &histograms, unsigned int layers, std::vector< int > thicknesses)
 
void bookTracksterHistos (DQMStore::IBooker &ibook, Histograms &histograms, unsigned int layers)
 
void bookTracksterSTSHistos (DQMStore::IBooker &ibook, Histograms &histograms, const validationType valType)
 
double distance (const double x1, const double y1, const double x2, const double y2) const
 
double distance2 (const double x1, const double y1, const double x2, const double y2) const
 
void fill_caloparticle_histos (const Histograms &histograms, int pdgid, const CaloParticle &caloparticle, std::vector< SimVertex > const &simVertices, unsigned int layers, std::unordered_map< DetId, const unsigned int > const &, std::vector< HGCRecHit > const &hits) const
 
void fill_cluster_histos (const Histograms &histograms, const int count, const reco::CaloCluster &cluster) const
 
void fill_generic_cluster_histos (const Histograms &histograms, const int count, edm::Handle< reco::CaloClusterCollection > clusterHandle, const reco::CaloClusterCollection &clusters, edm::Handle< std::vector< CaloParticle >> caloParticleHandle, std::vector< CaloParticle > const &cP, std::vector< size_t > const &cPIndices, std::vector< size_t > const &cPSelectedIndices, std::unordered_map< DetId, const unsigned int > const &, std::map< double, double > cummatbudg, unsigned int layers, std::vector< int > thicknesses, const ticl::RecoToSimCollection &recSimColl, const ticl::SimToRecoCollection &simRecColl, std::vector< HGCRecHit > const &hits) const
 
void fill_info_histos (const Histograms &histograms, unsigned int layers) const
 
void fill_simCluster_histos (const Histograms &histograms, std::vector< SimCluster > const &simClusters, unsigned int layers, std::vector< int > thicknesses) const
 
void fill_simClusterAssociation_histos (const Histograms &histograms, const int count, edm::Handle< reco::CaloClusterCollection > clusterHandle, const reco::CaloClusterCollection &clusters, edm::Handle< std::vector< SimCluster >> simClusterHandle, std::vector< SimCluster > const &simClusters, std::vector< size_t > const &sCIndices, const std::vector< float > &mask, std::unordered_map< DetId, const unsigned int > const &hitMap, unsigned int layers, const ticl::RecoToSimCollectionWithSimClusters &recSimColl, const ticl::SimToRecoCollectionWithSimClusters &simRecColl, std::vector< HGCRecHit > const &hits) const
 
void fill_trackster_histos (const Histograms &histograms, const int count, const ticl::TracksterCollection &Tracksters, const reco::CaloClusterCollection &layerClusters, const ticl::TracksterCollection &simTS, const ticl::TracksterCollection &simTS_fromCP, std::map< uint, std::vector< uint >> const &simTrackstersMap, std::vector< SimCluster > const &sC, const edm::ProductID &cPHandle_id, std::vector< CaloParticle > const &cP, std::vector< size_t > const &cPIndices, std::vector< size_t > const &cPSelectedIndices, std::unordered_map< DetId, const unsigned int > const &, unsigned int layers, std::vector< HGCRecHit > const &hits) const
 
DetId findmaxhit (const reco::CaloCluster &cluster, std::unordered_map< DetId, const unsigned int > const &, std::vector< HGCRecHit > const &hits) const
 
 HGVHistoProducerAlgo (const edm::ParameterSet &pset)
 
void layerClusters_to_CaloParticles (const Histograms &histograms, edm::Handle< reco::CaloClusterCollection > clusterHandle, const reco::CaloClusterCollection &clusters, edm::Handle< std::vector< CaloParticle >> caloParticleHandle, std::vector< CaloParticle > const &cP, std::vector< size_t > const &cPIndices, std::vector< size_t > const &cPSelectedIndices, std::unordered_map< DetId, const unsigned int > const &, unsigned int layers, const ticl::RecoToSimCollection &recSimColl, const ticl::SimToRecoCollection &simRecColl, std::vector< HGCRecHit > const &hits) const
 
void layerClusters_to_SimClusters (const Histograms &histograms, const int count, edm::Handle< reco::CaloClusterCollection > clusterHandle, const reco::CaloClusterCollection &clusters, edm::Handle< std::vector< SimCluster >> simClusterHandle, std::vector< SimCluster > const &simClusters, std::vector< size_t > const &sCIndices, const std::vector< float > &mask, std::unordered_map< DetId, const unsigned int > const &, unsigned int layers, const ticl::RecoToSimCollectionWithSimClusters &recSimColl, const ticl::SimToRecoCollectionWithSimClusters &simRecColl, std::vector< HGCRecHit > const &hits) const
 
void setRecHitTools (std::shared_ptr< hgcal::RecHitTools > recHitTools)
 
void tracksters_to_SimTracksters (const Histograms &histograms, const int count, const ticl::TracksterCollection &Tracksters, const reco::CaloClusterCollection &layerClusters, const ticl::TracksterCollection &simTS, const validationType valType, const ticl::TracksterCollection &simTS_fromCP, std::map< uint, std::vector< uint >> const &simTrackstersMap, std::vector< SimCluster > const &sC, const edm::ProductID &cPHandle_id, std::vector< CaloParticle > const &cP, std::vector< size_t > const &cPIndices, std::vector< size_t > const &cPSelectedIndices, std::unordered_map< DetId, const unsigned int > const &, unsigned int layers, std::vector< HGCRecHit > const &hits) const
 
 ~HGVHistoProducerAlgo ()
 

Private Member Functions

double getEta (double eta) const
 

Private Attributes

double maxCellsEneDensperthick_
 
double maxClEnepermultiplicity_
 
double maxClEneperthickperlayer_
 
double maxDisSeedToMaxperthickperlayer_
 
double maxDisToMaxperthickperlayer_
 
double maxDisToMaxperthickperlayerenewei_
 
double maxDisToSeedperthickperlayer_
 
double maxDisToSeedperthickperlayerenewei_
 
double maxEne_
 
double maxEneCl_
 
double maxEneClperlay_
 
double maxEta_
 
double maxLongDepBary_
 
double maxMixedHitsCluster_
 
double maxMixedHitsSimCluster_
 
double maxMplofLCs_
 
double maxPhi_
 
double maxPt_
 
double maxScore_
 
double maxSharedEneFrac_
 
double maxSizeCLsinTSTs_
 
double maxTotNcellsperthickperlayer_
 
double maxTotNClsinTSTs_
 
double maxTotNClsinTSTsperlayer_
 
double maxTotNClsperlay_
 
double maxTotNClsperthick_
 
double maxTotNsimClsperlay_
 
double maxTotNsimClsperthick_
 
double maxTotNTSTs_
 
double maxTSTSharedEneFrac_
 
double maxX_
 
double maxY_
 
double maxZ_
 
double maxZpos_
 
double minCellsEneDensperthick_
 
double minClEnepermultiplicity_
 
double minClEneperthickperlayer_
 
double minDisSeedToMaxperthickperlayer_
 
double minDisToMaxperthickperlayer_
 
double minDisToMaxperthickperlayerenewei_
 
double minDisToSeedperthickperlayer_
 
double minDisToSeedperthickperlayerenewei_
 
double minEne_
 
double minEneCl_
 
double minEneClperlay_
 
double minEta_
 
double minLongDepBary_
 
double minMixedHitsCluster_
 
double minMixedHitsSimCluster_
 
double minMplofLCs_
 
double minPhi_
 
double minPt_
 
double minScore_
 
double minSharedEneFrac_
 
double minSizeCLsinTSTs_
 
double minTotNcellsperthickperlayer_
 
double minTotNClsinTSTs_
 
double minTotNClsinTSTsperlayer_
 
double minTotNClsperlay_
 
double minTotNClsperthick_
 
double minTotNsimClsperlay_
 
double minTotNsimClsperthick_
 
double minTotNTSTs_
 
double minTSTSharedEneFrac_
 
double minTSTSharedEneFracEfficiency_
 
double minX_
 
double minY_
 
double minZ_
 
double minZpos_
 
int nintCellsEneDensperthick_
 
int nintClEnepermultiplicity_
 
int nintClEneperthickperlayer_
 
int nintDisSeedToMaxperthickperlayer_
 
int nintDisToMaxperthickperlayer_
 
int nintDisToMaxperthickperlayerenewei_
 
int nintDisToSeedperthickperlayer_
 
int nintDisToSeedperthickperlayerenewei_
 
int nintEne_
 
int nintEneCl_
 
int nintEneClperlay_
 
int nintEta_
 
int nintLongDepBary_
 
int nintMixedHitsCluster_
 
int nintMixedHitsSimCluster_
 
int nintMplofLCs_
 
int nintPhi_
 
int nintPt_
 
int nintScore_
 
int nintSharedEneFrac_
 
int nintSizeCLsinTSTs_
 
int nintTotNcellsperthickperlayer_
 
int nintTotNClsinTSTs_
 
int nintTotNClsinTSTsperlayer_
 
int nintTotNClsperlay_
 
int nintTotNClsperthick_
 
int nintTotNsimClsperlay_
 
int nintTotNsimClsperthick_
 
int nintTotNTSTs_
 
int nintTSTSharedEneFrac_
 
int nintX_
 
int nintY_
 
int nintZ_
 
int nintZpos_
 
std::shared_ptr< hgcal::RecHitTools > recHitTools_
 
bool useFabsEta_
 

Detailed Description

Definition at line 225 of file HGVHistoProducerAlgo.h.

Member Typedef Documentation

◆ DQMStore

typedef dqm::legacy::DQMStore HGVHistoProducerAlgo::DQMStore

Definition at line 227 of file HGVHistoProducerAlgo.h.

◆ Histograms

using HGVHistoProducerAlgo::Histograms = HGVHistoProducerAlgoHistograms

Definition at line 233 of file HGVHistoProducerAlgo.h.

◆ MonitorElement

typedef dqm::legacy::MonitorElement HGVHistoProducerAlgo::MonitorElement

Definition at line 228 of file HGVHistoProducerAlgo.h.

Member Enumeration Documentation

◆ validationType

enum HGVHistoProducerAlgo::validationType
Enumerator
Linking 
PatternRecognition 
PatternRecognition_CP 

Definition at line 262 of file HGVHistoProducerAlgo.h.

262 { Linking = 0, PatternRecognition, PatternRecognition_CP };

Constructor & Destructor Documentation

◆ HGVHistoProducerAlgo()

HGVHistoProducerAlgo::HGVHistoProducerAlgo ( const edm::ParameterSet &  pset)

Definition at line 23 of file HGVHistoProducerAlgo.cc.

24  : //parameters for eta
25  minEta_(pset.getParameter<double>("minEta")),
26  maxEta_(pset.getParameter<double>("maxEta")),
27  nintEta_(pset.getParameter<int>("nintEta")),
28  useFabsEta_(pset.getParameter<bool>("useFabsEta")),
29 
30  //parameters for energy
31  minEne_(pset.getParameter<double>("minEne")),
32  maxEne_(pset.getParameter<double>("maxEne")),
33  nintEne_(pset.getParameter<int>("nintEne")),
34 
35  //parameters for pt
36  minPt_(pset.getParameter<double>("minPt")),
37  maxPt_(pset.getParameter<double>("maxPt")),
38  nintPt_(pset.getParameter<int>("nintPt")),
39 
40  //parameters for phi
41  minPhi_(pset.getParameter<double>("minPhi")),
42  maxPhi_(pset.getParameter<double>("maxPhi")),
43  nintPhi_(pset.getParameter<int>("nintPhi")),
44 
45  //parameters for counting mixed hits SimClusters
46  minMixedHitsSimCluster_(pset.getParameter<double>("minMixedHitsSimCluster")),
47  maxMixedHitsSimCluster_(pset.getParameter<double>("maxMixedHitsSimCluster")),
48  nintMixedHitsSimCluster_(pset.getParameter<int>("nintMixedHitsSimCluster")),
49 
50  //parameters for counting mixed hits clusters
51  minMixedHitsCluster_(pset.getParameter<double>("minMixedHitsCluster")),
52  maxMixedHitsCluster_(pset.getParameter<double>("maxMixedHitsCluster")),
53  nintMixedHitsCluster_(pset.getParameter<int>("nintMixedHitsCluster")),
54 
55  //parameters for the total amount of energy clustered by all layer clusters (fraction over CaloParticless)
56  minEneCl_(pset.getParameter<double>("minEneCl")),
57  maxEneCl_(pset.getParameter<double>("maxEneCl")),
58  nintEneCl_(pset.getParameter<int>("nintEneCl")),
59 
60  //parameters for the longitudinal depth barycenter.
61  minLongDepBary_(pset.getParameter<double>("minLongDepBary")),
62  maxLongDepBary_(pset.getParameter<double>("maxLongDepBary")),
63  nintLongDepBary_(pset.getParameter<int>("nintLongDepBary")),
64 
65  //parameters for z positionof vertex plots
66  minZpos_(pset.getParameter<double>("minZpos")),
67  maxZpos_(pset.getParameter<double>("maxZpos")),
68  nintZpos_(pset.getParameter<int>("nintZpos")),
69 
70  //Parameters for the total number of SimClusters per layer
71  minTotNsimClsperlay_(pset.getParameter<double>("minTotNsimClsperlay")),
72  maxTotNsimClsperlay_(pset.getParameter<double>("maxTotNsimClsperlay")),
73  nintTotNsimClsperlay_(pset.getParameter<int>("nintTotNsimClsperlay")),
74 
75  //Parameters for the total number of layer clusters per layer
76  minTotNClsperlay_(pset.getParameter<double>("minTotNClsperlay")),
77  maxTotNClsperlay_(pset.getParameter<double>("maxTotNClsperlay")),
78  nintTotNClsperlay_(pset.getParameter<int>("nintTotNClsperlay")),
79 
80  //Parameters for the energy clustered by layer clusters per layer (fraction over CaloParticless)
81  minEneClperlay_(pset.getParameter<double>("minEneClperlay")),
82  maxEneClperlay_(pset.getParameter<double>("maxEneClperlay")),
83  nintEneClperlay_(pset.getParameter<int>("nintEneClperlay")),
84 
85  //Parameters for the score both for:
86  //1. calo particle to layer clusters association per layer
87  //2. layer cluster to calo particles association per layer
88  minScore_(pset.getParameter<double>("minScore")),
89  maxScore_(pset.getParameter<double>("maxScore")),
90  nintScore_(pset.getParameter<int>("nintScore")),
91 
92  //Parameters for shared energy fraction. That is:
93  //1. Fraction of each of the layer clusters energy related to a
94  //calo particle over that calo particle's energy.
95  //2. Fraction of each of the calo particles energy
96  //related to a layer cluster over that layer cluster's energy.
97  minSharedEneFrac_(pset.getParameter<double>("minSharedEneFrac")),
98  maxSharedEneFrac_(pset.getParameter<double>("maxSharedEneFrac")),
99  nintSharedEneFrac_(pset.getParameter<int>("nintSharedEneFrac")),
100  minTSTSharedEneFracEfficiency_(pset.getParameter<double>("minTSTSharedEneFracEfficiency")),
101 
102  //Same as above for Tracksters
103  minTSTSharedEneFrac_(pset.getParameter<double>("minTSTSharedEneFrac")),
104  maxTSTSharedEneFrac_(pset.getParameter<double>("maxTSTSharedEneFrac")),
105  nintTSTSharedEneFrac_(pset.getParameter<int>("nintTSTSharedEneFrac")),
106 
107  //Parameters for the total number of SimClusters per thickness
108  minTotNsimClsperthick_(pset.getParameter<double>("minTotNsimClsperthick")),
109  maxTotNsimClsperthick_(pset.getParameter<double>("maxTotNsimClsperthick")),
110  nintTotNsimClsperthick_(pset.getParameter<int>("nintTotNsimClsperthick")),
111 
112  //Parameters for the total number of layer clusters per thickness
113  minTotNClsperthick_(pset.getParameter<double>("minTotNClsperthick")),
114  maxTotNClsperthick_(pset.getParameter<double>("maxTotNClsperthick")),
115  nintTotNClsperthick_(pset.getParameter<int>("nintTotNClsperthick")),
116 
117  //Parameters for the total number of cells per per thickness per layer
118  minTotNcellsperthickperlayer_(pset.getParameter<double>("minTotNcellsperthickperlayer")),
119  maxTotNcellsperthickperlayer_(pset.getParameter<double>("maxTotNcellsperthickperlayer")),
120  nintTotNcellsperthickperlayer_(pset.getParameter<int>("nintTotNcellsperthickperlayer")),
121 
122  //Parameters for the distance of cluster cells to seed cell per thickness per layer
123  minDisToSeedperthickperlayer_(pset.getParameter<double>("minDisToSeedperthickperlayer")),
124  maxDisToSeedperthickperlayer_(pset.getParameter<double>("maxDisToSeedperthickperlayer")),
125  nintDisToSeedperthickperlayer_(pset.getParameter<int>("nintDisToSeedperthickperlayer")),
126 
127  //Parameters for the energy weighted distance of cluster cells to seed cell per thickness per layer
128  minDisToSeedperthickperlayerenewei_(pset.getParameter<double>("minDisToSeedperthickperlayerenewei")),
129  maxDisToSeedperthickperlayerenewei_(pset.getParameter<double>("maxDisToSeedperthickperlayerenewei")),
130  nintDisToSeedperthickperlayerenewei_(pset.getParameter<int>("nintDisToSeedperthickperlayerenewei")),
131 
132  //Parameters for the distance of cluster cells to max cell per thickness per layer
133  minDisToMaxperthickperlayer_(pset.getParameter<double>("minDisToMaxperthickperlayer")),
134  maxDisToMaxperthickperlayer_(pset.getParameter<double>("maxDisToMaxperthickperlayer")),
135  nintDisToMaxperthickperlayer_(pset.getParameter<int>("nintDisToMaxperthickperlayer")),
136 
137  //Parameters for the energy weighted distance of cluster cells to max cell per thickness per layer
138  minDisToMaxperthickperlayerenewei_(pset.getParameter<double>("minDisToMaxperthickperlayerenewei")),
139  maxDisToMaxperthickperlayerenewei_(pset.getParameter<double>("maxDisToMaxperthickperlayerenewei")),
140  nintDisToMaxperthickperlayerenewei_(pset.getParameter<int>("nintDisToMaxperthickperlayerenewei")),
141 
142  //Parameters for the distance of seed cell to max cell per thickness per layer
143  minDisSeedToMaxperthickperlayer_(pset.getParameter<double>("minDisSeedToMaxperthickperlayer")),
144  maxDisSeedToMaxperthickperlayer_(pset.getParameter<double>("maxDisSeedToMaxperthickperlayer")),
145  nintDisSeedToMaxperthickperlayer_(pset.getParameter<int>("nintDisSeedToMaxperthickperlayer")),
146 
147  //Parameters for the energy of a cluster per thickness per layer
148  minClEneperthickperlayer_(pset.getParameter<double>("minClEneperthickperlayer")),
149  maxClEneperthickperlayer_(pset.getParameter<double>("maxClEneperthickperlayer")),
150  nintClEneperthickperlayer_(pset.getParameter<int>("nintClEneperthickperlayer")),
151 
152  //Parameters for the energy density of cluster cells per thickness
153  minCellsEneDensperthick_(pset.getParameter<double>("minCellsEneDensperthick")),
154  maxCellsEneDensperthick_(pset.getParameter<double>("maxCellsEneDensperthick")),
155  nintCellsEneDensperthick_(pset.getParameter<int>("nintCellsEneDensperthick")),
156 
157  //Parameters for the total number of Tracksters per event
158  // Always treat one event as two events, one in +z one in -z
159  minTotNTSTs_(pset.getParameter<double>("minTotNTSTs")),
160  maxTotNTSTs_(pset.getParameter<double>("maxTotNTSTs")),
161  nintTotNTSTs_(pset.getParameter<int>("nintTotNTSTs")),
162 
163  //Parameters for the total number of layer clusters in Trackster
164  minTotNClsinTSTs_(pset.getParameter<double>("minTotNClsinTSTs")),
165  maxTotNClsinTSTs_(pset.getParameter<double>("maxTotNClsinTSTs")),
166  nintTotNClsinTSTs_(pset.getParameter<int>("nintTotNClsinTSTs")),
167 
168  //Parameters for the total number of layer clusters in Trackster per layer
169  minTotNClsinTSTsperlayer_(pset.getParameter<double>("minTotNClsinTSTsperlayer")),
170  maxTotNClsinTSTsperlayer_(pset.getParameter<double>("maxTotNClsinTSTsperlayer")),
171  nintTotNClsinTSTsperlayer_(pset.getParameter<int>("nintTotNClsinTSTsperlayer")),
172 
173  //Parameters for the multiplicity of layer clusters in Trackster
174  minMplofLCs_(pset.getParameter<double>("minMplofLCs")),
175  maxMplofLCs_(pset.getParameter<double>("maxMplofLCs")),
176  nintMplofLCs_(pset.getParameter<int>("nintMplofLCs")),
177 
178  //Parameters for cluster size
179  minSizeCLsinTSTs_(pset.getParameter<double>("minSizeCLsinTSTs")),
180  maxSizeCLsinTSTs_(pset.getParameter<double>("maxSizeCLsinTSTs")),
181  nintSizeCLsinTSTs_(pset.getParameter<int>("nintSizeCLsinTSTs")),
182 
183  //Parameters for the energy of a cluster per thickness per layer
184  minClEnepermultiplicity_(pset.getParameter<double>("minClEnepermultiplicity")),
185  maxClEnepermultiplicity_(pset.getParameter<double>("maxClEnepermultiplicity")),
186  nintClEnepermultiplicity_(pset.getParameter<int>("nintClEnepermultiplicity")),
187 
188  //parameters for x
189  minX_(pset.getParameter<double>("minX")),
190  maxX_(pset.getParameter<double>("maxX")),
191  nintX_(pset.getParameter<int>("nintX")),
192 
193  //parameters for y
194  minY_(pset.getParameter<double>("minY")),
195  maxY_(pset.getParameter<double>("maxY")),
196  nintY_(pset.getParameter<int>("nintY")),
197 
198  //parameters for z
199  minZ_(pset.getParameter<double>("minZ")),
200  maxZ_(pset.getParameter<double>("maxZ")),
201  nintZ_(pset.getParameter<int>("nintZ")) {}
muonDTDigis_cfi.pset
pset
Definition: muonDTDigis_cfi.py:27

◆ ~HGVHistoProducerAlgo()

HGVHistoProducerAlgo::~HGVHistoProducerAlgo ( )

Definition at line 203 of file HGVHistoProducerAlgo.cc.

203 {}

Member Function Documentation

◆ bookCaloParticleHistos()

void HGVHistoProducerAlgo::bookCaloParticleHistos ( DQMStore::IBooker &  ibook,
Histograms &  histograms,
int  pdgid,
unsigned int  layers 
)

Definition at line 214 of file HGVHistoProducerAlgo.cc.

References dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), hgcalTBTopologyTester_cfi::layers, maxEne_, maxEta_, maxPhi_, maxPt_, maxZpos_, minEne_, minEta_, minPhi_, minPt_, minZpos_, nintEne_, nintEta_, nintPhi_, nintPt_, nintZpos_, and EgammaValidation_cff::pdgid.

217  {
218  histograms.h_caloparticle_eta[pdgid] =
219  ibook.book1D("N of caloparticle vs eta", "N of caloParticles vs eta", nintEta_, minEta_, maxEta_);
220  histograms.h_caloparticle_eta_Zorigin[pdgid] =
221  ibook.book2D("Eta vs Zorigin", "Eta vs Zorigin", nintEta_, minEta_, maxEta_, nintZpos_, minZpos_, maxZpos_);
222 
223  histograms.h_caloparticle_energy[pdgid] =
224  ibook.book1D("Energy", "Energy of CaloParticles; Energy [GeV]", nintEne_, minEne_, maxEne_);
225  histograms.h_caloparticle_pt[pdgid] = ibook.book1D("Pt", "Pt of CaloParticles", nintPt_, minPt_, maxPt_);
226  histograms.h_caloparticle_phi[pdgid] = ibook.book1D("Phi", "Phi of CaloParticles", nintPhi_, minPhi_, maxPhi_);
227  histograms.h_caloparticle_selfenergy[pdgid] =
228  ibook.book1D("SelfEnergy", "Total Energy of Hits in Sim Clusters (matched)", nintEne_, minEne_, maxEne_);
229  histograms.h_caloparticle_energyDifference[pdgid] =
230  ibook.book1D("EnergyDifference", "(Energy-SelfEnergy)/Energy", 300., -5., 1.);
231 
232  histograms.h_caloparticle_nSimClusters[pdgid] =
233  ibook.book1D("Num Sim Clusters", "Num Sim Clusters in CaloParticles", 100, 0., 100.);
234  histograms.h_caloparticle_nHitsInSimClusters[pdgid] =
235  ibook.book1D("Num Hits in Sim Clusters", "Num Hits in Sim Clusters in CaloParticles", 1000, 0., 1000.);
236  histograms.h_caloparticle_nHitsInSimClusters_matchedtoRecHit[pdgid] = ibook.book1D(
237  "Num Rec-matched Hits in Sim Clusters", "Num Hits in Sim Clusters (matched) in CaloParticles", 1000, 0., 1000.);
238 
239  histograms.h_caloparticle_nHits_matched_energy[pdgid] =
240  ibook.book1D("Energy of Rec-matched Hits", "Energy of Hits in Sim Clusters (matched)", 100, 0., 10.);
241  histograms.h_caloparticle_nHits_matched_energy_layer[pdgid] =
242  ibook.book2D("Energy of Rec-matched Hits vs layer",
243  "Energy of Hits in Sim Clusters (matched) vs layer",
244  2 * layers,
245  0.,
246  (float)2 * layers,
247  100,
248  0.,
249  10.);
250  histograms.h_caloparticle_nHits_matched_energy_layer_1SimCl[pdgid] =
251  ibook.book2D("Energy of Rec-matched Hits vs layer (1SC)",
252  "Energy of Hits only 1 Sim Clusters (matched) vs layer",
253  2 * layers,
254  0.,
255  (float)2 * layers,
256  100,
257  0.,
258  10.);
259  histograms.h_caloparticle_sum_energy_layer[pdgid] =
260  ibook.book2D("Rec-matched Hits Sum Energy vs layer",
261  "Rescaled Sum Energy of Hits in Sim Clusters (matched) vs layer",
262  2 * layers,
263  0.,
264  (float)2 * layers,
265  110,
266  0.,
267  110.);
268  histograms.h_caloparticle_fractions[pdgid] =
269  ibook.book2D("HitFractions", "Hit fractions;Hit fraction;E_{hit}^{2} fraction", 101, 0, 1.01, 100, 0, 1);
270  histograms.h_caloparticle_fractions_weight[pdgid] = ibook.book2D(
271  "HitFractions_weighted", "Hit fractions weighted;Hit fraction;E_{hit}^{2} fraction", 101, 0, 1.01, 100, 0, 1);
272 
273  histograms.h_caloparticle_firstlayer[pdgid] =
274  ibook.book1D("First Layer", "First layer of the CaloParticles", 2 * layers, 0., (float)2 * layers);
275  histograms.h_caloparticle_lastlayer[pdgid] =
276  ibook.book1D("Last Layer", "Last layer of the CaloParticles", 2 * layers, 0., (float)2 * layers);
277  histograms.h_caloparticle_layersnum[pdgid] =
278  ibook.book1D("Number of Layers", "Number of layers of the CaloParticles", 2 * layers, 0., (float)2 * layers);
279  histograms.h_caloparticle_firstlayer_matchedtoRecHit[pdgid] = ibook.book1D(
280  "First Layer (rec-matched hit)", "First layer of the CaloParticles (matched)", 2 * layers, 0., (float)2 * layers);
281  histograms.h_caloparticle_lastlayer_matchedtoRecHit[pdgid] = ibook.book1D(
282  "Last Layer (rec-matched hit)", "Last layer of the CaloParticles (matched)", 2 * layers, 0., (float)2 * layers);
283  histograms.h_caloparticle_layersnum_matchedtoRecHit[pdgid] =
284  ibook.book1D("Number of Layers (rec-matched hit)",
285  "Number of layers of the CaloParticles (matched)",
286  2 * layers,
287  0.,
288  (float)2 * layers);
289 }
hgcalTBTopologyTester_cfi.layers
layers
Definition: hgcalTBTopologyTester_cfi.py:8
EgammaValidation_cff.pdgid
pdgid
Definition: EgammaValidation_cff.py:29
dqm::implementation::IBooker::book2D
MonitorElement * book2D(TString const &name, TString const &title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, FUNC onbooking=NOOP())
Definition: DQMStore.h:221
dqm::implementation::IBooker::book1D
MonitorElement * book1D(TString const &name, TString const &title, int const nchX, double const lowX, double const highX, FUNC onbooking=NOOP())
Definition: DQMStore.h:98

◆ bookClusterHistos_CellLevel()

void HGVHistoProducerAlgo::bookClusterHistos_CellLevel ( DQMStore::IBooker &  ibook,
Histograms &  histograms,
unsigned int  layers,
std::vector< int >  thicknesses 
)

Definition at line 864 of file HGVHistoProducerAlgo.cc.

References dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, hgcalTBTopologyTester_cfi::layers, maxCellsEneDensperthick_, maxClEneperthickperlayer_, maxDisSeedToMaxperthickperlayer_, maxDisToMaxperthickperlayer_, maxDisToMaxperthickperlayerenewei_, maxDisToSeedperthickperlayer_, maxDisToSeedperthickperlayerenewei_, maxTotNcellsperthickperlayer_, minCellsEneDensperthick_, minClEneperthickperlayer_, minDisSeedToMaxperthickperlayer_, minDisToMaxperthickperlayer_, minDisToMaxperthickperlayerenewei_, minDisToSeedperthickperlayer_, minDisToSeedperthickperlayerenewei_, minTotNcellsperthickperlayer_, nintCellsEneDensperthick_, nintClEneperthickperlayer_, nintDisSeedToMaxperthickperlayer_, nintDisToMaxperthickperlayer_, nintDisToMaxperthickperlayerenewei_, nintDisToSeedperthickperlayer_, nintDisToSeedperthickperlayerenewei_, nintTotNcellsperthickperlayer_, AlCaHLTBitMon_QueryRunRegistry::string, and to_string().

867  {
868  //----------------------------------------------------------------------------------------------------------------------------
869  for (unsigned ilayer = 0; ilayer < 2 * layers; ++ilayer) {
870  auto istr1 = std::to_string(ilayer);
871  while (istr1.size() < 2) {
872  istr1.insert(0, "0");
873  }
874  // Make a mapping to the regural layer naming plus z- or z+ for convenience
875  std::string istr2 = "";
876  // first with the -z endcap
877  if (ilayer < layers) {
878  istr2 = std::to_string(ilayer + 1) + " in z-";
879  } else { // then for the +z
880  istr2 = std::to_string(ilayer - (layers - 1)) + " in z+";
881  }
882  histograms.h_cellAssociation_perlayer[ilayer] =
883  ibook.book1D("cellAssociation_perlayer" + istr1, "Cell Association for layer " + istr2, 5, -4., 1.);
884  histograms.h_cellAssociation_perlayer[ilayer]->setBinLabel(2, "TN(purity)");
885  histograms.h_cellAssociation_perlayer[ilayer]->setBinLabel(3, "FN(ineff.)");
886  histograms.h_cellAssociation_perlayer[ilayer]->setBinLabel(4, "FP(fake)");
887  histograms.h_cellAssociation_perlayer[ilayer]->setBinLabel(5, "TP(eff.)");
888  }
889  //----------------------------------------------------------------------------------------------------------------------------
890  for (std::vector<int>::iterator it = thicknesses.begin(); it != thicknesses.end(); ++it) {
891  auto istr = std::to_string(*it);
892  histograms.h_cellsenedens_perthick[(*it)] = ibook.book1D("cellsenedens_thick_" + istr,
893  "energy density of cluster cells for thickness " + istr,
894  nintCellsEneDensperthick_,
895  minCellsEneDensperthick_,
896  maxCellsEneDensperthick_);
897  }
898  //----------------------------------------------------------------------------------------------------------------------------
899  //Not all combination exists but should keep them all for cross checking reason.
900  for (std::vector<int>::iterator it = thicknesses.begin(); it != thicknesses.end(); ++it) {
901  for (unsigned ilayer = 0; ilayer < 2 * layers; ++ilayer) {
902  auto istr1 = std::to_string(*it);
903  auto istr2 = std::to_string(ilayer);
904  while (istr2.size() < 2)
905  istr2.insert(0, "0");
906  auto istr = istr1 + "_" + istr2;
907  // Make a mapping to the regural layer naming plus z- or z+ for convenience
908  std::string istr3 = "";
909  // first with the -z endcap
910  if (ilayer < layers) {
911  istr3 = std::to_string(ilayer + 1) + " in z- ";
912  } else { // then for the +z
913  istr3 = std::to_string(ilayer - (layers - 1)) + " in z+ ";
914  }
915  //---
916  histograms.h_cellsnum_perthickperlayer[istr] =
917  ibook.book1D("cellsnum_perthick_perlayer_" + istr,
918  "total number of cells for layer " + istr3 + " for thickness " + istr1,
919  nintTotNcellsperthickperlayer_,
920  minTotNcellsperthickperlayer_,
921  maxTotNcellsperthickperlayer_);
922  //---
923  histograms.h_distancetoseedcell_perthickperlayer[istr] =
924  ibook.book1D("distancetoseedcell_perthickperlayer_" + istr,
925  "distance of cluster cells to seed cell for layer " + istr3 + " for thickness " + istr1,
926  nintDisToSeedperthickperlayer_,
927  minDisToSeedperthickperlayer_,
928  maxDisToSeedperthickperlayer_);
929  //---
930  histograms.h_distancetoseedcell_perthickperlayer_eneweighted[istr] = ibook.book1D(
931  "distancetoseedcell_perthickperlayer_eneweighted_" + istr,
932  "energy weighted distance of cluster cells to seed cell for layer " + istr3 + " for thickness " + istr1,
933  nintDisToSeedperthickperlayerenewei_,
934  minDisToSeedperthickperlayerenewei_,
935  maxDisToSeedperthickperlayerenewei_);
936  //---
937  histograms.h_distancetomaxcell_perthickperlayer[istr] =
938  ibook.book1D("distancetomaxcell_perthickperlayer_" + istr,
939  "distance of cluster cells to max cell for layer " + istr3 + " for thickness " + istr1,
940  nintDisToMaxperthickperlayer_,
941  minDisToMaxperthickperlayer_,
942  maxDisToMaxperthickperlayer_);
943  //---
944  histograms.h_distancetomaxcell_perthickperlayer_eneweighted[istr] = ibook.book1D(
945  "distancetomaxcell_perthickperlayer_eneweighted_" + istr,
946  "energy weighted distance of cluster cells to max cell for layer " + istr3 + " for thickness " + istr1,
947  nintDisToMaxperthickperlayerenewei_,
948  minDisToMaxperthickperlayerenewei_,
949  maxDisToMaxperthickperlayerenewei_);
950  //---
951  histograms.h_distancebetseedandmaxcell_perthickperlayer[istr] =
952  ibook.book1D("distancebetseedandmaxcell_perthickperlayer_" + istr,
953  "distance of seed cell to max cell for layer " + istr3 + " for thickness " + istr1,
954  nintDisSeedToMaxperthickperlayer_,
955  minDisSeedToMaxperthickperlayer_,
956  maxDisSeedToMaxperthickperlayer_);
957  //---
958  histograms.h_distancebetseedandmaxcellvsclusterenergy_perthickperlayer[istr] = ibook.book2D(
959  "distancebetseedandmaxcellvsclusterenergy_perthickperlayer_" + istr,
960  "distance of seed cell to max cell vs cluster energy for layer " + istr3 + " for thickness " + istr1,
961  nintDisSeedToMaxperthickperlayer_,
962  minDisSeedToMaxperthickperlayer_,
963  maxDisSeedToMaxperthickperlayer_,
964  nintClEneperthickperlayer_,
965  minClEneperthickperlayer_,
966  maxClEneperthickperlayer_);
967  }
968  }
969 }
hgcalTBTopologyTester_cfi.layers
layers
Definition: hgcalTBTopologyTester_cfi.py:8
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
to_string
static std::string to_string(const XMLCh *ch)
Definition: TotemDAQMappingESSourceXML.cc:353
dqm::implementation::IBooker::book2D
MonitorElement * book2D(TString const &name, TString const &title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, FUNC onbooking=NOOP())
Definition: DQMStore.h:221
ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it
auto & it
Definition: splitVertices.h:28
dqm::implementation::IBooker::book1D
MonitorElement * book1D(TString const &name, TString const &title, int const nchX, double const lowX, double const highX, FUNC onbooking=NOOP())
Definition: DQMStore.h:98

◆ bookClusterHistos_ClusterLevel()

void HGVHistoProducerAlgo::bookClusterHistos_ClusterLevel ( DQMStore::IBooker &  ibook,
Histograms &  histograms,
unsigned int  layers,
std::vector< int >  thicknesses,
std::string  pathtomatbudfile 
)

Definition at line 600 of file HGVHistoProducerAlgo.cc.

References dqm::implementation::IBooker::book1D(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, hgcalTBTopologyTester_cfi::layers, maxEneCl_, maxEneClperlay_, maxEta_, maxLongDepBary_, maxMixedHitsCluster_, maxTotNClsperlay_, maxTotNClsperthick_, minEneCl_, minEneClperlay_, minEta_, minLongDepBary_, minMixedHitsCluster_, minTotNClsperlay_, minTotNClsperthick_, nintEneCl_, nintEneClperlay_, nintEta_, nintLongDepBary_, nintMixedHitsCluster_, nintTotNClsperlay_, nintTotNClsperthick_, AlCaHLTBitMon_QueryRunRegistry::string, and to_string().

604  {
605  //---------------------------------------------------------------------------------------------------------------------------
606  histograms.h_cluster_eta.push_back(
607  ibook.book1D("num_reco_cluster_eta", "N of reco clusters vs eta", nintEta_, minEta_, maxEta_));
608 
609  //---------------------------------------------------------------------------------------------------------------------------
610  //z-
611  histograms.h_mixedhitscluster_zminus.push_back(
612  ibook.book1D("mixedhitscluster_zminus",
613  "N of reco clusters that contain hits of more than one kind in z-",
614  nintMixedHitsCluster_,
615  minMixedHitsCluster_,
616  maxMixedHitsCluster_));
617  //z+
618  histograms.h_mixedhitscluster_zplus.push_back(
619  ibook.book1D("mixedhitscluster_zplus",
620  "N of reco clusters that contain hits of more than one kind in z+",
621  nintMixedHitsCluster_,
622  minMixedHitsCluster_,
623  maxMixedHitsCluster_));
624 
625  //---------------------------------------------------------------------------------------------------------------------------
626  //z-
627  histograms.h_energyclustered_zminus.push_back(
628  ibook.book1D("energyclustered_zminus",
629  "percent of total energy clustered by all layer clusters over CaloParticless energy in z-",
630  nintEneCl_,
631  minEneCl_,
632  maxEneCl_));
633  //z+
634  histograms.h_energyclustered_zplus.push_back(
635  ibook.book1D("energyclustered_zplus",
636  "percent of total energy clustered by all layer clusters over CaloParticless energy in z+",
637  nintEneCl_,
638  minEneCl_,
639  maxEneCl_));
640 
641  //---------------------------------------------------------------------------------------------------------------------------
642  //z-
643  std::string subpathtomat = pathtomatbudfile.substr(pathtomatbudfile.find("Validation"));
644  histograms.h_longdepthbarycentre_zminus.push_back(
645  ibook.book1D("longdepthbarycentre_zminus",
646  "The longitudinal depth barycentre in z- for " + subpathtomat,
647  nintLongDepBary_,
648  minLongDepBary_,
649  maxLongDepBary_));
650  //z+
651  histograms.h_longdepthbarycentre_zplus.push_back(
652  ibook.book1D("longdepthbarycentre_zplus",
653  "The longitudinal depth barycentre in z+ for " + subpathtomat,
654  nintLongDepBary_,
655  minLongDepBary_,
656  maxLongDepBary_));
657 
658  //---------------------------------------------------------------------------------------------------------------------------
659  for (unsigned ilayer = 0; ilayer < 2 * layers; ++ilayer) {
660  auto istr1 = std::to_string(ilayer);
661  while (istr1.size() < 2) {
662  istr1.insert(0, "0");
663  }
664  // Make a mapping to the regural layer naming plus z- or z+ for convenience
665  std::string istr2 = "";
666  // first with the -z endcap
667  if (ilayer < layers) {
668  istr2 = std::to_string(ilayer + 1) + " in z-";
669  } else { // then for the +z
670  istr2 = std::to_string(ilayer - (layers - 1)) + " in z+";
671  }
672  histograms.h_clusternum_perlayer[ilayer] = ibook.book1D("totclusternum_layer_" + istr1,
673  "total number of layer clusters for layer " + istr2,
674  nintTotNClsperlay_,
675  minTotNClsperlay_,
676  maxTotNClsperlay_);
677  histograms.h_energyclustered_perlayer[ilayer] = ibook.book1D(
678  "energyclustered_perlayer" + istr1,
679  "percent of total energy clustered by layer clusters over CaloParticless energy for layer " + istr2,
680  nintEneClperlay_,
681  minEneClperlay_,
682  maxEneClperlay_);
683  }
684 
685  //---------------------------------------------------------------------------------------------------------------------------
686  for (std::vector<int>::iterator it = thicknesses.begin(); it != thicknesses.end(); ++it) {
687  auto istr = std::to_string(*it);
688  histograms.h_clusternum_perthick[(*it)] = ibook.book1D("totclusternum_thick_" + istr,
689  "total number of layer clusters for thickness " + istr,
690  nintTotNClsperthick_,
691  minTotNClsperthick_,
692  maxTotNClsperthick_);
693  }
694  //---------------------------------------------------------------------------------------------------------------------------
695 }
hgcalTBTopologyTester_cfi.layers
layers
Definition: hgcalTBTopologyTester_cfi.py:8
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
to_string
static std::string to_string(const XMLCh *ch)
Definition: TotemDAQMappingESSourceXML.cc:353
ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it
auto & it
Definition: splitVertices.h:28
dqm::implementation::IBooker::book1D
MonitorElement * book1D(TString const &name, TString const &title, int const nchX, double const lowX, double const highX, FUNC onbooking=NOOP())
Definition: DQMStore.h:98

◆ bookClusterHistos_LCtoCP_association()

void HGVHistoProducerAlgo::bookClusterHistos_LCtoCP_association ( DQMStore::IBooker &  ibook,
Histograms &  histograms,
unsigned int  layers 
)

Definition at line 697 of file HGVHistoProducerAlgo.cc.

References dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), dqm::implementation::IBooker::bookProfile(), hgcalTBTopologyTester_cfi::layers, maxEta_, maxPhi_, maxScore_, maxSharedEneFrac_, minEta_, minPhi_, minScore_, minSharedEneFrac_, nintEta_, nintPhi_, nintScore_, nintSharedEneFrac_, AlCaHLTBitMon_QueryRunRegistry::string, and to_string().

699  {
700  //----------------------------------------------------------------------------------------------------------------------------
701  for (unsigned ilayer = 0; ilayer < 2 * layers; ++ilayer) {
702  auto istr1 = std::to_string(ilayer);
703  while (istr1.size() < 2) {
704  istr1.insert(0, "0");
705  }
706  // Make a mapping to the regural layer naming plus z- or z+ for convenience
707  std::string istr2 = "";
708  // first with the -z endcap
709  if (ilayer < layers) {
710  istr2 = std::to_string(ilayer + 1) + " in z-";
711  } else { // then for the +z
712  istr2 = std::to_string(ilayer - (layers - 1)) + " in z+";
713  }
714  histograms.h_score_layercl2caloparticle_perlayer[ilayer] =
715  ibook.book1D("Score_layercl2caloparticle_perlayer" + istr1,
716  "Score of Layer Cluster per CaloParticle for layer " + istr2,
717  nintScore_,
718  minScore_,
719  maxScore_);
720  histograms.h_score_caloparticle2layercl_perlayer[ilayer] =
721  ibook.book1D("Score_caloparticle2layercl_perlayer" + istr1,
722  "Score of CaloParticle per Layer Cluster for layer " + istr2,
723  nintScore_,
724  minScore_,
725  maxScore_);
726  histograms.h_energy_vs_score_caloparticle2layercl_perlayer[ilayer] =
727  ibook.book2D("Energy_vs_Score_caloparticle2layer_perlayer" + istr1,
728  "Energy vs Score of CaloParticle per Layer Cluster for layer " + istr2,
729  nintScore_,
730  minScore_,
731  maxScore_,
732  nintSharedEneFrac_,
733  minSharedEneFrac_,
734  maxSharedEneFrac_);
735  histograms.h_energy_vs_score_layercl2caloparticle_perlayer[ilayer] =
736  ibook.book2D("Energy_vs_Score_layer2caloparticle_perlayer" + istr1,
737  "Energy vs Score of Layer Cluster per CaloParticle Layer for layer " + istr2,
738  nintScore_,
739  minScore_,
740  maxScore_,
741  nintSharedEneFrac_,
742  minSharedEneFrac_,
743  maxSharedEneFrac_);
744  histograms.h_sharedenergy_caloparticle2layercl_perlayer[ilayer] =
745  ibook.book1D("SharedEnergy_caloparticle2layercl_perlayer" + istr1,
746  "Shared Energy of CaloParticle per Layer Cluster for layer " + istr2,
747  nintSharedEneFrac_,
748  minSharedEneFrac_,
749  maxSharedEneFrac_);
750  histograms.h_sharedenergy_caloparticle2layercl_vs_eta_perlayer[ilayer] =
751  ibook.bookProfile("SharedEnergy_caloparticle2layercl_vs_eta_perlayer" + istr1,
752  "Shared Energy of CaloParticle vs #eta per best Layer Cluster for layer " + istr2,
753  nintEta_,
754  minEta_,
755  maxEta_,
756  minSharedEneFrac_,
757  maxSharedEneFrac_);
758  histograms.h_sharedenergy_caloparticle2layercl_vs_phi_perlayer[ilayer] =
759  ibook.bookProfile("SharedEnergy_caloparticle2layercl_vs_phi_perlayer" + istr1,
760  "Shared Energy of CaloParticle vs #phi per best Layer Cluster for layer " + istr2,
761  nintPhi_,
762  minPhi_,
763  maxPhi_,
764  minSharedEneFrac_,
765  maxSharedEneFrac_);
766  histograms.h_sharedenergy_layercl2caloparticle_perlayer[ilayer] =
767  ibook.book1D("SharedEnergy_layercluster2caloparticle_perlayer" + istr1,
768  "Shared Energy of Layer Cluster per Layer Calo Particle for layer " + istr2,
769  nintSharedEneFrac_,
770  minSharedEneFrac_,
771  maxSharedEneFrac_);
772  histograms.h_sharedenergy_layercl2caloparticle_vs_eta_perlayer[ilayer] =
773  ibook.bookProfile("SharedEnergy_layercl2caloparticle_vs_eta_perlayer" + istr1,
774  "Shared Energy of LayerCluster vs #eta per best Calo Particle for layer " + istr2,
775  nintEta_,
776  minEta_,
777  maxEta_,
778  minSharedEneFrac_,
779  maxSharedEneFrac_);
780  histograms.h_sharedenergy_layercl2caloparticle_vs_phi_perlayer[ilayer] =
781  ibook.bookProfile("SharedEnergy_layercl2caloparticle_vs_phi_perlayer" + istr1,
782  "Shared Energy of LayerCluster vs #phi per best Calo Particle for layer " + istr2,
783  nintPhi_,
784  minPhi_,
785  maxPhi_,
786  minSharedEneFrac_,
787  maxSharedEneFrac_);
788  histograms.h_num_caloparticle_eta_perlayer[ilayer] =
789  ibook.book1D("Num_CaloParticle_Eta_perlayer" + istr1,
790  "Num CaloParticle Eta per Layer Cluster for layer " + istr2,
791  nintEta_,
792  minEta_,
793  maxEta_);
794  histograms.h_numDup_caloparticle_eta_perlayer[ilayer] =
795  ibook.book1D("NumDup_CaloParticle_Eta_perlayer" + istr1,
796  "Num Duplicate CaloParticle Eta per Layer Cluster for layer " + istr2,
797  nintEta_,
798  minEta_,
799  maxEta_);
800  histograms.h_denom_caloparticle_eta_perlayer[ilayer] =
801  ibook.book1D("Denom_CaloParticle_Eta_perlayer" + istr1,
802  "Denom CaloParticle Eta per Layer Cluster for layer " + istr2,
803  nintEta_,
804  minEta_,
805  maxEta_);
806  histograms.h_num_caloparticle_phi_perlayer[ilayer] =
807  ibook.book1D("Num_CaloParticle_Phi_perlayer" + istr1,
808  "Num CaloParticle Phi per Layer Cluster for layer " + istr2,
809  nintPhi_,
810  minPhi_,
811  maxPhi_);
812  histograms.h_numDup_caloparticle_phi_perlayer[ilayer] =
813  ibook.book1D("NumDup_CaloParticle_Phi_perlayer" + istr1,
814  "Num Duplicate CaloParticle Phi per Layer Cluster for layer " + istr2,
815  nintPhi_,
816  minPhi_,
817  maxPhi_);
818  histograms.h_denom_caloparticle_phi_perlayer[ilayer] =
819  ibook.book1D("Denom_CaloParticle_Phi_perlayer" + istr1,
820  "Denom CaloParticle Phi per Layer Cluster for layer " + istr2,
821  nintPhi_,
822  minPhi_,
823  maxPhi_);
824  histograms.h_num_layercl_eta_perlayer[ilayer] =
825  ibook.book1D("Num_LayerCluster_Eta_perlayer" + istr1,
826  "Num LayerCluster Eta per Layer Cluster for layer " + istr2,
827  nintEta_,
828  minEta_,
829  maxEta_);
830  histograms.h_numMerge_layercl_eta_perlayer[ilayer] =
831  ibook.book1D("NumMerge_LayerCluster_Eta_perlayer" + istr1,
832  "Num Merge LayerCluster Eta per Layer Cluster for layer " + istr2,
833  nintEta_,
834  minEta_,
835  maxEta_);
836  histograms.h_denom_layercl_eta_perlayer[ilayer] =
837  ibook.book1D("Denom_LayerCluster_Eta_perlayer" + istr1,
838  "Denom LayerCluster Eta per Layer Cluster for layer " + istr2,
839  nintEta_,
840  minEta_,
841  maxEta_);
842  histograms.h_num_layercl_phi_perlayer[ilayer] =
843  ibook.book1D("Num_LayerCluster_Phi_perlayer" + istr1,
844  "Num LayerCluster Phi per Layer Cluster for layer " + istr2,
845  nintPhi_,
846  minPhi_,
847  maxPhi_);
848  histograms.h_numMerge_layercl_phi_perlayer[ilayer] =
849  ibook.book1D("NumMerge_LayerCluster_Phi_perlayer" + istr1,
850  "Num Merge LayerCluster Phi per Layer Cluster for layer " + istr2,
851  nintPhi_,
852  minPhi_,
853  maxPhi_);
854  histograms.h_denom_layercl_phi_perlayer[ilayer] =
855  ibook.book1D("Denom_LayerCluster_Phi_perlayer" + istr1,
856  "Denom LayerCluster Phi per Layer Cluster for layer " + istr2,
857  nintPhi_,
858  minPhi_,
859  maxPhi_);
860  }
861  //---------------------------------------------------------------------------------------------------------------------------
862 }
hgcalTBTopologyTester_cfi.layers
layers
Definition: hgcalTBTopologyTester_cfi.py:8
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
to_string
static std::string to_string(const XMLCh *ch)
Definition: TotemDAQMappingESSourceXML.cc:353
dqm::implementation::IBooker::bookProfile
MonitorElement * bookProfile(TString const &name, TString const &title, int nchX, double lowX, double highX, int, double lowY, double highY, char const *option="s", FUNC onbooking=NOOP())
Definition: DQMStore.h:408
dqm::implementation::IBooker::book2D
MonitorElement * book2D(TString const &name, TString const &title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, FUNC onbooking=NOOP())
Definition: DQMStore.h:221
dqm::implementation::IBooker::book1D
MonitorElement * book1D(TString const &name, TString const &title, int const nchX, double const lowX, double const highX, FUNC onbooking=NOOP())
Definition: DQMStore.h:98

◆ bookInfo()

void HGVHistoProducerAlgo::bookInfo ( DQMStore::IBooker &  ibook,
Histograms &  histograms 
)

Definition at line 205 of file HGVHistoProducerAlgo.cc.

References dqm::implementation::IBooker::bookInt().

205  {
206  histograms.lastLayerEEzm = ibook.bookInt("lastLayerEEzm");
207  histograms.lastLayerFHzm = ibook.bookInt("lastLayerFHzm");
208  histograms.maxlayerzm = ibook.bookInt("maxlayerzm");
209  histograms.lastLayerEEzp = ibook.bookInt("lastLayerEEzp");
210  histograms.lastLayerFHzp = ibook.bookInt("lastLayerFHzp");
211  histograms.maxlayerzp = ibook.bookInt("maxlayerzp");
212 }
dqm::implementation::IBooker::bookInt
MonitorElement * bookInt(TString const &name, FUNC onbooking=NOOP())
Definition: DQMStore.h:73

◆ bookSimClusterAssociationHistos()

void HGVHistoProducerAlgo::bookSimClusterAssociationHistos ( DQMStore::IBooker &  ibook,
Histograms &  histograms,
unsigned int  layers,
std::vector< int >  thicknesses 
)

Definition at line 343 of file HGVHistoProducerAlgo.cc.

References dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), dqm::implementation::IBooker::bookProfile(), hgcalTBTopologyTester_cfi::layers, maxEta_, maxPhi_, maxScore_, maxSharedEneFrac_, minEta_, minPhi_, minScore_, minSharedEneFrac_, eostools::move(), nintEta_, nintPhi_, nintScore_, nintSharedEneFrac_, AlCaHLTBitMon_QueryRunRegistry::string, and to_string().

346  {
347  std::unordered_map<int, dqm::reco::MonitorElement*> denom_layercl_in_simcl_eta_perlayer;
348  denom_layercl_in_simcl_eta_perlayer.clear();
349  std::unordered_map<int, dqm::reco::MonitorElement*> denom_layercl_in_simcl_phi_perlayer;
350  denom_layercl_in_simcl_phi_perlayer.clear();
351  std::unordered_map<int, dqm::reco::MonitorElement*> score_layercl2simcluster_perlayer;
352  score_layercl2simcluster_perlayer.clear();
353  std::unordered_map<int, dqm::reco::MonitorElement*> sharedenergy_layercl2simcluster_perlayer;
354  sharedenergy_layercl2simcluster_perlayer.clear();
355  std::unordered_map<int, dqm::reco::MonitorElement*> energy_vs_score_layercl2simcluster_perlayer;
356  energy_vs_score_layercl2simcluster_perlayer.clear();
357  std::unordered_map<int, dqm::reco::MonitorElement*> num_layercl_in_simcl_eta_perlayer;
358  num_layercl_in_simcl_eta_perlayer.clear();
359  std::unordered_map<int, dqm::reco::MonitorElement*> num_layercl_in_simcl_phi_perlayer;
360  num_layercl_in_simcl_phi_perlayer.clear();
361  std::unordered_map<int, dqm::reco::MonitorElement*> numMerge_layercl_in_simcl_eta_perlayer;
362  numMerge_layercl_in_simcl_eta_perlayer.clear();
363  std::unordered_map<int, dqm::reco::MonitorElement*> numMerge_layercl_in_simcl_phi_perlayer;
364  numMerge_layercl_in_simcl_phi_perlayer.clear();
365  std::unordered_map<int, dqm::reco::MonitorElement*> sharedenergy_layercl2simcluster_vs_eta_perlayer;
366  sharedenergy_layercl2simcluster_vs_eta_perlayer.clear();
367  std::unordered_map<int, dqm::reco::MonitorElement*> sharedenergy_layercl2simcluster_vs_phi_perlayer;
368  sharedenergy_layercl2simcluster_vs_phi_perlayer.clear();
369  std::unordered_map<int, dqm::reco::MonitorElement*> denom_simcluster_eta_perlayer;
370  denom_simcluster_eta_perlayer.clear();
371  std::unordered_map<int, dqm::reco::MonitorElement*> denom_simcluster_phi_perlayer;
372  denom_simcluster_phi_perlayer.clear();
373  std::unordered_map<int, dqm::reco::MonitorElement*> score_simcluster2layercl_perlayer;
374  score_simcluster2layercl_perlayer.clear();
375  std::unordered_map<int, dqm::reco::MonitorElement*> sharedenergy_simcluster2layercl_perlayer;
376  sharedenergy_simcluster2layercl_perlayer.clear();
377  std::unordered_map<int, dqm::reco::MonitorElement*> energy_vs_score_simcluster2layercl_perlayer;
378  energy_vs_score_simcluster2layercl_perlayer.clear();
379  std::unordered_map<int, dqm::reco::MonitorElement*> num_simcluster_eta_perlayer;
380  num_simcluster_eta_perlayer.clear();
381  std::unordered_map<int, dqm::reco::MonitorElement*> num_simcluster_phi_perlayer;
382  num_simcluster_phi_perlayer.clear();
383  std::unordered_map<int, dqm::reco::MonitorElement*> numDup_simcluster_eta_perlayer;
384  numDup_simcluster_eta_perlayer.clear();
385  std::unordered_map<int, dqm::reco::MonitorElement*> numDup_simcluster_phi_perlayer;
386  numDup_simcluster_phi_perlayer.clear();
387  std::unordered_map<int, dqm::reco::MonitorElement*> sharedenergy_simcluster2layercl_vs_eta_perlayer;
388  sharedenergy_simcluster2layercl_vs_eta_perlayer.clear();
389  std::unordered_map<int, dqm::reco::MonitorElement*> sharedenergy_simcluster2layercl_vs_phi_perlayer;
390  sharedenergy_simcluster2layercl_vs_phi_perlayer.clear();
391 
392  //---------------------------------------------------------------------------------------------------------------------------
393  for (unsigned ilayer = 0; ilayer < 2 * layers; ++ilayer) {
394  auto istr1 = std::to_string(ilayer);
395  while (istr1.size() < 2) {
396  istr1.insert(0, "0");
397  }
398  // Make a mapping to the regural layer naming plus z- or z+ for convenience
399  std::string istr2 = "";
400  // first with the -z endcap
401  if (ilayer < layers) {
402  istr2 = std::to_string(ilayer + 1) + " in z-";
403  } else { // then for the +z
404  istr2 = std::to_string(ilayer - (layers - 1)) + " in z+";
405  }
406  //-------------------------------------------------------------------------------------------------------------------------
407  denom_layercl_in_simcl_eta_perlayer[ilayer] =
408  ibook.book1D("Denom_LayerCluster_in_SimCluster_Eta_perlayer" + istr1,
409  "Denom LayerCluster in SimCluster Eta per Layer Cluster for layer " + istr2,
410  nintEta_,
411  minEta_,
412  maxEta_);
413  //-------------------------------------------------------------------------------------------------------------------------
414  denom_layercl_in_simcl_phi_perlayer[ilayer] =
415  ibook.book1D("Denom_LayerCluster_in_SimCluster_Phi_perlayer" + istr1,
416  "Denom LayerCluster in SimCluster Phi per Layer Cluster for layer " + istr2,
417  nintPhi_,
418  minPhi_,
419  maxPhi_);
420  //-------------------------------------------------------------------------------------------------------------------------
421  score_layercl2simcluster_perlayer[ilayer] = ibook.book1D("Score_layercl2simcluster_perlayer" + istr1,
422  "Score of Layer Cluster per SimCluster for layer " + istr2,
423  nintScore_,
424  minScore_,
425  maxScore_);
426  //-------------------------------------------------------------------------------------------------------------------------
427  score_simcluster2layercl_perlayer[ilayer] = ibook.book1D("Score_simcluster2layercl_perlayer" + istr1,
428  "Score of SimCluster per Layer Cluster for layer " + istr2,
429  nintScore_,
430  minScore_,
431  maxScore_);
432  //-------------------------------------------------------------------------------------------------------------------------
433  energy_vs_score_simcluster2layercl_perlayer[ilayer] =
434  ibook.book2D("Energy_vs_Score_simcluster2layer_perlayer" + istr1,
435  "Energy vs Score of SimCluster per Layer Cluster for layer " + istr2,
436  nintScore_,
437  minScore_,
438  maxScore_,
439  nintSharedEneFrac_,
440  minSharedEneFrac_,
441  maxSharedEneFrac_);
442  //-------------------------------------------------------------------------------------------------------------------------
443  energy_vs_score_layercl2simcluster_perlayer[ilayer] =
444  ibook.book2D("Energy_vs_Score_layer2simcluster_perlayer" + istr1,
445  "Energy vs Score of Layer Cluster per SimCluster for layer " + istr2,
446  nintScore_,
447  minScore_,
448  maxScore_,
449  nintSharedEneFrac_,
450  minSharedEneFrac_,
451  maxSharedEneFrac_);
452  //-------------------------------------------------------------------------------------------------------------------------
453  sharedenergy_simcluster2layercl_perlayer[ilayer] =
454  ibook.book1D("SharedEnergy_simcluster2layercl_perlayer" + istr1,
455  "Shared Energy of SimCluster per Layer Cluster for layer " + istr2,
456  nintSharedEneFrac_,
457  minSharedEneFrac_,
458  maxSharedEneFrac_);
459  //-------------------------------------------------------------------------------------------------------------------------
460  sharedenergy_simcluster2layercl_vs_eta_perlayer[ilayer] =
461  ibook.bookProfile("SharedEnergy_simcluster2layercl_vs_eta_perlayer" + istr1,
462  "Shared Energy of SimCluster vs #eta per best Layer Cluster for layer " + istr2,
463  nintEta_,
464  minEta_,
465  maxEta_,
466  minSharedEneFrac_,
467  maxSharedEneFrac_);
468  //-------------------------------------------------------------------------------------------------------------------------
469  sharedenergy_simcluster2layercl_vs_phi_perlayer[ilayer] =
470  ibook.bookProfile("SharedEnergy_simcluster2layercl_vs_phi_perlayer" + istr1,
471  "Shared Energy of SimCluster vs #phi per best Layer Cluster for layer " + istr2,
472  nintPhi_,
473  minPhi_,
474  maxPhi_,
475  minSharedEneFrac_,
476  maxSharedEneFrac_);
477  //-------------------------------------------------------------------------------------------------------------------------
478  sharedenergy_layercl2simcluster_perlayer[ilayer] =
479  ibook.book1D("SharedEnergy_layercluster2simcluster_perlayer" + istr1,
480  "Shared Energy of Layer Cluster per SimCluster for layer " + istr2,
481  nintSharedEneFrac_,
482  minSharedEneFrac_,
483  maxSharedEneFrac_);
484  //-------------------------------------------------------------------------------------------------------------------------
485  sharedenergy_layercl2simcluster_vs_eta_perlayer[ilayer] =
486  ibook.bookProfile("SharedEnergy_layercl2simcluster_vs_eta_perlayer" + istr1,
487  "Shared Energy of LayerCluster vs #eta per best SimCluster for layer " + istr2,
488  nintEta_,
489  minEta_,
490  maxEta_,
491  minSharedEneFrac_,
492  maxSharedEneFrac_);
493  //-------------------------------------------------------------------------------------------------------------------------
494  sharedenergy_layercl2simcluster_vs_phi_perlayer[ilayer] =
495  ibook.bookProfile("SharedEnergy_layercl2simcluster_vs_phi_perlayer" + istr1,
496  "Shared Energy of LayerCluster vs #phi per best SimCluster for layer " + istr2,
497  nintPhi_,
498  minPhi_,
499  maxPhi_,
500  minSharedEneFrac_,
501  maxSharedEneFrac_);
502  //-------------------------------------------------------------------------------------------------------------------------
503  num_simcluster_eta_perlayer[ilayer] = ibook.book1D("Num_SimCluster_Eta_perlayer" + istr1,
504  "Num SimCluster Eta per Layer Cluster for layer " + istr2,
505  nintEta_,
506  minEta_,
507  maxEta_);
508  //-------------------------------------------------------------------------------------------------------------------------
509  numDup_simcluster_eta_perlayer[ilayer] =
510  ibook.book1D("NumDup_SimCluster_Eta_perlayer" + istr1,
511  "Num Duplicate SimCluster Eta per Layer Cluster for layer " + istr2,
512  nintEta_,
513  minEta_,
514  maxEta_);
515  //-------------------------------------------------------------------------------------------------------------------------
516  denom_simcluster_eta_perlayer[ilayer] = ibook.book1D("Denom_SimCluster_Eta_perlayer" + istr1,
517  "Denom SimCluster Eta per Layer Cluster for layer " + istr2,
518  nintEta_,
519  minEta_,
520  maxEta_);
521  //-------------------------------------------------------------------------------------------------------------------------
522  num_simcluster_phi_perlayer[ilayer] = ibook.book1D("Num_SimCluster_Phi_perlayer" + istr1,
523  "Num SimCluster Phi per Layer Cluster for layer " + istr2,
524  nintPhi_,
525  minPhi_,
526  maxPhi_);
527  //-------------------------------------------------------------------------------------------------------------------------
528  numDup_simcluster_phi_perlayer[ilayer] =
529  ibook.book1D("NumDup_SimCluster_Phi_perlayer" + istr1,
530  "Num Duplicate SimCluster Phi per Layer Cluster for layer " + istr2,
531  nintPhi_,
532  minPhi_,
533  maxPhi_);
534  //-------------------------------------------------------------------------------------------------------------------------
535  denom_simcluster_phi_perlayer[ilayer] = ibook.book1D("Denom_SimCluster_Phi_perlayer" + istr1,
536  "Denom SimCluster Phi per Layer Cluster for layer " + istr2,
537  nintPhi_,
538  minPhi_,
539  maxPhi_);
540  //-------------------------------------------------------------------------------------------------------------------------
541  num_layercl_in_simcl_eta_perlayer[ilayer] =
542  ibook.book1D("Num_LayerCluster_in_SimCluster_Eta_perlayer" + istr1,
543  "Num LayerCluster Eta per Layer Cluster in SimCluster for layer " + istr2,
544  nintEta_,
545  minEta_,
546  maxEta_);
547  //-------------------------------------------------------------------------------------------------------------------------
548  numMerge_layercl_in_simcl_eta_perlayer[ilayer] =
549  ibook.book1D("NumMerge_LayerCluster_in_SimCluster_Eta_perlayer" + istr1,
550  "Num Merge LayerCluster Eta per Layer Cluster in SimCluster for layer " + istr2,
551  nintEta_,
552  minEta_,
553  maxEta_);
554  //-------------------------------------------------------------------------------------------------------------------------
555  num_layercl_in_simcl_phi_perlayer[ilayer] =
556  ibook.book1D("Num_LayerCluster_in_SimCluster_Phi_perlayer" + istr1,
557  "Num LayerCluster Phi per Layer Cluster in SimCluster for layer " + istr2,
558  nintPhi_,
559  minPhi_,
560  maxPhi_);
561  //-------------------------------------------------------------------------------------------------------------------------
562  numMerge_layercl_in_simcl_phi_perlayer[ilayer] =
563  ibook.book1D("NumMerge_LayerCluster_in_SimCluster_Phi_perlayer" + istr1,
564  "Num Merge LayerCluster Phi per Layer Cluster in SimCluster for layer " + istr2,
565  nintPhi_,
566  minPhi_,
567  maxPhi_);
568 
569  } //end of loop over layers
570 
571  histograms.h_denom_layercl_in_simcl_eta_perlayer.push_back(std::move(denom_layercl_in_simcl_eta_perlayer));
572  histograms.h_denom_layercl_in_simcl_phi_perlayer.push_back(std::move(denom_layercl_in_simcl_phi_perlayer));
573  histograms.h_score_layercl2simcluster_perlayer.push_back(std::move(score_layercl2simcluster_perlayer));
574  histograms.h_sharedenergy_layercl2simcluster_perlayer.push_back(std::move(sharedenergy_layercl2simcluster_perlayer));
575  histograms.h_energy_vs_score_layercl2simcluster_perlayer.push_back(
576  std::move(energy_vs_score_layercl2simcluster_perlayer));
577  histograms.h_num_layercl_in_simcl_eta_perlayer.push_back(std::move(num_layercl_in_simcl_eta_perlayer));
578  histograms.h_num_layercl_in_simcl_phi_perlayer.push_back(std::move(num_layercl_in_simcl_phi_perlayer));
579  histograms.h_numMerge_layercl_in_simcl_eta_perlayer.push_back(std::move(numMerge_layercl_in_simcl_eta_perlayer));
580  histograms.h_numMerge_layercl_in_simcl_phi_perlayer.push_back(std::move(numMerge_layercl_in_simcl_phi_perlayer));
581  histograms.h_sharedenergy_layercl2simcluster_vs_eta_perlayer.push_back(
582  std::move(sharedenergy_layercl2simcluster_vs_eta_perlayer));
583  histograms.h_sharedenergy_layercl2simcluster_vs_phi_perlayer.push_back(
584  std::move(sharedenergy_layercl2simcluster_vs_phi_perlayer));
585  histograms.h_denom_simcluster_eta_perlayer.push_back(std::move(denom_simcluster_eta_perlayer));
586  histograms.h_denom_simcluster_phi_perlayer.push_back(std::move(denom_simcluster_phi_perlayer));
587  histograms.h_score_simcluster2layercl_perlayer.push_back(std::move(score_simcluster2layercl_perlayer));
588  histograms.h_sharedenergy_simcluster2layercl_perlayer.push_back(std::move(sharedenergy_simcluster2layercl_perlayer));
589  histograms.h_energy_vs_score_simcluster2layercl_perlayer.push_back(
590  std::move(energy_vs_score_simcluster2layercl_perlayer));
591  histograms.h_num_simcluster_eta_perlayer.push_back(std::move(num_simcluster_eta_perlayer));
592  histograms.h_num_simcluster_phi_perlayer.push_back(std::move(num_simcluster_phi_perlayer));
593  histograms.h_numDup_simcluster_eta_perlayer.push_back(std::move(numDup_simcluster_eta_perlayer));
594  histograms.h_numDup_simcluster_phi_perlayer.push_back(std::move(numDup_simcluster_phi_perlayer));
595  histograms.h_sharedenergy_simcluster2layercl_vs_eta_perlayer.push_back(
596  std::move(sharedenergy_simcluster2layercl_vs_eta_perlayer));
597  histograms.h_sharedenergy_simcluster2layercl_vs_phi_perlayer.push_back(
598  std::move(sharedenergy_simcluster2layercl_vs_phi_perlayer));
599 }
hgcalTBTopologyTester_cfi.layers
layers
Definition: hgcalTBTopologyTester_cfi.py:8
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
to_string
static std::string to_string(const XMLCh *ch)
Definition: TotemDAQMappingESSourceXML.cc:353
dqm::implementation::IBooker::bookProfile
MonitorElement * bookProfile(TString const &name, TString const &title, int nchX, double lowX, double highX, int, double lowY, double highY, char const *option="s", FUNC onbooking=NOOP())
Definition: DQMStore.h:408
dqm::implementation::IBooker::book2D
MonitorElement * book2D(TString const &name, TString const &title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, FUNC onbooking=NOOP())
Definition: DQMStore.h:221
dqm::implementation::IBooker::book1D
MonitorElement * book1D(TString const &name, TString const &title, int const nchX, double const lowX, double const highX, FUNC onbooking=NOOP())
Definition: DQMStore.h:98
eostools.move
def move(src, dest)
Definition: eostools.py:511

◆ bookSimClusterHistos()

void HGVHistoProducerAlgo::bookSimClusterHistos ( DQMStore::IBooker &  ibook,
Histograms &  histograms,
unsigned int  layers,
std::vector< int >  thicknesses 
)

Definition at line 291 of file HGVHistoProducerAlgo.cc.

References dqm::implementation::IBooker::book1D(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, hgcalTBTopologyTester_cfi::layers, maxMixedHitsSimCluster_, maxTotNsimClsperlay_, maxTotNsimClsperthick_, minMixedHitsSimCluster_, minTotNsimClsperlay_, minTotNsimClsperthick_, nintMixedHitsSimCluster_, nintTotNsimClsperlay_, nintTotNsimClsperthick_, AlCaHLTBitMon_QueryRunRegistry::string, and to_string().

294  {
295  //---------------------------------------------------------------------------------------------------------------------------
296  for (unsigned ilayer = 0; ilayer < 2 * layers; ++ilayer) {
297  auto istr1 = std::to_string(ilayer);
298  while (istr1.size() < 2) {
299  istr1.insert(0, "0");
300  }
301  // Make a mapping to the regural layer naming plus z- or z+ for convenience
302  std::string istr2 = "";
303  // first with the -z endcap
304  if (ilayer < layers) {
305  istr2 = std::to_string(ilayer + 1) + " in z-";
306  } else { // then for the +z
307  istr2 = std::to_string(ilayer - (layers - 1)) + " in z+";
308  }
309  histograms.h_simclusternum_perlayer[ilayer] = ibook.book1D("totsimclusternum_layer_" + istr1,
310  "total number of SimClusters for layer " + istr2,
311  nintTotNsimClsperlay_,
312  minTotNsimClsperlay_,
313  maxTotNsimClsperlay_);
314 
315  } //end of loop over layers
316  //---------------------------------------------------------------------------------------------------------------------------
317  for (std::vector<int>::iterator it = thicknesses.begin(); it != thicknesses.end(); ++it) {
318  auto istr = std::to_string(*it);
319  histograms.h_simclusternum_perthick[(*it)] = ibook.book1D("totsimclusternum_thick_" + istr,
320  "total number of simclusters for thickness " + istr,
321  nintTotNsimClsperthick_,
322  minTotNsimClsperthick_,
323  maxTotNsimClsperthick_);
324  } //end of loop over thicknesses
325 
326  //---------------------------------------------------------------------------------------------------------------------------
327  //z-
328  histograms.h_mixedhitssimcluster_zminus =
329  ibook.book1D("mixedhitssimcluster_zminus",
330  "N of simclusters that contain hits of more than one kind in z-",
331  nintMixedHitsSimCluster_,
332  minMixedHitsSimCluster_,
333  maxMixedHitsSimCluster_);
334  //z+
335  histograms.h_mixedhitssimcluster_zplus =
336  ibook.book1D("mixedhitssimcluster_zplus",
337  "N of simclusters that contain hits of more than one kind in z+",
338  nintMixedHitsSimCluster_,
339  minMixedHitsSimCluster_,
340  maxMixedHitsSimCluster_);
341 }
hgcalTBTopologyTester_cfi.layers
layers
Definition: hgcalTBTopologyTester_cfi.py:8
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
to_string
static std::string to_string(const XMLCh *ch)
Definition: TotemDAQMappingESSourceXML.cc:353
ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it
auto & it
Definition: splitVertices.h:28
dqm::implementation::IBooker::book1D
MonitorElement * book1D(TString const &name, TString const &title, int const nchX, double const lowX, double const highX, FUNC onbooking=NOOP())
Definition: DQMStore.h:98

◆ bookTracksterHistos()

void HGVHistoProducerAlgo::bookTracksterHistos ( DQMStore::IBooker &  ibook,
Histograms &  histograms,
unsigned int  layers 
)

Definition at line 972 of file HGVHistoProducerAlgo.cc.

References dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), dqm::implementation::IBooker::bookProfile(), hgcalTBTopologyTester_cfi::layers, maxClEnepermultiplicity_, maxEne_, maxEta_, maxMplofLCs_, maxPhi_, maxPt_, maxSizeCLsinTSTs_, maxTotNClsinTSTs_, maxTotNClsinTSTsperlayer_, maxTotNTSTs_, maxX_, maxY_, maxZ_, minClEnepermultiplicity_, minEne_, minEta_, minMplofLCs_, minPhi_, minPt_, minSizeCLsinTSTs_, minTotNClsinTSTs_, minTotNClsinTSTsperlayer_, minTotNTSTs_, minX_, minY_, minZ_, eostools::move(), nintClEnepermultiplicity_, nintEne_, nintEta_, nintMplofLCs_, nintPhi_, nintPt_, nintSizeCLsinTSTs_, nintTotNClsinTSTs_, nintTotNClsinTSTsperlayer_, nintTotNTSTs_, nintX_, nintY_, nintZ_, AlCaHLTBitMon_QueryRunRegistry::string, and to_string().

972  {
973  std::unordered_map<int, dqm::reco::MonitorElement*> clusternum_in_trackster_perlayer;
974  clusternum_in_trackster_perlayer.clear();
975 
976  for (unsigned ilayer = 0; ilayer < 2 * layers; ++ilayer) {
977  auto istr1 = std::to_string(ilayer);
978  while (istr1.size() < 2) {
979  istr1.insert(0, "0");
980  }
981  // Make a mapping to the regural layer naming plus z- or z+ for convenience
982  std::string istr2 = "";
983  // first with the -z endcap
984  if (ilayer < layers) {
985  istr2 = std::to_string(ilayer + 1) + " in z-";
986  } else { // then for the +z
987  istr2 = std::to_string(ilayer - (layers - 1)) + " in z+";
988  }
989 
990  clusternum_in_trackster_perlayer[ilayer] = ibook.book1D("clusternum_in_trackster_perlayer" + istr1,
991  "Number of layer clusters in Trackster for layer " + istr2,
992  nintTotNClsinTSTsperlayer_,
993  minTotNClsinTSTsperlayer_,
994  maxTotNClsinTSTsperlayer_);
995  }
996 
997  histograms.h_clusternum_in_trackster_perlayer.push_back(std::move(clusternum_in_trackster_perlayer));
998 
999  histograms.h_tracksternum.push_back(ibook.book1D(
1000  "tottracksternum", "total number of Tracksters;# of Tracksters", nintTotNTSTs_, minTotNTSTs_, maxTotNTSTs_));
1001 
1002  histograms.h_conttracksternum.push_back(ibook.book1D(
1003  "conttracksternum", "number of Tracksters with 3 contiguous layers", nintTotNTSTs_, minTotNTSTs_, maxTotNTSTs_));
1004 
1005  histograms.h_nonconttracksternum.push_back(ibook.book1D("nonconttracksternum",
1006  "number of Tracksters without 3 contiguous layers",
1007  nintTotNTSTs_,
1008  minTotNTSTs_,
1009  maxTotNTSTs_));
1010 
1011  histograms.h_clusternum_in_trackster.push_back(
1012  ibook.book1D("clusternum_in_trackster",
1013  "total number of layer clusters in Trackster;# of LayerClusters",
1014  nintTotNClsinTSTs_,
1015  minTotNClsinTSTs_,
1016  maxTotNClsinTSTs_));
1017 
1018  histograms.h_clusternum_in_trackster_vs_layer.push_back(ibook.bookProfile(
1019  "clusternum_in_trackster_vs_layer",
1020  "Profile of 2d layer clusters in Trackster vs layer number;layer number;<2D LayerClusters in Trackster>",
1021  2 * layers,
1022  0.,
1023  2. * layers,
1024  minTotNClsinTSTsperlayer_,
1025  maxTotNClsinTSTsperlayer_));
1026 
1027  histograms.h_multiplicityOfLCinTST.push_back(
1028  ibook.book2D("multiplicityOfLCinTST",
1029  "Multiplicity vs Layer cluster size in Tracksters;LayerCluster multiplicity in Tracksters;Cluster "
1030  "size (n_{hits})",
1031  nintMplofLCs_,
1032  minMplofLCs_,
1033  maxMplofLCs_,
1034  nintSizeCLsinTSTs_,
1035  minSizeCLsinTSTs_,
1036  maxSizeCLsinTSTs_));
1037 
1038  histograms.h_multiplicity_numberOfEventsHistogram.push_back(ibook.book1D("multiplicity_numberOfEventsHistogram",
1039  "multiplicity numberOfEventsHistogram",
1040  nintMplofLCs_,
1041  minMplofLCs_,
1042  maxMplofLCs_));
1043 
1044  histograms.h_multiplicity_zminus_numberOfEventsHistogram.push_back(
1045  ibook.book1D("multiplicity_zminus_numberOfEventsHistogram",
1046  "multiplicity numberOfEventsHistogram in z-",
1047  nintMplofLCs_,
1048  minMplofLCs_,
1049  maxMplofLCs_));
1050 
1051  histograms.h_multiplicity_zplus_numberOfEventsHistogram.push_back(
1052  ibook.book1D("multiplicity_zplus_numberOfEventsHistogram",
1053  "multiplicity numberOfEventsHistogram in z+",
1054  nintMplofLCs_,
1055  minMplofLCs_,
1056  maxMplofLCs_));
1057 
1058  histograms.h_multiplicityOfLCinTST_vs_layercluster_zminus.push_back(
1059  ibook.book2D("multiplicityOfLCinTST_vs_layercluster_zminus",
1060  "Multiplicity vs Layer number in z-;LayerCluster multiplicity in Tracksters;layer number",
1061  nintMplofLCs_,
1062  minMplofLCs_,
1063  maxMplofLCs_,
1064  layers,
1065  0.,
1066  (float)layers));
1067 
1068  histograms.h_multiplicityOfLCinTST_vs_layercluster_zplus.push_back(
1069  ibook.book2D("multiplicityOfLCinTST_vs_layercluster_zplus",
1070  "Multiplicity vs Layer number in z+;LayerCluster multiplicity in Tracksters;layer number",
1071  nintMplofLCs_,
1072  minMplofLCs_,
1073  maxMplofLCs_,
1074  layers,
1075  0.,
1076  (float)layers));
1077 
1078  histograms.h_multiplicityOfLCinTST_vs_layerclusterenergy.push_back(
1079  ibook.book2D("multiplicityOfLCinTST_vs_layerclusterenergy",
1080  "Multiplicity vs Layer cluster energy;LayerCluster multiplicity in Tracksters;Cluster energy [GeV]",
1081  nintMplofLCs_,
1082  minMplofLCs_,
1083  maxMplofLCs_,
1084  nintClEnepermultiplicity_,
1085  minClEnepermultiplicity_,
1086  maxClEnepermultiplicity_));
1087 
1088  histograms.h_trackster_pt.push_back(
1089  ibook.book1D("trackster_pt", "Pt of the Trackster;Trackster p_{T} [GeV]", nintPt_, minPt_, maxPt_));
1090  histograms.h_trackster_eta.push_back(
1091  ibook.book1D("trackster_eta", "Eta of the Trackster;Trackster #eta", nintEta_, minEta_, maxEta_));
1092  histograms.h_trackster_phi.push_back(
1093  ibook.book1D("trackster_phi", "Phi of the Trackster;Trackster #phi", nintPhi_, minPhi_, maxPhi_));
1094  histograms.h_trackster_energy.push_back(
1095  ibook.book1D("trackster_energy", "Energy of the Trackster;Trackster energy [GeV]", nintEne_, minEne_, maxEne_));
1096  histograms.h_trackster_x.push_back(
1097  ibook.book1D("trackster_x", "X position of the Trackster;Trackster x", nintX_, minX_, maxX_));
1098  histograms.h_trackster_y.push_back(
1099  ibook.book1D("trackster_y", "Y position of the Trackster;Trackster y", nintY_, minY_, maxY_));
1100  histograms.h_trackster_z.push_back(
1101  ibook.book1D("trackster_z", "Z position of the Trackster;Trackster z", nintZ_, minZ_, maxZ_));
1102  histograms.h_trackster_firstlayer.push_back(ibook.book1D(
1103  "trackster_firstlayer", "First layer of the Trackster;Trackster First Layer", 2 * layers, 0., (float)2 * layers));
1104  histograms.h_trackster_lastlayer.push_back(ibook.book1D(
1105  "trackster_lastlayer", "Last layer of the Trackster;Trackster Last Layer", 2 * layers, 0., (float)2 * layers));
1106  histograms.h_trackster_layersnum.push_back(
1107  ibook.book1D("trackster_layersnum",
1108  "Number of layers of the Trackster;Trackster Number of Layers",
1109  2 * layers,
1110  0.,
1111  (float)2 * layers));
1112 }
hgcalTBTopologyTester_cfi.layers
layers
Definition: hgcalTBTopologyTester_cfi.py:8
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
to_string
static std::string to_string(const XMLCh *ch)
Definition: TotemDAQMappingESSourceXML.cc:353
dqm::implementation::IBooker::bookProfile
MonitorElement * bookProfile(TString const &name, TString const &title, int nchX, double lowX, double highX, int, double lowY, double highY, char const *option="s", FUNC onbooking=NOOP())
Definition: DQMStore.h:408
dqm::implementation::IBooker::book2D
MonitorElement * book2D(TString const &name, TString const &title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, FUNC onbooking=NOOP())
Definition: DQMStore.h:221
dqm::implementation::IBooker::book1D
MonitorElement * book1D(TString const &name, TString const &title, int const nchX, double const lowX, double const highX, FUNC onbooking=NOOP())
Definition: DQMStore.h:98
eostools.move
def move(src, dest)
Definition: eostools.py:511

◆ bookTracksterSTSHistos()

void HGVHistoProducerAlgo::bookTracksterSTSHistos ( DQMStore::IBooker &  ibook,
Histograms &  histograms,
const validationType  valType 
)

Definition at line 1114 of file HGVHistoProducerAlgo.cc.

References dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), dqm::implementation::IBooker::bookProfile(), maxEne_, maxEta_, maxPhi_, maxPt_, maxScore_, maxTSTSharedEneFrac_, minEne_, minEta_, minPhi_, minPt_, minScore_, minTSTSharedEneFrac_, nintEne_, nintEta_, nintPhi_, nintPt_, nintScore_, nintSharedEneFrac_, and heppy_batch::val.

1116  {
1117  const string ref[] = {"caloparticle", "simtrackster", "simtrackster_fromCP"};
1118  const string refT[] = {"CaloParticle", "SimTrackster", "SimTrackster_fromCP"};
1119  // Must be in sync with labels in PostProcessorHGCAL_cfi.py
1120  const string val[] = {"_Link", "_PR"};
1121  //const string val[] = {"_CP", "_PR", "_Link"};
1122  const string rtos = ";score Reco-to-Sim";
1123  const string stor = ";score Sim-to-Reco";
1124  const string shREnFr = ";shared Reco energy fraction";
1125  const string shSEnFr = ";shared Sim energy fraction";
1126 
1127  histograms.h_score_trackster2caloparticle[valType].push_back(
1128  ibook.book1D("Score_trackster2" + ref[valType],
1129  "Score of Trackster per " + refT[valType] + rtos,
1130  nintScore_,
1131  minScore_,
1132  maxScore_));
1133  histograms.h_score_trackster2bestCaloparticle[valType].push_back(
1134  ibook.book1D("ScoreFake_trackster2" + ref[valType],
1135  "Score of Trackster per best " + refT[valType] + rtos,
1136  nintScore_,
1137  minScore_,
1138  maxScore_));
1139  histograms.h_score_trackster2bestCaloparticle2[valType].push_back(
1140  ibook.book1D("ScoreMerge_trackster2" + ref[valType],
1141  "Score of Trackster per 2^{nd} best " + refT[valType] + rtos,
1142  nintScore_,
1143  minScore_,
1144  maxScore_));
1145  histograms.h_score_caloparticle2trackster[valType].push_back(
1146  ibook.book1D("Score_" + ref[valType] + "2trackster",
1147  "Score of " + refT[valType] + " per Trackster" + stor,
1148  nintScore_,
1149  minScore_,
1150  maxScore_));
1151  histograms.h_scorePur_caloparticle2trackster[valType].push_back(
1152  ibook.book1D("ScorePur_" + ref[valType] + "2trackster",
1153  "Score of " + refT[valType] + " per best Trackster" + stor,
1154  nintScore_,
1155  minScore_,
1156  maxScore_));
1157  histograms.h_scoreDupl_caloparticle2trackster[valType].push_back(
1158  ibook.book1D("ScoreDupl_" + ref[valType] + "2trackster",
1159  "Score of " + refT[valType] + " per 2^{nd} best Trackster" + stor,
1160  nintScore_,
1161  minScore_,
1162  maxScore_));
1163  histograms.h_energy_vs_score_trackster2caloparticle[valType].push_back(
1164  ibook.book2D("Energy_vs_Score_trackster2" + refT[valType],
1165  "Energy vs Score of Trackster per " + refT[valType] + rtos + shREnFr,
1166  nintScore_,
1167  minScore_,
1168  maxScore_,
1169  nintSharedEneFrac_,
1170  minTSTSharedEneFrac_,
1171  maxTSTSharedEneFrac_));
1172  histograms.h_energy_vs_score_trackster2bestCaloparticle[valType].push_back(
1173  ibook.book2D("Energy_vs_Score_trackster2best" + refT[valType],
1174  "Energy vs Score of Trackster per best " + refT[valType] + rtos + shREnFr,
1175  nintScore_,
1176  minScore_,
1177  maxScore_,
1178  nintSharedEneFrac_,
1179  minTSTSharedEneFrac_,
1180  maxTSTSharedEneFrac_));
1181  histograms.h_energy_vs_score_trackster2bestCaloparticle2[valType].push_back(
1182  ibook.book2D("Energy_vs_Score_trackster2secBest" + refT[valType],
1183  "Energy vs Score of Trackster per 2^{nd} best " + refT[valType] + rtos + shREnFr,
1184  nintScore_,
1185  minScore_,
1186  maxScore_,
1187  nintSharedEneFrac_,
1188  minTSTSharedEneFrac_,
1189  maxTSTSharedEneFrac_));
1190  histograms.h_energy_vs_score_caloparticle2trackster[valType].push_back(
1191  ibook.book2D("Energy_vs_Score_" + ref[valType] + "2Trackster",
1192  "Energy vs Score of " + refT[valType] + " per Trackster" + stor + shSEnFr,
1193  nintScore_,
1194  minScore_,
1195  maxScore_,
1196  nintSharedEneFrac_,
1197  minTSTSharedEneFrac_,
1198  maxTSTSharedEneFrac_));
1199  histograms.h_energy_vs_score_caloparticle2bestTrackster[valType].push_back(
1200  ibook.book2D("Energy_vs_Score_" + ref[valType] + "2bestTrackster",
1201  "Energy vs Score of " + refT[valType] + " per best Trackster" + stor + shSEnFr,
1202  nintScore_,
1203  minScore_,
1204  maxScore_,
1205  nintSharedEneFrac_,
1206  minTSTSharedEneFrac_,
1207  maxTSTSharedEneFrac_));
1208  histograms.h_energy_vs_score_caloparticle2bestTrackster2[valType].push_back(
1209  ibook.book2D("Energy_vs_Score_" + ref[valType] + "2secBestTrackster",
1210  "Energy vs Score of " + refT[valType] + " per 2^{nd} best Trackster" + stor + shSEnFr,
1211  nintScore_,
1212  minScore_,
1213  maxScore_,
1214  nintSharedEneFrac_,
1215  minTSTSharedEneFrac_,
1216  maxTSTSharedEneFrac_));
1217 
1218  // Back to all Tracksters
1219  // eta
1220  histograms.h_num_trackster_eta[valType].push_back(ibook.book1D(
1221  "Num_Trackster_Eta" + val[valType], "Num Trackster Eta per Trackster;#eta", nintEta_, minEta_, maxEta_));
1222  histograms.h_numMerge_trackster_eta[valType].push_back(ibook.book1D("NumMerge_Trackster_Eta" + val[valType],
1223  "Num Merge Trackster Eta per Trackster;#eta",
1224  nintEta_,
1225  minEta_,
1226  maxEta_));
1227  histograms.h_denom_trackster_eta[valType].push_back(ibook.book1D(
1228  "Denom_Trackster_Eta" + val[valType], "Denom Trackster Eta per Trackster;#eta", nintEta_, minEta_, maxEta_));
1229  // phi
1230  histograms.h_num_trackster_phi[valType].push_back(ibook.book1D(
1231  "Num_Trackster_Phi" + val[valType], "Num Trackster Phi per Trackster;#phi", nintPhi_, minPhi_, maxPhi_));
1232  histograms.h_numMerge_trackster_phi[valType].push_back(ibook.book1D("NumMerge_Trackster_Phi" + val[valType],
1233  "Num Merge Trackster Phi per Trackster;#phi",
1234  nintPhi_,
1235  minPhi_,
1236  maxPhi_));
1237  histograms.h_denom_trackster_phi[valType].push_back(ibook.book1D(
1238  "Denom_Trackster_Phi" + val[valType], "Denom Trackster Phi per Trackster;#phi", nintPhi_, minPhi_, maxPhi_));
1239  // energy
1240  histograms.h_num_trackster_en[valType].push_back(ibook.book1D("Num_Trackster_Energy" + val[valType],
1241  "Num Trackster Energy per Trackster;energy [GeV]",
1242  nintEne_,
1243  minEne_,
1244  maxEne_));
1245  histograms.h_numMerge_trackster_en[valType].push_back(
1246  ibook.book1D("NumMerge_Trackster_Energy" + val[valType],
1247  "Num Merge Trackster Energy per Trackster;energy [GeV]",
1248  nintEne_,
1249  minEne_,
1250  maxEne_));
1251  histograms.h_denom_trackster_en[valType].push_back(ibook.book1D("Denom_Trackster_Energy" + val[valType],
1252  "Denom Trackster Energy per Trackster;energy [GeV]",
1253  nintEne_,
1254  minEne_,
1255  maxEne_));
1256  // pT
1257  histograms.h_num_trackster_pt[valType].push_back(ibook.book1D(
1258  "Num_Trackster_Pt" + val[valType], "Num Trackster p_{T} per Trackster;p_{T} [GeV]", nintPt_, minPt_, maxPt_));
1259  histograms.h_numMerge_trackster_pt[valType].push_back(
1260  ibook.book1D("NumMerge_Trackster_Pt" + val[valType],
1261  "Num Merge Trackster p_{T} per Trackster;p_{T} [GeV]",
1262  nintPt_,
1263  minPt_,
1264  maxPt_));
1265  histograms.h_denom_trackster_pt[valType].push_back(ibook.book1D(
1266  "Denom_Trackster_Pt" + val[valType], "Denom Trackster p_{T} per Trackster;p_{T} [GeV]", nintPt_, minPt_, maxPt_));
1267 
1268  histograms.h_sharedenergy_trackster2caloparticle[valType].push_back(
1269  ibook.book1D("SharedEnergy_trackster2" + ref[valType],
1270  "Shared Energy of Trackster per " + refT[valType] + shREnFr,
1271  nintSharedEneFrac_,
1272  minTSTSharedEneFrac_,
1273  maxTSTSharedEneFrac_));
1274  histograms.h_sharedenergy_trackster2bestCaloparticle[valType].push_back(
1275  ibook.book1D("SharedEnergy_trackster2" + ref[valType] + "_assoc",
1276  "Shared Energy of Trackster per best " + refT[valType] + shREnFr,
1277  nintSharedEneFrac_,
1278  minTSTSharedEneFrac_,
1279  maxTSTSharedEneFrac_));
1280  histograms.h_sharedenergy_trackster2bestCaloparticle_vs_eta[valType].push_back(
1281  ibook.bookProfile("SharedEnergy_trackster2" + ref[valType] + "_assoc_vs_eta",
1282  "Shared Energy of Trackster vs #eta per best " + refT[valType] + ";Trackster #eta" + shREnFr,
1283  nintEta_,
1284  minEta_,
1285  maxEta_,
1286  minTSTSharedEneFrac_,
1287  maxTSTSharedEneFrac_));
1288  histograms.h_sharedenergy_trackster2bestCaloparticle_vs_phi[valType].push_back(
1289  ibook.bookProfile("SharedEnergy_trackster2" + ref[valType] + "_assoc_vs_phi",
1290  "Shared Energy of Trackster vs #phi per best " + refT[valType] + ";Trackster #phi" + shREnFr,
1291  nintPhi_,
1292  minPhi_,
1293  maxPhi_,
1294  minTSTSharedEneFrac_,
1295  maxTSTSharedEneFrac_));
1296  histograms.h_sharedenergy_trackster2bestCaloparticle2[valType].push_back(
1297  ibook.book1D("SharedEnergy_trackster2" + ref[valType] + "_assoc2",
1298  "Shared Energy of Trackster per 2^{nd} best " + refT[valType] + shREnFr,
1299  nintSharedEneFrac_,
1300  minTSTSharedEneFrac_,
1301  maxTSTSharedEneFrac_));
1302 
1303  histograms.h_sharedenergy_caloparticle2trackster[valType].push_back(
1304  ibook.book1D("SharedEnergy_" + ref[valType] + "2trackster",
1305  "Shared Energy of " + refT[valType] + " per Trackster" + shSEnFr,
1306  nintSharedEneFrac_,
1307  minTSTSharedEneFrac_,
1308  maxTSTSharedEneFrac_));
1309  histograms.h_sharedenergy_caloparticle2trackster_assoc[valType].push_back(
1310  ibook.book1D("SharedEnergy_" + ref[valType] + "2trackster_assoc",
1311  "Shared Energy of " + refT[valType] + " per best Trackster" + shSEnFr,
1312  nintSharedEneFrac_,
1313  minTSTSharedEneFrac_,
1314  maxTSTSharedEneFrac_));
1315  histograms.h_sharedenergy_caloparticle2trackster_assoc_vs_eta[valType].push_back(ibook.bookProfile(
1316  "SharedEnergy_" + ref[valType] + "2trackster_assoc_vs_eta",
1317  "Shared Energy of " + refT[valType] + " vs #eta per best Trackster;" + refT[valType] + " #eta" + shSEnFr,
1318  nintEta_,
1319  minEta_,
1320  maxEta_,
1321  minTSTSharedEneFrac_,
1322  maxTSTSharedEneFrac_));
1323  histograms.h_sharedenergy_caloparticle2trackster_assoc_vs_phi[valType].push_back(ibook.bookProfile(
1324  "SharedEnergy_" + ref[valType] + "2trackster_assoc_vs_phi",
1325  "Shared Energy of " + refT[valType] + " vs #phi per best Trackster;" + refT[valType] + " #phi" + shSEnFr,
1326  nintPhi_,
1327  minPhi_,
1328  maxPhi_,
1329  minTSTSharedEneFrac_,
1330  maxTSTSharedEneFrac_));
1331  histograms.h_sharedenergy_caloparticle2trackster_assoc2[valType].push_back(
1332  ibook.book1D("SharedEnergy_" + ref[valType] + "2trackster_assoc2",
1333  "Shared Energy of " + refT[valType] + " per 2^{nd} best Trackster;" + shSEnFr,
1334  nintSharedEneFrac_,
1335  minTSTSharedEneFrac_,
1336  maxTSTSharedEneFrac_));
1337 
1338  // eta
1339  histograms.h_numEff_caloparticle_eta[valType].push_back(
1340  ibook.book1D("NumEff_" + refT[valType] + "_Eta",
1341  "Num Efficiency " + refT[valType] + " Eta per Trackster;#eta",
1342  nintEta_,
1343  minEta_,
1344  maxEta_));
1345  histograms.h_num_caloparticle_eta[valType].push_back(
1346  ibook.book1D("Num_" + refT[valType] + "_Eta",
1347  "Num Purity " + refT[valType] + " Eta per Trackster;#eta",
1348  nintEta_,
1349  minEta_,
1350  maxEta_));
1351  histograms.h_numDup_trackster_eta[valType].push_back(ibook.book1D(
1352  "NumDup_Trackster_Eta" + val[valType], "Num Duplicate Trackster vs Eta;#eta", nintEta_, minEta_, maxEta_));
1353  histograms.h_denom_caloparticle_eta[valType].push_back(
1354  ibook.book1D("Denom_" + refT[valType] + "_Eta",
1355  "Denom " + refT[valType] + " Eta per Trackster;#eta",
1356  nintEta_,
1357  minEta_,
1358  maxEta_));
1359  // phi
1360  histograms.h_numEff_caloparticle_phi[valType].push_back(
1361  ibook.book1D("NumEff_" + refT[valType] + "_Phi",
1362  "Num Efficiency " + refT[valType] + " Phi per Trackster;#phi",
1363  nintPhi_,
1364  minPhi_,
1365  maxPhi_));
1366  histograms.h_num_caloparticle_phi[valType].push_back(
1367  ibook.book1D("Num_" + refT[valType] + "_Phi",
1368  "Num Purity " + refT[valType] + " Phi per Trackster;#phi",
1369  nintPhi_,
1370  minPhi_,
1371  maxPhi_));
1372  histograms.h_numDup_trackster_phi[valType].push_back(ibook.book1D(
1373  "NumDup_Trackster_Phi" + val[valType], "Num Duplicate Trackster vs Phi;#phi", nintPhi_, minPhi_, maxPhi_));
1374  histograms.h_denom_caloparticle_phi[valType].push_back(
1375  ibook.book1D("Denom_" + refT[valType] + "_Phi",
1376  "Denom " + refT[valType] + " Phi per Trackster;#phi",
1377  nintPhi_,
1378  minPhi_,
1379  maxPhi_));
1380  // energy
1381  histograms.h_numEff_caloparticle_en[valType].push_back(
1382  ibook.book1D("NumEff_" + refT[valType] + "_Energy",
1383  "Num Efficiency " + refT[valType] + " Energy per Trackster;energy [GeV]",
1384  nintEne_,
1385  minEne_,
1386  maxEne_));
1387  histograms.h_num_caloparticle_en[valType].push_back(
1388  ibook.book1D("Num_" + refT[valType] + "_Energy",
1389  "Num Purity " + refT[valType] + " Energy per Trackster;energy [GeV]",
1390  nintEne_,
1391  minEne_,
1392  maxEne_));
1393  histograms.h_numDup_trackster_en[valType].push_back(ibook.book1D("NumDup_Trackster_Energy" + val[valType],
1394  "Num Duplicate Trackster vs Energy;energy [GeV]",
1395  nintEne_,
1396  minEne_,
1397  maxEne_));
1398  histograms.h_denom_caloparticle_en[valType].push_back(
1399  ibook.book1D("Denom_" + refT[valType] + "_Energy",
1400  "Denom " + refT[valType] + " Energy per Trackster;energy [GeV]",
1401  nintEne_,
1402  minEne_,
1403  maxEne_));
1404  // pT
1405  histograms.h_numEff_caloparticle_pt[valType].push_back(
1406  ibook.book1D("NumEff_" + refT[valType] + "_Pt",
1407  "Num Efficiency " + refT[valType] + " p_{T} per Trackster;p_{T} [GeV]",
1408  nintPt_,
1409  minPt_,
1410  maxPt_));
1411  histograms.h_num_caloparticle_pt[valType].push_back(
1412  ibook.book1D("Num_" + refT[valType] + "_Pt",
1413  "Num Purity " + refT[valType] + " p_{T} per Trackster;p_{T} [GeV]",
1414  nintPt_,
1415  minPt_,
1416  maxPt_));
1417  histograms.h_numDup_trackster_pt[valType].push_back(ibook.book1D(
1418  "NumDup_Trackster_Pt" + val[valType], "Num Duplicate Trackster vs p_{T};p_{T} [GeV]", nintPt_, minPt_, maxPt_));
1419  histograms.h_denom_caloparticle_pt[valType].push_back(
1420  ibook.book1D("Denom_" + refT[valType] + "_Pt",
1421  "Denom " + refT[valType] + " p_{T} per Trackster;p_{T} [GeV]",
1422  nintPt_,
1423  minPt_,
1424  maxPt_));
1425 }
dqm::implementation::IBooker::bookProfile
MonitorElement * bookProfile(TString const &name, TString const &title, int nchX, double lowX, double highX, int, double lowY, double highY, char const *option="s", FUNC onbooking=NOOP())
Definition: DQMStore.h:408
dqm::implementation::IBooker::book2D
MonitorElement * book2D(TString const &name, TString const &title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, FUNC onbooking=NOOP())
Definition: DQMStore.h:221
dqm::implementation::IBooker::book1D
MonitorElement * book1D(TString const &name, TString const &title, int const nchX, double const lowX, double const highX, FUNC onbooking=NOOP())
Definition: DQMStore.h:98
heppy_batch.val
val
Definition: heppy_batch.py:351

◆ distance()

double HGVHistoProducerAlgo::distance ( const double  x1,
const double  y1,
const double  x2,
const double  y2 
) const

Definition at line 3552 of file HGVHistoProducerAlgo.cc.

References distance2(), mathSSE::sqrt(), testProducerWithPsetDescEmpty_cfi::x1, testProducerWithPsetDescEmpty_cfi::x2, testProducerWithPsetDescEmpty_cfi::y1, and testProducerWithPsetDescEmpty_cfi::y2.

Referenced by fill_generic_cluster_histos().

3555  { //2-d distance on the layer (x-y)
3556  return std::sqrt(distance2(x1, y1, x2, y2));
3557 }
testProducerWithPsetDescEmpty_cfi.y2
y2
Definition: testProducerWithPsetDescEmpty_cfi.py:30
testProducerWithPsetDescEmpty_cfi.x2
x2
Definition: testProducerWithPsetDescEmpty_cfi.py:28
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:23
HGVHistoProducerAlgo::distance2
double distance2(const double x1, const double y1, const double x2, const double y2) const
Definition: HGVHistoProducerAlgo.cc:3544
testProducerWithPsetDescEmpty_cfi.y1
y1
Definition: testProducerWithPsetDescEmpty_cfi.py:29
testProducerWithPsetDescEmpty_cfi.x1
x1
Definition: testProducerWithPsetDescEmpty_cfi.py:33

◆ distance2()

double HGVHistoProducerAlgo::distance2 ( const double  x1,
const double  y1,
const double  x2,
const double  y2 
) const

Definition at line 3544 of file HGVHistoProducerAlgo.cc.

References PVValHelper::dx, PVValHelper::dy, testProducerWithPsetDescEmpty_cfi::x1, testProducerWithPsetDescEmpty_cfi::x2, testProducerWithPsetDescEmpty_cfi::y1, and testProducerWithPsetDescEmpty_cfi::y2.

Referenced by distance().

3547  { //distance squared
3548  const double dx = x1 - x2;
3549  const double dy = y1 - y2;
3550  return (dx * dx + dy * dy);
3551 } //distance squaredq
testProducerWithPsetDescEmpty_cfi.y2
y2
Definition: testProducerWithPsetDescEmpty_cfi.py:30
testProducerWithPsetDescEmpty_cfi.x2
x2
Definition: testProducerWithPsetDescEmpty_cfi.py:28
testProducerWithPsetDescEmpty_cfi.y1
y1
Definition: testProducerWithPsetDescEmpty_cfi.py:29
testProducerWithPsetDescEmpty_cfi.x1
x1
Definition: testProducerWithPsetDescEmpty_cfi.py:33

◆ fill_caloparticle_histos()

void HGVHistoProducerAlgo::fill_caloparticle_histos ( const Histograms &  histograms,
int  pdgid,
const CaloParticle &  caloparticle,
std::vector< SimVertex > const &  simVertices,
unsigned int  layers,
std::unordered_map< DetId, const unsigned int > const &  hitMap,
std::vector< HGCRecHit > const &  hits 
) const

Definition at line 1440 of file HGVHistoProducerAlgo.cc.

References hcalRecHitTable_cff::energy, CaloParticle::energy(), PVValHelper::eta, CaloParticle::eta(), newFWLiteAna::found, CaloParticle::g4Tracks(), getEta(), hfClusterShapes_cfi::hits, mps_fire::i, hgcalTBTopologyTester_cfi::layers, LogDebug, SiStripPI::max, SiStripPI::min, EgammaValidation_cff::pdgid, CaloParticle::phi(), position, funct::pow(), CaloParticle::pt(), recHitTools_, CaloParticle::simClusters(), FastTrackerRecHitCombiner_cfi::simHits, HGCalValidator_cfi::simVertices, edm::RefVector< C, T, F >::size(), and findQualityFiles::v.

1446  {
1447  const auto eta = getEta(caloParticle.eta());
1448  if (histograms.h_caloparticle_eta.count(pdgid)) {
1449  histograms.h_caloparticle_eta.at(pdgid)->Fill(eta);
1450  }
1451  if (histograms.h_caloparticle_eta_Zorigin.count(pdgid)) {
1452  histograms.h_caloparticle_eta_Zorigin.at(pdgid)->Fill(
1453  simVertices.at(caloParticle.g4Tracks()[0].vertIndex()).position().z(), eta);
1454  }
1455 
1456  if (histograms.h_caloparticle_energy.count(pdgid)) {
1457  histograms.h_caloparticle_energy.at(pdgid)->Fill(caloParticle.energy());
1458  }
1459  if (histograms.h_caloparticle_pt.count(pdgid)) {
1460  histograms.h_caloparticle_pt.at(pdgid)->Fill(caloParticle.pt());
1461  }
1462  if (histograms.h_caloparticle_phi.count(pdgid)) {
1463  histograms.h_caloparticle_phi.at(pdgid)->Fill(caloParticle.phi());
1464  }
1465 
1466  if (histograms.h_caloparticle_nSimClusters.count(pdgid)) {
1467  histograms.h_caloparticle_nSimClusters.at(pdgid)->Fill(caloParticle.simClusters().size());
1468 
1469  int simHits = 0;
1470  int minLayerId = 999;
1471  int maxLayerId = 0;
1472 
1473  int simHits_matched = 0;
1474  int minLayerId_matched = 999;
1475  int maxLayerId_matched = 0;
1476 
1477  float energy = 0.;
1478  std::map<int, double> totenergy_layer;
1479 
1480  float hitEnergyWeight_invSum = 0;
1481  std::vector<std::pair<DetId, float>> haf_cp;
1482  for (const auto& sc : caloParticle.simClusters()) {
1483  LogDebug("HGCalValidator") << " This sim cluster has " << sc->hits_and_fractions().size() << " simHits and "
1484  << sc->energy() << " energy. " << std::endl;
1485  simHits += sc->hits_and_fractions().size();
1486  for (auto const& h_and_f : sc->hits_and_fractions()) {
1487  const auto hitDetId = h_and_f.first;
1488  const int layerId =
1489  recHitTools_->getLayerWithOffset(hitDetId) + layers * ((recHitTools_->zside(hitDetId) + 1) >> 1) - 1;
1490  // set to 0 if matched RecHit not found
1491  int layerId_matched_min = 999;
1492  int layerId_matched_max = 0;
1493  std::unordered_map<DetId, const unsigned int>::const_iterator itcheck = hitMap.find(hitDetId);
1494  if (itcheck != hitMap.end()) {
1495  layerId_matched_min = layerId;
1496  layerId_matched_max = layerId;
1497  simHits_matched++;
1498 
1499  const auto hitEn = (hits[itcheck->second]).energy();
1500  hitEnergyWeight_invSum += pow(hitEn, 2);
1501  const auto hitFr = h_and_f.second;
1502  const auto hitEnFr = hitEn * hitFr;
1503  energy += hitEnFr;
1504  histograms.h_caloparticle_nHits_matched_energy.at(pdgid)->Fill(hitEnFr);
1505  histograms.h_caloparticle_nHits_matched_energy_layer.at(pdgid)->Fill(layerId, hitEnFr);
1506 
1507  if (totenergy_layer.find(layerId) != totenergy_layer.end()) {
1508  totenergy_layer[layerId] = totenergy_layer.at(layerId) + hitEn;
1509  } else {
1510  totenergy_layer.emplace(layerId, hitEn);
1511  }
1512  if (caloParticle.simClusters().size() == 1)
1513  histograms.h_caloparticle_nHits_matched_energy_layer_1SimCl.at(pdgid)->Fill(layerId, hitEnFr);
1514 
1515  auto found = std::find_if(std::begin(haf_cp),
1516  std::end(haf_cp),
1517  [&hitDetId](const std::pair<DetId, float>& v) { return v.first == hitDetId; });
1518  if (found != haf_cp.end())
1519  found->second += hitFr;
1520  else
1521  haf_cp.emplace_back(hitDetId, hitFr);
1522 
1523  } else {
1524  LogDebug("HGCalValidator") << " matched to RecHit NOT found !" << std::endl;
1525  }
1526 
1527  minLayerId = std::min(minLayerId, layerId);
1528  maxLayerId = std::max(maxLayerId, layerId);
1529  minLayerId_matched = std::min(minLayerId_matched, layerId_matched_min);
1530  maxLayerId_matched = std::max(maxLayerId_matched, layerId_matched_max);
1531  }
1532  LogDebug("HGCalValidator") << std::endl;
1533  } // End loop over SimClusters of CaloParticle
1534  if (hitEnergyWeight_invSum)
1535  hitEnergyWeight_invSum = 1 / hitEnergyWeight_invSum;
1536 
1537  histograms.h_caloparticle_firstlayer.at(pdgid)->Fill(minLayerId);
1538  histograms.h_caloparticle_lastlayer.at(pdgid)->Fill(maxLayerId);
1539  histograms.h_caloparticle_layersnum.at(pdgid)->Fill(int(maxLayerId - minLayerId));
1540 
1541  histograms.h_caloparticle_firstlayer_matchedtoRecHit.at(pdgid)->Fill(minLayerId_matched);
1542  histograms.h_caloparticle_lastlayer_matchedtoRecHit.at(pdgid)->Fill(maxLayerId_matched);
1543  histograms.h_caloparticle_layersnum_matchedtoRecHit.at(pdgid)->Fill(int(maxLayerId_matched - minLayerId_matched));
1544 
1545  histograms.h_caloparticle_nHitsInSimClusters.at(pdgid)->Fill((float)simHits);
1546  histograms.h_caloparticle_nHitsInSimClusters_matchedtoRecHit.at(pdgid)->Fill((float)simHits_matched);
1547  histograms.h_caloparticle_selfenergy.at(pdgid)->Fill((float)energy);
1548  histograms.h_caloparticle_energyDifference.at(pdgid)->Fill((float)1. - energy / caloParticle.energy());
1549 
1550  //Calculate sum energy per-layer
1551  auto i = totenergy_layer.begin();
1552  double sum_energy = 0.0;
1553  while (i != totenergy_layer.end()) {
1554  sum_energy += i->second;
1555  histograms.h_caloparticle_sum_energy_layer.at(pdgid)->Fill(i->first, sum_energy / caloParticle.energy() * 100.);
1556  i++;
1557  }
1558 
1559  for (auto const& haf : haf_cp) {
1560  const auto hitEn = (hits[hitMap.find(haf.first)->second]).energy();
1561  const auto weight = pow(hitEn, 2);
1562  histograms.h_caloparticle_fractions.at(pdgid)->Fill(haf.second, weight * hitEnergyWeight_invSum);
1563  histograms.h_caloparticle_fractions_weight.at(pdgid)->Fill(haf.second, weight * hitEnergyWeight_invSum, weight);
1564  }
1565  }
1566 }
hgcalTBTopologyTester_cfi.layers
layers
Definition: hgcalTBTopologyTester_cfi.py:8
mps_fire.i
i
Definition: mps_fire.py:429
hfClusterShapes_cfi.hits
hits
Definition: hfClusterShapes_cfi.py:5
weight
Definition: weight.py:1
EgammaValidation_cff.pdgid
pdgid
Definition: EgammaValidation_cff.py:29
hcalRecHitTable_cff.energy
energy
Definition: hcalRecHitTable_cff.py:13
HGVHistoProducerAlgo::getEta
double getEta(double eta) const
Definition: HGVHistoProducerAlgo.cc:3584
HGVHistoProducerAlgo::recHitTools_
std::shared_ptr< hgcal::RecHitTools > recHitTools_
Definition: HGVHistoProducerAlgo.h:394
position
static int position[264][3]
Definition: ReadPGInfo.cc:289
FastTrackerRecHitCombiner_cfi.simHits
simHits
Definition: FastTrackerRecHitCombiner_cfi.py:5
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:29
HGCalValidator_cfi.simVertices
simVertices
Definition: HGCalValidator_cfi.py:78
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:241

◆ fill_cluster_histos()

void HGVHistoProducerAlgo::fill_cluster_histos ( const Histograms &  histograms,
const int  count,
const reco::CaloCluster &  cluster 
) const

Definition at line 1732 of file HGVHistoProducerAlgo.cc.

References submitPVResolutionJobs::count, PVValHelper::eta, reco::CaloCluster::eta(), and getEta().

1734  {
1735  const auto eta = getEta(cluster.eta());
1736  histograms.h_cluster_eta[count]->Fill(eta);
1737 }
HGVHistoProducerAlgo::getEta
double getEta(double eta) const
Definition: HGVHistoProducerAlgo.cc:3584
reco::CaloCluster::eta
double eta() const
pseudorapidity of cluster centroid
Definition: CaloCluster.h:181

◆ fill_generic_cluster_histos()

void HGVHistoProducerAlgo::fill_generic_cluster_histos ( const Histograms &  histograms,
const int  count,
edm::Handle< reco::CaloClusterCollection >  clusterHandle,
const reco::CaloClusterCollection &  clusters,
edm::Handle< std::vector< CaloParticle >>  caloParticleHandle,
std::vector< CaloParticle > const &  cP,
std::vector< size_t > const &  cPIndices,
std::vector< size_t > const &  cPSelectedIndices,
std::unordered_map< DetId, const unsigned int > const &  hitMap,
std::map< double, double >  cummatbudg,
unsigned int  layers,
std::vector< int >  thicknesses,
const ticl::RecoToSimCollection &  recSimColl,
const ticl::SimToRecoCollection &  simRecColl,
std::vector< HGCRecHit > const &  hits 
) const

Definition at line 2178 of file HGVHistoProducerAlgo.cc.

References bsc_activity_cfg::clusters, submitPVResolutionJobs::count, DetId::det(), distance(), HLT_2024v14_cff::distance, PVValHelper::eta, findmaxhit(), DetId::Forward, DetId::HGCalEE, DetId::HGCalHSc, DetId::HGCalHSi, hfClusterShapes_cfi::hits, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, layerClusters_to_CaloParticles(), hgcalTBTopologyTester_cfi::layers, LogDebug, DetId::rawId(), recHitTools_, AlCaHLTBitMon_QueryRunRegistry::string, Calorimetry_cff::thickness, to_string(), trackerHitRTTI::vector, and ecaldqm::zside().

2192  {
2193  //Each event to be treated as two events: an event in +ve endcap,
2194  //plus another event in -ve endcap. In this spirit there will be
2195  //a layer variable (layerid) that maps the layers in :
2196  //-z: 0->51
2197  //+z: 52->103
2198 
2199  //To keep track of total num of layer clusters per layer
2200  //tnlcpl[layerid]
2201  std::vector<int> tnlcpl(1000, 0); //tnlcpl.clear(); tnlcpl.reserve(1000);
2202 
2203  //To keep track of the total num of clusters per thickness in plus and in minus endcaps
2204  std::map<std::string, int> tnlcpthplus;
2205  tnlcpthplus.clear();
2206  std::map<std::string, int> tnlcpthminus;
2207  tnlcpthminus.clear();
2208  //At the beginning of the event all layers should be initialized to zero total clusters per thickness
2209  for (std::vector<int>::iterator it = thicknesses.begin(); it != thicknesses.end(); ++it) {
2210  tnlcpthplus.insert(std::pair<std::string, int>(std::to_string(*it), 0));
2211  tnlcpthminus.insert(std::pair<std::string, int>(std::to_string(*it), 0));
2212  }
2213  //To keep track of the total num of clusters with mixed thickness hits per event
2214  tnlcpthplus.insert(std::pair<std::string, int>("mixed", 0));
2215  tnlcpthminus.insert(std::pair<std::string, int>("mixed", 0));
2216 
2217  layerClusters_to_CaloParticles(histograms,
2218  clusterHandle,
2219  clusters,
2220  caloParticleHandle,
2221  cP,
2222  cPIndices,
2223  cPSelectedIndices,
2224  hitMap,
2225  layers,
2226  cpsInLayerClusterMap,
2227  cPOnLayerMap,
2228  hits);
2229 
2230  //To find out the total amount of energy clustered per layer
2231  //Initialize with zeros because I see clear gives weird numbers.
2232  std::vector<double> tecpl(1000, 0.0); //tecpl.clear(); tecpl.reserve(1000);
2233  //for the longitudinal depth barycenter
2234  std::vector<double> ldbar(1000, 0.0); //ldbar.clear(); ldbar.reserve(1000);
2235 
2236  // Need to compare with the total amount of energy coming from CaloParticles
2237  double caloparteneplus = 0.;
2238  double caloparteneminus = 0.;
2239  for (const auto& cpId : cPIndices) {
2240  if (cP[cpId].eta() >= 0.) {
2241  caloparteneplus = caloparteneplus + cP[cpId].energy();
2242  } else if (cP[cpId].eta() < 0.) {
2243  caloparteneminus = caloparteneminus + cP[cpId].energy();
2244  }
2245  }
2246 
2247  // loop through clusters of the event
2248  for (const auto& lcId : clusters) {
2249  const auto seedid = lcId.seed();
2250  const double seedx = recHitTools_->getPosition(seedid).x();
2251  const double seedy = recHitTools_->getPosition(seedid).y();
2252  DetId maxid = findmaxhit(lcId, hitMap, hits);
2253 
2254  // const DetId maxid = lcId.max();
2255  double maxx = recHitTools_->getPosition(maxid).x();
2256  double maxy = recHitTools_->getPosition(maxid).y();
2257 
2258  //Auxillary variables to count the number of different kind of hits in each cluster
2259  int nthhits120p = 0;
2260  int nthhits200p = 0;
2261  int nthhits300p = 0;
2262  int nthhitsscintp = 0;
2263  int nthhits120m = 0;
2264  int nthhits200m = 0;
2265  int nthhits300m = 0;
2266  int nthhitsscintm = 0;
2267  //For the hits thickness of the layer cluster.
2268  double thickness = 0.;
2269  //The layer the cluster belongs to. As mentioned in the mapping above, it takes into account -z and +z.
2270  int layerid = 0;
2271  // Need another layer variable for the longitudinal material budget file reading.
2272  //In this case need no distinction between -z and +z.
2273  int lay = 0;
2274  // Need to save the combination thick_lay
2275  std::string istr = "";
2276  //boolean to check for the layer that the cluster belong to. Maybe later will check all the layer hits.
2277  bool cluslay = true;
2278  //zside that the current cluster belongs to.
2279  int zside = 0;
2280 
2281  const auto& hits_and_fractions = lcId.hitsAndFractions();
2282  for (std::vector<std::pair<DetId, float>>::const_iterator it_haf = hits_and_fractions.begin();
2283  it_haf != hits_and_fractions.end();
2284  ++it_haf) {
2285  const DetId rh_detid = it_haf->first;
2286  //The layer that the current hit belongs to
2287  layerid = recHitTools_->getLayerWithOffset(rh_detid) + layers * ((recHitTools_->zside(rh_detid) + 1) >> 1) - 1;
2288  lay = recHitTools_->getLayerWithOffset(rh_detid);
2289  zside = recHitTools_->zside(rh_detid);
2290  if (rh_detid.det() == DetId::Forward || rh_detid.det() == DetId::HGCalEE || rh_detid.det() == DetId::HGCalHSi) {
2291  thickness = recHitTools_->getSiThickness(rh_detid);
2292  } else if (rh_detid.det() == DetId::HGCalHSc) {
2293  thickness = -1;
2294  } else {
2295  LogDebug("HGCalValidator") << "These are HGCal layer clusters, you shouldn't be here !!! " << layerid << "\n";
2296  continue;
2297  }
2298 
2299  //Count here only once the layer cluster and save the combination thick_layerid
2300  std::string curistr = std::to_string((int)thickness);
2301  std::string lay_string = std::to_string(layerid);
2302  while (lay_string.size() < 2)
2303  lay_string.insert(0, "0");
2304  curistr += "_" + lay_string;
2305  if (cluslay) {
2306  tnlcpl[layerid]++;
2307  istr = curistr;
2308  cluslay = false;
2309  }
2310 
2311  if ((thickness == 120.) && (recHitTools_->zside(rh_detid) > 0.)) {
2312  nthhits120p++;
2313  } else if ((thickness == 120.) && (recHitTools_->zside(rh_detid) < 0.)) {
2314  nthhits120m++;
2315  } else if ((thickness == 200.) && (recHitTools_->zside(rh_detid) > 0.)) {
2316  nthhits200p++;
2317  } else if ((thickness == 200.) && (recHitTools_->zside(rh_detid) < 0.)) {
2318  nthhits200m++;
2319  } else if ((thickness == 300.) && (recHitTools_->zside(rh_detid) > 0.)) {
2320  nthhits300p++;
2321  } else if ((thickness == 300.) && (recHitTools_->zside(rh_detid) < 0.)) {
2322  nthhits300m++;
2323  } else if ((thickness == -1) && (recHitTools_->zside(rh_detid) > 0.)) {
2324  nthhitsscintp++;
2325  } else if ((thickness == -1) && (recHitTools_->zside(rh_detid) < 0.)) {
2326  nthhitsscintm++;
2327  } else { //assert(0);
2328  LogDebug("HGCalValidator")
2329  << " You are running a geometry that contains thicknesses different than the normal ones. "
2330  << "\n";
2331  }
2332 
2333  std::unordered_map<DetId, const unsigned int>::const_iterator itcheck = hitMap.find(rh_detid);
2334  if (itcheck == hitMap.end()) {
2335  std::ostringstream st1;
2336  if ((rh_detid.det() == DetId::HGCalEE) || (rh_detid.det() == DetId::HGCalHSi)) {
2337  st1 << HGCSiliconDetId(rh_detid);
2338  } else if (rh_detid.det() == DetId::HGCalHSc) {
2339  st1 << HGCScintillatorDetId(rh_detid);
2340  } else {
2341  st1 << HFNoseDetId(rh_detid);
2342  }
2343  LogDebug("HGCalValidator") << " You shouldn't be here - Unable to find a hit " << rh_detid.rawId() << " "
2344  << rh_detid.det() << " " << st1.str() << "\n";
2345  continue;
2346  }
2347 
2348  const HGCRecHit* hit = &(hits[itcheck->second]);
2349  //Here for the per cell plots
2350  //----
2351  const double hit_x = recHitTools_->getPosition(rh_detid).x();
2352  const double hit_y = recHitTools_->getPosition(rh_detid).y();
2353  double distancetoseed = distance(seedx, seedy, hit_x, hit_y);
2354  double distancetomax = distance(maxx, maxy, hit_x, hit_y);
2355  if (distancetoseed != 0. && histograms.h_distancetoseedcell_perthickperlayer.count(curistr)) {
2356  histograms.h_distancetoseedcell_perthickperlayer.at(curistr)->Fill(distancetoseed);
2357  }
2358  //----
2359  if (distancetoseed != 0. && histograms.h_distancetoseedcell_perthickperlayer_eneweighted.count(curistr)) {
2360  histograms.h_distancetoseedcell_perthickperlayer_eneweighted.at(curistr)->Fill(distancetoseed, hit->energy());
2361  }
2362  //----
2363  if (distancetomax != 0. && histograms.h_distancetomaxcell_perthickperlayer.count(curistr)) {
2364  histograms.h_distancetomaxcell_perthickperlayer.at(curistr)->Fill(distancetomax);
2365  }
2366  //----
2367  if (distancetomax != 0. && histograms.h_distancetomaxcell_perthickperlayer_eneweighted.count(curistr)) {
2368  histograms.h_distancetomaxcell_perthickperlayer_eneweighted.at(curistr)->Fill(distancetomax, hit->energy());
2369  }
2370 
2371  } // end of loop through hits and fractions
2372 
2373  //Check for simultaneously having hits of different kind. Checking at least two combinations is sufficient.
2374  if ((nthhits120p != 0 && nthhits200p != 0) || (nthhits120p != 0 && nthhits300p != 0) ||
2375  (nthhits120p != 0 && nthhitsscintp != 0) || (nthhits200p != 0 && nthhits300p != 0) ||
2376  (nthhits200p != 0 && nthhitsscintp != 0) || (nthhits300p != 0 && nthhitsscintp != 0)) {
2377  tnlcpthplus["mixed"]++;
2378  } else if ((nthhits120p != 0 || nthhits200p != 0 || nthhits300p != 0 || nthhitsscintp != 0)) {
2379  //This is a cluster with hits of one kind
2380  tnlcpthplus[std::to_string((int)thickness)]++;
2381  }
2382  if ((nthhits120m != 0 && nthhits200m != 0) || (nthhits120m != 0 && nthhits300m != 0) ||
2383  (nthhits120m != 0 && nthhitsscintm != 0) || (nthhits200m != 0 && nthhits300m != 0) ||
2384  (nthhits200m != 0 && nthhitsscintm != 0) || (nthhits300m != 0 && nthhitsscintm != 0)) {
2385  tnlcpthminus["mixed"]++;
2386  } else if ((nthhits120m != 0 || nthhits200m != 0 || nthhits300m != 0 || nthhitsscintm != 0)) {
2387  //This is a cluster with hits of one kind
2388  tnlcpthminus[std::to_string((int)thickness)]++;
2389  }
2390 
2391  //To find the thickness with the biggest amount of cells
2392  std::vector<int> bigamoth;
2393  bigamoth.clear();
2394  if (zside > 0) {
2395  bigamoth.push_back(nthhits120p);
2396  bigamoth.push_back(nthhits200p);
2397  bigamoth.push_back(nthhits300p);
2398  bigamoth.push_back(nthhitsscintp);
2399  } else if (zside < 0) {
2400  bigamoth.push_back(nthhits120m);
2401  bigamoth.push_back(nthhits200m);
2402  bigamoth.push_back(nthhits300m);
2403  bigamoth.push_back(nthhitsscintm);
2404  }
2405  auto bgth = std::max_element(bigamoth.begin(), bigamoth.end());
2406  istr = std::to_string(thicknesses[std::distance(bigamoth.begin(), bgth)]);
2407  std::string lay_string = std::to_string(layerid);
2408  while (lay_string.size() < 2)
2409  lay_string.insert(0, "0");
2410  istr += "_" + lay_string;
2411 
2412  //Here for the per cluster plots that need the thickness_layer info
2413  if (histograms.h_cellsnum_perthickperlayer.count(istr)) {
2414  histograms.h_cellsnum_perthickperlayer.at(istr)->Fill(hits_and_fractions.size());
2415  }
2416 
2417  //Now, with the distance between seed and max cell.
2418  double distancebetseedandmax = distance(seedx, seedy, maxx, maxy);
2419  //The thickness_layer combination in this case will use the thickness of the seed as a convention.
2420  std::string seedstr = std::to_string((int)recHitTools_->getSiThickness(seedid)) + "_" + std::to_string(layerid);
2421  seedstr += "_" + lay_string;
2422  if (histograms.h_distancebetseedandmaxcell_perthickperlayer.count(seedstr)) {
2423  histograms.h_distancebetseedandmaxcell_perthickperlayer.at(seedstr)->Fill(distancebetseedandmax);
2424  }
2425  const auto lc_en = lcId.energy();
2426  if (histograms.h_distancebetseedandmaxcellvsclusterenergy_perthickperlayer.count(seedstr)) {
2427  histograms.h_distancebetseedandmaxcellvsclusterenergy_perthickperlayer.at(seedstr)->Fill(distancebetseedandmax,
2428  lc_en);
2429  }
2430 
2431  //Energy clustered per layer
2432  tecpl[layerid] = tecpl[layerid] + lc_en;
2433  ldbar[layerid] = ldbar[layerid] + lc_en * cummatbudg[(double)lay];
2434 
2435  } //end of loop through clusters of the event
2436 
2437  // First a couple of variables to keep the sum of the energy of all clusters
2438  double sumeneallcluspl = 0.;
2439  double sumeneallclusmi = 0.;
2440  // and the longitudinal variable
2441  double sumldbarpl = 0.;
2442  double sumldbarmi = 0.;
2443  //Per layer : Loop 0->103
2444  for (unsigned ilayer = 0; ilayer < layers * 2; ++ilayer) {
2445  if (histograms.h_clusternum_perlayer.count(ilayer)) {
2446  histograms.h_clusternum_perlayer.at(ilayer)->Fill(tnlcpl[ilayer]);
2447  }
2448  // Two times one for plus and one for minus
2449  //First with the -z endcap
2450  if (ilayer < layers) {
2451  if (histograms.h_energyclustered_perlayer.count(ilayer)) {
2452  if (caloparteneminus != 0.) {
2453  histograms.h_energyclustered_perlayer.at(ilayer)->Fill(100. * tecpl[ilayer] / caloparteneminus);
2454  }
2455  }
2456  //Keep here the total energy for the event in -z
2457  sumeneallclusmi = sumeneallclusmi + tecpl[ilayer];
2458  //And for the longitudinal variable
2459  sumldbarmi = sumldbarmi + ldbar[ilayer];
2460  } else { //Then for the +z
2461  if (histograms.h_energyclustered_perlayer.count(ilayer)) {
2462  if (caloparteneplus != 0.) {
2463  histograms.h_energyclustered_perlayer.at(ilayer)->Fill(100. * tecpl[ilayer] / caloparteneplus);
2464  }
2465  }
2466  //Keep here the total energy for the event in -z
2467  sumeneallcluspl = sumeneallcluspl + tecpl[ilayer];
2468  //And for the longitudinal variable
2469  sumldbarpl = sumldbarpl + ldbar[ilayer];
2470  } //end of +z loop
2471 
2472  } //end of loop over layers
2473 
2474  //Per thickness
2475  for (std::vector<int>::iterator it = thicknesses.begin(); it != thicknesses.end(); ++it) {
2476  if (histograms.h_clusternum_perthick.count(*it)) {
2477  histograms.h_clusternum_perthick.at(*it)->Fill(tnlcpthplus[std::to_string(*it)]);
2478  histograms.h_clusternum_perthick.at(*it)->Fill(tnlcpthminus[std::to_string(*it)]);
2479  }
2480  }
2481  //Mixed thickness clusters
2482  histograms.h_mixedhitscluster_zplus[count]->Fill(tnlcpthplus["mixed"]);
2483  histograms.h_mixedhitscluster_zminus[count]->Fill(tnlcpthminus["mixed"]);
2484 
2485  //Total energy clustered from all layer clusters (fraction)
2486  if (caloparteneplus != 0.) {
2487  histograms.h_energyclustered_zplus[count]->Fill(100. * sumeneallcluspl / caloparteneplus);
2488  }
2489  if (caloparteneminus != 0.) {
2490  histograms.h_energyclustered_zminus[count]->Fill(100. * sumeneallclusmi / caloparteneminus);
2491  }
2492 
2493  //For the longitudinal depth barycenter
2494  histograms.h_longdepthbarycentre_zplus[count]->Fill(sumldbarpl / sumeneallcluspl);
2495  histograms.h_longdepthbarycentre_zminus[count]->Fill(sumldbarmi / sumeneallclusmi);
2496 }
Calorimetry_cff.thickness
thickness
Definition: Calorimetry_cff.py:115
hgcalTBTopologyTester_cfi.layers
layers
Definition: hgcalTBTopologyTester_cfi.py:8
HGVHistoProducerAlgo::layerClusters_to_CaloParticles
void layerClusters_to_CaloParticles(const Histograms &histograms, edm::Handle< reco::CaloClusterCollection > clusterHandle, const reco::CaloClusterCollection &clusters, edm::Handle< std::vector< CaloParticle >> caloParticleHandle, std::vector< CaloParticle > const &cP, std::vector< size_t > const &cPIndices, std::vector< size_t > const &cPSelectedIndices, std::unordered_map< DetId, const unsigned int > const &, unsigned int layers, const ticl::RecoToSimCollection &recSimColl, const ticl::SimToRecoCollection &simRecColl, std::vector< HGCRecHit > const &hits) const
Definition: HGVHistoProducerAlgo.cc:1739
hfClusterShapes_cfi.hits
hits
Definition: hfClusterShapes_cfi.py:5
ecaldqm::zside
int zside(DetId const &)
Definition: EcalDQMCommonUtils.cc:189
DetId::det
constexpr Detector det() const
get the detector field from this detid
Definition: DetId.h:46
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
to_string
static std::string to_string(const XMLCh *ch)
Definition: TotemDAQMappingESSourceXML.cc:353
HLT_2024v14_cff.distance
distance
Definition: HLT_2024v14_cff.py:5740
DetId
Definition: DetId.h:17
HGVHistoProducerAlgo::recHitTools_
std::shared_ptr< hgcal::RecHitTools > recHitTools_
Definition: HGVHistoProducerAlgo.h:394
DetId::rawId
constexpr uint32_t rawId() const
get the raw id
Definition: DetId.h:57
ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it
auto & it
Definition: splitVertices.h:28
HGVHistoProducerAlgo::distance
double distance(const double x1, const double y1, const double x2, const double y2) const
Definition: HGVHistoProducerAlgo.cc:3552
HGVHistoProducerAlgo::findmaxhit
DetId findmaxhit(const reco::CaloCluster &cluster, std::unordered_map< DetId, const unsigned int > const &, std::vector< HGCRecHit > const &hits) const
Definition: HGVHistoProducerAlgo.cc:3563
bsc_activity_cfg.clusters
clusters
Definition: bsc_activity_cfg.py:36
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:241

◆ fill_info_histos()

void HGVHistoProducerAlgo::fill_info_histos ( const Histograms &  histograms,
unsigned int  layers 
) const

Definition at line 1427 of file HGVHistoProducerAlgo.cc.

References hgcalTBTopologyTester_cfi::layers, and recHitTools_.

1427  {
1428  // Save some info straight from geometry to avoid mistakes from updates
1429  //----------- TODO ----------------------------------------------------------
1430  // For now values returned for 'lastLayerFHzp': '104', 'lastLayerFHzm': '52' are not the one expected.
1431  // Will come back to this when there will be info in CMSSW to put in DQM file.
1432  histograms.lastLayerEEzm->Fill(recHitTools_->lastLayerEE());
1433  histograms.lastLayerFHzm->Fill(recHitTools_->lastLayerFH());
1434  histograms.maxlayerzm->Fill(layers);
1435  histograms.lastLayerEEzp->Fill(recHitTools_->lastLayerEE() + layers);
1436  histograms.lastLayerFHzp->Fill(recHitTools_->lastLayerFH() + layers);
1437  histograms.maxlayerzp->Fill(layers + layers);
1438 }
hgcalTBTopologyTester_cfi.layers
layers
Definition: hgcalTBTopologyTester_cfi.py:8
HGVHistoProducerAlgo::recHitTools_
std::shared_ptr< hgcal::RecHitTools > recHitTools_
Definition: HGVHistoProducerAlgo.h:394

◆ fill_simCluster_histos()

void HGVHistoProducerAlgo::fill_simCluster_histos ( const Histograms &  histograms,
std::vector< SimCluster > const &  simClusters,
unsigned int  layers,
std::vector< int >  thicknesses 
) const

◆ fill_simClusterAssociation_histos()

void HGVHistoProducerAlgo::fill_simClusterAssociation_histos ( const Histograms &  histograms,
const int  count,
edm::Handle< reco::CaloClusterCollection >  clusterHandle,
const reco::CaloClusterCollection &  clusters,
edm::Handle< std::vector< SimCluster >>  simClusterHandle,
std::vector< SimCluster > const &  simClusters,
std::vector< size_t > const &  sCIndices,
const std::vector< float > &  mask,
std::unordered_map< DetId, const unsigned int > const &  hitMap,
unsigned int  layers,
const ticl::RecoToSimCollectionWithSimClusters &  recSimColl,
const ticl::SimToRecoCollectionWithSimClusters &  simRecColl,
std::vector< HGCRecHit > const &  hits 
) const

◆ fill_trackster_histos()

void HGVHistoProducerAlgo::fill_trackster_histos ( const Histograms &  histograms,
const int  count,
const ticl::TracksterCollection &  Tracksters,
const reco::CaloClusterCollection &  layerClusters,
const ticl::TracksterCollection &  simTS,
const ticl::TracksterCollection &  simTS_fromCP,
std::map< uint, std::vector< uint >> const &  simTrackstersMap,
std::vector< SimCluster > const &  sC,
const edm::ProductID &  cPHandle_id,
std::vector< CaloParticle > const &  cP,
std::vector< size_t > const &  cPIndices,
std::vector< size_t > const &  cPSelectedIndices,
std::unordered_map< DetId, const unsigned int > const &  ,
unsigned int  layers,
std::vector< HGCRecHit > const &  hits 
) const

Definition at line 3326 of file HGVHistoProducerAlgo.cc.

References submitPVResolutionJobs::count, hfClusterShapes_cfi::hits, hltEgammaHGCALIDVarsL1Seeded_cfi::layerClusters, hgcalTBTopologyTester_cfi::layers, Linking, recHitTools_, and tracksters_to_SimTracksters().

3341  {
3342  //Each event to be treated as two events:
3343  //an event in +ve endcap, plus another event in -ve endcap.
3344 
3345  //To keep track of total num of Tracksters
3346  int totNTstZm = 0; //-z
3347  int totNTstZp = 0; //+z
3348  //To count the number of Tracksters with 3 contiguous layers per event.
3349  int totNContTstZp = 0; //+z
3350  int totNContTstZm = 0; //-z
3351  //For the number of Tracksters without 3 contiguous layers per event.
3352  int totNNotContTstZp = 0; //+z
3353  int totNNotContTstZm = 0; //-z
3354  // Check below the score of cont and non cont Tracksters
3355  std::vector<bool> contTracksters;
3356  contTracksters.clear();
3357 
3358  //[tstId]-> vector of 2d layer clusters size
3359  std::unordered_map<unsigned int, std::vector<unsigned int>> multiplicity;
3360  //[tstId]-> [layer][cluster size]
3361  std::unordered_map<unsigned int, std::vector<unsigned int>> multiplicity_vs_layer;
3362  //We will need for the scale text option
3363  // unsigned int totalLcInTsts = 0;
3364  // for (unsigned int tstId = 0; tstId < nTracksters; ++tstId) {
3365  // totalLcInTsts = totalLcInTsts + tracksters[tstId].vertices().size();
3366  // }
3367 
3368  const auto nTracksters = tracksters.size();
3369  // loop through Tracksters
3370  for (unsigned int tstId = 0; tstId < nTracksters; ++tstId) {
3371  const auto& tst = tracksters[tstId];
3372  if (tst.vertices().empty())
3373  continue;
3374 
3375  if (tst.barycenter().z() < 0.)
3376  totNTstZm++;
3377  else if (tst.barycenter().z() > 0.)
3378  totNTstZp++;
3379 
3380  //Total number of layer clusters in Trackster
3381  int tnLcInTst = 0;
3382 
3383  //To keep track of total num of layer clusters per Trackster
3384  //tnLcInTstperlaypz[layerid], tnLcInTstperlaymz[layerid]
3385  std::vector<int> tnLcInTstperlay(1000, 0); //+z
3386 
3387  //For the layers the Trackster expands to. Will use a set because there would be many
3388  //duplicates and then go back to vector for random access, since they say it is faster.
3389  std::set<unsigned int> trackster_layers;
3390 
3391  bool tracksterInZplus = false;
3392  bool tracksterInZminus = false;
3393 
3394  //Loop through layer clusters
3395  for (const auto lcId : tst.vertices()) {
3396  //take the hits and their fraction of the specific layer cluster.
3397  const auto& hits_and_fractions = layerClusters[lcId].hitsAndFractions();
3398 
3399  //For the multiplicity of the 2d layer clusters in Tracksters
3400  multiplicity[tstId].emplace_back(hits_and_fractions.size());
3401 
3402  const auto firstHitDetId = hits_and_fractions[0].first;
3403  //The layer that the layer cluster belongs to
3404  const auto layerid = recHitTools_->getLayerWithOffset(firstHitDetId) +
3405  layers * ((recHitTools_->zside(firstHitDetId) + 1) >> 1) - 1;
3406  trackster_layers.insert(layerid);
3407  multiplicity_vs_layer[tstId].emplace_back(layerid);
3408 
3409  tnLcInTstperlay[layerid]++;
3410  tnLcInTst++;
3411 
3412  if (recHitTools_->zside(firstHitDetId) > 0.)
3413  tracksterInZplus = true;
3414  else if (recHitTools_->zside(firstHitDetId) < 0.)
3415  tracksterInZminus = true;
3416  } // end of loop through layerClusters
3417 
3418  // Per layer : Loop 0->99
3419  for (unsigned ilayer = 0; ilayer < layers * 2; ++ilayer) {
3420  if (histograms.h_clusternum_in_trackster_perlayer[count].count(ilayer) && tnLcInTstperlay[ilayer] != 0) {
3421  histograms.h_clusternum_in_trackster_perlayer[count].at(ilayer)->Fill((float)tnLcInTstperlay[ilayer]);
3422  }
3423  // For the profile now of 2d layer cluster in Tracksters vs layer number.
3424  if (tnLcInTstperlay[ilayer] != 0) {
3425  histograms.h_clusternum_in_trackster_vs_layer[count]->Fill((float)ilayer, (float)tnLcInTstperlay[ilayer]);
3426  }
3427  } // end of loop over layers
3428 
3429  // Looking for Tracksters with 3 contiguous layers per event.
3430  std::vector<int> trackster_layers_vec(trackster_layers.begin(), trackster_layers.end());
3431  // Check also for non contiguous Tracksters
3432  bool contiTrackster = false;
3433  // Start from 1 and go up to size - 1 element.
3434  if (trackster_layers_vec.size() >= 3) {
3435  for (unsigned int iLayer = 1; iLayer < trackster_layers_vec.size() - 1; ++iLayer) {
3436  if ((trackster_layers_vec[iLayer - 1] + 1 == trackster_layers_vec[iLayer]) &&
3437  (trackster_layers_vec[iLayer + 1] - 1 == trackster_layers_vec[iLayer])) {
3438  // Trackster with 3 contiguous layers per event
3439  if (tracksterInZplus)
3440  totNContTstZp++;
3441  else if (tracksterInZminus)
3442  totNContTstZm++;
3443 
3444  contiTrackster = true;
3445  break;
3446  }
3447  }
3448  }
3449  // Count non contiguous Tracksters
3450  if (!contiTrackster) {
3451  if (tracksterInZplus)
3452  totNNotContTstZp++;
3453  else if (tracksterInZminus)
3454  totNNotContTstZm++;
3455  }
3456 
3457  // Save for the score
3458  contTracksters.push_back(contiTrackster);
3459 
3460  histograms.h_clusternum_in_trackster[count]->Fill(tnLcInTst);
3461 
3462  for (unsigned int lc = 0; lc < multiplicity[tstId].size(); ++lc) {
3463  //multiplicity of the current LC
3464  float mlp = std::count(std::begin(multiplicity[tstId]), std::end(multiplicity[tstId]), multiplicity[tstId][lc]);
3465  //LogDebug("HGCalValidator") << "mlp %" << (100. * mlp)/ ((float) nLayerClusters) << std::endl;
3466  // histograms.h_multiplicityOfLCinTST[count]->Fill( mlp , multiplicity[tstId][lc] , 100. / (float) totalLcInTsts );
3467  histograms.h_multiplicityOfLCinTST[count]->Fill(mlp, multiplicity[tstId][lc]);
3468  //When plotting with the text option we want the entries to be the same
3469  //as the % of the current cell over the whole number of layerClusters. For this we need an extra histo.
3470  histograms.h_multiplicity_numberOfEventsHistogram[count]->Fill(mlp);
3471  //For the cluster multiplicity vs layer
3472  //First with the -z endcap (V10:0->49)
3473  if (multiplicity_vs_layer[tstId][lc] < layers) {
3474  histograms.h_multiplicityOfLCinTST_vs_layercluster_zminus[count]->Fill(mlp, multiplicity_vs_layer[tstId][lc]);
3475  histograms.h_multiplicity_zminus_numberOfEventsHistogram[count]->Fill(mlp);
3476  } else { //Then for the +z (V10:50->99)
3477  histograms.h_multiplicityOfLCinTST_vs_layercluster_zplus[count]->Fill(
3478  mlp, multiplicity_vs_layer[tstId][lc] - layers);
3479  histograms.h_multiplicity_zplus_numberOfEventsHistogram[count]->Fill(mlp);
3480  }
3481  //For the cluster multiplicity vs cluster energy
3482  histograms.h_multiplicityOfLCinTST_vs_layerclusterenergy[count]->Fill(mlp,
3483  layerClusters[tst.vertices(lc)].energy());
3484  }
3485 
3486  if (!trackster_layers.empty()) {
3487  histograms.h_trackster_x[count]->Fill(tst.barycenter().x());
3488  histograms.h_trackster_y[count]->Fill(tst.barycenter().y());
3489  histograms.h_trackster_z[count]->Fill(tst.barycenter().z());
3490  histograms.h_trackster_eta[count]->Fill(tst.barycenter().eta());
3491  histograms.h_trackster_phi[count]->Fill(tst.barycenter().phi());
3492 
3493  histograms.h_trackster_firstlayer[count]->Fill((float)*trackster_layers.begin());
3494  histograms.h_trackster_lastlayer[count]->Fill((float)*trackster_layers.rbegin());
3495  histograms.h_trackster_layersnum[count]->Fill((float)trackster_layers.size());
3496 
3497  histograms.h_trackster_pt[count]->Fill(tst.raw_pt());
3498  histograms.h_trackster_energy[count]->Fill(tst.raw_energy());
3499  }
3500 
3501  } //end of loop through Tracksters
3502 
3503  histograms.h_tracksternum[count]->Fill(totNTstZm + totNTstZp);
3504  histograms.h_conttracksternum[count]->Fill(totNContTstZp + totNContTstZm);
3505  histograms.h_nonconttracksternum[count]->Fill(totNNotContTstZp + totNNotContTstZm);
3506 
3507  // CaloParticle
3508  tracksters_to_SimTracksters(histograms,
3509  count,
3510  tracksters,
3511  layerClusters,
3512  simTSs_fromCP,
3513  Linking,
3514  simTSs_fromCP,
3515  cpToSc_SimTrackstersMap,
3516  sC,
3517  cPHandle_id,
3518  cP,
3519  cPIndices,
3520  cPSelectedIndices,
3521  hitMap,
3522  layers,
3523  hits);
3524 
3525  // Pattern recognition
3526  tracksters_to_SimTracksters(histograms,
3527  count,
3528  tracksters,
3529  layerClusters,
3530  simTSs,
3531  PatternRecognition,
3532  simTSs_fromCP,
3533  cpToSc_SimTrackstersMap,
3534  sC,
3535  cPHandle_id,
3536  cP,
3537  cPIndices,
3538  cPSelectedIndices,
3539  hitMap,
3540  layers,
3541  hits);
3542 }
hgcalTBTopologyTester_cfi.layers
layers
Definition: hgcalTBTopologyTester_cfi.py:8
HGVHistoProducerAlgo::tracksters_to_SimTracksters
void tracksters_to_SimTracksters(const Histograms &histograms, const int count, const ticl::TracksterCollection &Tracksters, const reco::CaloClusterCollection &layerClusters, const ticl::TracksterCollection &simTS, const validationType valType, const ticl::TracksterCollection &simTS_fromCP, std::map< uint, std::vector< uint >> const &simTrackstersMap, std::vector< SimCluster > const &sC, const edm::ProductID &cPHandle_id, std::vector< CaloParticle > const &cP, std::vector< size_t > const &cPIndices, std::vector< size_t > const &cPSelectedIndices, std::unordered_map< DetId, const unsigned int > const &, unsigned int layers, std::vector< HGCRecHit > const &hits) const
Definition: HGVHistoProducerAlgo.cc:2498
hfClusterShapes_cfi.hits
hits
Definition: hfClusterShapes_cfi.py:5
hltEgammaHGCALIDVarsL1Seeded_cfi.layerClusters
layerClusters
Definition: hltEgammaHGCALIDVarsL1Seeded_cfi.py:5
HGVHistoProducerAlgo::recHitTools_
std::shared_ptr< hgcal::RecHitTools > recHitTools_
Definition: HGVHistoProducerAlgo.h:394

◆ findmaxhit()

DetId HGVHistoProducerAlgo::findmaxhit ( const reco::CaloCluster &  cluster,
std::unordered_map< DetId, const unsigned int > const &  hitMap,
std::vector< HGCRecHit > const &  hits 
) const

Definition at line 3563 of file HGVHistoProducerAlgo.cc.

References hcalRecHitTable_cff::energy, hfClusterShapes_cfi::hits, reco::CaloCluster::hitsAndFractions(), and trackerHitRTTI::vector.

Referenced by fill_generic_cluster_histos().

3565  {
3566  const auto& hits_and_fractions = cluster.hitsAndFractions();
3567 
3568  DetId themaxid;
3569  double maxene = 0.;
3570  for (std::vector<std::pair<DetId, float>>::const_iterator it_haf = hits_and_fractions.begin();
3571  it_haf != hits_and_fractions.end();
3572  ++it_haf) {
3573  const DetId rh_detid = it_haf->first;
3574  const auto hitEn = (hits[hitMap.find(rh_detid)->second]).energy();
3575  if (maxene < hitEn) {
3576  maxene = hitEn;
3577  themaxid = rh_detid;
3578  }
3579  }
3580 
3581  return themaxid;
3582 }
reco::CaloCluster::hitsAndFractions
const std::vector< std::pair< DetId, float > > & hitsAndFractions() const
Definition: CaloCluster.h:210
hfClusterShapes_cfi.hits
hits
Definition: hfClusterShapes_cfi.py:5
hcalRecHitTable_cff.energy
energy
Definition: hcalRecHitTable_cff.py:13
DetId
Definition: DetId.h:17

◆ getEta()

double HGVHistoProducerAlgo::getEta ( double  eta) const
private

Definition at line 3584 of file HGVHistoProducerAlgo.cc.

References PVValHelper::eta, and useFabsEta_.

Referenced by fill_caloparticle_histos(), and fill_cluster_histos().

3584  {
3585  if (useFabsEta_)
3586  return fabs(eta);
3587  else
3588  return eta;
3589 }

◆ layerClusters_to_CaloParticles()

void HGVHistoProducerAlgo::layerClusters_to_CaloParticles ( const Histograms &  histograms,
edm::Handle< reco::CaloClusterCollection >  clusterHandle,
const reco::CaloClusterCollection &  clusters,
edm::Handle< std::vector< CaloParticle >>  caloParticleHandle,
std::vector< CaloParticle > const &  cP,
std::vector< size_t > const &  cPIndices,
std::vector< size_t > const &  cPSelectedIndices,
std::unordered_map< DetId, const unsigned int > const &  hitMap,
unsigned int  layers,
const ticl::RecoToSimCollection &  recSimColl,
const ticl::SimToRecoCollection &  simRecColl,
std::vector< HGCRecHit > const &  hits 
) const

Definition at line 1739 of file HGVHistoProducerAlgo.cc.

References trackingPlots::assoc, bsc_activity_cfg::clusters, edm::AssociationMap< Tag >::end(), mps_fire::end, PVValHelper::eta, spr::find(), edm::AssociationMap< Tag >::find(), dqmdumpme::first, h, hfClusterShapes_cfi::hits, hgcalTBTopologyTester_cfi::layers, LogDebug, getGTfromDQMFile::obj, AlCaHLTBitMon_ParallelJobs::p, phi, recHitTools_, ScoreCutCPtoLC_, and ScoreCutLCtoCP_.

Referenced by fill_generic_cluster_histos().

1750  {
1751  const auto nLayerClusters = clusters.size();
1752 
1753  std::unordered_map<DetId, std::vector<HGVHistoProducerAlgo::detIdInfoInCluster>> detIdToCaloParticleId_Map;
1754  std::unordered_map<DetId, std::vector<HGVHistoProducerAlgo::detIdInfoInCluster>> detIdToLayerClusterId_Map;
1755 
1756  // The association has to be done in an all-vs-all fashion.
1757  // For this reason use the full set of CaloParticles, with the only filter on bx
1758  for (const auto& cpId : cPIndices) {
1759  for (const auto& simCluster : cP[cpId].simClusters()) {
1760  for (const auto& it_haf : simCluster->hits_and_fractions()) {
1761  const DetId hitid = (it_haf.first);
1762  if (hitMap.find(hitid) != hitMap.end()) {
1763  if (detIdToCaloParticleId_Map.find(hitid) == detIdToCaloParticleId_Map.end()) {
1764  detIdToCaloParticleId_Map[hitid] = std::vector<HGVHistoProducerAlgo::detIdInfoInCluster>();
1765  detIdToCaloParticleId_Map[hitid].emplace_back(
1766  HGVHistoProducerAlgo::detIdInfoInCluster{cpId, it_haf.second});
1767  } else {
1768  auto findHitIt =
1769  std::find(detIdToCaloParticleId_Map[hitid].begin(),
1770  detIdToCaloParticleId_Map[hitid].end(),
1771  HGVHistoProducerAlgo::detIdInfoInCluster{
1772  cpId, 0.f}); // only the first element is used for the matching (overloaded operator==)
1773  if (findHitIt != detIdToCaloParticleId_Map[hitid].end())
1774  findHitIt->fraction += it_haf.second;
1775  else
1776  detIdToCaloParticleId_Map[hitid].emplace_back(
1777  HGVHistoProducerAlgo::detIdInfoInCluster{cpId, it_haf.second});
1778  }
1779  }
1780  }
1781  }
1782  }
1783 
1784  for (unsigned int lcId = 0; lcId < nLayerClusters; ++lcId) {
1785  const auto& hits_and_fractions = clusters[lcId].hitsAndFractions();
1786  const auto numberOfHitsInLC = hits_and_fractions.size();
1787 
1788  // This vector will store, for each hit in the Layercluster, the index of
1789  // the CaloParticle that contributed the most, in terms of energy, to it.
1790  // Special values are:
1791  //
1792  // -2 --> the reconstruction fraction of the RecHit is 0 (used in the past to monitor Halo Hits)
1793  // -3 --> same as before with the added condition that no CaloParticle has been linked to this RecHit
1794  // -1 --> the reco fraction is >0, but no CaloParticle has been linked to it
1795  // >=0 --> index of the linked CaloParticle
1796  std::vector<int> hitsToCaloParticleId(numberOfHitsInLC);
1797  const auto firstHitDetId = hits_and_fractions[0].first;
1798  int lcLayerId =
1799  recHitTools_->getLayerWithOffset(firstHitDetId) + layers * ((recHitTools_->zside(firstHitDetId) + 1) >> 1) - 1;
1800 
1801  // This will store the fraction of the CaloParticle energy shared with the LayerCluster: e_shared/cp_energy
1802  std::unordered_map<unsigned, float> CPEnergyInLC;
1803 
1804  for (unsigned int iHit = 0; iHit < numberOfHitsInLC; iHit++) {
1805  const DetId rh_detid = hits_and_fractions[iHit].first;
1806  const auto rhFraction = hits_and_fractions[iHit].second;
1807 
1808  std::unordered_map<DetId, const unsigned int>::const_iterator itcheck = hitMap.find(rh_detid);
1809  const HGCRecHit* hit = &(hits[itcheck->second]);
1810 
1811  if (detIdToLayerClusterId_Map.find(rh_detid) == detIdToLayerClusterId_Map.end()) {
1812  detIdToLayerClusterId_Map[rh_detid] = std::vector<HGVHistoProducerAlgo::detIdInfoInCluster>();
1813  }
1814  detIdToLayerClusterId_Map[rh_detid].emplace_back(HGVHistoProducerAlgo::detIdInfoInCluster{lcId, rhFraction});
1815 
1816  const auto& hit_find_in_CP = detIdToCaloParticleId_Map.find(rh_detid);
1817 
1818  // if the fraction is zero or the hit does not belong to any calo
1819  // particle, set the caloparticleId for the hit to -1 this will
1820  // contribute to the number of noise hits
1821 
1822  // MR Remove the case in which the fraction is 0, since this could be a
1823  // real hit that has been marked as halo.
1824  if (rhFraction == 0.) {
1825  hitsToCaloParticleId[iHit] = -2;
1826  }
1827  if (hit_find_in_CP == detIdToCaloParticleId_Map.end()) {
1828  hitsToCaloParticleId[iHit] -= 1;
1829  } else {
1830  auto maxCPEnergyInLC = 0.f;
1831  auto maxCPId = -1;
1832  for (auto& h : hit_find_in_CP->second) {
1833  const auto iCP = h.clusterId;
1834  CPEnergyInLC[iCP] += h.fraction * hit->energy();
1835  // Keep track of which CaloParticle contributed the most, in terms
1836  // of energy, to this specific LayerCluster.
1837  if (CPEnergyInLC[iCP] > maxCPEnergyInLC) {
1838  maxCPEnergyInLC = CPEnergyInLC[iCP];
1839  maxCPId = iCP;
1840  }
1841  }
1842  hitsToCaloParticleId[iHit] = maxCPId;
1843  }
1844  histograms.h_cellAssociation_perlayer.at(lcLayerId)->Fill(
1845  hitsToCaloParticleId[iHit] > 0. ? 0. : hitsToCaloParticleId[iHit]);
1846  } // End loop over hits on a LayerCluster
1847 
1848  } // End of loop over LayerClusters
1849 
1850  // Fill the plots to compute the different metrics linked to
1851  // reco-level, namely fake-rate an merge-rate. In this loop should *not*
1852  // restrict only to the selected caloParaticles.
1853  for (unsigned int lcId = 0; lcId < nLayerClusters; ++lcId) {
1854  const auto firstHitDetId = (clusters[lcId].hitsAndFractions())[0].first;
1855  const int lcLayerId =
1856  recHitTools_->getLayerWithOffset(firstHitDetId) + layers * ((recHitTools_->zside(firstHitDetId) + 1) >> 1) - 1;
1857  histograms.h_denom_layercl_eta_perlayer.at(lcLayerId)->Fill(clusters[lcId].eta());
1858  histograms.h_denom_layercl_phi_perlayer.at(lcLayerId)->Fill(clusters[lcId].phi());
1859  //
1860  const edm::Ref<reco::CaloClusterCollection> lcRef(clusterHandle, lcId);
1861  const auto& cpsIt = cpsInLayerClusterMap.find(lcRef);
1862  if (cpsIt == cpsInLayerClusterMap.end())
1863  continue;
1864 
1865  const auto lc_en = clusters[lcId].energy();
1866  const auto& cps = cpsIt->val;
1867  if (lc_en == 0. && !cps.empty()) {
1868  for (const auto& cpPair : cps)
1869  histograms.h_score_layercl2caloparticle_perlayer.at(lcLayerId)->Fill(cpPair.second);
1870  continue;
1871  }
1872  for (const auto& cpPair : cps) {
1873  LogDebug("HGCalValidator") << "layerCluster Id: \t" << lcId << "\t CP id: \t" << cpPair.first.index()
1874  << "\t score \t" << cpPair.second << std::endl;
1875  histograms.h_score_layercl2caloparticle_perlayer.at(lcLayerId)->Fill(cpPair.second);
1876  auto const& cp_linked =
1877  std::find_if(std::begin(cPOnLayerMap[cpPair.first]),
1878  std::end(cPOnLayerMap[cpPair.first]),
1879  [&lcRef](const std::pair<edm::Ref<reco::CaloClusterCollection>, std::pair<float, float>>& p) {
1880  return p.first == lcRef;
1881  });
1882  if (cp_linked ==
1883  cPOnLayerMap[cpPair.first].end()) // This should never happen by construction of the association maps
1884  continue;
1885  histograms.h_sharedenergy_layercl2caloparticle_perlayer.at(lcLayerId)->Fill(cp_linked->second.first / lc_en,
1886  lc_en);
1887  histograms.h_energy_vs_score_layercl2caloparticle_perlayer.at(lcLayerId)->Fill(cpPair.second,
1888  cp_linked->second.first / lc_en);
1889  }
1890  const auto assoc =
1891  std::count_if(std::begin(cps), std::end(cps), [](const auto& obj) { return obj.second < ScoreCutLCtoCP_; });
1892  if (assoc) {
1893  histograms.h_num_layercl_eta_perlayer.at(lcLayerId)->Fill(clusters[lcId].eta());
1894  histograms.h_num_layercl_phi_perlayer.at(lcLayerId)->Fill(clusters[lcId].phi());
1895  if (assoc > 1) {
1896  histograms.h_numMerge_layercl_eta_perlayer.at(lcLayerId)->Fill(clusters[lcId].eta());
1897  histograms.h_numMerge_layercl_phi_perlayer.at(lcLayerId)->Fill(clusters[lcId].phi());
1898  }
1899  const auto& best = std::min_element(
1900  std::begin(cps), std::end(cps), [](const auto& obj1, const auto& obj2) { return obj1.second < obj2.second; });
1901  const auto& best_cp_linked =
1902  std::find_if(std::begin(cPOnLayerMap[best->first]),
1903  std::end(cPOnLayerMap[best->first]),
1904  [&lcRef](const std::pair<edm::Ref<reco::CaloClusterCollection>, std::pair<float, float>>& p) {
1905  return p.first == lcRef;
1906  });
1907  if (best_cp_linked ==
1908  cPOnLayerMap[best->first].end()) // This should never happen by construction of the association maps
1909  continue;
1910  histograms.h_sharedenergy_layercl2caloparticle_vs_eta_perlayer.at(lcLayerId)->Fill(
1911  clusters[lcId].eta(), best_cp_linked->second.first / lc_en);
1912  histograms.h_sharedenergy_layercl2caloparticle_vs_phi_perlayer.at(lcLayerId)->Fill(
1913  clusters[lcId].phi(), best_cp_linked->second.first / lc_en);
1914  }
1915  } // End of loop over LayerClusters
1916 
1917  // Here Fill the plots to compute the different metrics linked to
1918  // gen-level, namely efficiency and duplicate. In this loop should restrict
1919  // only to the selected caloParaticles.
1920  for (const auto& cpId : cPSelectedIndices) {
1921  const edm::Ref<CaloParticleCollection> cpRef(caloParticleHandle, cpId);
1922  const auto& lcsIt = cPOnLayerMap.find(cpRef);
1923 
1924  std::map<unsigned int, float> cPEnergyOnLayer;
1925  for (unsigned int layerId = 0; layerId < layers * 2; ++layerId)
1926  cPEnergyOnLayer[layerId] = 0;
1927 
1928  for (const auto& simCluster : cP[cpId].simClusters()) {
1929  for (const auto& it_haf : simCluster->hits_and_fractions()) {
1930  const DetId hitid = (it_haf.first);
1931  const auto hitLayerId =
1932  recHitTools_->getLayerWithOffset(hitid) + layers * ((recHitTools_->zside(hitid) + 1) >> 1) - 1;
1933  std::unordered_map<DetId, const unsigned int>::const_iterator itcheck = hitMap.find(hitid);
1934  if (itcheck != hitMap.end()) {
1935  const HGCRecHit* hit = &(hits[itcheck->second]);
1936  cPEnergyOnLayer[hitLayerId] += it_haf.second * hit->energy();
1937  }
1938  }
1939  }
1940 
1941  for (unsigned int layerId = 0; layerId < layers * 2; ++layerId) {
1942  if (!cPEnergyOnLayer[layerId])
1943  continue;
1944 
1945  histograms.h_denom_caloparticle_eta_perlayer.at(layerId)->Fill(cP[cpId].g4Tracks()[0].momentum().eta());
1946  histograms.h_denom_caloparticle_phi_perlayer.at(layerId)->Fill(cP[cpId].g4Tracks()[0].momentum().phi());
1947 
1948  if (lcsIt == cPOnLayerMap.end())
1949  continue;
1950  const auto& lcs = lcsIt->val;
1951 
1952  auto getLCLayerId = [&](const unsigned int lcId) {
1953  const auto firstHitDetId = (clusters[lcId].hitsAndFractions())[0].first;
1954  const auto lcLayerId = recHitTools_->getLayerWithOffset(firstHitDetId) +
1955  layers * ((recHitTools_->zside(firstHitDetId) + 1) >> 1) - 1;
1956  return lcLayerId;
1957  };
1958 
1959  for (const auto& lcPair : lcs) {
1960  if (getLCLayerId(lcPair.first.index()) != layerId)
1961  continue;
1962  histograms.h_score_caloparticle2layercl_perlayer.at(layerId)->Fill(lcPair.second.second);
1963  histograms.h_sharedenergy_caloparticle2layercl_perlayer.at(layerId)->Fill(
1964  lcPair.second.first / cPEnergyOnLayer[layerId], cPEnergyOnLayer[layerId]);
1965  histograms.h_energy_vs_score_caloparticle2layercl_perlayer.at(layerId)->Fill(
1966  lcPair.second.second, lcPair.second.first / cPEnergyOnLayer[layerId]);
1967  }
1968  const auto assoc = std::count_if(std::begin(lcs), std::end(lcs), [&](const auto& obj) {
1969  if (getLCLayerId(obj.first.index()) != layerId)
1970  return false;
1971  else
1972  return obj.second.second < ScoreCutCPtoLC_;
1973  });
1974  if (assoc) {
1975  histograms.h_num_caloparticle_eta_perlayer.at(layerId)->Fill(cP[cpId].g4Tracks()[0].momentum().eta());
1976  histograms.h_num_caloparticle_phi_perlayer.at(layerId)->Fill(cP[cpId].g4Tracks()[0].momentum().phi());
1977  if (assoc > 1) {
1978  histograms.h_numDup_caloparticle_eta_perlayer.at(layerId)->Fill(cP[cpId].g4Tracks()[0].momentum().eta());
1979  histograms.h_numDup_caloparticle_phi_perlayer.at(layerId)->Fill(cP[cpId].g4Tracks()[0].momentum().phi());
1980  }
1981  const auto best = std::min_element(std::begin(lcs), std::end(lcs), [&](const auto& obj1, const auto& obj2) {
1982  if (getLCLayerId(obj1.first.index()) != layerId)
1983  return false;
1984  else if (getLCLayerId(obj2.first.index()) == layerId)
1985  return obj1.second.second < obj2.second.second;
1986  else
1987  return true;
1988  });
1989  histograms.h_sharedenergy_caloparticle2layercl_vs_eta_perlayer.at(layerId)->Fill(
1990  cP[cpId].g4Tracks()[0].momentum().eta(), best->second.first / cPEnergyOnLayer[layerId]);
1991  histograms.h_sharedenergy_caloparticle2layercl_vs_phi_perlayer.at(layerId)->Fill(
1992  cP[cpId].g4Tracks()[0].momentum().phi(), best->second.first / cPEnergyOnLayer[layerId]);
1993  }
1994  }
1995  }
1996 }
hgcalTBTopologyTester_cfi.layers
layers
Definition: hgcalTBTopologyTester_cfi.py:8
hfClusterShapes_cfi.hits
hits
Definition: hfClusterShapes_cfi.py:5
spr::find
void find(edm::Handle< EcalRecHitCollection > &hits, DetId thisDet, std::vector< EcalRecHitCollection::const_iterator > &hit, bool debug=false)
Definition: FindCaloHit.cc:19
ScoreCutLCtoCP_
const double ScoreCutLCtoCP_
Definition: HGVHistoProducerAlgo.cc:16
DetId
Definition: DetId.h:17
mps_fire.end
end
Definition: mps_fire.py:242
HGVHistoProducerAlgo::recHitTools_
std::shared_ptr< hgcal::RecHitTools > recHitTools_
Definition: HGVHistoProducerAlgo.h:394
h
The Signals That Services Can Subscribe To This is based on ActivityRegistry h
Helper function to determine trigger accepts.
Definition: Activities.doc:4
ScoreCutCPtoLC_
const double ScoreCutCPtoLC_
Definition: HGVHistoProducerAlgo.cc:17
AlCaHLTBitMon_ParallelJobs.p
def p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
bsc_activity_cfg.clusters
clusters
Definition: bsc_activity_cfg.py:36
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:241

◆ layerClusters_to_SimClusters()

void HGVHistoProducerAlgo::layerClusters_to_SimClusters ( const Histograms &  histograms,
const int  count,
edm::Handle< reco::CaloClusterCollection >  clusterHandle,
const reco::CaloClusterCollection &  clusters,
edm::Handle< std::vector< SimCluster >>  simClusterHandle,
std::vector< SimCluster > const &  simClusters,
std::vector< size_t > const &  sCIndices,
const std::vector< float > &  mask,
std::unordered_map< DetId, const unsigned int > const &  hitMap,
unsigned int  layers,
const ticl::RecoToSimCollectionWithSimClusters &  recSimColl,
const ticl::SimToRecoCollectionWithSimClusters &  simRecColl,
std::vector< HGCRecHit > const &  hits 
) const

Definition at line 1998 of file HGVHistoProducerAlgo.cc.

References trackingPlots::assoc, bsc_activity_cfg::clusters, submitPVResolutionJobs::count, edm::AssociationMap< Tag >::end(), PVValHelper::eta, edm::AssociationMap< Tag >::find(), dqmdumpme::first, hfClusterShapes_cfi::hits, hgcalTBTopologyTester_cfi::layers, LogDebug, ALPAKA_ACCELERATOR_NAMESPACE::pixelClustering::pixelStatus::mask, getGTfromDQMFile::obj, AlCaHLTBitMon_ParallelJobs::p, phi, recHitTools_, ScoreCutLCtoSC_, and ScoreCutSCtoLC_.

2011  {
2012  // Here fill the plots to compute the different metrics linked to
2013  // reco-level, namely fake-rate and merge-rate. In this loop should *not*
2014  // restrict only to the selected SimClusters.
2015  for (unsigned int lcId = 0; lcId < clusters.size(); ++lcId) {
2016  if (mask[lcId] != 0.) {
2017  LogDebug("HGCalValidator") << "Skipping layer cluster " << lcId << " not belonging to mask" << std::endl;
2018  continue;
2019  }
2020  const auto firstHitDetId = (clusters[lcId].hitsAndFractions())[0].first;
2021  const auto lcLayerId =
2022  recHitTools_->getLayerWithOffset(firstHitDetId) + layers * ((recHitTools_->zside(firstHitDetId) + 1) >> 1) - 1;
2023  //Although the ones below are already created in the LC to CP association, will
2024  //recreate them here since in the post processor it looks in a specific directory.
2025  histograms.h_denom_layercl_in_simcl_eta_perlayer[count].at(lcLayerId)->Fill(clusters[lcId].eta());
2026  histograms.h_denom_layercl_in_simcl_phi_perlayer[count].at(lcLayerId)->Fill(clusters[lcId].phi());
2027  //
2028  const edm::Ref<reco::CaloClusterCollection> lcRef(clusterHandle, lcId);
2029  const auto& scsIt = scsInLayerClusterMap.find(lcRef);
2030  if (scsIt == scsInLayerClusterMap.end())
2031  continue;
2032 
2033  const auto lc_en = clusters[lcId].energy();
2034  const auto& scs = scsIt->val;
2035  // If a reconstructed LayerCluster has energy 0 but is linked to at least a
2036  // SimCluster, then his score should be 1 as set in the associator
2037  if (lc_en == 0. && !scs.empty()) {
2038  for (const auto& scPair : scs) {
2039  histograms.h_score_layercl2simcluster_perlayer[count].at(lcLayerId)->Fill(scPair.second);
2040  }
2041  continue;
2042  }
2043  //Loop through all SimClusters linked to the layer cluster under study
2044  for (const auto& scPair : scs) {
2045  LogDebug("HGCalValidator") << "layerCluster Id: \t" << lcId << "\t SC id: \t" << scPair.first.index()
2046  << "\t score \t" << scPair.second << std::endl;
2047  //This should be filled #layerClusters in layer x #linked SimClusters
2048  histograms.h_score_layercl2simcluster_perlayer[count].at(lcLayerId)->Fill(scPair.second);
2049  auto const& sc_linked =
2050  std::find_if(std::begin(lcsInSimClusterMap[scPair.first]),
2051  std::end(lcsInSimClusterMap[scPair.first]),
2052  [&lcRef](const std::pair<edm::Ref<reco::CaloClusterCollection>, std::pair<float, float>>& p) {
2053  return p.first == lcRef;
2054  });
2055  if (sc_linked ==
2056  lcsInSimClusterMap[scPair.first].end()) // This should never happen by construction of the association maps
2057  continue;
2058  histograms.h_sharedenergy_layercl2simcluster_perlayer[count].at(lcLayerId)->Fill(sc_linked->second.first / lc_en,
2059  lc_en);
2060  histograms.h_energy_vs_score_layercl2simcluster_perlayer[count].at(lcLayerId)->Fill(
2061  scPair.second, sc_linked->second.first / lc_en);
2062  }
2063  //Here he counts how many of the linked SimClusters of the layer cluster under study have a score above a certain value.
2064  const auto assoc =
2065  std::count_if(std::begin(scs), std::end(scs), [](const auto& obj) { return obj.second < ScoreCutLCtoSC_; });
2066  if (assoc) {
2067  histograms.h_num_layercl_in_simcl_eta_perlayer[count].at(lcLayerId)->Fill(clusters[lcId].eta());
2068  histograms.h_num_layercl_in_simcl_phi_perlayer[count].at(lcLayerId)->Fill(clusters[lcId].phi());
2069  if (assoc > 1) {
2070  histograms.h_numMerge_layercl_in_simcl_eta_perlayer[count].at(lcLayerId)->Fill(clusters[lcId].eta());
2071  histograms.h_numMerge_layercl_in_simcl_phi_perlayer[count].at(lcLayerId)->Fill(clusters[lcId].phi());
2072  }
2073  const auto& best = std::min_element(
2074  std::begin(scs), std::end(scs), [](const auto& obj1, const auto& obj2) { return obj1.second < obj2.second; });
2075  //From all SimClusters he founds the one with the best (lowest) score and takes his scId
2076  const auto& best_sc_linked =
2077  std::find_if(std::begin(lcsInSimClusterMap[best->first]),
2078  std::end(lcsInSimClusterMap[best->first]),
2079  [&lcRef](const std::pair<edm::Ref<reco::CaloClusterCollection>, std::pair<float, float>>& p) {
2080  return p.first == lcRef;
2081  });
2082  if (best_sc_linked ==
2083  lcsInSimClusterMap[best->first].end()) // This should never happen by construction of the association maps
2084  continue;
2085  histograms.h_sharedenergy_layercl2simcluster_vs_eta_perlayer[count].at(lcLayerId)->Fill(
2086  clusters[lcId].eta(), best_sc_linked->second.first / lc_en);
2087  histograms.h_sharedenergy_layercl2simcluster_vs_phi_perlayer[count].at(lcLayerId)->Fill(
2088  clusters[lcId].phi(), best_sc_linked->second.first / lc_en);
2089  }
2090  } // End of loop over LayerClusters
2091 
2092  // Fill the plots to compute the different metrics linked to
2093  // gen-level, namely efficiency and duplicate. In this loop should restrict
2094  // only to the selected SimClusters.
2095  for (const auto& scId : sCIndices) {
2096  const edm::Ref<SimClusterCollection> scRef(simClusterHandle, scId);
2097  const auto& lcsIt = lcsInSimClusterMap.find(scRef);
2098 
2099  std::map<unsigned int, float> sCEnergyOnLayer;
2100  for (unsigned int layerId = 0; layerId < layers * 2; ++layerId)
2101  sCEnergyOnLayer[layerId] = 0;
2102 
2103  for (const auto& it_haf : sC[scId].hits_and_fractions()) {
2104  const DetId hitid = (it_haf.first);
2105  const auto scLayerId =
2106  recHitTools_->getLayerWithOffset(hitid) + layers * ((recHitTools_->zside(hitid) + 1) >> 1) - 1;
2107  std::unordered_map<DetId, const unsigned int>::const_iterator itcheck = hitMap.find(hitid);
2108  if (itcheck != hitMap.end()) {
2109  const HGCRecHit* hit = &(hits[itcheck->second]);
2110  sCEnergyOnLayer[scLayerId] += it_haf.second * hit->energy();
2111  }
2112  }
2113 
2114  for (unsigned int layerId = 0; layerId < layers * 2; ++layerId) {
2115  if (!sCEnergyOnLayer[layerId])
2116  continue;
2117 
2118  histograms.h_denom_simcluster_eta_perlayer[count].at(layerId)->Fill(sC[scId].eta());
2119  histograms.h_denom_simcluster_phi_perlayer[count].at(layerId)->Fill(sC[scId].phi());
2120 
2121  if (lcsIt == lcsInSimClusterMap.end())
2122  continue;
2123  const auto& lcs = lcsIt->val;
2124 
2125  auto getLCLayerId = [&](const unsigned int lcId) {
2126  const auto firstHitDetId = (clusters[lcId].hitsAndFractions())[0].first;
2127  const unsigned int lcLayerId = recHitTools_->getLayerWithOffset(firstHitDetId) +
2128  layers * ((recHitTools_->zside(firstHitDetId) + 1) >> 1) - 1;
2129  return lcLayerId;
2130  };
2131 
2132  //Loop through layer clusters linked to the SimCluster under study
2133  for (const auto& lcPair : lcs) {
2134  auto lcId = lcPair.first.index();
2135  if (mask[lcId] != 0.) {
2136  LogDebug("HGCalValidator") << "Skipping layer cluster " << lcId << " not belonging to mask" << std::endl;
2137  continue;
2138  }
2139 
2140  if (getLCLayerId(lcId) != layerId)
2141  continue;
2142  histograms.h_score_simcluster2layercl_perlayer[count].at(layerId)->Fill(lcPair.second.second);
2143  histograms.h_sharedenergy_simcluster2layercl_perlayer[count].at(layerId)->Fill(
2144  lcPair.second.first / sCEnergyOnLayer[layerId], sCEnergyOnLayer[layerId]);
2145  histograms.h_energy_vs_score_simcluster2layercl_perlayer[count].at(layerId)->Fill(
2146  lcPair.second.second, lcPair.second.first / sCEnergyOnLayer[layerId]);
2147  }
2148  const auto assoc = std::count_if(std::begin(lcs), std::end(lcs), [&](const auto& obj) {
2149  if (getLCLayerId(obj.first.index()) != layerId)
2150  return false;
2151  else
2152  return obj.second.second < ScoreCutSCtoLC_;
2153  });
2154  if (assoc) {
2155  histograms.h_num_simcluster_eta_perlayer[count].at(layerId)->Fill(sC[scId].eta());
2156  histograms.h_num_simcluster_phi_perlayer[count].at(layerId)->Fill(sC[scId].phi());
2157  if (assoc > 1) {
2158  histograms.h_numDup_simcluster_eta_perlayer[count].at(layerId)->Fill(sC[scId].eta());
2159  histograms.h_numDup_simcluster_phi_perlayer[count].at(layerId)->Fill(sC[scId].phi());
2160  }
2161  const auto best = std::min_element(std::begin(lcs), std::end(lcs), [&](const auto& obj1, const auto& obj2) {
2162  if (getLCLayerId(obj1.first.index()) != layerId)
2163  return false;
2164  else if (getLCLayerId(obj2.first.index()) == layerId)
2165  return obj1.second.second < obj2.second.second;
2166  else
2167  return true;
2168  });
2169  histograms.h_sharedenergy_simcluster2layercl_vs_eta_perlayer[count].at(layerId)->Fill(
2170  sC[scId].eta(), best->second.first / sCEnergyOnLayer[layerId]);
2171  histograms.h_sharedenergy_simcluster2layercl_vs_phi_perlayer[count].at(layerId)->Fill(
2172  sC[scId].phi(), best->second.first / sCEnergyOnLayer[layerId]);
2173  }
2174  }
2175  }
2176 }
ALPAKA_ACCELERATOR_NAMESPACE::pixelClustering::pixelStatus::mask
constexpr uint32_t mask
Definition: PixelClustering.h:35
hgcalTBTopologyTester_cfi.layers
layers
Definition: hgcalTBTopologyTester_cfi.py:8
ScoreCutSCtoLC_
const double ScoreCutSCtoLC_
Definition: HGVHistoProducerAlgo.cc:19
hfClusterShapes_cfi.hits
hits
Definition: hfClusterShapes_cfi.py:5
ScoreCutLCtoSC_
const double ScoreCutLCtoSC_
Definition: HGVHistoProducerAlgo.cc:18
DetId
Definition: DetId.h:17
HGVHistoProducerAlgo::recHitTools_
std::shared_ptr< hgcal::RecHitTools > recHitTools_
Definition: HGVHistoProducerAlgo.h:394
AlCaHLTBitMon_ParallelJobs.p
def p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
bsc_activity_cfg.clusters
clusters
Definition: bsc_activity_cfg.py:36
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:241

◆ setRecHitTools()

void HGVHistoProducerAlgo::setRecHitTools ( std::shared_ptr< hgcal::RecHitTools >  recHitTools)

Definition at line 3559 of file HGVHistoProducerAlgo.cc.

References recHitTools_.

3559  {
3560  recHitTools_ = recHitTools;
3561 }
HGVHistoProducerAlgo::recHitTools_
std::shared_ptr< hgcal::RecHitTools > recHitTools_
Definition: HGVHistoProducerAlgo.h:394

◆ tracksters_to_SimTracksters()

void HGVHistoProducerAlgo::tracksters_to_SimTracksters ( const Histograms &  histograms,
const int  count,
const ticl::TracksterCollection &  Tracksters,
const reco::CaloClusterCollection &  layerClusters,
const ticl::TracksterCollection &  simTS,
const validationType  valType,
const ticl::TracksterCollection &  simTS_fromCP,
std::map< uint, std::vector< uint >> const &  simTrackstersMap,
std::vector< SimCluster > const &  sC,
const edm::ProductID &  cPHandle_id,
std::vector< CaloParticle > const &  cP,
std::vector< size_t > const &  cPIndices,
std::vector< size_t > const &  cPSelectedIndices,
std::unordered_map< DetId, const unsigned int > const &  ,
unsigned int  layers,
std::vector< HGCRecHit > const &  hits 
) const

Definition at line 2498 of file HGVHistoProducerAlgo.cc.

References DummyCfis::c, submitPVResolutionJobs::count, HLT_2024v14_cff::distance, relativeConstraints::empty, mps_fire::end, hcalRecHitTable_cff::energy, f, spr::find(), newFWLiteAna::found, HLT_2024v14_cff::fraction, h, hfClusterShapes_cfi::hits, heavyIonCSV_trainingSettings::idx, ALPAKA_ACCELERATOR_NAMESPACE::caPixelDoublets::if(), dqmiolumiharvest::j, dqmdumpme::last, hltEgammaHGCALIDVarsL1Seeded_cfi::layerClusters, LogDebug, SiStripPI::min, minTSTSharedEneFracEfficiency_, GetRecoTauVFromDQM_MC_cff::next, getGTfromDQMFile::obj, funct::pow(), offlineSlimmedPrimaryVertices_cfi::score, ScoreCutSTStoTSPurDup_, ScoreCutTStoSTSFakeMerge_, ticl::Trackster::seedID(), ticl::Trackster::seedIndex(), ticl::Trackster::SIM, jetUpdater_cfi::sort, tier0::unique(), findQualityFiles::v, ticl::Trackster::vertex_multiplicity(), AlignmentTracksFromVertexSelector_cfi::vertices, and ticl::Trackster::vertices().

Referenced by fill_trackster_histos().

2514  {
2515  const auto nTracksters = tracksters.size();
2516  const auto nSimTracksters = simTSs.size();
2517 
2518  std::unordered_map<DetId, std::vector<HGVHistoProducerAlgo::detIdInfoInCluster>> detIdSimTSId_Map;
2519  std::unordered_map<DetId, std::vector<HGVHistoProducerAlgo::detIdInfoInTrackster>> detIdToTracksterId_Map;
2520  std::vector<int> tracksters_FakeMerge(nTracksters, 0);
2521  std::vector<int> tracksters_PurityDuplicate(nSimTracksters, 0);
2522 
2523  // This vector contains the ids of the SimTracksters contributing with at least one hit to the Trackster and the reconstruction error
2524  //stsInTrackster[trackster][STSids]
2525  //Connects a Trackster with all related SimTracksters.
2526  std::vector<std::vector<std::pair<unsigned int, float>>> stsInTrackster;
2527  stsInTrackster.resize(nTracksters);
2528 
2529  // cPOnLayer[caloparticle]:
2530  //1. the sum of all rechits energy times fraction of the relevant simhit related to that calo particle.
2531  //2. the hits and fractions of that calo particle.
2532  //3. the layer clusters with matched rechit id.
2533  std::unordered_map<int, caloParticleOnLayer> cPOnLayer;
2534  std::unordered_map<int, std::vector<caloParticleOnLayer>> sCOnLayer;
2535  //Consider CaloParticles coming from the hard scatterer, excluding the PU contribution.
2536  for (const auto cpIndex : cPIndices) {
2537  cPOnLayer[cpIndex].caloParticleId = cpIndex;
2538  cPOnLayer[cpIndex].energy = 0.f;
2539  cPOnLayer[cpIndex].hits_and_fractions.clear();
2540  const auto nSC_inCP = sC.size();
2541  sCOnLayer[cpIndex].resize(nSC_inCP);
2542  for (unsigned int iSC = 0; iSC < nSC_inCP; iSC++) {
2543  sCOnLayer[cpIndex][iSC].caloParticleId = cpIndex;
2544  sCOnLayer[cpIndex][iSC].energy = 0.f;
2545  sCOnLayer[cpIndex][iSC].hits_and_fractions.clear();
2546  }
2547  }
2548 
2549  auto getCPId = [](const ticl::Trackster& simTS,
2550  const unsigned int iSTS,
2551  const edm::ProductID& cPHandle_id,
2552  const std::map<unsigned int, std::vector<unsigned int>>& cpToSc_SimTrackstersMap,
2553  const ticl::TracksterCollection& simTSs_fromCP) {
2554  unsigned int cpId = -1;
2555 
2556  const auto productID = simTS.seedID();
2557  if (productID == cPHandle_id) {
2558  cpId = simTS.seedIndex();
2559  } else { // SimTrackster from SimCluster
2560  const auto findSimTSFromCP = std::find_if(
2561  std::begin(cpToSc_SimTrackstersMap),
2562  std::end(cpToSc_SimTrackstersMap),
2563  [&](const std::pair<unsigned int, std::vector<unsigned int>>& cpToScs) {
2564  return std::find(std::begin(cpToScs.second), std::end(cpToScs.second), iSTS) != std::end(cpToScs.second);
2565  });
2566  if (findSimTSFromCP != std::end(cpToSc_SimTrackstersMap)) {
2567  cpId = simTSs_fromCP[findSimTSFromCP->first].seedIndex();
2568  }
2569  }
2570 
2571  return cpId;
2572  };
2573 
2574  auto getLCId = [](const std::vector<unsigned int>& tst_vertices,
2575  const reco::CaloClusterCollection& layerClusters,
2576  const DetId& hitid) {
2577  unsigned int lcId = -1;
2578  std::for_each(std::begin(tst_vertices), std::end(tst_vertices), [&](unsigned int idx) {
2579  const auto& lc_haf = layerClusters[idx].hitsAndFractions();
2580  const auto& hitFound = std::find_if(std::begin(lc_haf),
2581  std::end(lc_haf),
2582  [&hitid](const std::pair<DetId, float>& v) { return v.first == hitid; });
2583  if (hitFound != lc_haf.end()) // not all hits may be clusterized
2584  lcId = idx;
2585  });
2586  return lcId;
2587  };
2588 
2589  for (unsigned int iSTS = 0; iSTS < nSimTracksters; ++iSTS) {
2590  const auto cpId = getCPId(simTSs[iSTS], iSTS, cPHandle_id, cpToSc_SimTrackstersMap, simTSs_fromCP);
2591  if (std::find(cPIndices.begin(), cPIndices.end(), cpId) == cPIndices.end())
2592  continue;
2593 
2594  // Loop through SimClusters
2595  for (const auto& simCluster : cP[cpId].simClusters()) {
2596  auto iSim = simTSs[iSTS].seedIndex();
2597  if (simTSs[iSTS].seedID() != cPHandle_id) { // SimTrackster from SimCluster
2598  if (iSim != (&(*simCluster) - &(sC[0])))
2599  continue;
2600  } else
2601  iSim = 0;
2602 
2603  for (const auto& it_haf : simCluster->hits_and_fractions()) {
2604  const auto hitid = (it_haf.first);
2605  const auto lcId = getLCId(simTSs[iSTS].vertices(), layerClusters, hitid);
2606  //V9:maps the layers in -z: 0->51 and in +z: 52->103
2607  //V10:maps the layers in -z: 0->49 and in +z: 50->99
2608  const auto itcheck = hitMap.find(hitid);
2609  //Check whether the current hit belonging to sim cluster has a reconstructed hit
2610  if ((valType == 0 && itcheck != hitMap.end()) || (valType > 0 && int(lcId) >= 0)) {
2611  float lcFraction = 0;
2612  if (valType > 0) {
2613  const auto iLC = std::find(simTSs[iSTS].vertices().begin(), simTSs[iSTS].vertices().end(), lcId);
2614  lcFraction =
2615  1.f / simTSs[iSTS].vertex_multiplicity(std::distance(std::begin(simTSs[iSTS].vertices()), iLC));
2616  }
2617  const auto elemId = (valType == 0) ? hitid : lcId;
2618  const auto elemFr = (valType == 0) ? it_haf.second : lcFraction;
2619  //Since the current hit from SimCluster has a reconstructed hit {with the same detid, belonging to the corresponding SimTrackster},
2620  //make a map that will connect a {detid,lcID} with:
2621  //1. the SimTracksters that have a SimCluster with {sim hits in, LCs containing} that cell via SimTrackster id.
2622  //2. the sum of all {SimHits, LCs} fractions that contributes to that detid.
2623  //So, keep in mind that in case of multiple CaloParticles contributing in the same cell
2624  //the fraction is the sum over all calo particles. So, something like:
2625  //detid: (caloparticle 1, sum of hits fractions in that detid over all cp) , (caloparticle 2, sum of hits fractions in that detid over all cp), (caloparticle 3, sum of hits fractions in that detid over all cp) ...
2626  if (detIdSimTSId_Map.find(elemId) == detIdSimTSId_Map.end()) {
2627  detIdSimTSId_Map[elemId] = std::vector<HGVHistoProducerAlgo::detIdInfoInCluster>();
2628  detIdSimTSId_Map[elemId].emplace_back(HGVHistoProducerAlgo::detIdInfoInCluster{iSTS, elemFr});
2629  } else {
2630  auto findSTSIt =
2631  std::find(detIdSimTSId_Map[elemId].begin(),
2632  detIdSimTSId_Map[elemId].end(),
2633  HGVHistoProducerAlgo::detIdInfoInCluster{
2634  iSTS, 0}); // only the first element is used for the matching (overloaded operator==)
2635  if (findSTSIt != detIdSimTSId_Map[elemId].end()) {
2636  if (valType == 0)
2637  findSTSIt->fraction += elemFr;
2638  } else {
2639  detIdSimTSId_Map[elemId].emplace_back(HGVHistoProducerAlgo::detIdInfoInCluster{iSTS, elemFr});
2640  }
2641  }
2642  const auto hitEn = (hits[itcheck->second]).energy();
2643  //Since the current hit from sim cluster has a reconstructed hit with the same detid,
2644  //fill the cPOnLayer[caloparticle][layer] object with energy (sum of all rechits energy times fraction
2645  //of the relevant simhit) and keep the hit (detid and fraction) that contributed.
2646  cPOnLayer[cpId].energy += it_haf.second * hitEn;
2647  sCOnLayer[cpId][iSim].energy += elemFr * hitEn;
2648  // Need to compress the hits and fractions in order to have a
2649  // reasonable score between CP and LC. Imagine, for example, that a
2650  // CP has detID X used by 2 SimClusters with different fractions. If
2651  // a single LC uses X with fraction 1 and is compared to the 2
2652  // contributions separately, it will be assigned a score != 0, which
2653  // is wrong.
2654  auto& haf = cPOnLayer[cpId].hits_and_fractions;
2655  auto found = std::find_if(
2656  std::begin(haf), std::end(haf), [&hitid](const std::pair<DetId, float>& v) { return v.first == hitid; });
2657  if (found != haf.end())
2658  found->second += it_haf.second;
2659  else
2660  haf.emplace_back(hitid, it_haf.second);
2661  // Same for sCOnLayer
2662  auto& haf_sc = sCOnLayer[cpId][iSim].hits_and_fractions;
2663  auto found_sc = std::find_if(std::begin(haf_sc),
2664  std::end(haf_sc),
2665  [&hitid](const std::pair<DetId, float>& v) { return v.first == hitid; });
2666  if (found_sc != haf_sc.end())
2667  found_sc->second += it_haf.second;
2668  else
2669  haf_sc.emplace_back(hitid, it_haf.second);
2670  }
2671  } // end of loop through SimHits
2672  } // end of loop through SimClusters
2673  } // end of loop through SimTracksters
2674 
2675  auto apply_LCMultiplicity = [](const ticl::Trackster& trackster, const reco::CaloClusterCollection& layerClusters) {
2676  std::vector<std::pair<DetId, float>> hits_and_fractions_norm;
2677  int lcInTst = 0;
2678  std::for_each(std::begin(trackster.vertices()), std::end(trackster.vertices()), [&](unsigned int idx) {
2679  const auto fraction = 1.f / trackster.vertex_multiplicity(lcInTst++);
2680  for (const auto& cell : layerClusters[idx].hitsAndFractions()) {
2681  hits_and_fractions_norm.emplace_back(
2682  cell.first, cell.second * fraction); // cell.second is the hit fraction in the layerCluster
2683  }
2684  });
2685  return hits_and_fractions_norm;
2686  };
2687 
2688  auto ScoreCutSTStoTSPurDup = ScoreCutSTStoTSPurDup_[0];
2689  auto ScoreCutTStoSTSFakeMerge = ScoreCutTStoSTSFakeMerge_[0];
2690  // Loop through Tracksters
2691  for (unsigned int tstId = 0; tstId < nTracksters; ++tstId) {
2692  const auto& tst = tracksters[tstId];
2693  if (tstId == 0)
2694  if ((valType > 0) && (tst.ticlIteration() == ticl::Trackster::SIM)) {
2695  ScoreCutSTStoTSPurDup = ScoreCutSTStoTSPurDup_[valType];
2696  ScoreCutTStoSTSFakeMerge = ScoreCutTStoSTSFakeMerge_[valType];
2697  }
2698 
2699  if (tst.vertices().empty())
2700  continue;
2701 
2702  std::unordered_map<unsigned, float> CPEnergyInTS;
2703  int maxCPId_byNumberOfHits = -1;
2704  unsigned int maxCPNumberOfHitsInTS = 0;
2705  int maxCPId_byEnergy = -1;
2706  float maxEnergySharedTSandCP = 0.f;
2707  float energyFractionOfTSinCP = 0.f;
2708  float energyFractionOfCPinTS = 0.f;
2709 
2710  //In case of matched rechit-simhit, so matched
2711  //CaloParticle-LayerCluster-Trackster, he counts and saves the number of
2712  //rechits related to the maximum energy CaloParticle out of all
2713  //CaloParticles related to that layer cluster and Trackster.
2714 
2715  std::unordered_map<unsigned, unsigned> occurrencesCPinTS;
2716  unsigned int numberOfNoiseHitsInTS = 0;
2717 
2718  const auto tst_hitsAndFractions = apply_LCMultiplicity(tst, layerClusters);
2719  const auto numberOfHitsInTS = tst_hitsAndFractions.size();
2720 
2721  //hitsToCaloParticleId is a vector of ints, one for each rechit of the
2722  //layer cluster under study. If negative, there is no simhit from any CaloParticle related.
2723  //If positive, at least one CaloParticle has been found with matched simhit.
2724  //In more detail:
2725  // 1. hitsToCaloParticleId[iHit] = -3
2726  // TN: These represent Halo Cells(N) that have not been
2727  // assigned to any CaloParticle (hence the T).
2728  // 2. hitsToCaloParticleId[iHit] = -2
2729  // FN: There represent Halo Cells(N) that have been assigned
2730  // to a CaloParticle (hence the F, since those should have not been marked as halo)
2731  // 3. hitsToCaloParticleId[iHit] = -1
2732  // FP: These represent Real Cells(P) that have not been
2733  // assigned to any CaloParticle (hence the F, since these are fakes)
2734  // 4. hitsToCaloParticleId[iHit] >= 0
2735  // TP There represent Real Cells(P) that have been assigned
2736  // to a CaloParticle (hence the T)
2737  std::vector<int> hitsToCaloParticleId(numberOfHitsInTS);
2738 
2739  //Loop through the hits of the trackster under study
2740  for (unsigned int iHit = 0; iHit < numberOfHitsInTS; iHit++) {
2741  const auto rh_detid = tst_hitsAndFractions[iHit].first;
2742  const auto rhFraction = tst_hitsAndFractions[iHit].second;
2743 
2744  const auto lcId_r = getLCId(tst.vertices(), layerClusters, rh_detid);
2745  const auto iLC_r = std::find(tst.vertices().begin(), tst.vertices().end(), lcId_r);
2746  const auto lcFraction_r = 1.f / tst.vertex_multiplicity(std::distance(std::begin(tst.vertices()), iLC_r));
2747 
2748  //Make a map that will connect a detid (that belongs to a rechit of the layer cluster under study,
2749  //no need to save others) with:
2750  //1. the layer clusters that have rechits in that detid
2751  //2. the fraction of the rechit of each layer cluster that contributes to that detid.
2752  //So, something like:
2753  //detid: (layer cluster 1, hit fraction) , (layer cluster 2, hit fraction), (layer cluster 3, hit fraction) ...
2754  //here comparing with the calo particle map above the
2755  if (detIdToTracksterId_Map.find(rh_detid) == detIdToTracksterId_Map.end()) {
2756  detIdToTracksterId_Map[rh_detid] = std::vector<HGVHistoProducerAlgo::detIdInfoInTrackster>();
2757  detIdToTracksterId_Map[rh_detid].emplace_back(
2758  HGVHistoProducerAlgo::detIdInfoInTrackster{tstId, lcId_r, rhFraction});
2759  } else {
2760  auto findTSIt =
2761  std::find(detIdToTracksterId_Map[rh_detid].begin(),
2762  detIdToTracksterId_Map[rh_detid].end(),
2763  HGVHistoProducerAlgo::detIdInfoInTrackster{
2764  tstId, 0, 0}); // only the first element is used for the matching (overloaded operator==)
2765  if (findTSIt != detIdToTracksterId_Map[rh_detid].end()) {
2766  if (valType == 0)
2767  findTSIt->fraction += rhFraction;
2768  } else {
2769  detIdToTracksterId_Map[rh_detid].emplace_back(
2770  HGVHistoProducerAlgo::detIdInfoInTrackster{tstId, lcId_r, rhFraction});
2771  }
2772  }
2773 
2774  // if the fraction is zero or the hit does not belong to any calo
2775  // particle, set the caloparticleId for the hit to -1 this will
2776  // contribute to the number of noise hits
2777  // MR Remove the case in which the fraction is 0, since this could be a
2778  // real hit that has been marked as halo.
2779  if (rhFraction == 0.) {
2780  hitsToCaloParticleId[iHit] = -2;
2781  }
2782 
2783  // Check whether the RecHit of the trackster under study has a SimHit in the same cell
2784  const auto elemId = (valType == 0) ? rh_detid.rawId() : lcId_r;
2785  const auto recoFr = (valType == 0) ? rhFraction : lcFraction_r;
2786  const auto& hit_find_in_STS = detIdSimTSId_Map.find(elemId);
2787  if (hit_find_in_STS == detIdSimTSId_Map.end()) {
2788  hitsToCaloParticleId[iHit] -= 1;
2789  } else {
2790  // Since the hit is belonging to the layer cluster, it must be also in the rechits map
2791  const auto hitEn = (hits[hitMap.find(rh_detid)->second]).energy();
2792  //const auto layerId =
2793  //recHitTools_->getLayerWithOffset(rh_detid) + layers * ((recHitTools_->zside(rh_detid) + 1) >> 1) - 1;
2794  //0;
2795 
2796  auto maxCPEnergyInTS = 0.f;
2797  auto maxCPId = -1;
2798  for (const auto& h : hit_find_in_STS->second) {
2799  const auto shared_fraction = std::min(recoFr, h.fraction);
2800  const auto iSTS = h.clusterId;
2801  const auto& simTS = simTSs[iSTS];
2802  auto iSim = simTS.seedIndex();
2803  if (simTSs[iSTS].seedID() == cPHandle_id) // SimTrackster from CaloParticle
2804  iSim = 0;
2805 
2806  // SimTrackster with simHits connected via detid with the rechit under study
2807  //So, from all layers clusters, find the rechits that are connected with a calo particle and save/calculate the
2808  //energy of that calo particle as the sum over all rechits of the rechits energy weighted
2809  //by the caloparticle's fraction related to that rechit.
2810  const auto cpId = getCPId(simTS, iSTS, cPHandle_id, cpToSc_SimTrackstersMap, simTSs_fromCP);
2811  if (std::find(cPIndices.begin(), cPIndices.end(), cpId) == cPIndices.end())
2812  continue;
2813 
2814  CPEnergyInTS[cpId] += shared_fraction * hitEn;
2815  //Here cPOnLayer[caloparticle][layer] describe above is set.
2816  //Here for Tracksters with matched rechit the CP fraction times hit energy is added and saved .
2817  cPOnLayer[cpId].layerClusterIdToEnergyAndScore[tstId].first += shared_fraction * hitEn;
2818  sCOnLayer[cpId][iSim].layerClusterIdToEnergyAndScore[tstId].first += shared_fraction * hitEn;
2819  cPOnLayer[cpId].layerClusterIdToEnergyAndScore[tstId].second = FLT_MAX;
2820  sCOnLayer[cpId][iSim].layerClusterIdToEnergyAndScore[tstId].second = FLT_MAX;
2821  //stsInTrackster[trackster][STSids]
2822  //Connects a Trackster with all related SimTracksters.
2823  stsInTrackster[tstId].emplace_back(iSTS, FLT_MAX);
2824  //From all CaloParticles related to a layer cluster, it saves id and energy of the calo particle
2825  //that after simhit-rechit matching in layer has the maximum energy.
2826  if (shared_fraction > maxCPEnergyInTS) {
2827  //energy is used only here. cpid is saved for Tracksters
2828  maxCPEnergyInTS = CPEnergyInTS[cpId];
2829  maxCPId = cpId;
2830  }
2831  }
2832  //Keep in mind here maxCPId could be zero. So, below ask for negative not including zero to count noise.
2833  hitsToCaloParticleId[iHit] = maxCPId;
2834  }
2835 
2836  } //end of loop through rechits of the layer cluster.
2837 
2838  //Loop through all rechits to count how many of them are noise and how many are matched.
2839  //In case of matched rechit-simhit, he counts and saves the number of rechits related to the maximum energy CaloParticle.
2840  for (auto c : hitsToCaloParticleId) {
2841  if (c < 0)
2842  numberOfNoiseHitsInTS++;
2843  else
2844  occurrencesCPinTS[c]++;
2845  }
2846 
2847  //Below from all maximum energy CaloParticles, he saves the one with the largest amount
2848  //of related rechits.
2849  for (auto& c : occurrencesCPinTS) {
2850  if (c.second > maxCPNumberOfHitsInTS) {
2851  maxCPId_byNumberOfHits = c.first;
2852  maxCPNumberOfHitsInTS = c.second;
2853  }
2854  }
2855 
2856  //Find the CaloParticle that has the maximum energy shared with the Trackster under study.
2857  for (auto& c : CPEnergyInTS) {
2858  if (c.second > maxEnergySharedTSandCP) {
2859  maxCPId_byEnergy = c.first;
2860  maxEnergySharedTSandCP = c.second;
2861  }
2862  }
2863  //The energy of the CaloParticle that found to have the maximum energy shared with the Trackster under study.
2864  float totalCPEnergyFromLayerCP = 0.f;
2865  if (maxCPId_byEnergy >= 0) {
2866  totalCPEnergyFromLayerCP += cPOnLayer[maxCPId_byEnergy].energy;
2867  energyFractionOfCPinTS = maxEnergySharedTSandCP / totalCPEnergyFromLayerCP;
2868  if (tst.raw_energy() > 0.f) {
2869  energyFractionOfTSinCP = maxEnergySharedTSandCP / tst.raw_energy();
2870  }
2871  }
2872 
2873  LogDebug("HGCalValidator") << std::setw(12) << "Trackster\t" << std::setw(10) << "energy\t" << std::setw(5)
2874  << "nhits\t" << std::setw(12) << "noise hits\t" << std::setw(22)
2875  << "maxCPId_byNumberOfHits\t" << std::setw(8) << "nhitsCP\t" << std::setw(16)
2876  << "maxCPId_byEnergy\t" << std::setw(23) << "maxEnergySharedTSandCP\t" << std::setw(22)
2877  << "totalCPEnergyFromAllLayerCP\t" << std::setw(22) << "energyFractionOfTSinCP\t"
2878  << std::setw(25) << "energyFractionOfCPinTS\t" << std::endl;
2879  LogDebug("HGCalValidator") << std::setw(12) << tstId << "\t" //LogDebug("HGCalValidator")
2880  << std::setw(10) << tst.raw_energy() << "\t" << std::setw(5) << numberOfHitsInTS << "\t"
2881  << std::setw(12) << numberOfNoiseHitsInTS << "\t" << std::setw(22)
2882  << maxCPId_byNumberOfHits << "\t" << std::setw(8) << maxCPNumberOfHitsInTS << "\t"
2883  << std::setw(16) << maxCPId_byEnergy << "\t" << std::setw(23) << maxEnergySharedTSandCP
2884  << "\t" << std::setw(22) << totalCPEnergyFromLayerCP << "\t" << std::setw(22)
2885  << energyFractionOfTSinCP << "\t" << std::setw(25) << energyFractionOfCPinTS
2886  << std::endl;
2887 
2888  } // end of loop through Tracksters
2889 
2890  // Loop through Tracksters
2891  for (unsigned int tstId = 0; tstId < nTracksters; ++tstId) {
2892  const auto& tst = tracksters[tstId];
2893  if (tst.vertices().empty())
2894  continue;
2895 
2896  // find the unique SimTrackster ids contributing to the Trackster
2897  //stsInTrackster[trackster][STSids]
2898  std::sort(stsInTrackster[tstId].begin(), stsInTrackster[tstId].end());
2899  const auto last = std::unique(stsInTrackster[tstId].begin(), stsInTrackster[tstId].end());
2900  stsInTrackster[tstId].erase(last, stsInTrackster[tstId].end());
2901 
2902  if (tst.raw_energy() == 0. && !stsInTrackster[tstId].empty()) {
2903  //Loop through all SimTracksters contributing to Trackster tstId
2904  for (auto& stsPair : stsInTrackster[tstId]) {
2905  // In case of a Trackster with zero energy but related SimTracksters the score is set to 1
2906  stsPair.second = 1.;
2907  LogDebug("HGCalValidator") << "Trackster Id:\t" << tstId << "\tSimTrackster id:\t" << stsPair.first
2908  << "\tscore\t" << stsPair.second << std::endl;
2909  histograms.h_score_trackster2caloparticle[valType][count]->Fill(stsPair.second);
2910  }
2911  continue;
2912  }
2913 
2914  const auto tst_hitsAndFractions = apply_LCMultiplicity(tst, layerClusters);
2915 
2916  // Compute the correct normalization
2917  float tracksterEnergy = 0.f, invTracksterEnergyWeight = 0.f;
2918  for (const auto& haf : tst_hitsAndFractions) {
2919  const HGCRecHit* hit = &(hits[hitMap.at(haf.first)]);
2920  float hitFr = 0.f;
2921  if (valType == 0) {
2922  hitFr = haf.second;
2923  } else {
2924  const auto lcId = getLCId(tst.vertices(), layerClusters, haf.first);
2925  const auto iLC = std::find(tst.vertices().begin(), tst.vertices().end(), lcId);
2926  hitFr = 1.f / tst.vertex_multiplicity(std::distance(std::begin(tst.vertices()), iLC));
2927  }
2928  tracksterEnergy += hitFr * hit->energy();
2929  invTracksterEnergyWeight += pow(hitFr * hit->energy(), 2);
2930  }
2931  if (invTracksterEnergyWeight)
2932  invTracksterEnergyWeight = 1.f / invTracksterEnergyWeight;
2933 
2934  for (const auto& haf : tst_hitsAndFractions) {
2935  const auto rh_detid = haf.first;
2936  unsigned int elemId = 0;
2937  float rhFraction = 0.f;
2938  if (valType == 0) {
2939  elemId = rh_detid.rawId();
2940  rhFraction = haf.second;
2941  } else {
2942  const auto lcId = getLCId(tst.vertices(), layerClusters, rh_detid);
2943  elemId = lcId;
2944  const auto iLC = std::find(tst.vertices().begin(), tst.vertices().end(), lcId);
2945  rhFraction = 1.f / tst.vertex_multiplicity(std::distance(std::begin(tst.vertices()), iLC));
2946  }
2947 
2948  bool hitWithNoSTS = false;
2949  if (detIdSimTSId_Map.find(elemId) == detIdSimTSId_Map.end())
2950  hitWithNoSTS = true;
2951  const HGCRecHit* hit = &(hits[hitMap.find(rh_detid)->second]);
2952  const auto hitEnergyWeight = pow(hit->energy(), 2);
2953 
2954  for (auto& stsPair : stsInTrackster[tstId]) {
2955  float cpFraction = 0.f;
2956  if (!hitWithNoSTS) {
2957  const auto& findSTSIt = std::find(
2958  detIdSimTSId_Map[elemId].begin(),
2959  detIdSimTSId_Map[elemId].end(),
2960  HGVHistoProducerAlgo::detIdInfoInCluster{
2961  stsPair.first, 0.f}); // only the first element is used for the matching (overloaded operator==)
2962  if (findSTSIt != detIdSimTSId_Map[elemId].end())
2963  cpFraction = findSTSIt->fraction;
2964  }
2965  if (stsPair.second == FLT_MAX) {
2966  stsPair.second = 0.f;
2967  }
2968  stsPair.second +=
2969  min(pow(rhFraction - cpFraction, 2), pow(rhFraction, 2)) * hitEnergyWeight * invTracksterEnergyWeight;
2970  }
2971  } // end of loop through trackster rechits
2972 
2973  //In case of a Trackster with some energy but none related CaloParticles print some info.
2974  if (stsInTrackster[tstId].empty())
2975  LogDebug("HGCalValidator") << "Trackster Id: " << tstId << "\tSimTrackster id: -1"
2976  << "\tscore: -1\n";
2977 
2978  tracksters_FakeMerge[tstId] =
2979  std::count_if(std::begin(stsInTrackster[tstId]),
2980  std::end(stsInTrackster[tstId]),
2981  [ScoreCutTStoSTSFakeMerge](const auto& obj) { return obj.second < ScoreCutTStoSTSFakeMerge; });
2982 
2983  const auto score = std::min_element(std::begin(stsInTrackster[tstId]),
2984  std::end(stsInTrackster[tstId]),
2985  [](const auto& obj1, const auto& obj2) { return obj1.second < obj2.second; });
2986  float score2 = -1;
2987  float sharedEneFrac2 = 0;
2988  for (const auto& stsPair : stsInTrackster[tstId]) {
2989  const auto iSTS = stsPair.first;
2990  const auto iScore = stsPair.second;
2991  const auto cpId = getCPId(simTSs[iSTS], iSTS, cPHandle_id, cpToSc_SimTrackstersMap, simTSs_fromCP);
2992  auto iSim = simTSs[iSTS].seedIndex();
2993  if (simTSs[iSTS].seedID() == cPHandle_id) // SimTrackster from CaloParticle
2994  iSim = 0;
2995  const auto& simOnLayer = (valType == 0) ? cPOnLayer[cpId] : sCOnLayer[cpId][iSim];
2996 
2997  float sharedeneCPallLayers = 0.;
2998  sharedeneCPallLayers += simOnLayer.layerClusterIdToEnergyAndScore.count(tstId)
2999  ? simOnLayer.layerClusterIdToEnergyAndScore.at(tstId).first
3000  : 0;
3001  if (tracksterEnergy == 0)
3002  continue;
3003  const auto sharedEneFrac = sharedeneCPallLayers / tracksterEnergy;
3004  LogDebug("HGCalValidator") << "\nTrackster id: " << tstId << " (" << tst.vertices().size() << " vertices)"
3005  << "\tSimTrackster Id: " << iSTS << " (" << simTSs[iSTS].vertices().size()
3006  << " vertices)"
3007  << " (CP id: " << cpId << ")\tscore: " << iScore
3008  << "\tsharedeneCPallLayers: " << sharedeneCPallLayers << std::endl;
3009 
3010  histograms.h_score_trackster2caloparticle[valType][count]->Fill(iScore);
3011  histograms.h_sharedenergy_trackster2caloparticle[valType][count]->Fill(sharedEneFrac);
3012  histograms.h_energy_vs_score_trackster2caloparticle[valType][count]->Fill(iScore, sharedEneFrac);
3013  if (iSTS == score->first) {
3014  histograms.h_score_trackster2bestCaloparticle[valType][count]->Fill(iScore);
3015  histograms.h_sharedenergy_trackster2bestCaloparticle[valType][count]->Fill(sharedEneFrac);
3016  histograms.h_sharedenergy_trackster2bestCaloparticle_vs_eta[valType][count]->Fill(tst.barycenter().eta(),
3017  sharedEneFrac);
3018  histograms.h_sharedenergy_trackster2bestCaloparticle_vs_phi[valType][count]->Fill(tst.barycenter().phi(),
3019  sharedEneFrac);
3020  histograms.h_energy_vs_score_trackster2bestCaloparticle[valType][count]->Fill(iScore, sharedEneFrac);
3021  } else if (score2 < 0 || iScore < score2) {
3022  score2 = iScore;
3023  sharedEneFrac2 = sharedEneFrac;
3024  }
3025  } // end of loop through SimTracksters associated to Trackster
3026  if (score2 > -1) {
3027  histograms.h_score_trackster2bestCaloparticle2[valType][count]->Fill(score2);
3028  histograms.h_sharedenergy_trackster2bestCaloparticle2[valType][count]->Fill(sharedEneFrac2);
3029  histograms.h_energy_vs_score_trackster2bestCaloparticle2[valType][count]->Fill(score2, sharedEneFrac2);
3030  }
3031  } // end of loop through Tracksters
3032 
3033  std::unordered_map<unsigned int, std::vector<float>> score3d;
3034  std::unordered_map<unsigned int, std::vector<float>> tstSharedEnergy;
3035 
3036  for (unsigned int iSTS = 0; iSTS < nSimTracksters; ++iSTS) {
3037  score3d[iSTS].resize(nTracksters);
3038  tstSharedEnergy[iSTS].resize(nTracksters);
3039  for (unsigned int j = 0; j < nTracksters; ++j) {
3040  score3d[iSTS][j] = FLT_MAX;
3041  tstSharedEnergy[iSTS][j] = 0.f;
3042  }
3043  }
3044 
3045  // Fill the plots to compute the different metrics linked to
3046  // gen-level, namely efficiency, purity and duplicate. In this loop should restrict
3047  // only to the selected caloParaticles.
3048  for (unsigned int iSTS = 0; iSTS < nSimTracksters; ++iSTS) {
3049  const auto& sts = simTSs[iSTS];
3050  const auto& cpId = getCPId(sts, iSTS, cPHandle_id, cpToSc_SimTrackstersMap, simTSs_fromCP);
3051  if (valType == 0 && std::find(cPSelectedIndices.begin(), cPSelectedIndices.end(), cpId) == cPSelectedIndices.end())
3052  continue;
3053 
3054  const auto& hafLC = apply_LCMultiplicity(sts, layerClusters);
3055  float SimEnergy_LC = 0.f;
3056  for (const auto& haf : hafLC) {
3057  const auto lcId = getLCId(sts.vertices(), layerClusters, haf.first);
3058  const auto iLC = std::find(sts.vertices().begin(), sts.vertices().end(), lcId);
3059  const HGCRecHit* hit = &(hits[hitMap.at(haf.first)]);
3060  SimEnergy_LC += hit->energy() / sts.vertex_multiplicity(std::distance(std::begin(sts.vertices()), iLC));
3061  }
3062 
3063  auto iSim = sts.seedIndex();
3064  if (sts.seedID() == cPHandle_id) // SimTrackster from CaloParticle
3065  iSim = 0;
3066  auto& simOnLayer = (valType == 0) ? cPOnLayer[cpId] : sCOnLayer[cpId][iSim];
3067 
3068  // Keep the Trackster ids that are related to
3069  // SimTrackster under study for the final filling of the score
3070  std::set<unsigned int> stsId_tstId_related;
3071  auto& score3d_iSTS = score3d[iSTS];
3072 
3073  float SimEnergy = 0.f;
3074  float SimEnergyWeight = 0.f, hitsEnergyWeight = 0.f;
3075  //for (unsigned int layerId = 0; layerId < 1/*layers * 2*/; ++layerId) {
3076  const auto SimNumberOfHits = simOnLayer.hits_and_fractions.size();
3077  if (SimNumberOfHits == 0)
3078  continue;
3079  SimEnergy += simOnLayer.energy;
3080  int tstWithMaxEnergyInCP = -1;
3081  //This is the maximum energy related to Trackster per layer.
3082  float maxEnergyTSperlayerinSim = 0.f;
3083  float SimEnergyFractionInTSperlayer = 0.f;
3084  //Remember and not confused by name. layerClusterIdToEnergyAndScore contains the Trackster id.
3085  for (const auto& tst : simOnLayer.layerClusterIdToEnergyAndScore) {
3086  if (tst.second.first > maxEnergyTSperlayerinSim) {
3087  maxEnergyTSperlayerinSim = tst.second.first;
3088  tstWithMaxEnergyInCP = tst.first;
3089  }
3090  }
3091  if (SimEnergy > 0.f)
3092  SimEnergyFractionInTSperlayer = maxEnergyTSperlayerinSim / SimEnergy;
3093 
3094  LogDebug("HGCalValidator") << std::setw(12) << "caloparticle\t" << std::setw(15) << "cp total energy\t"
3095  << std::setw(15) << "cpEnergyOnLayer\t" << std::setw(14) << "CPNhitsOnLayer\t"
3096  << std::setw(18) << "tstWithMaxEnergyInCP\t" << std::setw(15) << "maxEnergyTSinCP\t"
3097  << std::setw(20) << "CPEnergyFractionInTS"
3098  << "\n";
3099  LogDebug("HGCalValidator") << std::setw(12) << cpId << "\t" << std::setw(15) << sts.raw_energy() << "\t"
3100  << std::setw(15) << SimEnergy << "\t" << std::setw(14) << SimNumberOfHits << "\t"
3101  << std::setw(18) << tstWithMaxEnergyInCP << "\t" << std::setw(15)
3102  << maxEnergyTSperlayerinSim << "\t" << std::setw(20) << SimEnergyFractionInTSperlayer
3103  << "\n";
3104 
3105  for (const auto& haf : ((valType == 0) ? simOnLayer.hits_and_fractions : hafLC)) {
3106  const auto& hitDetId = haf.first;
3107  // Compute the correct normalization
3108  // Need to loop on the simOnLayer data structure since this is the
3109  // only one that has the compressed information for multiple usage
3110  // of the same DetId by different SimClusters by a single CaloParticle.
3111  const HGCRecHit* hit = &(hits[hitMap.at(hitDetId)]);
3112  SimEnergyWeight += pow(haf.second * hit->energy(), 2);
3113 
3114  const auto lcId = getLCId(sts.vertices(), layerClusters, hitDetId);
3115  float cpFraction = 0.f;
3116  if (valType == 0) {
3117  cpFraction = haf.second;
3118  } else {
3119  const auto iLC = std::find(sts.vertices().begin(), sts.vertices().end(), lcId);
3120  cpFraction = 1.f / sts.vertex_multiplicity(std::distance(std::begin(sts.vertices()), iLC));
3121  }
3122  if (cpFraction == 0.f)
3123  continue; // hopefully this should never happen
3124 
3125  bool hitWithNoTS = false;
3126  if (detIdToTracksterId_Map.find(hitDetId) == detIdToTracksterId_Map.end())
3127  hitWithNoTS = true;
3128  const auto hitEnergyWeight = pow(hit->energy(), 2);
3129  hitsEnergyWeight += pow(cpFraction, 2) * hitEnergyWeight;
3130 
3131  for (auto& tsPair : simOnLayer.layerClusterIdToEnergyAndScore) {
3132  const auto tstId = tsPair.first;
3133  stsId_tstId_related.insert(tstId);
3134 
3135  float tstFraction = 0.f;
3136  if (!hitWithNoTS) {
3137  const auto findTSIt =
3138  std::find(detIdToTracksterId_Map[hitDetId].begin(),
3139  detIdToTracksterId_Map[hitDetId].end(),
3140  HGVHistoProducerAlgo::detIdInfoInTrackster{
3141  tstId, 0, 0.f}); // only the first element is used for the matching (overloaded operator==)
3142  if (findTSIt != detIdToTracksterId_Map[hitDetId].end()) {
3143  if (valType == 0) {
3144  tstFraction = findTSIt->fraction;
3145  } else {
3146  const auto iLC = std::find(
3147  tracksters[tstId].vertices().begin(), tracksters[tstId].vertices().end(), findTSIt->clusterId);
3148  if (iLC != tracksters[tstId].vertices().end()) {
3149  tstFraction = 1.f / tracksters[tstId].vertex_multiplicity(
3150  std::distance(std::begin(tracksters[tstId].vertices()), iLC));
3151  }
3152  }
3153  }
3154  }
3155  // Here do not divide as before by the trackster energy weight. Should sum first
3156  // over all layers and divide with the total CP energy over all layers.
3157  if (tsPair.second.second == FLT_MAX) {
3158  tsPair.second.second = 0.f;
3159  }
3160  tsPair.second.second += min(pow(tstFraction - cpFraction, 2), pow(cpFraction, 2)) * hitEnergyWeight;
3161 
3162  LogDebug("HGCalValidator") << "\nTracksterId:\t" << tstId << "\tSimTracksterId:\t" << iSTS << "\tcpId:\t"
3163  << cpId << "\ttstfraction, cpfraction:\t" << tstFraction << ", " << cpFraction
3164  << "\thitEnergyWeight:\t" << hitEnergyWeight << "\tadded delta:\t"
3165  << pow((tstFraction - cpFraction), 2) * hitEnergyWeight
3166  << "\tcurrent Sim-score numerator:\t" << tsPair.second.second
3167  << "\tshared Sim energy:\t" << tsPair.second.first << '\n';
3168  }
3169  } // end of loop through SimCluster SimHits on current layer
3170 
3171  if (simOnLayer.layerClusterIdToEnergyAndScore.empty())
3172  LogDebug("HGCalValidator") << "CP Id:\t" << cpId << "\tTS id:\t-1"
3173  << " Sub score in \t -1\n";
3174 
3175  for (const auto& tsPair : simOnLayer.layerClusterIdToEnergyAndScore) {
3176  const auto tstId = tsPair.first;
3177  // 3D score here without the denominator at this point
3178  if (score3d_iSTS[tstId] == FLT_MAX) {
3179  score3d_iSTS[tstId] = 0.f;
3180  }
3181  score3d_iSTS[tstId] += tsPair.second.second;
3182  tstSharedEnergy[iSTS][tstId] += tsPair.second.first;
3183  }
3184  //} // end of loop through layers
3185 
3186  const auto scoreDenom = (valType == 0) ? SimEnergyWeight : hitsEnergyWeight;
3187  const auto energyDenom = (valType == 0) ? SimEnergy : SimEnergy_LC;
3188 
3189  const auto sts_eta = sts.barycenter().eta();
3190  const auto sts_phi = sts.barycenter().phi();
3191  const auto sts_en = sts.raw_energy();
3192  const auto sts_pt = sts.raw_pt();
3193  histograms.h_denom_caloparticle_eta[valType][count]->Fill(sts_eta);
3194  histograms.h_denom_caloparticle_phi[valType][count]->Fill(sts_phi);
3195  histograms.h_denom_caloparticle_en[valType][count]->Fill(sts_en);
3196  histograms.h_denom_caloparticle_pt[valType][count]->Fill(sts_pt);
3197 
3198  //Loop through related Tracksters here
3199  // In case the threshold to associate a CaloParticle to a Trackster is
3200  // below 50%, there could be cases in which the CP is linked to more than
3201  // one tracksters, leading to efficiencies >1. This boolean is used to
3202  // avoid "over counting".
3203  bool sts_considered_efficient = false;
3204  bool sts_considered_pure = false;
3205  for (const auto tstId : stsId_tstId_related) {
3206  // Now time for the denominator
3207  score3d_iSTS[tstId] /= scoreDenom;
3208  const auto tstSharedEnergyFrac = tstSharedEnergy[iSTS][tstId] / energyDenom;
3209  LogDebug("HGCalValidator") << "STS id: " << iSTS << "\t(CP id: " << cpId << ")\tTS id: " << tstId
3210  << "\nSimEnergy: " << energyDenom << "\tSimEnergyWeight: " << SimEnergyWeight
3211  << "\tTrackste energy: " << tracksters[tstId].raw_energy()
3212  << "\nscore: " << score3d_iSTS[tstId]
3213  << "\tshared energy: " << tstSharedEnergy[iSTS][tstId]
3214  << "\tshared energy fraction: " << tstSharedEnergyFrac << "\n";
3215 
3216  histograms.h_score_caloparticle2trackster[valType][count]->Fill(score3d_iSTS[tstId]);
3217  histograms.h_sharedenergy_caloparticle2trackster[valType][count]->Fill(tstSharedEnergyFrac);
3218  histograms.h_energy_vs_score_caloparticle2trackster[valType][count]->Fill(score3d_iSTS[tstId],
3219  tstSharedEnergyFrac);
3220  // Fill the numerator for the efficiency calculation. The efficiency is computed by considering the energy shared between a Trackster and a _corresponding_ caloParticle. The threshold is configurable via python.
3221  if (!sts_considered_efficient && (tstSharedEnergyFrac >= minTSTSharedEneFracEfficiency_)) {
3222  sts_considered_efficient = true;
3223  histograms.h_numEff_caloparticle_eta[valType][count]->Fill(sts_eta);
3224  histograms.h_numEff_caloparticle_phi[valType][count]->Fill(sts_phi);
3225  histograms.h_numEff_caloparticle_en[valType][count]->Fill(sts_en);
3226  histograms.h_numEff_caloparticle_pt[valType][count]->Fill(sts_pt);
3227  }
3228 
3229  if (score3d_iSTS[tstId] < ScoreCutSTStoTSPurDup) {
3230  if (tracksters_PurityDuplicate[iSTS] < 1)
3231  tracksters_PurityDuplicate[iSTS]++; // for Purity
3232  if (sts_considered_pure)
3233  tracksters_PurityDuplicate[iSTS]++; // for Duplicate
3234  sts_considered_pure = true;
3235  }
3236  } // end of loop through Tracksters related to SimTrackster
3237 
3238  const auto best = std::min_element(std::begin(score3d_iSTS), std::end(score3d_iSTS));
3239  if (best != score3d_iSTS.end()) {
3240  const auto bestTstId = std::distance(std::begin(score3d_iSTS), best);
3241  const auto bestTstSharedEnergyFrac = tstSharedEnergy[iSTS][bestTstId] / energyDenom;
3242  histograms.h_scorePur_caloparticle2trackster[valType][count]->Fill(*best);
3243  histograms.h_sharedenergy_caloparticle2trackster_assoc[valType][count]->Fill(bestTstSharedEnergyFrac);
3244  histograms.h_sharedenergy_caloparticle2trackster_assoc_vs_eta[valType][count]->Fill(sts_eta,
3245  bestTstSharedEnergyFrac);
3246  histograms.h_sharedenergy_caloparticle2trackster_assoc_vs_phi[valType][count]->Fill(sts_phi,
3247  bestTstSharedEnergyFrac);
3248  histograms.h_energy_vs_score_caloparticle2bestTrackster[valType][count]->Fill(*best, bestTstSharedEnergyFrac);
3249  LogDebug("HGCalValidator") << count << " " << sts_eta << " " << sts_phi << " "
3250  << tracksters[bestTstId].raw_energy() << " " << sts.raw_energy() << " "
3251  << bestTstSharedEnergyFrac << "\n";
3252 
3253  if (score3d_iSTS.size() > 1) {
3254  auto best2 = (best == score3d_iSTS.begin()) ? std::next(best, 1) : score3d_iSTS.begin();
3255  for (auto tstId = score3d_iSTS.begin(); tstId != score3d_iSTS.end() && tstId != best; tstId++)
3256  if (*tstId < *best2)
3257  best2 = tstId;
3258  const auto best2TstId = std::distance(std::begin(score3d_iSTS), best2);
3259  const auto best2TstSharedEnergyFrac = tstSharedEnergy[iSTS][best2TstId] / energyDenom;
3260  histograms.h_scoreDupl_caloparticle2trackster[valType][count]->Fill(*best2);
3261  histograms.h_sharedenergy_caloparticle2trackster_assoc2[valType][count]->Fill(best2TstSharedEnergyFrac);
3262  histograms.h_energy_vs_score_caloparticle2bestTrackster2[valType][count]->Fill(*best2,
3263  best2TstSharedEnergyFrac);
3264  }
3265  }
3266  } // end of loop through SimTracksters
3267 
3268  // Fill the plots to compute the different metrics linked to
3269  // sim-level, namely purity and duplicate-rate
3270  for (unsigned int stsId = 0; stsId < nSimTracksters; ++stsId) {
3271  const auto& sts = simTSs[stsId];
3272  if (sts.vertices().empty())
3273  continue;
3274  const auto sts_eta = sts.barycenter().eta();
3275  const auto sts_phi = sts.barycenter().phi();
3276  const auto sts_en = sts.raw_energy();
3277  const auto sts_pt = sts.raw_pt();
3278 
3279  if (tracksters_PurityDuplicate[stsId] > 0) {
3280  histograms.h_num_caloparticle_eta[valType][count]->Fill(sts_eta);
3281  histograms.h_num_caloparticle_phi[valType][count]->Fill(sts_phi);
3282  histograms.h_num_caloparticle_en[valType][count]->Fill(sts_en);
3283  histograms.h_num_caloparticle_pt[valType][count]->Fill(sts_pt);
3284 
3285  if (tracksters_PurityDuplicate[stsId] > 1) {
3286  histograms.h_numDup_trackster_eta[valType][count]->Fill(sts_eta);
3287  histograms.h_numDup_trackster_phi[valType][count]->Fill(sts_phi);
3288  histograms.h_numDup_trackster_en[valType][count]->Fill(sts_en);
3289  histograms.h_numDup_trackster_pt[valType][count]->Fill(sts_pt);
3290  }
3291  }
3292  }
3293 
3294  // Fill the plots to compute the different metrics linked to
3295  // reco-level, namely fake-rate an merge-rate. Should *not*
3296  // restrict only to the selected caloParaticles.
3297  for (unsigned int tstId = 0; tstId < nTracksters; ++tstId) {
3298  const auto& tst = tracksters[tstId];
3299  if (tst.vertices().empty())
3300  continue;
3301  const auto iTS_eta = tst.barycenter().eta();
3302  const auto iTS_phi = tst.barycenter().phi();
3303  const auto iTS_en = tst.raw_energy();
3304  const auto iTS_pt = tst.raw_pt();
3305  histograms.h_denom_trackster_eta[valType][count]->Fill(iTS_eta);
3306  histograms.h_denom_trackster_phi[valType][count]->Fill(iTS_phi);
3307  histograms.h_denom_trackster_en[valType][count]->Fill(iTS_en);
3308  histograms.h_denom_trackster_pt[valType][count]->Fill(iTS_pt);
3309 
3310  if (tracksters_FakeMerge[tstId] > 0) {
3311  histograms.h_num_trackster_eta[valType][count]->Fill(iTS_eta);
3312  histograms.h_num_trackster_phi[valType][count]->Fill(iTS_phi);
3313  histograms.h_num_trackster_en[valType][count]->Fill(iTS_en);
3314  histograms.h_num_trackster_pt[valType][count]->Fill(iTS_pt);
3315 
3316  if (tracksters_FakeMerge[tstId] > 1) {
3317  histograms.h_numMerge_trackster_eta[valType][count]->Fill(iTS_eta);
3318  histograms.h_numMerge_trackster_phi[valType][count]->Fill(iTS_phi);
3319  histograms.h_numMerge_trackster_en[valType][count]->Fill(iTS_en);
3320  histograms.h_numMerge_trackster_pt[valType][count]->Fill(iTS_pt);
3321  }
3322  }
3323  } // End loop over Tracksters
3324 }
jetUpdater_cfi.sort
sort
Definition: jetUpdater_cfi.py:30
HLT_2024v14_cff.fraction
fraction
Definition: HLT_2024v14_cff.py:38465
heavyIonCSV_trainingSettings.idx
idx
Definition: heavyIonCSV_trainingSettings.py:5
offlineSlimmedPrimaryVertices_cfi.score
score
Definition: offlineSlimmedPrimaryVertices_cfi.py:6
hfClusterShapes_cfi.hits
hits
Definition: hfClusterShapes_cfi.py:5
hltEgammaHGCALIDVarsL1Seeded_cfi.layerClusters
layerClusters
Definition: hltEgammaHGCALIDVarsL1Seeded_cfi.py:5
spr::find
void find(edm::Handle< EcalRecHitCollection > &hits, DetId thisDet, std::vector< EcalRecHitCollection::const_iterator > &hit, bool debug=false)
Definition: FindCaloHit.cc:19
GetRecoTauVFromDQM_MC_cff.next
next
Definition: GetRecoTauVFromDQM_MC_cff.py:31
hcalRecHitTable_cff.energy
energy
Definition: hcalRecHitTable_cff.py:13
AlignmentTracksFromVertexSelector_cfi.vertices
vertices
Definition: AlignmentTracksFromVertexSelector_cfi.py:5
tier0.unique
def unique(seq, keepstr=True)
Definition: tier0.py:24
reco::CaloClusterCollection
std::vector< CaloCluster > CaloClusterCollection
collection of CaloCluster objects
Definition: CaloClusterFwd.h:19
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
HLT_2024v14_cff.distance
distance
Definition: HLT_2024v14_cff.py:5740
ScoreCutTStoSTSFakeMerge_
const double ScoreCutTStoSTSFakeMerge_[]
Definition: HGVHistoProducerAlgo.cc:20
ticl::Trackster::vertices
std::vector< unsigned int > & vertices()
Definition: Trackster.h:57
DetId
Definition: DetId.h:17
mps_fire.end
end
Definition: mps_fire.py:242
ticl::Trackster::seedID
const edm::ProductID & seedID() const
Definition: Trackster.h:149
ticl::Trackster::vertex_multiplicity
std::vector< float > & vertex_multiplicity()
Definition: Trackster.h:58
ScoreCutSTStoTSPurDup_
const double ScoreCutSTStoTSPurDup_[]
Definition: HGVHistoProducerAlgo.cc:21
ticl::Trackster::seedIndex
const int seedIndex() const
Definition: Trackster.h:150
ticl::TracksterCollection
std::vector< Trackster > TracksterCollection
Definition: Trackster.h:254
h
The Signals That Services Can Subscribe To This is based on ActivityRegistry h
Helper function to determine trigger accepts.
Definition: Activities.doc:4
ALPAKA_ACCELERATOR_NAMESPACE::caPixelDoublets::if
if(threadIdxLocalY==0 &&threadIdxLocalX==0)
Definition: CAPixelDoubletsAlgos.h:173
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:29
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:241

Member Data Documentation

◆ maxCellsEneDensperthick_

double HGVHistoProducerAlgo::maxCellsEneDensperthick_
private

Definition at line 447 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ maxClEnepermultiplicity_

double HGVHistoProducerAlgo::maxClEnepermultiplicity_
private

Definition at line 459 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ maxClEneperthickperlayer_

double HGVHistoProducerAlgo::maxClEneperthickperlayer_
private

Definition at line 445 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ maxDisSeedToMaxperthickperlayer_

double HGVHistoProducerAlgo::maxDisSeedToMaxperthickperlayer_
private

Definition at line 443 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ maxDisToMaxperthickperlayer_

double HGVHistoProducerAlgo::maxDisToMaxperthickperlayer_
private

Definition at line 439 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ maxDisToMaxperthickperlayerenewei_

double HGVHistoProducerAlgo::maxDisToMaxperthickperlayerenewei_
private

Definition at line 441 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ maxDisToSeedperthickperlayer_

double HGVHistoProducerAlgo::maxDisToSeedperthickperlayer_
private

Definition at line 435 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ maxDisToSeedperthickperlayerenewei_

double HGVHistoProducerAlgo::maxDisToSeedperthickperlayerenewei_
private

Definition at line 437 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ maxEne_

double HGVHistoProducerAlgo::maxEne_
private

Definition at line 400 of file HGVHistoProducerAlgo.h.

Referenced by bookCaloParticleHistos(), bookTracksterHistos(), and bookTracksterSTSHistos().

◆ maxEneCl_

double HGVHistoProducerAlgo::maxEneCl_
private

Definition at line 410 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ maxEneClperlay_

double HGVHistoProducerAlgo::maxEneClperlay_
private

Definition at line 420 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ maxEta_

double HGVHistoProducerAlgo::maxEta_
private

Definition at line 397 of file HGVHistoProducerAlgo.h.

Referenced by bookCaloParticleHistos(), bookClusterHistos_ClusterLevel(), bookClusterHistos_LCtoCP_association(), bookSimClusterAssociationHistos(), bookTracksterHistos(), and bookTracksterSTSHistos().

◆ maxLongDepBary_

double HGVHistoProducerAlgo::maxLongDepBary_
private

Definition at line 412 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ maxMixedHitsCluster_

double HGVHistoProducerAlgo::maxMixedHitsCluster_
private

Definition at line 408 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ maxMixedHitsSimCluster_

double HGVHistoProducerAlgo::maxMixedHitsSimCluster_
private

Definition at line 406 of file HGVHistoProducerAlgo.h.

Referenced by bookSimClusterHistos().

◆ maxMplofLCs_

double HGVHistoProducerAlgo::maxMplofLCs_
private

Definition at line 455 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ maxPhi_

double HGVHistoProducerAlgo::maxPhi_
private

Definition at line 404 of file HGVHistoProducerAlgo.h.

Referenced by bookCaloParticleHistos(), bookClusterHistos_LCtoCP_association(), bookSimClusterAssociationHistos(), bookTracksterHistos(), and bookTracksterSTSHistos().

◆ maxPt_

double HGVHistoProducerAlgo::maxPt_
private

Definition at line 402 of file HGVHistoProducerAlgo.h.

Referenced by bookCaloParticleHistos(), bookTracksterHistos(), and bookTracksterSTSHistos().

◆ maxScore_

double HGVHistoProducerAlgo::maxScore_
private

Definition at line 422 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_LCtoCP_association(), bookSimClusterAssociationHistos(), and bookTracksterSTSHistos().

◆ maxSharedEneFrac_

double HGVHistoProducerAlgo::maxSharedEneFrac_
private

Definition at line 424 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_LCtoCP_association(), and bookSimClusterAssociationHistos().

◆ maxSizeCLsinTSTs_

double HGVHistoProducerAlgo::maxSizeCLsinTSTs_
private

Definition at line 457 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ maxTotNcellsperthickperlayer_

double HGVHistoProducerAlgo::maxTotNcellsperthickperlayer_
private

Definition at line 433 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ maxTotNClsinTSTs_

double HGVHistoProducerAlgo::maxTotNClsinTSTs_
private

Definition at line 451 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ maxTotNClsinTSTsperlayer_

double HGVHistoProducerAlgo::maxTotNClsinTSTsperlayer_
private

Definition at line 453 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ maxTotNClsperlay_

double HGVHistoProducerAlgo::maxTotNClsperlay_
private

Definition at line 418 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ maxTotNClsperthick_

double HGVHistoProducerAlgo::maxTotNClsperthick_
private

Definition at line 431 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ maxTotNsimClsperlay_

double HGVHistoProducerAlgo::maxTotNsimClsperlay_
private

Definition at line 416 of file HGVHistoProducerAlgo.h.

Referenced by bookSimClusterHistos().

◆ maxTotNsimClsperthick_

double HGVHistoProducerAlgo::maxTotNsimClsperthick_
private

Definition at line 429 of file HGVHistoProducerAlgo.h.

Referenced by bookSimClusterHistos().

◆ maxTotNTSTs_

double HGVHistoProducerAlgo::maxTotNTSTs_
private

Definition at line 449 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ maxTSTSharedEneFrac_

double HGVHistoProducerAlgo::maxTSTSharedEneFrac_
private

Definition at line 427 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterSTSHistos().

◆ maxX_

double HGVHistoProducerAlgo::maxX_
private

Definition at line 461 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ maxY_

double HGVHistoProducerAlgo::maxY_
private

Definition at line 463 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ maxZ_

double HGVHistoProducerAlgo::maxZ_
private

Definition at line 465 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ maxZpos_

double HGVHistoProducerAlgo::maxZpos_
private

Definition at line 414 of file HGVHistoProducerAlgo.h.

Referenced by bookCaloParticleHistos().

◆ minCellsEneDensperthick_

double HGVHistoProducerAlgo::minCellsEneDensperthick_
private

Definition at line 447 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ minClEnepermultiplicity_

double HGVHistoProducerAlgo::minClEnepermultiplicity_
private

Definition at line 459 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ minClEneperthickperlayer_

double HGVHistoProducerAlgo::minClEneperthickperlayer_
private

Definition at line 445 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ minDisSeedToMaxperthickperlayer_

double HGVHistoProducerAlgo::minDisSeedToMaxperthickperlayer_
private

Definition at line 443 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ minDisToMaxperthickperlayer_

double HGVHistoProducerAlgo::minDisToMaxperthickperlayer_
private

Definition at line 439 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ minDisToMaxperthickperlayerenewei_

double HGVHistoProducerAlgo::minDisToMaxperthickperlayerenewei_
private

Definition at line 441 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ minDisToSeedperthickperlayer_

double HGVHistoProducerAlgo::minDisToSeedperthickperlayer_
private

Definition at line 435 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ minDisToSeedperthickperlayerenewei_

double HGVHistoProducerAlgo::minDisToSeedperthickperlayerenewei_
private

Definition at line 437 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ minEne_

double HGVHistoProducerAlgo::minEne_
private

Definition at line 400 of file HGVHistoProducerAlgo.h.

Referenced by bookCaloParticleHistos(), bookTracksterHistos(), and bookTracksterSTSHistos().

◆ minEneCl_

double HGVHistoProducerAlgo::minEneCl_
private

Definition at line 410 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ minEneClperlay_

double HGVHistoProducerAlgo::minEneClperlay_
private

Definition at line 420 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ minEta_

double HGVHistoProducerAlgo::minEta_
private

Definition at line 397 of file HGVHistoProducerAlgo.h.

Referenced by bookCaloParticleHistos(), bookClusterHistos_ClusterLevel(), bookClusterHistos_LCtoCP_association(), bookSimClusterAssociationHistos(), bookTracksterHistos(), and bookTracksterSTSHistos().

◆ minLongDepBary_

double HGVHistoProducerAlgo::minLongDepBary_
private

Definition at line 412 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ minMixedHitsCluster_

double HGVHistoProducerAlgo::minMixedHitsCluster_
private

Definition at line 408 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ minMixedHitsSimCluster_

double HGVHistoProducerAlgo::minMixedHitsSimCluster_
private

Definition at line 406 of file HGVHistoProducerAlgo.h.

Referenced by bookSimClusterHistos().

◆ minMplofLCs_

double HGVHistoProducerAlgo::minMplofLCs_
private

Definition at line 455 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ minPhi_

double HGVHistoProducerAlgo::minPhi_
private

Definition at line 404 of file HGVHistoProducerAlgo.h.

Referenced by bookCaloParticleHistos(), bookClusterHistos_LCtoCP_association(), bookSimClusterAssociationHistos(), bookTracksterHistos(), and bookTracksterSTSHistos().

◆ minPt_

double HGVHistoProducerAlgo::minPt_
private

Definition at line 402 of file HGVHistoProducerAlgo.h.

Referenced by bookCaloParticleHistos(), bookTracksterHistos(), and bookTracksterSTSHistos().

◆ minScore_

double HGVHistoProducerAlgo::minScore_
private

Definition at line 422 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_LCtoCP_association(), bookSimClusterAssociationHistos(), and bookTracksterSTSHistos().

◆ minSharedEneFrac_

double HGVHistoProducerAlgo::minSharedEneFrac_
private

Definition at line 424 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_LCtoCP_association(), and bookSimClusterAssociationHistos().

◆ minSizeCLsinTSTs_

double HGVHistoProducerAlgo::minSizeCLsinTSTs_
private

Definition at line 457 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ minTotNcellsperthickperlayer_

double HGVHistoProducerAlgo::minTotNcellsperthickperlayer_
private

Definition at line 433 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ minTotNClsinTSTs_

double HGVHistoProducerAlgo::minTotNClsinTSTs_
private

Definition at line 451 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ minTotNClsinTSTsperlayer_

double HGVHistoProducerAlgo::minTotNClsinTSTsperlayer_
private

Definition at line 453 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ minTotNClsperlay_

double HGVHistoProducerAlgo::minTotNClsperlay_
private

Definition at line 418 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ minTotNClsperthick_

double HGVHistoProducerAlgo::minTotNClsperthick_
private

Definition at line 431 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ minTotNsimClsperlay_

double HGVHistoProducerAlgo::minTotNsimClsperlay_
private

Definition at line 416 of file HGVHistoProducerAlgo.h.

Referenced by bookSimClusterHistos().

◆ minTotNsimClsperthick_

double HGVHistoProducerAlgo::minTotNsimClsperthick_
private

Definition at line 429 of file HGVHistoProducerAlgo.h.

Referenced by bookSimClusterHistos().

◆ minTotNTSTs_

double HGVHistoProducerAlgo::minTotNTSTs_
private

Definition at line 449 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ minTSTSharedEneFrac_

double HGVHistoProducerAlgo::minTSTSharedEneFrac_
private

Definition at line 427 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterSTSHistos().

◆ minTSTSharedEneFracEfficiency_

double HGVHistoProducerAlgo::minTSTSharedEneFracEfficiency_
private

Definition at line 426 of file HGVHistoProducerAlgo.h.

Referenced by tracksters_to_SimTracksters().

◆ minX_

double HGVHistoProducerAlgo::minX_
private

Definition at line 461 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ minY_

double HGVHistoProducerAlgo::minY_
private

Definition at line 463 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ minZ_

double HGVHistoProducerAlgo::minZ_
private

Definition at line 465 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ minZpos_

double HGVHistoProducerAlgo::minZpos_
private

Definition at line 414 of file HGVHistoProducerAlgo.h.

Referenced by bookCaloParticleHistos().

◆ nintCellsEneDensperthick_

int HGVHistoProducerAlgo::nintCellsEneDensperthick_
private

Definition at line 448 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ nintClEnepermultiplicity_

int HGVHistoProducerAlgo::nintClEnepermultiplicity_
private

Definition at line 460 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ nintClEneperthickperlayer_

int HGVHistoProducerAlgo::nintClEneperthickperlayer_
private

Definition at line 446 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ nintDisSeedToMaxperthickperlayer_

int HGVHistoProducerAlgo::nintDisSeedToMaxperthickperlayer_
private

Definition at line 444 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ nintDisToMaxperthickperlayer_

int HGVHistoProducerAlgo::nintDisToMaxperthickperlayer_
private

Definition at line 440 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ nintDisToMaxperthickperlayerenewei_

int HGVHistoProducerAlgo::nintDisToMaxperthickperlayerenewei_
private

Definition at line 442 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ nintDisToSeedperthickperlayer_

int HGVHistoProducerAlgo::nintDisToSeedperthickperlayer_
private

Definition at line 436 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ nintDisToSeedperthickperlayerenewei_

int HGVHistoProducerAlgo::nintDisToSeedperthickperlayerenewei_
private

Definition at line 438 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ nintEne_

int HGVHistoProducerAlgo::nintEne_
private

Definition at line 401 of file HGVHistoProducerAlgo.h.

Referenced by bookCaloParticleHistos(), bookTracksterHistos(), and bookTracksterSTSHistos().

◆ nintEneCl_

int HGVHistoProducerAlgo::nintEneCl_
private

Definition at line 411 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ nintEneClperlay_

int HGVHistoProducerAlgo::nintEneClperlay_
private

Definition at line 421 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ nintEta_

int HGVHistoProducerAlgo::nintEta_
private

Definition at line 398 of file HGVHistoProducerAlgo.h.

Referenced by bookCaloParticleHistos(), bookClusterHistos_ClusterLevel(), bookClusterHistos_LCtoCP_association(), bookSimClusterAssociationHistos(), bookTracksterHistos(), and bookTracksterSTSHistos().

◆ nintLongDepBary_

int HGVHistoProducerAlgo::nintLongDepBary_
private

Definition at line 413 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ nintMixedHitsCluster_

int HGVHistoProducerAlgo::nintMixedHitsCluster_
private

Definition at line 409 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ nintMixedHitsSimCluster_

int HGVHistoProducerAlgo::nintMixedHitsSimCluster_
private

Definition at line 407 of file HGVHistoProducerAlgo.h.

Referenced by bookSimClusterHistos().

◆ nintMplofLCs_

int HGVHistoProducerAlgo::nintMplofLCs_
private

Definition at line 456 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ nintPhi_

int HGVHistoProducerAlgo::nintPhi_
private

Definition at line 405 of file HGVHistoProducerAlgo.h.

Referenced by bookCaloParticleHistos(), bookClusterHistos_LCtoCP_association(), bookSimClusterAssociationHistos(), bookTracksterHistos(), and bookTracksterSTSHistos().

◆ nintPt_

int HGVHistoProducerAlgo::nintPt_
private

Definition at line 403 of file HGVHistoProducerAlgo.h.

Referenced by bookCaloParticleHistos(), bookTracksterHistos(), and bookTracksterSTSHistos().

◆ nintScore_

int HGVHistoProducerAlgo::nintScore_
private

Definition at line 423 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_LCtoCP_association(), bookSimClusterAssociationHistos(), and bookTracksterSTSHistos().

◆ nintSharedEneFrac_

int HGVHistoProducerAlgo::nintSharedEneFrac_
private

Definition at line 425 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_LCtoCP_association(), bookSimClusterAssociationHistos(), and bookTracksterSTSHistos().

◆ nintSizeCLsinTSTs_

int HGVHistoProducerAlgo::nintSizeCLsinTSTs_
private

Definition at line 458 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ nintTotNcellsperthickperlayer_

int HGVHistoProducerAlgo::nintTotNcellsperthickperlayer_
private

Definition at line 434 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ nintTotNClsinTSTs_

int HGVHistoProducerAlgo::nintTotNClsinTSTs_
private

Definition at line 452 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ nintTotNClsinTSTsperlayer_

int HGVHistoProducerAlgo::nintTotNClsinTSTsperlayer_
private

Definition at line 454 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ nintTotNClsperlay_

int HGVHistoProducerAlgo::nintTotNClsperlay_
private

Definition at line 419 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ nintTotNClsperthick_

int HGVHistoProducerAlgo::nintTotNClsperthick_
private

Definition at line 432 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ nintTotNsimClsperlay_

int HGVHistoProducerAlgo::nintTotNsimClsperlay_
private

Definition at line 417 of file HGVHistoProducerAlgo.h.

Referenced by bookSimClusterHistos().

◆ nintTotNsimClsperthick_

int HGVHistoProducerAlgo::nintTotNsimClsperthick_
private

Definition at line 430 of file HGVHistoProducerAlgo.h.

Referenced by bookSimClusterHistos().

◆ nintTotNTSTs_

int HGVHistoProducerAlgo::nintTotNTSTs_
private

Definition at line 450 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ nintTSTSharedEneFrac_

int HGVHistoProducerAlgo::nintTSTSharedEneFrac_
private

Definition at line 428 of file HGVHistoProducerAlgo.h.

◆ nintX_

int HGVHistoProducerAlgo::nintX_
private

Definition at line 462 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ nintY_

int HGVHistoProducerAlgo::nintY_
private

Definition at line 464 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ nintZ_

int HGVHistoProducerAlgo::nintZ_
private

Definition at line 466 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ nintZpos_

int HGVHistoProducerAlgo::nintZpos_
private

Definition at line 415 of file HGVHistoProducerAlgo.h.

Referenced by bookCaloParticleHistos().

◆ recHitTools_

std::shared_ptr<hgcal::RecHitTools> HGVHistoProducerAlgo::recHitTools_
private

Definition at line 394 of file HGVHistoProducerAlgo.h.

Referenced by fill_caloparticle_histos(), fill_generic_cluster_histos(), fill_info_histos(), fill_trackster_histos(), layerClusters_to_CaloParticles(), layerClusters_to_SimClusters(), and setRecHitTools().

◆ useFabsEta_

bool HGVHistoProducerAlgo::useFabsEta_
private

Definition at line 399 of file HGVHistoProducerAlgo.h.

Referenced by getEta().

Generated for CMSSW Reference Manual by doxygen 1.8.14