ATLAS Offline Software
Loading...
Searching...
No Matches
EgammaPhysValMonitoringTool.cxx
Go to the documentation of this file.
1/*
2 Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
3*/
4
5// EgammaPhysValMonitoringTool.cxx
6// Implementation file for class EgammaPhysValMonitoringTool
7// Author:
9
10// PhysVal includes
11#include "EgammaPhysValMonitoringTool.h"
12
13
14
15// FrameWork includes
16#include "GaudiKernel/IToolSvc.h"
17#include "AthenaBaseComps/AthCheckMacros.h"
18#include "xAODEgamma/EgammaEnums.h"
19#include "xAODEgamma/EgammaDefs.h"
20#include "xAODEgamma/EgammaxAODHelpers.h"
21#include "xAODEgamma/PhotonxAODHelpers.h"
22#include "xAODTruth/xAODTruthHelpers.h"
23#include <EgammaAnalysisHelpers/PhotonHelpers.h>
24
25#include "TruthUtils/TruthClasses.h"
26
27#include "StoreGate/ReadHandle.h"
28#include "AthContainers/ConstAccessor.h"
29
30#include "TruthUtils/HepMCHelpers.h"
31// STL includes
32#include <vector>
33
34using CLHEP::GeV;
35using namespace std;
36using namespace MCTruthPartClassifier;
37
38namespace EgammaPhysValMonitoring {
39
41// Public methods:
43
44// Constructors
46
47EgammaPhysValMonitoringTool::EgammaPhysValMonitoringTool( const std::string& type,
48 const std::string& name,
49 const IInterface* parent ):
50 ManagedMonitorToolBase( type, name, parent ),
51 m_oElectronValidationPlots(nullptr, "Electron/"),
52 m_oPhotonValidationPlots(nullptr, "Photon/"),
53 m_oLRTElectronValidationPlots(nullptr, "LRTElectron/"),
54 m_acc_electronLLH_VeryLooseNoPix("DFCommonElectronsLHVeryLooseNoPix"),
55 m_acc_electronLLH_LooseNoPix("DFCommonElectronsLHLooseNoPix"),
56 m_acc_electronLLH_MediumNoPix("DFCommonElectronsLHMediumNoPix"),
57 m_acc_electronLLH_TightNoPix("DFCommonElectronsLHTightNoPix")
58{
59}
60
61// Athena algtool's Hooks
83
84StatusCode EgammaPhysValMonitoringTool::bookHistograms()
85{
86 ATH_MSG_INFO ("Booking hists " << name() << "...");
87
88 m_oElectronValidationPlots.initialize();
89 std::vector<HistData> hists = m_oElectronValidationPlots.retrieveBookedHistograms();
90 for (auto &hist : hists){
91 ATH_MSG_DEBUG ("Initializing " << hist.first << " " << hist.first->GetName() << " " << hist.second << "...");
92 ATH_CHECK(regHist(hist.first,hist.second,all));
93 }
94
95 m_oPhotonValidationPlots.initialize();
96 hists = m_oPhotonValidationPlots.retrieveBookedHistograms();
97 for (auto &hist : hists){
98 ATH_MSG_DEBUG ("Initializing " << hist.first << " " << hist.first->GetName() << " " << hist.second << "...");
99 ATH_CHECK(regHist(hist.first,hist.second,all));
100 }
101
102 m_oLRTElectronValidationPlots.initialize();
103 hists = m_oLRTElectronValidationPlots.retrieveBookedHistograms();
104 for (auto &hist : hists){
105 ATH_MSG_DEBUG ("Initializing " << hist.first << " " << hist.first->GetName() << " " << hist.second << "...");
106 ATH_CHECK(regHist(hist.first,hist.second,all));
107 }
108
109 return StatusCode::SUCCESS;
110}
111
112
113StatusCode EgammaPhysValMonitoringTool::fillHistograms(const EventContext& ctx)
114{
115 ATH_MSG_DEBUG("Filling hists " << name() << "...");
116
117 SG::ReadHandle<xAOD::EventInfo> eventInfo(m_EventInfoContainerKey, ctx);
118 ATH_CHECK(eventInfo.isValid());
119
120 float weight = eventInfo->beamSpotWeight();
121
122 if (m_isMC) {
123 SG::ReadHandle<xAOD::TruthParticleContainer> truthParticles =
124 SG::ReadHandle<xAOD::TruthParticleContainer>(m_egammaTruthContainerKey, ctx);
125
126 // filling truth iso (prompt) particles from egammaTruthParticles container
127 // (containing only iso particles)
128 // validity check is only really needed for serial running. Remove when MT
129 // is only way.
130 ATH_CHECK(truthParticles.isValid());
131
132 for (const auto* const truthParticle : *truthParticles) {
133
134 //--electrons
135 if (std::abs(truthParticle->pdgId()) == 11 &&
136 MC::isStable(truthParticle) && HepMC::generations(truthParticle) < 1) {
137 m_oElectronValidationPlots.m_oTruthIsoPlots.fill(*truthParticle,
138 *eventInfo);
139 } //-- end electrons
140
141 //--photons
142 if (std::abs(truthParticle->pdgId()) == 22 &&
143 MC::isStable(truthParticle) && HepMC::generations(truthParticle) < 1) {
144 m_oPhotonValidationPlots.m_oTruthIsoPlots.fill(*truthParticle,
145 *eventInfo);
146 //-- filling conversions
147 const xAOD::TruthParticle* tmp =
148 xAOD::TruthHelpers::getTruthParticle(*truthParticle); // 20.7.0.1
149 bool isTrueConv = false;
150 float trueR = -999;
151 float truthEta = -999;
152 if (tmp && tmp->hasDecayVtx()) {
153 float x = tmp->decayVtx()->x();
154 float y = tmp->decayVtx()->y();
155 trueR = std::sqrt(x * x + y * y);
156 }
157
158 if (tmp != nullptr) {
159 truthEta = tmp->eta();
160 isTrueConv = xAOD::EgammaHelpers::isTrueConvertedPhoton(tmp); // rel20
161 }
162
163 m_oPhotonValidationPlots.convTruthR->Fill(trueR, weight);
164 m_oPhotonValidationPlots.convTruthRvsEta->Fill(trueR, truthEta, weight);
165 if (isTrueConv)
166 m_oPhotonValidationPlots.m_oTruthIsoConvPlots.fill(*truthParticle,
167 *eventInfo);
168 if (!isTrueConv)
169 m_oPhotonValidationPlots.m_oTruthIsoUncPlots.fill(*truthParticle,
170 *eventInfo);
171
172 const xAOD::Photon* recoPhoton =
173 xAOD::EgammaHelpers::getRecoPhoton(truthParticle);
174 if (recoPhoton) {
175 m_oPhotonValidationPlots.convTruthMatchedR->Fill(trueR, weight);
176 m_oPhotonValidationPlots.convTruthMatchedRvsEta->Fill(
177 trueR, truthEta, weight);
178
179 m_oPhotonValidationPlots.m_oTruthRecoPlots.fill(*truthParticle,
180 *eventInfo);
181 if (isTrueConv) {
182 m_oPhotonValidationPlots.m_oTruthRecoConvPlots.fill(*truthParticle,
183 *eventInfo);
184 } else {
185 m_oPhotonValidationPlots.m_oTruthRecoUncPlots.fill(*truthParticle,
186 *eventInfo);
187 }
188 bool val_loose = false;
189 recoPhoton->passSelection(val_loose, "Loose");
190 if (val_loose) {
191 m_oPhotonValidationPlots.m_oTruthRecoLoosePlots.fill(*truthParticle,
192 *eventInfo);
193 if (isTrueConv) {
194 m_oPhotonValidationPlots.m_oTruthRecoLooseConvPlots.fill(
195 *truthParticle, *eventInfo);
196 } else {
197 m_oPhotonValidationPlots.m_oTruthRecoLooseUncPlots.fill(
198 *truthParticle, *eventInfo);
199 }
200 } //-- end truth loose
201 bool val_tight = false;
202 recoPhoton->passSelection(val_tight, "Tight");
203 if (val_tight) {
204 m_oPhotonValidationPlots.m_oTruthRecoTightPlots.fill(*truthParticle,
205 *eventInfo);
206 if (isTrueConv) {
207 m_oPhotonValidationPlots.m_oTruthRecoTightConvPlots.fill(
208 *truthParticle, *eventInfo);
209 } else {
210 m_oPhotonValidationPlots.m_oTruthRecoTightUncPlots.fill(
211 *truthParticle, *eventInfo);
212 }
213 } //-- end truth tight
214 } //-- end recoPhoton
215 } //-- end Photons
216 } // -- end fill histos iso particles
217
218 //---------Electrons----------------------
219 if (!fillRecoElecHistograms(truthParticles.ptr(), eventInfo.ptr())) {
220 ATH_MSG_ERROR("Filling reco elecectron hists failed " << name()
221 << "...");
222 return StatusCode::FAILURE;
223 }
224
225 //---------LRTElectrons----------------------
226 if(!m_lrtelectronContainerKey.empty()){
227 if (!fillLRTElecHistograms(truthParticles.ptr(), eventInfo.ptr())) {
228 ATH_MSG_ERROR("Filling lrt elecectron hists failed " << name() << "...");
229 return StatusCode::FAILURE;
230 }
231 }
232
233 //---------Frwd Electrons----------------------
234 if (!fillRecoFrwdElecHistograms(truthParticles.ptr(), eventInfo.ptr())) {
235 ATH_MSG_ERROR("Filling reco frwd elecectron hists failed " << name()
236 << "...");
237 return StatusCode::FAILURE;
238 }
239 //----------Photons
240 if (!fillRecoPhotHistograms(truthParticles.ptr(), eventInfo.ptr())) {
241 ATH_MSG_ERROR("Filling reco photon hists failed " << name() << "...");
242 return StatusCode::FAILURE;
243 }
244 } else // end is MC / code using truth particles
245 {//---------Electrons----------------------
246 if (!fillRecoElecHistograms(nullptr, eventInfo.ptr())) {
247 ATH_MSG_ERROR("Filling reco elecectron hists failed " << name()
248 << "...");
249 return StatusCode::FAILURE;
250 }
251 //---------Frwd Electrons----------------------
252 if (!fillRecoFrwdElecHistograms(nullptr, eventInfo.ptr())) {
253 ATH_MSG_ERROR("Filling reco frwd elecectron hists failed " << name()
254 << "...");
255 return StatusCode::FAILURE;
256 }
257 //----------Photons
258 if (!fillRecoPhotHistograms(nullptr, eventInfo.ptr())) {
259 ATH_MSG_ERROR("Filling reco photon hists failed " << name() << "...");
260 return StatusCode::FAILURE;
261 }
262
263 }
264
265
266
267 return StatusCode::SUCCESS;
268}
269
270StatusCode EgammaPhysValMonitoringTool::fillRecoElecHistograms(const xAOD::TruthParticleContainer* truthParticles, const xAOD::EventInfo* eventInfo)
271{
272 ATH_MSG_DEBUG ("Filling reco electron hists " << name() << "...");
273
274 const EventContext& ctx = Gaudi::Hive::currentContext();
275 SG::ReadHandle<xAOD::ElectronContainer> Electrons( m_electronContainerKey, ctx);
276 ATH_CHECK(Electrons.isValid());
277
278 int numofele=0;
279
280 float weight = eventInfo->beamSpotWeight();
281
282 for(const auto *const electron : *Electrons){
283 bool isElecPrompt=false;
284
285 if(!(electron->isGoodOQ (xAOD::EgammaParameters::BADCLUSELECTRON))) continue;
286
287 if(electron->author()&xAOD::EgammaParameters::AuthorElectron||
288 electron->author()&xAOD::EgammaParameters::AuthorAmbiguous) numofele++;
289
290 if(!m_isMC) m_oElectronValidationPlots.fill(*electron,*eventInfo,isElecPrompt);
291 else {
292 static const SG::ConstAccessor<int> truthTypeAcc ("truthType");
293 if(truthTypeAcc.isAvailable (*electron)) {
294 MCTruthPartClassifier::ParticleType type = (MCTruthPartClassifier::ParticleType) truthTypeAcc (*electron);
295 if(type==MCTruthPartClassifier::IsoElectron) {
296 isElecPrompt=true;
297 //fill energy scale
298 const xAOD::TruthParticle* thePart = xAOD::TruthHelpers::getTruthParticle(*electron); // 20.7.X.Y.I
299 if(thePart) {
300 float EtLin = (electron->pt()-thePart->pt())/thePart->pt();
301 m_oElectronValidationPlots.res_et->Fill(thePart->pt()/GeV,EtLin,weight);
302 m_oElectronValidationPlots.res_eta->Fill(thePart->eta(),EtLin,weight);
303 if (thePart->pt()/GeV>20.) {
304 m_oElectronValidationPlots.res_et_cut->Fill(thePart->pt()/GeV,EtLin,weight);
305 m_oElectronValidationPlots.res_eta_cut->Fill(thePart->eta(),EtLin,weight);
306 m_oElectronValidationPlots.res_et_cut_pt_20->Fill(thePart->pt()/GeV,EtLin,weight);
307 m_oElectronValidationPlots.res_eta_cut_pt_20->Fill(thePart->eta(),EtLin,weight);
308 }
309 m_oElectronValidationPlots.matrix->Fill(electron->pt()/GeV,thePart->pt()/GeV);
310 } else {
311 ATH_MSG_INFO ("Truth particle associated not in egamma truth collection");
312 }
313 }
314
315 } else if(m_isMC){ if(Match(electron,11, truthParticles)!=nullptr ) isElecPrompt=true;}
316
317 m_oElectronValidationPlots.fill(*electron,*eventInfo,isElecPrompt);
318 }
319 }
320 m_oElectronValidationPlots.m_oCentralElecPlots.nParticles->Fill(numofele);
321 m_oElectronValidationPlots.m_oCentralElecPlots.nParticles_weighted->Fill(numofele,weight);
322
323 return StatusCode::SUCCESS;
324}
325
326StatusCode EgammaPhysValMonitoringTool::fillLRTElecHistograms(const xAOD::TruthParticleContainer* truthParticles, const xAOD::EventInfo* eventInfo)
327{
328 ATH_MSG_DEBUG ("Filling lrt electron hists " << name() << "...");
329
330 const EventContext& ctx = Gaudi::Hive::currentContext();
331 SG::ReadHandle<xAOD::ElectronContainer> LRTElectrons( m_lrtelectronContainerKey, ctx);
332 ATH_CHECK(LRTElectrons.isValid());
333
334 int numofele=0;
335
336 float weight = eventInfo->beamSpotWeight();
337 static const SG::ConstAccessor<int> truthTypeAcc ("truthType");
338 for(const auto *const electron : *LRTElectrons){
339 bool isElecPrompt=false;
340
341 if(!(electron->isGoodOQ (xAOD::EgammaParameters::BADCLUSELECTRON))) continue;
342
343 // Retrieve electron ID, compute on-the-fly if decoration is missing (for AODs)
344 bool pass_LHVeryLooseNoPix = false;
345 if (m_acc_electronLLH_VeryLooseNoPix.isAvailable(*electron)) electron->passSelection(pass_LHVeryLooseNoPix, "DFCommonElectronsLHVeryLooseNoPix");
346 else pass_LHVeryLooseNoPix = static_cast<bool>(m_Electron_VeryLooseNoPix_LLHTool->accept(electron));
347
348 bool pass_LHLooseNoPix = false;
349 if (m_acc_electronLLH_LooseNoPix.isAvailable(*electron)) electron->passSelection(pass_LHLooseNoPix, "DFCommonElectronsLHLooseNoPix");
350 else pass_LHLooseNoPix = static_cast<bool>(m_Electron_LooseNoPix_LLHTool->accept(electron));
351
352 bool pass_LHMediumNoPix = false;
353 if (m_acc_electronLLH_MediumNoPix.isAvailable(*electron)) electron->passSelection(pass_LHMediumNoPix, "DFCommonElectronsLHMediumNoPix");
354 else pass_LHMediumNoPix = static_cast<bool>(m_Electron_MediumNoPix_LLHTool->accept(electron));
355
356 bool pass_LHTightNoPix = false;
357 if (m_acc_electronLLH_TightNoPix.isAvailable(*electron)) electron->passSelection(pass_LHTightNoPix, "DFCommonElectronsLHTightNoPix");
358 else pass_LHTightNoPix = static_cast<bool>(m_Electron_TightNoPix_LLHTool->accept(electron));
359
360
361 if(truthTypeAcc.isAvailable(*electron)) {
362 MCTruthPartClassifier::ParticleType type = (MCTruthPartClassifier::ParticleType) truthTypeAcc(*electron);
363 if(type==MCTruthPartClassifier::IsoElectron) {
364 isElecPrompt=true;
365 //fill energy scale
366 const xAOD::TruthParticle* thePart = xAOD::TruthHelpers::getTruthParticle(*electron); // 20.7.X.Y.I
367 if(thePart) {
368 float EtLin = (electron->pt()-thePart->pt())/thePart->pt();
369 m_oLRTElectronValidationPlots.res_et->Fill(thePart->pt()/GeV,EtLin,weight);
370 m_oLRTElectronValidationPlots.res_eta->Fill(thePart->eta(),EtLin,weight);
371 if (thePart->pt()/GeV>20.) {
372 m_oLRTElectronValidationPlots.res_et_cut->Fill(thePart->pt()/GeV,EtLin,weight);
373 m_oLRTElectronValidationPlots.res_eta_cut->Fill(thePart->eta(),EtLin,weight);
374 m_oLRTElectronValidationPlots.res_et_cut_pt_20->Fill(thePart->pt()/GeV,EtLin,weight);
375 m_oLRTElectronValidationPlots.res_eta_cut_pt_20->Fill(thePart->eta(),EtLin,weight);
376 }
377 m_oLRTElectronValidationPlots.matrix->Fill(electron->pt()/GeV,thePart->pt()/GeV);
378 }else {
379 ATH_MSG_INFO ("Truth particle associated not in egamma truth collection");
380 }
381 }
382 } else if(m_isMC){ if(Match(electron,11, truthParticles)!=nullptr ) isElecPrompt=true;}
383
384
385 m_oLRTElectronValidationPlots.fill(*electron,*eventInfo, isElecPrompt, pass_LHVeryLooseNoPix, pass_LHLooseNoPix, pass_LHMediumNoPix, pass_LHTightNoPix);
386 if(electron->author()&xAOD::EgammaParameters::AuthorElectron||
387 electron->author()&xAOD::EgammaParameters::AuthorAmbiguous) numofele++;
388
389 }
390
391 m_oLRTElectronValidationPlots.m_oCentralElecPlots.nParticles->Fill(numofele);
392 m_oLRTElectronValidationPlots.m_oCentralElecPlots.nParticles_weighted->Fill(numofele,weight);
393
394 return StatusCode::SUCCESS;
395}
396
397StatusCode EgammaPhysValMonitoringTool::fillRecoFrwdElecHistograms(const xAOD::TruthParticleContainer* truthParticles, const xAOD::EventInfo* eventInfo)
398{
399 ATH_MSG_DEBUG ("Filling reco frwd electron hists " << name() << "...");
400
401 const EventContext& ctx = Gaudi::Hive::currentContext();
402 SG::ReadHandle<xAOD::ElectronContainer> ElectronsFrwd( m_electronContainerFrwdKey, ctx);
403 ATH_CHECK(ElectronsFrwd.isValid());
404
405 int numoffrwdele=0;
406 float weight = eventInfo->beamSpotWeight();
407
408 for(const auto *const frwdelectron : *ElectronsFrwd){
409 if(!(frwdelectron->isGoodOQ (xAOD::EgammaParameters::BADCLUSELECTRON))) continue;
410 bool isElecPrompt=false;
411 if (m_isMC) {
412 if((Match(frwdelectron,11, truthParticles)!=nullptr )) isElecPrompt=true;
413 }
414 m_oElectronValidationPlots.fill(*frwdelectron,*eventInfo,isElecPrompt);
415 numoffrwdele++;
416 isElecPrompt=false;
417 }
418
419 m_oElectronValidationPlots.m_oFrwdElecPlots.nParticles->Fill(numoffrwdele);
420 m_oElectronValidationPlots.m_oFrwdElecPlots.nParticles_weighted->Fill(numoffrwdele,weight);
421
422 return StatusCode::SUCCESS;
423}
424
425StatusCode EgammaPhysValMonitoringTool::fillRecoPhotHistograms(const xAOD::TruthParticleContainer* truthParticles, const xAOD::EventInfo* eventInfo)
426{
427 ATH_MSG_DEBUG ("Filling reco photon hists " << name() << "...");
428
429 const EventContext& ctx = Gaudi::Hive::currentContext();
430 SG::ReadHandle<xAOD::PhotonContainer> Photons( m_photonContainerKey, ctx);
431 ATH_CHECK(Photons.isValid());
432
433 int numofPhot=0;
434 int numofAmb=0;
435 int numPhotAll=0;
436 int numofCnv=0;
437 float weight = eventInfo->beamSpotWeight();
438
439 for(const auto *photon : *Photons){
440 bool isPhotPrompt=false;
441 if (photon->author()&xAOD::EgammaParameters::AuthorCaloTopo35) continue;//21.0.>7
442 if(!(photon->isGoodOQ (xAOD::EgammaParameters::BADCLUSPHOTON))) continue;
443 if (m_useOQQuality) {
444 if (!PhotonHelpers::passOQquality(*photon)) continue;
445 }
446
447 if(photon->author()) numofPhot++;
448 else if(photon->author()&xAOD::EgammaParameters::AuthorAmbiguous) numofAmb++;
449 if(xAOD::EgammaHelpers::isConvertedPhoton(photon)) numofCnv++;
450 if(!m_isMC) m_oPhotonValidationPlots.fill(*photon,*eventInfo, isPhotPrompt);
451 else {
452 static const SG::ConstAccessor<int> truthTypeAcc ("truthType");
453 if(truthTypeAcc.isAvailable(*photon)) {
454 MCTruthPartClassifier::ParticleType type = (MCTruthPartClassifier::ParticleType) truthTypeAcc(*photon);
455 if(type==MCTruthPartClassifier::IsoPhoton) {
456 isPhotPrompt=true;
457 //fill energy scale
458 const xAOD::TruthParticle* thePart = xAOD::TruthHelpers::getTruthParticle(*photon);//20.7.X.Y.I
459 // const xAOD::TruthParticle* thePart = xAOD::EgammaHelpers::getTruthParticle(photon);
460 if(thePart&&thePart->pt()/GeV>20.) {
461 float EtLin = (photon->pt()-thePart->pt())/thePart->pt();
462 m_oPhotonValidationPlots.res_et->Fill(thePart->pt()/GeV,EtLin,weight);
463 m_oPhotonValidationPlots.res_eta->Fill(thePart->eta(),EtLin,weight);
464 if (std::abs(EtLin)<0.2){
465 m_oPhotonValidationPlots.res_et_cut->Fill(thePart->pt()/GeV,EtLin,weight);
466 m_oPhotonValidationPlots.res_eta_cut->Fill(thePart->eta(),EtLin,weight);
467 }
468 }else {
469 ATH_MSG_INFO("Truth particle associated not in egamma truth collection");
470 }
471 }
472
473 } else if(m_isMC){if(Match(photon,22, truthParticles)!=nullptr ) isPhotPrompt=true;}
474
475 m_oPhotonValidationPlots.fill(*photon,*eventInfo, isPhotPrompt);
476
477 }
478 }
479 numPhotAll = numofPhot+numofAmb;
480 m_oPhotonValidationPlots.m_oAllPlots.m_nParticles->Fill(numPhotAll);
481 m_oPhotonValidationPlots.m_oPhotPlots.m_nParticles->Fill(numofPhot);
482 m_oPhotonValidationPlots.m_oAmbPhotPlots.m_nParticles->Fill(numofAmb);
483 m_oPhotonValidationPlots.m_oConvPhotPlots.m_nParticles->Fill(numofCnv);
484
485 m_oPhotonValidationPlots.m_oAllPlots.m_nParticles_weighted->Fill(numPhotAll,weight);
486 m_oPhotonValidationPlots.m_oPhotPlots.m_nParticles_weighted->Fill(numofPhot,weight);
487 m_oPhotonValidationPlots.m_oAmbPhotPlots.m_nParticles_weighted->Fill(numofAmb,weight);
488 m_oPhotonValidationPlots.m_oConvPhotPlots.m_nParticles_weighted->Fill(numofCnv,weight);
489
490
491 return StatusCode::SUCCESS;
492}
493
494StatusCode EgammaPhysValMonitoringTool::procHistograms()
495 {
496 ATH_MSG_INFO ("Finalising hists " << name() << "...");
497 m_oElectronValidationPlots.finalize();
498 m_oPhotonValidationPlots.finalize();
499 return StatusCode::SUCCESS;
500 }
501
502const xAOD::TruthParticle* EgammaPhysValMonitoringTool::Match(const xAOD::Egamma* particle,
503 int pdg,
504 const xAOD::TruthParticleContainer* truthParticles) {
505 float currentdr = 0.05;
506 const xAOD::TruthParticle* matchedTruthParticle = nullptr;
507 if (truthParticles){
508 for (const auto *truthParticle: *truthParticles){
509 if (std::abs(truthParticle->pdgId()) != pdg || !MC::isStable(truthParticle)) continue;
510 float dr = particle->p4().DeltaR(truthParticle->p4());
511 if (dr < currentdr){
512 currentdr = dr;
513 matchedTruthParticle = truthParticle;
514 }
515 }
516 }
517 return matchedTruthParticle;
518}
519
520
521}
522
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition AthMsgStreamMacros.h:33
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition AthMsgStreamMacros.h:31
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
ConstAccessor.h
Helper class to provide constant type-safe access to aux data.
HepMCHelpers.h
ATLAS-specific HepMC functions.
ReadHandle.h
Handle class for reading from StoreGate.
y
#define y
x
#define x
EgammaPhysValMonitoring::EgammaPhysValMonitoringTool::m_truthParticleContainerKey
SG::ReadHandleKey< xAOD::TruthParticleContainer > m_truthParticleContainerKey
Definition EgammaPhysValMonitoringTool.h:105
EgammaPhysValMonitoring::EgammaPhysValMonitoringTool::m_acc_electronLLH_VeryLooseNoPix
SG::AuxElement::ConstAccessor< char > m_acc_electronLLH_VeryLooseNoPix
Definition EgammaPhysValMonitoringTool.h:149
EgammaPhysValMonitoring::EgammaPhysValMonitoringTool::fillRecoPhotHistograms
StatusCode fillRecoPhotHistograms(const xAOD::TruthParticleContainer *truthParticles, const xAOD::EventInfo *eventInfo)
Definition EgammaPhysValMonitoringTool.cxx:425
EgammaPhysValMonitoring::EgammaPhysValMonitoringTool::fillRecoElecHistograms
StatusCode fillRecoElecHistograms(const xAOD::TruthParticleContainer *truthParticles, const xAOD::EventInfo *eventInfo)
Definition EgammaPhysValMonitoringTool.cxx:270
EgammaPhysValMonitoring::EgammaPhysValMonitoringTool::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx)
An inheriting class should either override this function or fillHists().
Definition EgammaPhysValMonitoringTool.cxx:113
EgammaPhysValMonitoring::EgammaPhysValMonitoringTool::Match
static const xAOD::TruthParticle * Match(const xAOD::Egamma *particle, int pdg, const xAOD::TruthParticleContainer *truthParticles)
Definition EgammaPhysValMonitoringTool.cxx:502
EgammaPhysValMonitoring::EgammaPhysValMonitoringTool::m_electronContainerKey
SG::ReadHandleKey< xAOD::ElectronContainer > m_electronContainerKey
Definition EgammaPhysValMonitoringTool.h:99
EgammaPhysValMonitoring::EgammaPhysValMonitoringTool::m_Electron_LooseNoPix_LLHTool
ToolHandle< IAsgElectronLikelihoodTool > m_Electron_LooseNoPix_LLHTool
Definition EgammaPhysValMonitoringTool.h:127
EgammaPhysValMonitoring::EgammaPhysValMonitoringTool::m_photonContainerKey
SG::ReadHandleKey< xAOD::PhotonContainer > m_photonContainerKey
Definition EgammaPhysValMonitoringTool.h:97
EgammaPhysValMonitoring::EgammaPhysValMonitoringTool::EgammaPhysValMonitoringTool
EgammaPhysValMonitoringTool()=delete
Default constructor:
EgammaPhysValMonitoring::EgammaPhysValMonitoringTool::m_acc_electronLLH_MediumNoPix
SG::AuxElement::ConstAccessor< char > m_acc_electronLLH_MediumNoPix
Definition EgammaPhysValMonitoringTool.h:151
EgammaPhysValMonitoring::EgammaPhysValMonitoringTool::m_Electron_TightNoPix_LLHTool
ToolHandle< IAsgElectronLikelihoodTool > m_Electron_TightNoPix_LLHTool
Definition EgammaPhysValMonitoringTool.h:141
EgammaPhysValMonitoring::EgammaPhysValMonitoringTool::m_Electron_MediumNoPix_LLHTool
ToolHandle< IAsgElectronLikelihoodTool > m_Electron_MediumNoPix_LLHTool
Definition EgammaPhysValMonitoringTool.h:134
EgammaPhysValMonitoring::EgammaPhysValMonitoringTool::fillRecoFrwdElecHistograms
StatusCode fillRecoFrwdElecHistograms(const xAOD::TruthParticleContainer *truthParticles, const xAOD::EventInfo *eventInfo)
Definition EgammaPhysValMonitoringTool.cxx:397
EgammaPhysValMonitoring::EgammaPhysValMonitoringTool::m_electronContainerFrwdKey
SG::ReadHandleKey< xAOD::ElectronContainer > m_electronContainerFrwdKey
Definition EgammaPhysValMonitoringTool.h:103
EgammaPhysValMonitoring::EgammaPhysValMonitoringTool::fillLRTElecHistograms
StatusCode fillLRTElecHistograms(const xAOD::TruthParticleContainer *truthParticles, const xAOD::EventInfo *eventInfo)
Definition EgammaPhysValMonitoringTool.cxx:326
EgammaPhysValMonitoring::EgammaPhysValMonitoringTool::procHistograms
virtual StatusCode procHistograms()
An inheriting class should either override this function or finalHists().
Definition EgammaPhysValMonitoringTool.cxx:494
EgammaPhysValMonitoring::EgammaPhysValMonitoringTool::m_acc_electronLLH_TightNoPix
SG::AuxElement::ConstAccessor< char > m_acc_electronLLH_TightNoPix
Definition EgammaPhysValMonitoringTool.h:152
EgammaPhysValMonitoring::EgammaPhysValMonitoringTool::bookHistograms
virtual StatusCode bookHistograms()
An inheriting class should either override this function or bookHists().
Definition EgammaPhysValMonitoringTool.cxx:84
EgammaPhysValMonitoring::EgammaPhysValMonitoringTool::m_Electron_VeryLooseNoPix_LLHTool
ToolHandle< IAsgElectronLikelihoodTool > m_Electron_VeryLooseNoPix_LLHTool
Definition EgammaPhysValMonitoringTool.h:120
EgammaPhysValMonitoring::EgammaPhysValMonitoringTool::m_lrtelectronContainerKey
SG::ReadHandleKey< xAOD::ElectronContainer > m_lrtelectronContainerKey
Definition EgammaPhysValMonitoringTool.h:101
EgammaPhysValMonitoring::EgammaPhysValMonitoringTool::m_egammaTruthContainerKey
SG::ReadHandleKey< xAOD::TruthParticleContainer > m_egammaTruthContainerKey
Definition EgammaPhysValMonitoringTool.h:107
EgammaPhysValMonitoring::EgammaPhysValMonitoringTool::m_acc_electronLLH_LooseNoPix
SG::AuxElement::ConstAccessor< char > m_acc_electronLLH_LooseNoPix
Definition EgammaPhysValMonitoringTool.h:150
ManagedMonitorToolBase::regHist
virtual StatusCode regHist(TH1 *h, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical ...
Definition ManagedMonitorToolBase.cxx:1345
ManagedMonitorToolBase::ManagedMonitorToolBase
ManagedMonitorToolBase(const std::string &type, const std::string &name, const IInterface *parent)
Definition ManagedMonitorToolBase.cxx:339
SG::ConstAccessor
Helper class to provide constant type-safe access to aux data.
Definition ConstAccessor.h:55
SG::ConstAccessor::isAvailable
bool isAvailable(const ELT &e) const
Test to see if this variable exists in the store.
SG::ReadHandle::ptr
const_pointer_type ptr()
Dereference the pointer.
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
xAOD::Egamma_v1::passSelection
bool passSelection(bool &value, const std::string &menu) const
Check if the egamma object pass a selection menu (using the name) If the menu decision is stored in t...
xAOD::EventInfo_v1::beamSpotWeight
float beamSpotWeight() const
Weight for beam spot size reweighting.
Definition EventInfo_v1.cxx:970
xAOD::TruthParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition TruthParticle_v1.cxx:161
xAOD::TruthParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition TruthParticle_v1.cxx:169
HepMC::generations
int generations(const T &p)
Method to return how many interactions a particle has undergone during simulation (TODO migrate to be...
Definition MagicNumbers.h:325
MC::isStable
bool isStable(const T &p)
Identify if the particle is stable, i.e. has not decayed.
Definition HepMCHelpers.h:46
PhotonHelpers::passOQquality
bool passOQquality(const xAOD::Photon &ph)
Helper to ease the implemmantation of the pass Quality requirements.
Definition PhotonHelpers.cxx:12
std
STL namespace.
xAOD::EgammaHelpers::isConvertedPhoton
bool isConvertedPhoton(const xAOD::Egamma *eg, bool excludeTRT=false)
is the object a converted photon
Definition EgammaxAODHelpers.cxx:25
xAOD::EgammaHelpers::isTrueConvertedPhoton
bool isTrueConvertedPhoton(const xAOD::Photon *ph, float maxRadius=800.)
is the object matched to a true converted photon with R < maxRadius
Definition EgammaTruthxAODHelpers.cxx:69
xAOD::EgammaHelpers::getRecoPhoton
const xAOD::Photon * getRecoPhoton(const xAOD::TruthParticle *particle)
return the reco photon associated to the given TruthParticle (if any)
Definition EgammaTruthxAODHelpers.cxx:54
xAOD::EgammaParameters::BADCLUSELECTRON
const uint32_t BADCLUSELECTRON
Definition EgammaDefs.h:116
xAOD::EgammaParameters::AuthorCaloTopo35
const uint16_t AuthorCaloTopo35
Photon reconstructed by SW CaloTopo35 seeded clusters.
Definition EgammaDefs.h:38
xAOD::EgammaParameters::AuthorElectron
const uint16_t AuthorElectron
Object Reconstructed by standard cluster-based algorithm.
Definition EgammaDefs.h:24
xAOD::EgammaParameters::BADCLUSPHOTON
const uint32_t BADCLUSPHOTON
Definition EgammaDefs.h:124
xAOD::EgammaParameters::AuthorAmbiguous
const uint16_t AuthorAmbiguous
Object Reconstructed by standard cluster-based algorithm.
Definition EgammaDefs.h:32
xAOD::TruthHelpers::getTruthParticle
const xAOD::TruthParticle * getTruthParticle(const xAOD::IParticle &p)
Return the truthParticle associated to the given IParticle (if any).
Definition xAODTruthHelpers.cxx:25
xAOD::EventInfo
EventInfo_v1 EventInfo
Definition of the latest event info version.
Definition IEventInfoCnvTool.h:16
xAOD::Egamma
Egamma_v1 Egamma
Definition of the current "egamma version".
Definition Egamma.h:17
xAOD::TruthParticle
TruthParticle_v1 TruthParticle
Typedef to implementation.
Definition Event/xAOD/xAODTruth/xAODTruth/TruthParticle.h:15
xAOD::Photon
Photon_v1 Photon
Definition of the current "egamma version".
Definition Event/xAOD/xAODEgamma/xAODEgamma/Photon.h:17
xAOD::TruthParticleContainer
TruthParticleContainer_v1 TruthParticleContainer
Declare the latest version of the truth particle container.
Definition Event/xAOD/xAODTruth/xAODTruth/TruthParticleContainer.h:17
Generated on for ATLAS Offline Software by doxygen 1.17.0