ATLAS Offline Software
Loading...
Searching...
No Matches
METTruthAssociator.cxx
Go to the documentation of this file.
1
2
3/*
4 Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
5*/
6
7// METTruthAssociator.cxx
8// Implementation file for class METTruthAssociator
9//
10// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
11//
12// Author: P Loch, S Resconi, TJ Khoo, AS Mete, MA Klein
14
15// METReconstruction includes
16#include "METReconstruction/METTruthAssociator.h"
17
18// xAOD EDM
19#include "xAODMissingET/MissingETComposition.h"
20#include "xAODJet/JetContainer.h"
21#include "xAODMuon/MuonContainer.h"
22#include "xAODEgamma/ElectronContainer.h"
23#include "xAODEgamma/PhotonContainer.h"
24#include "xAODTau/TauJetContainer.h"
25#include "xAODTruth/TruthEventContainer.h"
26#include "AthContainers/ConstDataVector.h"
27
28// Helpers
29#include "xAODEgamma/EgammaxAODHelpers.h"
30//#include "xAODEgamma/EgammaTruthxAODHelpers.h"
31#include "xAODTruth/xAODTruthHelpers.h"
32#include "TruthUtils/HepMCHelpers.h"
33
34// DeltaR calculation
35#include "FourMomUtils/xAODP4Helpers.h"
36
37namespace met {
38
39 using namespace xAOD;
40
41 static const SG::AuxElement::ConstAccessor<std::vector<ElementLink<IParticleContainer> > > cacc_ghosttruth("GhostTruth");
42
43 // Constructors
49
50 // Destructor
52 METTruthAssociator::~METTruthAssociator()
53 = default;
54
55 // Athena algtool's Hooks
57 StatusCode METTruthAssociator::initialize()
58 {
59 ATH_CHECK( METAssociator::initialize() );
60 ATH_MSG_VERBOSE ("Initializing " << name() << "...");
61 //initialise ReadHandleKeys
62 ATH_CHECK( m_recoElKey.initialize());
63 ATH_CHECK( m_recoJetKey.initialize());
64 ATH_CHECK( m_recoMuKey.initialize());
65 ATH_CHECK( m_recoGamKey.initialize());
66 ATH_CHECK( m_recoTauKey.initialize());
67 ATH_CHECK( m_truthEventKey.initialize());
68
69 return StatusCode::SUCCESS;
70 }
71
72 StatusCode METTruthAssociator::finalize()
73 {
74 ATH_MSG_VERBOSE ("Finalizing " << name() << "...");
75 return StatusCode::SUCCESS;
76 }
77
78 // executeTool
80 StatusCode METTruthAssociator::executeTool(xAOD::MissingETContainer* metCont, xAOD::MissingETAssociationMap* metMap) const
81 {
82 ATH_MSG_VERBOSE ("In execute: " << name() << "...");
83
84 ATH_CHECK( associateJets(metMap) );
85
86 SG::ReadHandle<xAOD::ElectronContainer> electronCont(m_recoElKey);
87 if (!electronCont.isValid()) {
88 ATH_MSG_WARNING("Unable to retrieve input electron container " << m_recoElKey.key());
89 return StatusCode::FAILURE;
90 }
91
92 ATH_MSG_DEBUG("Successfully retrieved electron collection");
93 if(fillAssocMap(metMap,electronCont.cptr()).isFailure()) {
94 ATH_MSG_WARNING("Unable to fill map with electron container " << m_recoElKey.key());
95 return StatusCode::FAILURE;
96 }
97
98 SG::ReadHandle<xAOD::PhotonContainer> photonCont(m_recoGamKey);
99 if (!photonCont.isValid()) {
100 ATH_MSG_WARNING("Unable to retrieve input photon container " << m_recoGamKey.key());
101 return StatusCode::FAILURE;
102 }
103
104 ATH_MSG_DEBUG("Successfully retrieved photon collection");
105 if(fillAssocMap(metMap,photonCont.cptr()).isFailure()) {
106 ATH_MSG_WARNING("Unable to fill map with photon container " << m_recoGamKey.key());
107 return StatusCode::FAILURE;
108 }
109
110 SG::ReadHandle<xAOD::MuonContainer> muonCont(m_recoMuKey);
111 if (!muonCont.isValid()) {
112 ATH_MSG_WARNING("Unable to retrieve input muon container " << m_recoMuKey.key());
113 return StatusCode::FAILURE;
114 }
115
116 ATH_MSG_DEBUG("Successfully retrieved muon collection");
117 if(fillAssocMap(metMap,muonCont.cptr()).isFailure()) {
118 ATH_MSG_WARNING("Unable to fill map with muon container " << m_recoMuKey.key());
119 return StatusCode::FAILURE;
120 }
121
122 SG::ReadHandle<xAOD::TauJetContainer> tauCont(m_recoTauKey);
123 if (!tauCont.isValid()) {
124 ATH_MSG_WARNING("Unable to retrieve input tau container " << m_recoTauKey.key());
125 return StatusCode::FAILURE;
126 }
127 ATH_MSG_DEBUG("Successfully retrieved tau collection");
128 if(fillAssocMap(metMap,tauCont.cptr()).isFailure()) {
129 ATH_MSG_WARNING("Unable to fill map with tau container " << m_recoTauKey.key());
130 return StatusCode::FAILURE;
131 }
132
133 if( computeSoftTerms(metCont,metMap).isFailure() ) {
134 ATH_MSG_WARNING("Unable to build truth core soft terms.");
135 return StatusCode::FAILURE;
136 }
137
138 return StatusCode::SUCCESS;
139 }
140
141 //*********************************************************************************************************
142 // Build jet and soft contributions
143
144 StatusCode METTruthAssociator::associateJets(xAOD::MissingETAssociationMap* metMap) const
145 {
146 // Retrieve the jet container
147 SG::ReadHandle<xAOD::JetContainer> jetCont(m_recoJetKey);
148 if (!jetCont.isValid()) {
149 ATH_MSG_WARNING("Unable to retrieve input jet container " << m_recoJetKey.key());
150 return StatusCode::FAILURE;
151 }
152 ATH_MSG_DEBUG("Successfully retrieved jet collection");
153
154 // Create jet associations
155 std::vector<const IParticle*> chargedTruth;
156 std::vector<const IParticle*> jetTruth;
157 std::vector<ElementLink<IParticleContainer> > jetconst;
158 jetTruth.reserve(20);
159 for(const auto *const jet : *jetCont) {
160 jetTruth.clear();
161 jetconst.clear();
162 MissingETBase::Types::constvec_t trkvec;
163 MissingETBase::Types::constvec_t truthvec;
164 if(!cacc_ghosttruth.isAvailable(*jet)) {
165 ATH_MSG_WARNING("Failed to extract ghost truth particles from jet");
166 } else {
167 for (const auto& el : cacc_ghosttruth(*jet)) {
168 if(el.isValid()) {
169 const xAOD::TruthParticle *truth = static_cast<const xAOD::TruthParticle*>(*el);
170 ATH_MSG_VERBOSE("Jet contains truth particle " << truth);
171 if(fabs(truth->charge())>1e-6) {
172 trkvec += *truth;
173 }
174 if(!truth->isMuon()) {
175 jetconst.push_back(el);
176 jetTruth.push_back(truth);
177 truthvec += *truth;
178 }
179 }
180 }
181 }
182
183 MissingETComposition::add(metMap,jet,jetconst,trkvec);
184 MissingETComposition::insert(metMap,jet,jet,jetTruth);
185 ATH_MSG_VERBOSE("Added association " << metMap->findIndex(jet) << " pointing to jet " << jet);
186 ATH_MSG_VERBOSE("Jet pt, eta, phi = " << jet->pt() << ", " << jet->eta() << "," << jet->phi() );
187 ATH_MSG_VERBOSE("Jet truthvec pt = " << truthvec.cpt() );
188 ATH_MSG_VERBOSE("Jet trkvec pt = " << trkvec.cpt() );
189 }
190
191 MissingETComposition::addMiscAssociation(metMap);
192 ATH_MSG_DEBUG("Added miscellaneous association");
193
194 return StatusCode::SUCCESS;
195 }
196
197 StatusCode METTruthAssociator::computeSoftTerms(xAOD::MissingETContainer* metCont, xAOD::MissingETAssociationMap* metMap) const
198 {
199 // Add MET terms to the container
200 // Always do this in order that the terms exist even if the method fails
201 MissingET* metCoreAllTruth = new MissingET(0.,0.,0.,"SoftTruthAllCore",MissingETBase::Source::softEvent() | MissingETBase::Source::truthInt() | MissingETBase::Source::Category::Calo);
202 metCont->push_back(metCoreAllTruth);
203 MissingET* metCoreChargedTruth = new MissingET(0.,0.,0.,"SoftTruthChargedCore",MissingETBase::Source::softEvent() | MissingETBase::Source::truthInt() | MissingETBase::Source::Category::ID);
204 metCont->push_back(metCoreChargedTruth);
205 MissingET* metCoreChargedCentralTruth = new MissingET(0.,0.,0.,"SoftTruthChargedCentralCore",MissingETBase::Source::softEvent() | MissingETBase::Source::truthInt(MissingETBase::Source::Region::Central) | MissingETBase::Source::Category::ID);
206 metCont->push_back(metCoreChargedCentralTruth);
207
208 ATH_MSG_VERBOSE("Added core terms.");
209
210 // Retrieve the truth container
211 SG::ReadHandle<xAOD::TruthEventContainer> truthEventCont(m_truthEventKey);
212 if (!truthEventCont.isValid()) {
213 ATH_MSG_WARNING("Unable to retrieve input truthEvent container " << m_truthEventKey.key());
214 return StatusCode::FAILURE;
215 }
216
217 // First truth event is the hard scatter
218 const TruthEvent* hsevent = truthEventCont->front();
219 ConstDataVector<TruthParticleContainer> truthParticleCont(SG::VIEW_ELEMENTS);
220 for(size_t itp=0; itp<hsevent->nTruthParticles(); ++itp) {
221 const xAOD::TruthParticle* tp = hsevent->truthParticle(itp);
222 if(tp) {
223 truthParticleCont.push_back(tp);
224 ATH_MSG_VERBOSE("Extracted truth particle with index " << tp->index() );
225 }
226 }
227
228 const IParticleContainer* uniqueTruth = metMap->getUniqueSignals(truthParticleCont.asDataVector(),MissingETBase::UsageHandler::TruthParticle);
229 ATH_MSG_VERBOSE("Extracted " << uniqueTruth->size() << "/" << truthParticleCont.size()
230 << " unique truth particles.");
231 for(const auto *const part : *uniqueTruth) {
232 const xAOD::TruthParticle* truth = static_cast<const xAOD::TruthParticle*>(part);
233 // stable
234 if(!truth->isGenStable()) continue;
235 // interacting
236 if(!MC::isInteracting(truth->pdgId())) continue;
237 if(truth->pt()<1 || fabs(truth->eta())>5) continue;
238 ATH_MSG_VERBOSE("Accepted soft truth particle with pt " << truth->pt()
239 << " status " << truth->status()
240 << " pdgId " << truth->pdgId() );
241 if(fabs(truth->charge())>1e-6) {
242 // in ID acceptance
243 if(fabs(truth->eta())<2.5) *metCoreChargedCentralTruth += truth;
244 *metCoreChargedTruth += truth;
245 }
246 if(!truth->isMuon()) *metCoreAllTruth += truth;
247 }
248 delete uniqueTruth;
249 return StatusCode::SUCCESS;
250 }
251
252 //*********************************************************************************************************
253 // Get constituents
254 StatusCode METTruthAssociator::extractTruthParticles(const xAOD::IParticle* obj,
255 std::vector<const xAOD::IParticle*>& truthlist) const
256 {
257 switch(obj->type()) {
258 case xAOD::Type::Electron:
259 return extractTruthFromElectron(obj,truthlist);
260 case xAOD::Type::Photon:
261 return extractTruthFromPhoton(obj,truthlist);
262 case xAOD::Type::Muon:
263 return extractTruthFromMuon(obj,truthlist);
264 case xAOD::Type::Tau:
265 return extractTruthFromTau(obj,truthlist);
266 default:
267 ATH_MSG_WARNING("Invalid object type " << obj->type() << " passed to extractTruthParticle");
268 break;
269 }
270
271 return StatusCode::FAILURE;
272 }
273
274 StatusCode METTruthAssociator::extractTruthFromElectron(const xAOD::IParticle* obj,
275 std::vector<const xAOD::IParticle*>& truthlist) const
276 {
277 const xAOD::Electron* el = static_cast<const xAOD::Electron*>(obj);
278 // El --> TruthParticles
279 const xAOD::TruthParticle* eltruth = TruthHelpers::getTruthParticle( *el );
280 if(eltruth && eltruth->isGenStable())
281 truthlist.push_back(eltruth);
282
283 // for(size_t iTrk=0; iTrk<el->nTrackParticles(); ++iTrk) {
284 // const TrackParticle* eltrk = EgammaHelpers::getOriginalTrackParticleFromGSF(el->trackParticle(iTrk));
285 // const xAOD::IParticle* truth(0);
286 // if(eltrk) truth = TruthHelpers::getTruthParticle( *eltrk );
287 // if(truth && truth!=eltruth) truthlist.push_back(truth);
288 // }
289
290 // Retrieve the truth container
291 SG::ReadHandle<xAOD::TruthEventContainer> truthEventCont(m_truthEventKey);
292 if (!truthEventCont.isValid()) {
293 ATH_MSG_WARNING("Unable to retrieve input truthEvent container " << m_truthEventKey.key());
294 return StatusCode::SUCCESS;
295 }
296
297
298 // First truth event is the hard scatter
299 const TruthEvent* hsevent = truthEventCont->front();
300 ConstDataVector<TruthParticleContainer> truthParticleCont(SG::VIEW_ELEMENTS);
301 for(size_t itp=0; itp<hsevent->nTruthParticles(); ++itp) {
302 const xAOD::TruthParticle* tp = hsevent->truthParticle(itp);
303 if(tp) {
304 truthParticleCont.push_back(tp);
305 }
306 }
307
308 for(const auto truth : truthParticleCont) {
309 if(truth->pt()<1) continue;
310 // stable
311 if(!truth->isGenStable()) continue;
312 // interacting
313 if(!MC::isInteracting(truth->pdgId())) continue;
314 float etasize = 0.025/2;
315 float phisize = 0.025/2;
316 bool isSuperCluster = false;
317 float Rsize = 0.;
318 switch(el->caloCluster()->clusterSize()) {
319 case xAOD::CaloCluster::SW_55ele:
320 etasize *= 5; phisize *=5;
321 break;
322 case xAOD::CaloCluster::SW_35ele:
323 etasize *= 3; phisize *=5;
324 break;
325 case xAOD::CaloCluster::SW_37ele:
326 etasize *= 3; phisize *=7;
327 break;
328 case xAOD::CaloCluster::SuperCluster:
329 isSuperCluster = true;
330 Rsize = el->caloCluster()->getMomentValue( xAOD::CaloCluster::SECOND_R );
331 if (Rsize<0.) {ATH_MSG_VERBOSE("Invalid SECOND_R moment retrieved!");}
332 break;
333 default:
334 ATH_MSG_WARNING("Unexpected electron cluster size " << el->caloCluster()->clusterSize() << " received!");
335 continue;
336 }
337 float deltaEta(fabs(truth->eta()-el->caloCluster()->eta()));
338 float deltaPhi(fabs(truth->p4().DeltaPhi(el->caloCluster()->p4())));
339 if( (isSuperCluster && (deltaEta*deltaEta+deltaPhi*deltaPhi)<Rsize*Rsize ) ||
340 (deltaEta<etasize && deltaPhi<phisize) ) {
341 bool skip(false);
342 for(const auto& truthobj : truthlist) {
343 const xAOD::TruthParticle *truth2 = static_cast<const xAOD::TruthParticle*>(truthobj);
344 if(truth==truth2) { skip = true; break;}
345 }
346 if(!skip) {
347 truthlist.push_back(truth);
348 }
349 }
350 }
351
352 return StatusCode::SUCCESS;
353 }
354
355 StatusCode METTruthAssociator::extractTruthFromPhoton(const xAOD::IParticle* obj,
356 std::vector<const xAOD::IParticle*>& truthlist) const
357 {
358 const xAOD::Photon* ph = static_cast<const xAOD::Photon*>(obj);
359 // Ph --> TruthParticles
360 const xAOD::TruthParticle* phtruth = TruthHelpers::getTruthParticle( *ph );
361 if(phtruth && phtruth->isGenStable())
362 truthlist.push_back(phtruth);
363
364 // std::vector<const xAOD::TrackParticle*> phtrks;
365 // for(size_t iVtx=0; iVtx<ph->nVertices(); ++iVtx) {
366 // const xAOD::Vertex* phvx = ph->vertex(iVtx);
367 // for(size_t iTrk=0; iTrk<phvx->nTrackParticles(); ++iTrk) {
368 // const xAOD::TrackParticle* phtrk = EgammaHelpers::getOriginalTrackParticleFromGSF(phvx->trackParticle(iTrk));
369 // bool duplicate = false;
370 // for(const auto& gamtrk : phtrks) {
371 // if( (duplicate = (phtrk == gamtrk)) ) {
372 // ATH_MSG_VERBOSE("Veto duplicate track");
373 // break;
374 // }
375 // }
376 // if(!duplicate) {
377 // const xAOD::IParticle* truth(0);
378 // if(phtrk) truth = TruthHelpers::getTruthParticle( *phtrk );
379 // if(truth && truth!=phtruth) truthlist.push_back(truth);
380 // }
381 // }
382 // }
383
384 // Retrieve the truth container
385 SG::ReadHandle<xAOD::TruthEventContainer> truthEventCont(m_truthEventKey);
386 if (!truthEventCont.isValid()) {
387 ATH_MSG_WARNING("Unable to retrieve input truthEvent container " << m_truthEventKey.key());
388 return StatusCode::SUCCESS;
389 }
390
391 // First truth event is the hard scatter
392 const TruthEvent* hsevent = truthEventCont->front();
393 ConstDataVector<TruthParticleContainer> truthParticleCont(SG::VIEW_ELEMENTS);
394 for(size_t itp=0; itp<hsevent->nTruthParticles(); ++itp) {
395 const xAOD::TruthParticle* tp = hsevent->truthParticle(itp);
396 if(tp) {
397 truthParticleCont.push_back(tp);
398 }
399 }
400
401 for(const auto truth : truthParticleCont) {
402 if(!truth || truth->pt()<1) continue;
403 // stable
404 if(!truth->isGenStable()) continue;
405 // interacting
406 if(!MC::isInteracting(truth->pdgId())) continue;
407 float etasize(0.025/2);
408 float phisize(0.025/2);
409 bool isSuperCluster = false;
410 float Rsize = 0.;
411 switch(ph->caloCluster()->clusterSize()) {
412 case xAOD::CaloCluster::SW_55gam:
413 case xAOD::CaloCluster::SW_55Econv:
414 etasize *= 5; phisize *=5;
415 break;
416 case xAOD::CaloCluster::SW_35ele:
417 case xAOD::CaloCluster::SW_35gam:
418 case xAOD::CaloCluster::SW_35Econv:
419 etasize *= 3; phisize *=5;
420 break;
421 case xAOD::CaloCluster::SW_37gam:
422 case xAOD::CaloCluster::SW_37Econv:
423 etasize *= 3; phisize *=7;
424 break;
425 case xAOD::CaloCluster::SuperCluster:
426 isSuperCluster = true;
427 Rsize = ph->caloCluster()->getMomentValue( xAOD::CaloCluster::SECOND_R );
428 if (Rsize<0.) {ATH_MSG_VERBOSE("Invalid SECOND_R moment retrieved!");}
429 break;
430 default:
431 ATH_MSG_WARNING("Unexpected photon cluster size " << ph->caloCluster()->clusterSize() << " received!");
432 continue;
433 }
434 float deltaEta(fabs(truth->eta()-ph->caloCluster()->eta()));
435 float deltaPhi(fabs(truth->p4().DeltaPhi(ph->caloCluster()->p4())));
436 if( (isSuperCluster && (deltaEta*deltaEta+deltaPhi*deltaPhi)<Rsize*Rsize ) ||
437 (deltaEta<etasize && deltaPhi<phisize) ) {
438 bool skip(false);
439 for(const auto& truthobj : truthlist) {
440 const xAOD::TruthParticle *truth2 = static_cast<const xAOD::TruthParticle*>(truthobj);
441 if(truth==truth2) { skip = true; break;}
442 }
443 if(!skip) {
444 truthlist.push_back(truth);
445 }
446 }
447 }
448
449 return StatusCode::SUCCESS;
450 }
451
452 StatusCode METTruthAssociator::extractTruthFromMuon(const xAOD::IParticle* obj,
453 std::vector<const xAOD::IParticle*>& truthlist)
454 {
455 const xAOD::Muon* mu = static_cast<const xAOD::Muon*>(obj);
456 const TrackParticle* trk = mu->primaryTrackParticle();
457 const xAOD::TruthParticle* truth(nullptr);
458 if(trk) truth = TruthHelpers::getTruthParticle( *trk );
459 if(truth && truth->isGenStable())
460 truthlist.push_back(truth);
461 return StatusCode::SUCCESS;
462 }
463
464 StatusCode METTruthAssociator::extractTruthFromTau(const xAOD::IParticle* obj,
465 std::vector<const xAOD::IParticle*>& truthlist) const
466 {
467 const TauJet* tau = static_cast<const TauJet*>(obj);
468 const Jet* seedjet = *tau->jetLink();
469 std::vector<ElementLink<IParticleContainer> > jetconst = cacc_ghosttruth(*seedjet);
470 for(const auto& truth : jetconst) {
471 if(truth) {
472 // TEMP: use jet seed axis
473 // taus will provide an accessor
474 if(!xAOD::P4Helpers::isInDeltaR(*seedjet,**truth,0.2,m_useRapidity)) continue;
475 truthlist.push_back(*truth);
476 }
477 }
478 return StatusCode::SUCCESS;
479 }
480
481 //*********************************************************************************************************
482 // Override fill map method to use the extracted truth particles
483
484 StatusCode METTruthAssociator::fillAssocMap(xAOD::MissingETAssociationMap* metMap,
485 const xAOD::IParticleContainer* hardObjs) const
486 // std::vector<const xAOD::IParticle*>& mutracks)
487 {
488 std::vector<const IParticle*> constlist;
489 constlist.reserve(20);
490 std::vector<const IParticle*> hardObjs_tmp;
491 for(const auto *const obj : *hardObjs) {
492 hardObjs_tmp.push_back(obj);
493 }
494 std::sort(hardObjs_tmp.begin(),hardObjs_tmp.end(),greaterPt);
495
496 for(const auto& obj : hardObjs_tmp) {
497 if(obj->pt()<5e3 && obj->type()!=xAOD::Type::Muon) continue;
498 constlist.clear();
499 ATH_MSG_VERBOSE( "Object type, pt, eta, phi = " << obj->type() << ", " << obj->pt() << ", " << obj->eta() << "," << obj->phi() );
500 ATH_CHECK( this->extractTruthParticles(obj,constlist) );
501
502 // MissingETBase::Types::constvec_t chrgvec;
503 // MissingETBase::Types::constvec_t truthvec;
504
505 for(const auto& truthobj : constlist) {
506 const xAOD::TruthParticle *truth = static_cast<const xAOD::TruthParticle*>(truthobj);
507 ATH_MSG_VERBOSE("Matched truth particle with pt " << truth->pt()
508 << " status " << truth->status()
509 << " pdgId " << truth->pdgId()
510 << " charge " << truth->charge());
511 ATH_MSG_VERBOSE("DeltaR to hard object: " << xAOD::P4Helpers::deltaR(*truth,*obj,m_useRapidity));
512
513 // if(fabs(truth->charge())>1e-9)
514 // chrgvec += MissingETBase::Types::constvec_t(*truth);
515 // if(!truth->isMuon())
516 // truthvec += MissingETBase::Types::constvec_t(*truth);
517 }
518 // ATH_MSG_VERBOSE("Charged truth constvec: sumpt " << chrgvec.sumpt());
519 // ATH_MSG_VERBOSE("Calo truth constvec: sumpt " << truthvec.sumpt());
520
521 MissingETComposition::insert(metMap,obj,constlist);
522 ATH_MSG_VERBOSE("\n\n");
523 }
524 return StatusCode::SUCCESS;
525 }
526
527}
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition AthMsgStreamMacros.h:28
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition AthMsgStreamMacros.h:32
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
ConstDataVector.h
DataVector adapter that acts like it holds const pointers.
HepMCHelpers.h
ATLAS-specific HepMC functions.
ConstDataVector
DataVector adapter that acts like it holds const pointers.
Definition ConstDataVector.h:76
ConstDataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
ConstDataVector::asDataVector
const DV * asDataVector() const
Return a pointer to this object, as a const DataVector.
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
SG::AuxElement::ConstAccessor
SG::ConstAccessor< T, ALLOC > ConstAccessor
Definition AuxElement.h:570
SG::AuxElement::index
size_t index() const
Return the index of this element within its container.
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
SG::ReadHandle::cptr
const_pointer_type cptr()
Dereference the pointer.
asg::AsgTool::AsgTool
AsgTool(const std::string &name)
Constructor specifying the tool instance's name.
Definition AsgTool.cxx:58
met::METAssociator::initialize
virtual StatusCode initialize() override
Dummy implementation of the initialisation function.
Definition METAssociator.cxx:95
met::METAssociator::greaterPt
static bool greaterPt(const xAOD::IParticle *part1, const xAOD::IParticle *part2)
Definition METAssociator.h:167
met::METAssociator::METAssociator
METAssociator(const std::string &name)
Definition METAssociator.cxx:60
met::METTruthAssociator::extractTruthFromMuon
static StatusCode extractTruthFromMuon(const xAOD::IParticle *obj, std::vector< const xAOD::IParticle * > &truthlist)
Definition METTruthAssociator.cxx:452
met::METTruthAssociator::m_recoJetKey
SG::ReadHandleKey< xAOD::JetContainer > m_recoJetKey
Definition METTruthAssociator.h:92
met::METTruthAssociator::m_truthEventKey
SG::ReadHandleKey< xAOD::TruthEventContainer > m_truthEventKey
Definition METTruthAssociator.h:93
met::METTruthAssociator::extractTruthParticles
StatusCode extractTruthParticles(const xAOD::IParticle *obj, std::vector< const xAOD::IParticle * > &truthlist) const
Definition METTruthAssociator.cxx:254
met::METTruthAssociator::m_recoElKey
SG::ReadHandleKey< xAOD::ElectronContainer > m_recoElKey
Definition METTruthAssociator.h:88
met::METTruthAssociator::computeSoftTerms
StatusCode computeSoftTerms(xAOD::MissingETContainer *metCont, xAOD::MissingETAssociationMap *metMap) const
Definition METTruthAssociator.cxx:197
met::METTruthAssociator::METTruthAssociator
METTruthAssociator()
Default constructor:
met::METTruthAssociator::initialize
StatusCode initialize()
Dummy implementation of the initialisation function.
Definition METTruthAssociator.cxx:57
met::METTruthAssociator::extractTruthFromElectron
StatusCode extractTruthFromElectron(const xAOD::IParticle *obj, std::vector< const xAOD::IParticle * > &truthlist) const
Definition METTruthAssociator.cxx:274
met::METTruthAssociator::m_recoTauKey
SG::ReadHandleKey< xAOD::TauJetContainer > m_recoTauKey
Definition METTruthAssociator.h:90
met::METTruthAssociator::extractTruthFromPhoton
StatusCode extractTruthFromPhoton(const xAOD::IParticle *obj, std::vector< const xAOD::IParticle * > &truthlist) const
Definition METTruthAssociator.cxx:355
met::METTruthAssociator::executeTool
StatusCode executeTool(xAOD::MissingETContainer *metCont, xAOD::MissingETAssociationMap *metMap) const
Definition METTruthAssociator.cxx:80
met::METTruthAssociator::m_recoMuKey
SG::ReadHandleKey< xAOD::MuonContainer > m_recoMuKey
Definition METTruthAssociator.h:91
met::METTruthAssociator::m_recoGamKey
SG::ReadHandleKey< xAOD::PhotonContainer > m_recoGamKey
Definition METTruthAssociator.h:89
met::METTruthAssociator::associateJets
StatusCode associateJets(xAOD::MissingETAssociationMap *metMap) const
Definition METTruthAssociator.cxx:144
met::METTruthAssociator::extractTruthFromTau
StatusCode extractTruthFromTau(const xAOD::IParticle *obj, std::vector< const xAOD::IParticle * > &truthlist) const
Definition METTruthAssociator.cxx:464
met::METTruthAssociator::fillAssocMap
StatusCode fillAssocMap(xAOD::MissingETAssociationMap *metMap, const xAOD::IParticleContainer *hardObjs) const final
Definition METTruthAssociator.cxx:484
xAOD::CaloCluster_v1::clusterSize
ClusterSize clusterSize() const
Get cluster size.
Definition CaloCluster_v1.cxx:364
xAOD::CaloCluster_v1::getMomentValue
double getMomentValue(MomentType type) const
Retrieve individual moment - no check for existance! Returns -999 on error.
Definition CaloCluster_v1.h:897
xAOD::CaloCluster_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
Definition CaloCluster_v1.cxx:251
xAOD::CaloCluster_v1::SW_55ele
@ SW_55ele
Definition CaloCluster_v1.h:91
xAOD::CaloCluster_v1::SW_55Econv
@ SW_55Econv
Definition CaloCluster_v1.h:99
xAOD::CaloCluster_v1::SW_37gam
@ SW_37gam
Definition CaloCluster_v1.h:97
xAOD::CaloCluster_v1::SW_35gam
@ SW_35gam
Definition CaloCluster_v1.h:96
xAOD::CaloCluster_v1::SW_37ele
@ SW_37ele
Definition CaloCluster_v1.h:93
xAOD::CaloCluster_v1::SW_35ele
@ SW_35ele
Definition CaloCluster_v1.h:92
xAOD::CaloCluster_v1::SuperCluster
@ SuperCluster
Definition CaloCluster_v1.h:110
xAOD::CaloCluster_v1::SW_37Econv
@ SW_37Econv
Definition CaloCluster_v1.h:101
xAOD::CaloCluster_v1::SW_35Econv
@ SW_35Econv
Definition CaloCluster_v1.h:100
xAOD::CaloCluster_v1::SW_55gam
@ SW_55gam
Definition CaloCluster_v1.h:95
xAOD::CaloCluster_v1::SECOND_R
@ SECOND_R
Second Moment in .
Definition CaloCluster_v1.h:126
xAOD::CaloCluster_v1::p4
virtual FourMom_t p4() const
The full 4-momentum of the particle.
Definition CaloCluster_v1.cxx:465
xAOD::Egamma_v1::caloCluster
const xAOD::CaloCluster * caloCluster(size_t index=0) const
Pointer to the xAOD::CaloCluster/s that define the electron candidate.
Definition Egamma_v1.cxx:377
xAOD::IParticle
Class providing the definition of the 4-vector interface.
Definition Event/xAOD/xAODBase/xAODBase/IParticle.h:41
xAOD::MissingETAssociationMap_v1::getUniqueSignals
const IParticleContainer * getUniqueSignals(const IParticleContainer *signals, MissingETBase::UsageHandler::Policy p=MissingETBase::UsageHandler::TrackCluster) const
Extract a container of constituents that are not in jets.
Definition MissingETAssociationMap_v1.cxx:218
xAOD::MissingETAssociationMap_v1::findIndex
size_t findIndex(const Jet *pJet) const
Definition MissingETAssociationMap_v1.cxx:60
xAOD::MissingETAssociation_v1::ConstVec::cpt
float cpt() const
Returns .
Definition MissingETAssociation_v1.cxx:85
xAOD::TauJet_v3::jetLink
const JetLink_t & jetLink() const
xAOD::TruthEventBase_v1::truthParticle
const TruthParticle * truthParticle(size_t index) const
Get a pointer to one of the truth particles.
Definition TruthEventBase_v1.cxx:50
xAOD::TruthEventBase_v1::nTruthParticles
size_t nTruthParticles() const
Get the number of truth particles.
xAOD::TruthParticle_v1::status
int status() const
Status code.
xAOD::TruthParticle_v1::pdgId
int pdgId() const
PDG ID code.
xAOD::TruthParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition TruthParticle_v1.cxx:161
xAOD::TruthParticle_v1::isGenStable
bool isGenStable() const
Check if this is generator stable particle.
Definition TruthParticle_v1.cxx:311
xAOD::TruthParticle_v1::charge
double charge() const
Physical charge.
xAOD::TruthParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition TruthParticle_v1.cxx:169
xAOD::TruthParticle_v1::isMuon
bool isMuon() const
Whether the particle is a muon (or antimuon)
MC::isInteracting
bool isInteracting(const T &p)
Identify if the particle with given PDG ID would not interact with the detector, i....
Definition HepMCHelpers.h:51
MissingETBase::Types::constvec_t
xAOD::MissingETAssociation_v1::ConstVec constvec_t
Type for constituent vector.
Definition MissingETAssociation_v1.h:453
SG::VIEW_ELEMENTS
@ VIEW_ELEMENTS
this data object is a view, it does not own its elmts
Definition OwnershipPolicy.h:18
met::cacc_ghosttruth
static const SG::AuxElement::ConstAccessor< std::vector< ElementLink< IParticleContainer > > > cacc_ghosttruth("GhostTruth")
std::sort
void sort(typename DataModel_detail::iterator< DVL > beg, typename DataModel_detail::iterator< DVL > end)
Specialization of sort for DataVector/List.
Definition DVL_algorithms.h:554
xAODType::Photon
@ Photon
The object is a photon.
Definition ObjectType.h:47
xAODType::Muon
@ Muon
The object is a muon.
Definition ObjectType.h:48
xAODType::Electron
@ Electron
The object is an electron.
Definition ObjectType.h:46
xAODType::Tau
@ Tau
The object is a tau (jet)
Definition ObjectType.h:49
xAOD::P4Helpers::isInDeltaR
bool isInDeltaR(const xAOD::IParticle &p1, const xAOD::IParticle &p2, double dR, bool useRapidity=true)
Check if 2 xAOD::IParticle are in a cone.
Definition xAODP4Helpers.h:174
xAOD::P4Helpers::deltaR
double deltaR(double rapidity1, double phi1, double rapidity2, double phi2)
from bare bare rapidity,phi
Definition xAODP4Helpers.h:150
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::Jet
Jet_v1 Jet
Definition of the current "jet version".
Definition Event/xAOD/xAODJet/xAODJet/Jet.h:17
xAOD::MissingET
MissingET_v1 MissingET
Version control by type defintion.
Definition Event/xAOD/xAODMissingET/xAODMissingET/MissingET.h:15
xAOD::deltaPhi
setSAddress setEtaMS setDirPhiMS setDirZMS setBarrelRadius setEndcapAlpha setEndcapRadius setInterceptInner setEtaMap setEtaBin setIsTgcFailure setDeltaPt deltaPhi
Definition L2StandAloneMuon_v1.cxx:161
xAOD::TrackParticle
TrackParticle_v1 TrackParticle
Reference the current persistent version:
Definition Event/xAOD/xAODTracking/xAODTracking/TrackParticle.h:13
xAOD::TauJet
TauJet_v3 TauJet
Definition of the current "tau version".
Definition Event/xAOD/xAODTau/xAODTau/TauJet.h:17
xAOD::TruthEvent
TruthEvent_v1 TruthEvent
Typedef to implementation.
Definition TruthEvent.h:17
xAOD::TruthParticle
TruthParticle_v1 TruthParticle
Typedef to implementation.
Definition Event/xAOD/xAODTruth/xAODTruth/TruthParticle.h:15
xAOD::Muon
Muon_v1 Muon
Reference the current persistent version:
Definition Event/xAOD/xAODMuon/xAODMuon/Muon.h:13
xAOD::Photon
Photon_v1 Photon
Definition of the current "egamma version".
Definition Event/xAOD/xAODEgamma/xAODEgamma/Photon.h:17
xAOD::MissingETAssociationMap
MissingETAssociationMap_v1 MissingETAssociationMap
Version control by type defintion.
Definition MissingETAssociationMap.h:16
xAOD::Electron
Electron_v1 Electron
Definition of the current "egamma version".
Definition Event/xAOD/xAODEgamma/xAODEgamma/Electron.h:17
xAOD::IParticleContainer
DataVector< IParticle > IParticleContainer
Simple convenience declaration of IParticleContainer.
Definition xAOD/xAODBase/xAODBase/IParticleContainer.h:32
MissingETBase::Source::Category::Calo
@ Calo
Indicator for MET terms reconstructed from calorimeter signals alone.
Definition MissingETBase.h:168
MissingETBase::Source::Category::ID
@ ID
Indicator for MET terms reconstructed from inner detector (ID) tracks alone.
Definition MissingETBase.h:169
MissingETBase::Source::truthInt
static Types::bitmask_t truthInt(Region reg=Region::FullAcceptance)
Standard bit pattern indicating effective true MET.
Definition MissingETBase.h:328
MissingETBase::Source::softEvent
static Types::bitmask_t softEvent(Region reg=Region::FullAcceptance)
Standard MET term from reconstructed soft event.
Definition MissingETBase.h:264
MissingETBase::Source::Region::Central
@ Central
Indicator for MET contribution from the central region.
Definition MissingETBase.h:192
met::MissingETComposition::addMiscAssociation
static bool addMiscAssociation(MissingETAssociationMap *pMap)
Add an association to hold objects not associated to any jet.
Definition Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx:227
met::MissingETComposition::insert
static bool insert(MissingETComponentMap *pMap, const MissingET *pMET, const IParticle *pPart, MissingETBase::Types::weight_t weight=MissingETBase::Types::weight_t())
Insert contributing signal or physics object by pointer, with optional kinematic weight object.
Definition Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx:42
met::MissingETComposition::add
static bool add(MissingETComponentMap *pMap, const MissingET *pMET, MissingETBase::Types::bitmask_t sw=MissingETBase::Status::clearedStatus())
Adding a MissingET object to the map.
Definition Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx:29
Generated on for ATLAS Offline Software by doxygen 1.14.0