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 HGCRecHit *> const &) 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, const Density &densities, 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 HGCRecHit *> const &, std::map< double, double > cummatbudg, unsigned int layers, std::vector< int > thicknesses, const hgcal::RecoToSimCollection &recSimColl, const hgcal::SimToRecoCollection &simRecColl) 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 HGCRecHit *> const &hitMap, unsigned int layers, const hgcal::RecoToSimCollectionWithSimClusters &recSimColl, const hgcal::SimToRecoCollectionWithSimClusters &simRecColl) 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 HGCRecHit *> const &, unsigned int layers) const
 
DetId findmaxhit (const reco::CaloCluster &cluster, std::unordered_map< DetId, const HGCRecHit *> const &) 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 HGCRecHit *> const &, unsigned int layers, const hgcal::RecoToSimCollection &recSimColl, const hgcal::SimToRecoCollection &simRecColl) 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 HGCRecHit *> const &, unsigned int layers, const hgcal::RecoToSimCollectionWithSimClusters &recSimColl, const hgcal::SimToRecoCollectionWithSimClusters &simRecColl) 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 HGCRecHit *> const &, unsigned int layers) 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:212
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(), 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 cond::impl::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
cond::impl::to_string
std::string to_string(const V &value)
Definition: OMSAccess.h:77
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
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:212
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(), 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 cond::impl::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
cond::impl::to_string
std::string to_string(const V &value)
Definition: OMSAccess.h:77
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
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 cond::impl::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
cond::impl::to_string
std::string to_string(const V &value)
Definition: OMSAccess.h:77
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
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:399
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:212
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 cond::impl::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
cond::impl::to_string
std::string to_string(const V &value)
Definition: OMSAccess.h:77
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
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:399
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:212
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(), hgcalTBTopologyTester_cfi::layers, maxMixedHitsSimCluster_, maxTotNsimClsperlay_, maxTotNsimClsperthick_, minMixedHitsSimCluster_, minTotNsimClsperlay_, minTotNsimClsperthick_, nintMixedHitsSimCluster_, nintTotNsimClsperlay_, nintTotNsimClsperthick_, AlCaHLTBitMon_QueryRunRegistry::string, and cond::impl::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
cond::impl::to_string
std::string to_string(const V &value)
Definition: OMSAccess.h:77
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
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 cond::impl::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
cond::impl::to_string
std::string to_string(const V &value)
Definition: OMSAccess.h:77
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
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:399
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:212
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:399
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:212
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 3555 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().

3558  { //2-d distance on the layer (x-y)
3559  return std::sqrt(distance2(x1, y1, x2, y2));
3560 }
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:19
HGVHistoProducerAlgo::distance2
double distance2(const double x1, const double y1, const double x2, const double y2) const
Definition: HGVHistoProducerAlgo.cc:3547
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 3547 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().

3550  { //distance squared
3551  const double dx = x1 - x2;
3552  const double dy = y1 - y2;
3553  return (dx * dx + dy * dy);
3554 } //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 HGCRecHit *> const &  hitMap 
) const

Definition at line 1440 of file HGVHistoProducerAlgo.cc.

References HCALHighEnergyHPDFilter_cfi::energy, CaloParticle::energy(), PVValHelper::eta, CaloParticle::eta(), newFWLiteAna::found, CaloParticle::g4Tracks(), getEta(), 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.

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

◆ 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:3587
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,
const Density &  densities,
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 HGCRecHit *> const &  hitMap,
std::map< double, double >  cummatbudg,
unsigned int  layers,
std::vector< int >  thicknesses,
const hgcal::RecoToSimCollection &  recSimColl,
const hgcal::SimToRecoCollection &  simRecColl 
) const

Definition at line 2176 of file HGVHistoProducerAlgo.cc.

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

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

◆ 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:386

◆ 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 HGCRecHit *> const &  hitMap,
unsigned int  layers,
const hgcal::RecoToSimCollectionWithSimClusters &  recSimColl,
const hgcal::SimToRecoCollectionWithSimClusters &  simRecColl 
) 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 HGCRecHit *> const &  ,
unsigned int  layers 
) const

Definition at line 3332 of file HGVHistoProducerAlgo.cc.

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

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

◆ findmaxhit()

DetId HGVHistoProducerAlgo::findmaxhit ( const reco::CaloCluster &  cluster,
std::unordered_map< DetId, const HGCRecHit *> const &  hitMap 
) const

Definition at line 3566 of file HGVHistoProducerAlgo.cc.

References reco::CaloCluster::hitsAndFractions(), and trackerHitRTTI::vector.

Referenced by fill_generic_cluster_histos().

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

◆ getEta()

double HGVHistoProducerAlgo::getEta ( double  eta) const
private

Definition at line 3587 of file HGVHistoProducerAlgo.cc.

References PVValHelper::eta, and useFabsEta_.

Referenced by fill_caloparticle_histos(), and fill_cluster_histos().

3587  {
3588  if (useFabsEta_)
3589  return fabs(eta);
3590  else
3591  return eta;
3592 }

◆ 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 HGCRecHit *> const &  hitMap,
unsigned int  layers,
const hgcal::RecoToSimCollection &  recSimColl,
const hgcal::SimToRecoCollection &  simRecColl 
) 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, hgcalTBTopologyTester_cfi::layers, LogDebug, getGTfromDQMFile::obj, AlCaHLTBitMon_ParallelJobs::p, phi, recHitTools_, ScoreCutCPtoLC_, and ScoreCutLCtoCP_.

Referenced by fill_generic_cluster_histos().

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

◆ 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 HGCRecHit *> const &  hitMap,
unsigned int  layers,
const hgcal::RecoToSimCollectionWithSimClusters &  recSimColl,
const hgcal::SimToRecoCollectionWithSimClusters &  simRecColl 
) const

Definition at line 1997 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, hgcalTBTopologyTester_cfi::layers, LogDebug, gpuClustering::pixelStatus::mask, getGTfromDQMFile::obj, AlCaHLTBitMon_ParallelJobs::p, phi, recHitTools_, ScoreCutLCtoSC_, and ScoreCutSCtoLC_.

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

◆ setRecHitTools()

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

Definition at line 3562 of file HGVHistoProducerAlgo.cc.

References recHitTools_.

3562  {
3563  recHitTools_ = recHitTools;
3564 }
HGVHistoProducerAlgo::recHitTools_
std::shared_ptr< hgcal::RecHitTools > recHitTools_
Definition: HGVHistoProducerAlgo.h:386

◆ 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 HGCRecHit *> const &  ,
unsigned int  layers 
) const

Definition at line 2516 of file HGVHistoProducerAlgo.cc.

References HltBtagPostValidation_cff::c, submitPVResolutionJobs::count, HLT_2023v12_cff::distance, relativeConstraints::empty, mps_fire::end, f, spr::find(), newFWLiteAna::found, HLT_2023v12_cff::fraction, h, heavyIonCSV_trainingSettings::idx, caHitNtupletGeneratorKernels::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().

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

Member Data Documentation

◆ maxCellsEneDensperthick_

double HGVHistoProducerAlgo::maxCellsEneDensperthick_
private

Definition at line 439 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ maxClEnepermultiplicity_

double HGVHistoProducerAlgo::maxClEnepermultiplicity_
private

Definition at line 451 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ maxClEneperthickperlayer_

double HGVHistoProducerAlgo::maxClEneperthickperlayer_
private

Definition at line 437 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ maxDisSeedToMaxperthickperlayer_

double HGVHistoProducerAlgo::maxDisSeedToMaxperthickperlayer_
private

Definition at line 435 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ maxDisToMaxperthickperlayer_

double HGVHistoProducerAlgo::maxDisToMaxperthickperlayer_
private

Definition at line 431 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ maxDisToMaxperthickperlayerenewei_

double HGVHistoProducerAlgo::maxDisToMaxperthickperlayerenewei_
private

Definition at line 433 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ maxDisToSeedperthickperlayer_

double HGVHistoProducerAlgo::maxDisToSeedperthickperlayer_
private

Definition at line 427 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ maxDisToSeedperthickperlayerenewei_

double HGVHistoProducerAlgo::maxDisToSeedperthickperlayerenewei_
private

Definition at line 429 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ maxEne_

double HGVHistoProducerAlgo::maxEne_
private

Definition at line 392 of file HGVHistoProducerAlgo.h.

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

◆ maxEneCl_

double HGVHistoProducerAlgo::maxEneCl_
private

Definition at line 402 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ maxEneClperlay_

double HGVHistoProducerAlgo::maxEneClperlay_
private

Definition at line 412 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ maxEta_

double HGVHistoProducerAlgo::maxEta_
private

Definition at line 389 of file HGVHistoProducerAlgo.h.

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

◆ maxLongDepBary_

double HGVHistoProducerAlgo::maxLongDepBary_
private

Definition at line 404 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ maxMixedHitsCluster_

double HGVHistoProducerAlgo::maxMixedHitsCluster_
private

Definition at line 400 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ maxMixedHitsSimCluster_

double HGVHistoProducerAlgo::maxMixedHitsSimCluster_
private

Definition at line 398 of file HGVHistoProducerAlgo.h.

Referenced by bookSimClusterHistos().

◆ maxMplofLCs_

double HGVHistoProducerAlgo::maxMplofLCs_
private

Definition at line 447 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ maxPhi_

double HGVHistoProducerAlgo::maxPhi_
private

Definition at line 396 of file HGVHistoProducerAlgo.h.

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

◆ maxPt_

double HGVHistoProducerAlgo::maxPt_
private

Definition at line 394 of file HGVHistoProducerAlgo.h.

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

◆ maxScore_

double HGVHistoProducerAlgo::maxScore_
private

Definition at line 414 of file HGVHistoProducerAlgo.h.

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

◆ maxSharedEneFrac_

double HGVHistoProducerAlgo::maxSharedEneFrac_
private

Definition at line 416 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_LCtoCP_association(), and bookSimClusterAssociationHistos().

◆ maxSizeCLsinTSTs_

double HGVHistoProducerAlgo::maxSizeCLsinTSTs_
private

Definition at line 449 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ maxTotNcellsperthickperlayer_

double HGVHistoProducerAlgo::maxTotNcellsperthickperlayer_
private

Definition at line 425 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ maxTotNClsinTSTs_

double HGVHistoProducerAlgo::maxTotNClsinTSTs_
private

Definition at line 443 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ maxTotNClsinTSTsperlayer_

double HGVHistoProducerAlgo::maxTotNClsinTSTsperlayer_
private

Definition at line 445 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ maxTotNClsperlay_

double HGVHistoProducerAlgo::maxTotNClsperlay_
private

Definition at line 410 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ maxTotNClsperthick_

double HGVHistoProducerAlgo::maxTotNClsperthick_
private

Definition at line 423 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ maxTotNsimClsperlay_

double HGVHistoProducerAlgo::maxTotNsimClsperlay_
private

Definition at line 408 of file HGVHistoProducerAlgo.h.

Referenced by bookSimClusterHistos().

◆ maxTotNsimClsperthick_

double HGVHistoProducerAlgo::maxTotNsimClsperthick_
private

Definition at line 421 of file HGVHistoProducerAlgo.h.

Referenced by bookSimClusterHistos().

◆ maxTotNTSTs_

double HGVHistoProducerAlgo::maxTotNTSTs_
private

Definition at line 441 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ maxTSTSharedEneFrac_

double HGVHistoProducerAlgo::maxTSTSharedEneFrac_
private

Definition at line 419 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterSTSHistos().

◆ maxX_

double HGVHistoProducerAlgo::maxX_
private

Definition at line 453 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ maxY_

double HGVHistoProducerAlgo::maxY_
private

Definition at line 455 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ maxZ_

double HGVHistoProducerAlgo::maxZ_
private

Definition at line 457 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ maxZpos_

double HGVHistoProducerAlgo::maxZpos_
private

Definition at line 406 of file HGVHistoProducerAlgo.h.

Referenced by bookCaloParticleHistos().

◆ minCellsEneDensperthick_

double HGVHistoProducerAlgo::minCellsEneDensperthick_
private

Definition at line 439 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ minClEnepermultiplicity_

double HGVHistoProducerAlgo::minClEnepermultiplicity_
private

Definition at line 451 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ minClEneperthickperlayer_

double HGVHistoProducerAlgo::minClEneperthickperlayer_
private

Definition at line 437 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ minDisSeedToMaxperthickperlayer_

double HGVHistoProducerAlgo::minDisSeedToMaxperthickperlayer_
private

Definition at line 435 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ minDisToMaxperthickperlayer_

double HGVHistoProducerAlgo::minDisToMaxperthickperlayer_
private

Definition at line 431 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ minDisToMaxperthickperlayerenewei_

double HGVHistoProducerAlgo::minDisToMaxperthickperlayerenewei_
private

Definition at line 433 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ minDisToSeedperthickperlayer_

double HGVHistoProducerAlgo::minDisToSeedperthickperlayer_
private

Definition at line 427 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ minDisToSeedperthickperlayerenewei_

double HGVHistoProducerAlgo::minDisToSeedperthickperlayerenewei_
private

Definition at line 429 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ minEne_

double HGVHistoProducerAlgo::minEne_
private

Definition at line 392 of file HGVHistoProducerAlgo.h.

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

◆ minEneCl_

double HGVHistoProducerAlgo::minEneCl_
private

Definition at line 402 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ minEneClperlay_

double HGVHistoProducerAlgo::minEneClperlay_
private

Definition at line 412 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ minEta_

double HGVHistoProducerAlgo::minEta_
private

Definition at line 389 of file HGVHistoProducerAlgo.h.

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

◆ minLongDepBary_

double HGVHistoProducerAlgo::minLongDepBary_
private

Definition at line 404 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ minMixedHitsCluster_

double HGVHistoProducerAlgo::minMixedHitsCluster_
private

Definition at line 400 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ minMixedHitsSimCluster_

double HGVHistoProducerAlgo::minMixedHitsSimCluster_
private

Definition at line 398 of file HGVHistoProducerAlgo.h.

Referenced by bookSimClusterHistos().

◆ minMplofLCs_

double HGVHistoProducerAlgo::minMplofLCs_
private

Definition at line 447 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ minPhi_

double HGVHistoProducerAlgo::minPhi_
private

Definition at line 396 of file HGVHistoProducerAlgo.h.

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

◆ minPt_

double HGVHistoProducerAlgo::minPt_
private

Definition at line 394 of file HGVHistoProducerAlgo.h.

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

◆ minScore_

double HGVHistoProducerAlgo::minScore_
private

Definition at line 414 of file HGVHistoProducerAlgo.h.

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

◆ minSharedEneFrac_

double HGVHistoProducerAlgo::minSharedEneFrac_
private

Definition at line 416 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_LCtoCP_association(), and bookSimClusterAssociationHistos().

◆ minSizeCLsinTSTs_

double HGVHistoProducerAlgo::minSizeCLsinTSTs_
private

Definition at line 449 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ minTotNcellsperthickperlayer_

double HGVHistoProducerAlgo::minTotNcellsperthickperlayer_
private

Definition at line 425 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ minTotNClsinTSTs_

double HGVHistoProducerAlgo::minTotNClsinTSTs_
private

Definition at line 443 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ minTotNClsinTSTsperlayer_

double HGVHistoProducerAlgo::minTotNClsinTSTsperlayer_
private

Definition at line 445 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ minTotNClsperlay_

double HGVHistoProducerAlgo::minTotNClsperlay_
private

Definition at line 410 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ minTotNClsperthick_

double HGVHistoProducerAlgo::minTotNClsperthick_
private

Definition at line 423 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ minTotNsimClsperlay_

double HGVHistoProducerAlgo::minTotNsimClsperlay_
private

Definition at line 408 of file HGVHistoProducerAlgo.h.

Referenced by bookSimClusterHistos().

◆ minTotNsimClsperthick_

double HGVHistoProducerAlgo::minTotNsimClsperthick_
private

Definition at line 421 of file HGVHistoProducerAlgo.h.

Referenced by bookSimClusterHistos().

◆ minTotNTSTs_

double HGVHistoProducerAlgo::minTotNTSTs_
private

Definition at line 441 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ minTSTSharedEneFrac_

double HGVHistoProducerAlgo::minTSTSharedEneFrac_
private

Definition at line 419 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterSTSHistos().

◆ minTSTSharedEneFracEfficiency_

double HGVHistoProducerAlgo::minTSTSharedEneFracEfficiency_
private

Definition at line 418 of file HGVHistoProducerAlgo.h.

Referenced by tracksters_to_SimTracksters().

◆ minX_

double HGVHistoProducerAlgo::minX_
private

Definition at line 453 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ minY_

double HGVHistoProducerAlgo::minY_
private

Definition at line 455 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ minZ_

double HGVHistoProducerAlgo::minZ_
private

Definition at line 457 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ minZpos_

double HGVHistoProducerAlgo::minZpos_
private

Definition at line 406 of file HGVHistoProducerAlgo.h.

Referenced by bookCaloParticleHistos().

◆ nintCellsEneDensperthick_

int HGVHistoProducerAlgo::nintCellsEneDensperthick_
private

Definition at line 440 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ nintClEnepermultiplicity_

int HGVHistoProducerAlgo::nintClEnepermultiplicity_
private

Definition at line 452 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ nintClEneperthickperlayer_

int HGVHistoProducerAlgo::nintClEneperthickperlayer_
private

Definition at line 438 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ nintDisSeedToMaxperthickperlayer_

int HGVHistoProducerAlgo::nintDisSeedToMaxperthickperlayer_
private

Definition at line 436 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ nintDisToMaxperthickperlayer_

int HGVHistoProducerAlgo::nintDisToMaxperthickperlayer_
private

Definition at line 432 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ nintDisToMaxperthickperlayerenewei_

int HGVHistoProducerAlgo::nintDisToMaxperthickperlayerenewei_
private

Definition at line 434 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ nintDisToSeedperthickperlayer_

int HGVHistoProducerAlgo::nintDisToSeedperthickperlayer_
private

Definition at line 428 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ nintDisToSeedperthickperlayerenewei_

int HGVHistoProducerAlgo::nintDisToSeedperthickperlayerenewei_
private

Definition at line 430 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ nintEne_

int HGVHistoProducerAlgo::nintEne_
private

Definition at line 393 of file HGVHistoProducerAlgo.h.

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

◆ nintEneCl_

int HGVHistoProducerAlgo::nintEneCl_
private

Definition at line 403 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ nintEneClperlay_

int HGVHistoProducerAlgo::nintEneClperlay_
private

Definition at line 413 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ nintEta_

int HGVHistoProducerAlgo::nintEta_
private

Definition at line 390 of file HGVHistoProducerAlgo.h.

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

◆ nintLongDepBary_

int HGVHistoProducerAlgo::nintLongDepBary_
private

Definition at line 405 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ nintMixedHitsCluster_

int HGVHistoProducerAlgo::nintMixedHitsCluster_
private

Definition at line 401 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ nintMixedHitsSimCluster_

int HGVHistoProducerAlgo::nintMixedHitsSimCluster_
private

Definition at line 399 of file HGVHistoProducerAlgo.h.

Referenced by bookSimClusterHistos().

◆ nintMplofLCs_

int HGVHistoProducerAlgo::nintMplofLCs_
private

Definition at line 448 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ nintPhi_

int HGVHistoProducerAlgo::nintPhi_
private

Definition at line 397 of file HGVHistoProducerAlgo.h.

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

◆ nintPt_

int HGVHistoProducerAlgo::nintPt_
private

Definition at line 395 of file HGVHistoProducerAlgo.h.

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

◆ nintScore_

int HGVHistoProducerAlgo::nintScore_
private

Definition at line 415 of file HGVHistoProducerAlgo.h.

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

◆ nintSharedEneFrac_

int HGVHistoProducerAlgo::nintSharedEneFrac_
private

Definition at line 417 of file HGVHistoProducerAlgo.h.

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

◆ nintSizeCLsinTSTs_

int HGVHistoProducerAlgo::nintSizeCLsinTSTs_
private

Definition at line 450 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ nintTotNcellsperthickperlayer_

int HGVHistoProducerAlgo::nintTotNcellsperthickperlayer_
private

Definition at line 426 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_CellLevel().

◆ nintTotNClsinTSTs_

int HGVHistoProducerAlgo::nintTotNClsinTSTs_
private

Definition at line 444 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ nintTotNClsinTSTsperlayer_

int HGVHistoProducerAlgo::nintTotNClsinTSTsperlayer_
private

Definition at line 446 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ nintTotNClsperlay_

int HGVHistoProducerAlgo::nintTotNClsperlay_
private

Definition at line 411 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ nintTotNClsperthick_

int HGVHistoProducerAlgo::nintTotNClsperthick_
private

Definition at line 424 of file HGVHistoProducerAlgo.h.

Referenced by bookClusterHistos_ClusterLevel().

◆ nintTotNsimClsperlay_

int HGVHistoProducerAlgo::nintTotNsimClsperlay_
private

Definition at line 409 of file HGVHistoProducerAlgo.h.

Referenced by bookSimClusterHistos().

◆ nintTotNsimClsperthick_

int HGVHistoProducerAlgo::nintTotNsimClsperthick_
private

Definition at line 422 of file HGVHistoProducerAlgo.h.

Referenced by bookSimClusterHistos().

◆ nintTotNTSTs_

int HGVHistoProducerAlgo::nintTotNTSTs_
private

Definition at line 442 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ nintTSTSharedEneFrac_

int HGVHistoProducerAlgo::nintTSTSharedEneFrac_
private

Definition at line 420 of file HGVHistoProducerAlgo.h.

◆ nintX_

int HGVHistoProducerAlgo::nintX_
private

Definition at line 454 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ nintY_

int HGVHistoProducerAlgo::nintY_
private

Definition at line 456 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ nintZ_

int HGVHistoProducerAlgo::nintZ_
private

Definition at line 458 of file HGVHistoProducerAlgo.h.

Referenced by bookTracksterHistos().

◆ nintZpos_

int HGVHistoProducerAlgo::nintZpos_
private

Definition at line 407 of file HGVHistoProducerAlgo.h.

Referenced by bookCaloParticleHistos().

◆ recHitTools_

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

Definition at line 386 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 391 of file HGVHistoProducerAlgo.h.

Referenced by getEta().

Generated for CMSSW Reference Manual by doxygen 1.8.14