ATLAS Offline Software
Loading...
Searching...
No Matches
JetTruthLabelingTool.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#include "ParticleJetTools/JetTruthLabelingTool.h"
6
7#include "AsgDataHandles/ReadHandle.h"
8#include "AsgDataHandles/ReadDecorHandle.h"
9#include "AsgDataHandles/WriteDecorHandle.h"
10#include "AsgTools/CurrentContext.h"
11#include "AthContainers/ConstAccessor.h"
12#include "TruthUtils/HepMCHelpers.h"
13
14JetTruthLabelingTool::JetTruthLabelingTool(const std::string& name) :
15 asg::AsgTool(name)
16{}
17
18JetTruthLabelingTool::TruthLabelConfiguration
19JetTruthLabelingTool::parseLabel(const std::string& name) {
20
21 if (name == "R10TruthLabel_R21Precision_2022v1")
22 return TruthLabelConfiguration::R21Precision_2022v1;
23
24 if (name == "R10TruthLabel_R22v1")
25 return TruthLabelConfiguration::R10TruthLabel_R22v1;
26
27 if (name == "R10WZTruthLabel_R22v1")
28 return TruthLabelConfiguration::R10WZTruthLabel_R22v1;
29
30 if (name == "R4TruthLabel")
31 return TruthLabelConfiguration::R4TruthLabel;
32
33 if (name == "R4TruthDressedWZLabel")
34 return TruthLabelConfiguration::R4TruthDressedWZLabel;
35
36 if (name == "R4InTimeTruthLabel")
37 return TruthLabelConfiguration::R4InTimeTruthLabel;
38
39 if (name == "R4OutOfTimeTruthLabel")
40 return TruthLabelConfiguration::R4OutOfTimeTruthLabel;
41
42 return TruthLabelConfiguration::Unknown;
43}
44
45
46StatusCode JetTruthLabelingTool::initialize(){
47
48 ATH_MSG_INFO("Initializing " << name());
49
50 m_truthLabelConfig = parseLabel(m_truthLabelName);
51
53 if(m_truthLabelConfig == TruthLabelConfiguration::Unknown) {
54 ATH_MSG_ERROR("TruthLabelName " << m_truthLabelName << " is not supported. Exiting...");
55 return StatusCode::FAILURE;
56 }
57
59 m_useGhostJetMatch = false;
60 m_recoGhostFrac = 0.75;
61
62 switch(m_truthLabelConfig) {
64 case TruthLabelConfiguration::R21Precision_2022v1:
65 case TruthLabelConfiguration::R10TruthLabel_R22v1:
66 m_truthJetCollectionKey="AntiKt10TruthJets";
67 m_matchUngroomedParent = true;
68 m_dRTruthJet = 0.75;
69 if ( m_truthLabelConfig == TruthLabelConfiguration::R10TruthLabel_R22v1) {
70 m_getTruthGroomedJetValues = true;
71 m_truthGroomedJetCollectionKey="AntiKt10TruthSoftDropBeta100Zcut10Jets";
72 } else {
73 m_getTruthGroomedJetValues = false;
74 }
75 break;
77 case TruthLabelConfiguration::R10WZTruthLabel_R22v1:
78 m_truthJetCollectionKey="AntiKt10TruthDressedWZJets";
79 m_matchUngroomedParent = true;
80 m_dRTruthJet = 0.75;
81 m_mLowTop = 140.0;
82 m_mLowW = 50.0;
83 m_mLowZ = 50.0;
84 m_getTruthGroomedJetValues = true;
85 m_truthGroomedJetCollectionKey="AntiKt10TruthDressedWZSoftDropBeta100Zcut10Jets";
86 break;
87
89 case TruthLabelConfiguration::R4TruthLabel:
90 case TruthLabelConfiguration::R4TruthDressedWZLabel:
91 case TruthLabelConfiguration::R4InTimeTruthLabel:
92 case TruthLabelConfiguration::R4OutOfTimeTruthLabel:
93 switch (m_truthLabelConfig) {
94 case TruthLabelConfiguration::R4TruthLabel:
95 m_truthJetCollectionKey = "AntiKt4TruthJets";
96 break;
97 case TruthLabelConfiguration::R4TruthDressedWZLabel:
98 m_truthJetCollectionKey = "AntiKt4TruthDressedWZJets";
99 break;
100 case TruthLabelConfiguration::R4InTimeTruthLabel:
101 m_truthJetCollectionKey = "InTimeAntiKt4TruthJets";
102 break;
103 case TruthLabelConfiguration::R4OutOfTimeTruthLabel:
104 m_truthJetCollectionKey = "OutOfTimeAntiKt4TruthJets";
105 break;
106 default: // Cannot hit anything else
107 break;
108 }
109 m_matchUngroomedParent = false;
110 m_dRTruthJet = 0.3;
111 m_getTruthGroomedJetValues = false;
112 m_useGhostJetMatch = false;
113 m_doLargeRLabels = false;
114 break;
115 default:
116 ATH_MSG_ERROR(" Unhandled TruthLabelName " << m_truthLabelName << "! Exiting...");
117 return StatusCode::FAILURE;
118 }
119
120 if(m_forceDeltaRMatch) {
121 m_useGhostJetMatch = false;
122 }
123
124 print();
125
126 m_label_truthKey = m_truthJetCollectionKey.key() + "." + m_truthLabelName;
127 m_NB_truthKey = m_truthJetCollectionKey.key() + "." + m_truthLabelName + "_NB";
128 m_split12_truthKey = m_truthJetCollectionKey.key() + ".Split12";
129 m_split23_truthKey = m_truthJetCollectionKey.key() + ".Split23";
130
131 if(!m_isTruthJetCol){
132 m_label_recoKey = m_jetContainerName + "." + m_truthLabelName;
133 m_NB_recoKey = m_jetContainerName + "." + m_truthLabelName + "_NB";
134 m_truthSplit12_recoKey = m_jetContainerName + "." + m_truthLabelName + "_TruthJetSplit12";
135 m_truthSplit23_recoKey = m_jetContainerName + "." + m_truthLabelName + "_TruthJetSplit23";
136
137 m_matchedTruthJet_recoKey = m_jetContainerName + "." + m_truthLabelName + "_TruthMatch_Jet";
138 m_matchedTruthJetMass_recoKey = m_jetContainerName + "." + m_truthLabelName + "_TruthMatch_m";
139 m_matchedTruthJetPt_recoKey = m_jetContainerName + "." + m_truthLabelName + "_TruthMatch_pt";
140 m_matchedTruthJetRapidity_recoKey = m_jetContainerName + "." + m_truthLabelName + "_TruthMatch_rapidity";
141 m_matchedTruthJetPhi_recoKey = m_jetContainerName + "." + m_truthLabelName + "_TruthMatch_phi";
142 m_matchedTruthJetDR_recoKey = m_jetContainerName + "." + m_truthLabelName + "_TruthMatch_dR";
143
144 if (!m_doLargeRLabels) { //Simple naming for small R
145 m_matchedTruthJet_recoKey = m_jetContainerName + "." + "TruthMatch_Jet";
146 m_matchedTruthJetMass_recoKey = m_jetContainerName + "." + "TruthMatch_m";
147 m_matchedTruthJetPt_recoKey = m_jetContainerName + "." + "TruthMatch_pt";
148 m_matchedTruthJetRapidity_recoKey = m_jetContainerName + "." + "TruthMatch_rapidity";
149 m_matchedTruthJetPhi_recoKey = m_jetContainerName + "." + "TruthMatch_phi";
150 m_matchedTruthJetDR_recoKey = m_jetContainerName + "." + "TruthMatch_dR";
151 m_matchedPileupTag_recoKey = m_jetContainerName + "." + "TruthMatch_PileupLabel";
152 m_sumPtMatchedHSJets_recoKey = m_jetContainerName + "." + "TruthMatch_HSSumPt";
153 m_sumPtMatchedOOTJets_recoKey = m_jetContainerName + "." + "TruthMatch_OOTSumPt";
154 m_sumPtMatchedITJets_recoKey = m_jetContainerName + "." + "TruthMatch_ITSumPt";
155 }
156
157 m_matchedTruthGroomedJetMass_recoKey = m_jetContainerName + "." + m_truthLabelName + "_TruthMatch_GroomedJetMass";
158 m_matchedTruthGroomedJetPt_recoKey = m_jetContainerName + "." + m_truthLabelName + "_TruthMatch_GroomedJetPt";
159 }
160
161 ATH_CHECK(m_evtInfoKey.initialize());
162 ATH_CHECK(m_truthJetCollectionKey.initialize());
163 ATH_CHECK(m_truthGroomedJetCollectionKey.initialize(m_getTruthGroomedJetValues));
164
165 ATH_CHECK(m_ITJetName.initialize(!m_doLargeRLabels));
166 ATH_CHECK(m_OOTJetName.initialize(!m_doLargeRLabels));
167
168 ATH_CHECK(m_label_truthKey.initialize());
169 ATH_CHECK(m_NB_truthKey.initialize());
170
171 ATH_CHECK(m_split12_truthKey.initialize(m_truthLabelConfig == TruthLabelConfiguration::R21Precision_2022v1 || m_truthLabelConfig == TruthLabelConfiguration::R10TruthLabel_R22v1 || m_truthLabelConfig == TruthLabelConfiguration::R10WZTruthLabel_R22v1));
172 ATH_CHECK(m_split23_truthKey.initialize(m_truthLabelConfig == TruthLabelConfiguration::R21Precision_2022v1 || m_truthLabelConfig == TruthLabelConfiguration::R10TruthLabel_R22v1 || m_truthLabelConfig == TruthLabelConfiguration::R10WZTruthLabel_R22v1));
173
174 ATH_CHECK(m_label_recoKey.initialize(!m_isTruthJetCol));
175 ATH_CHECK(m_NB_recoKey.initialize(!m_isTruthJetCol));
176 ATH_CHECK(m_truthSplit12_recoKey.initialize(!m_isTruthJetCol && (m_truthLabelConfig == TruthLabelConfiguration::R21Precision_2022v1 || m_truthLabelConfig == TruthLabelConfiguration::R10TruthLabel_R22v1 || m_truthLabelConfig == TruthLabelConfiguration::R10WZTruthLabel_R22v1) ));
177 ATH_CHECK(m_truthSplit23_recoKey.initialize(!m_isTruthJetCol && (m_truthLabelConfig == TruthLabelConfiguration::R21Precision_2022v1 || m_truthLabelConfig == TruthLabelConfiguration::R10TruthLabel_R22v1 || m_truthLabelConfig == TruthLabelConfiguration::R10WZTruthLabel_R22v1)));
178
179 ATH_CHECK(m_matchedTruthJet_recoKey.initialize(!m_isTruthJetCol));
180 ATH_CHECK(m_matchedTruthJetMass_recoKey.initialize(!m_isTruthJetCol));
181 ATH_CHECK(m_matchedTruthJetPt_recoKey.initialize(!m_isTruthJetCol));
182 ATH_CHECK(m_matchedTruthJetRapidity_recoKey.initialize(!m_isTruthJetCol));
183 ATH_CHECK(m_matchedTruthJetPhi_recoKey.initialize(!m_isTruthJetCol));
184 ATH_CHECK(m_matchedTruthJetDR_recoKey.initialize(!m_isTruthJetCol));
185
186 ATH_CHECK(m_matchedPileupTag_recoKey.initialize(!m_isTruthJetCol && !m_doLargeRLabels));
187 ATH_CHECK(m_sumPtMatchedHSJets_recoKey.initialize(!m_isTruthJetCol && !m_doLargeRLabels));
188 ATH_CHECK(m_sumPtMatchedOOTJets_recoKey.initialize(!m_isTruthJetCol && !m_doLargeRLabels));
189 ATH_CHECK(m_sumPtMatchedITJets_recoKey.initialize(!m_isTruthJetCol && !m_doLargeRLabels));
190
191 ATH_CHECK(m_matchedTruthGroomedJetMass_recoKey.initialize((!m_isTruthJetCol) && (m_getTruthGroomedJetValues)));
192 ATH_CHECK(m_matchedTruthGroomedJetPt_recoKey.initialize((!m_isTruthJetCol) && (m_getTruthGroomedJetValues)));
193
194 return StatusCode::SUCCESS;
195}
196
197void JetTruthLabelingTool::print() const {
198 ATH_MSG_INFO("Parameters for " << name());
199
200 ATH_MSG_INFO("xAOD information:");
201 ATH_MSG_INFO("TruthLabelName: " << m_truthLabelName);
202 ATH_MSG_INFO("TruthJetCollectionName: " << m_truthJetCollectionKey.key());
203 ATH_MSG_INFO("dRTruthJet: " << std::to_string(m_dRTruthJet));
204
205 if(m_getTruthGroomedJetValues) {
206 ATH_MSG_INFO("truthGroomedJetCollectionName: " << m_truthGroomedJetCollectionKey.key());
207 }
208}
209
210
211JetTruthLabelingTool::DecorHandles::DecorHandles
212 (const JetTruthLabelingTool& tool, const EventContext& ctx)
213{
214 auto maybeInit = [&] (auto& h,
215 const SG::WriteDecorHandleKey<xAOD::JetContainer>& k)
216 {
217 if (!k.key().empty()) h.emplace (k, ctx);
218 };
219 maybeInit (labelHandle, tool.m_label_truthKey);
220 maybeInit (nbHandle, tool.m_NB_truthKey);
221 maybeInit (labelRecoHandle, tool.m_label_recoKey);
222 maybeInit (nbRecoHandle, tool.m_NB_recoKey);
223 maybeInit (split23Handle, tool.m_truthSplit23_recoKey);
224 maybeInit (split12Handle, tool.m_truthSplit12_recoKey);
225
226 maybeInit (matchedTruthJetHandle, tool.m_matchedTruthJet_recoKey);
227 maybeInit (matchedTruthJetMassHandle, tool.m_matchedTruthJetMass_recoKey);
228 maybeInit (matchedTruthJetPtHandle, tool.m_matchedTruthJetPt_recoKey);
229 maybeInit (matchedTruthJetRapidityHandle, tool.m_matchedTruthJetRapidity_recoKey);
230 maybeInit (matchedTruthJetPhiHandle, tool.m_matchedTruthJetPhi_recoKey);
231 maybeInit (matchedTruthJetDRHandle, tool.m_matchedTruthJetDR_recoKey);
232
233 maybeInit (matchedPileupTagHandle, tool.m_matchedPileupTag_recoKey);
234 maybeInit (sumPtMatchedHSJetsHandle, tool.m_sumPtMatchedHSJets_recoKey);
235 maybeInit (sumPtMatchedOOTJetsHandle, tool.m_sumPtMatchedOOTJets_recoKey);
236 maybeInit (sumPtMatchedITJetsHandle, tool.m_sumPtMatchedITJets_recoKey);
237
238 maybeInit (matchedTruthGroomedMassHandle, tool.m_matchedTruthGroomedJetMass_recoKey);
239 maybeInit (matchedTruthGroomedPtHandle, tool.m_matchedTruthGroomedJetPt_recoKey);
240}
241
242int JetTruthLabelingTool::getTruthJetLabelGA( DecorHandles& dh,
243 const xAOD::Jet &jet,
244 const EventContext& ctx ) const
245{
247 bool matchW = false;
248 bool matchZ = false;
249 bool matchH = false;
250 bool matchTop = false;
251
253 int nMatchW = getNGhostParticles( jet, "GhostWBosons" );
254
255 if ( nMatchW ) {
256 matchW = true;
257 }
258
260 int nMatchZ = getNGhostParticles( jet, "GhostZBosons" );
261
262 if ( nMatchZ ) {
263 matchZ = true;
264 }
265
267 int nMatchH = getNGhostParticles( jet, "GhostHBosons" );
268
269 if ( nMatchH ) {
270 matchH = true;
271 }
272
274 int nMatchTop = getNGhostParticles( jet, "GhostTQuarksFinal" );
275
276 if ( nMatchTop ) {
277 matchTop = true;
278 }
279
280 return getLabel( dh, jet, matchH, matchW, matchZ, matchTop, ctx );
281
282}
283
284StatusCode JetTruthLabelingTool::decorate(const xAOD::JetContainer& jets) const {
285 const EventContext& ctx = Gaudi::Hive::currentContext();
286 DecorHandles dh (*this, ctx);
287
289 if(m_isTruthJetCol) {
290 return labelTruthJets(dh, jets, ctx);
291 }
292
293 else if (!m_isTruthJetCol && !m_doLargeRLabels) {
294 return labelRecoJets(dh, jets, ctx);
295 }
296
298 else {
299 ATH_CHECK( labelTruthJets(dh, ctx) );
300 return labelRecoJets(dh, jets, ctx);
301 }
302
303 return StatusCode::SUCCESS;
304}
305
306StatusCode JetTruthLabelingTool::labelRecoJets(DecorHandles& dh,
307 const xAOD::JetContainer& jets,
308 const EventContext& ctx) const {
309
310 SG::ReadHandle<xAOD::JetContainer> truthJets(m_truthJetCollectionKey, ctx);
311
312 bool usePileupJets = true;
313
314 SG::ReadHandle<xAOD::JetContainer> inTimeTruthJets;
315 SG::ReadHandle<xAOD::JetContainer> outOfTimeTruthJets;
316 if (!m_doLargeRLabels) {
317 inTimeTruthJets = SG::makeHandle(m_ITJetName, ctx);
318 outOfTimeTruthJets = SG::makeHandle(m_OOTJetName, ctx);
319
320 if (!inTimeTruthJets.isValid() || !outOfTimeTruthJets.isValid()) {
321 ATH_MSG_WARNING("Pileup jet collections unavailabel for " << m_truthJetCollectionKey << ". Running without pileup tagger.");
322 usePileupJets = false;
323 }
324 }
325
326 SG::ReadHandle<xAOD::JetContainer> truthGroomedJets;
327 if ( m_getTruthGroomedJetValues ) {
328 truthGroomedJets = SG::makeHandle(m_truthGroomedJetCollectionKey, ctx);
329 }
330
331 const SG::AuxElement::Accessor<int> nbAcc (m_truthLabelName + "_NB");
332 static const SG::ConstAccessor< ElementLink< xAOD::JetContainer > > ParentAcc ("Parent");
333
334 for(const xAOD::Jet *jet : jets) {
335
337 const xAOD::Jet* parent = nullptr;
338 if ( m_matchUngroomedParent ){
339 ElementLink<xAOD::JetContainer> element_link = ParentAcc (*jet);
340 if ( element_link.isValid() ) {
341 parent = *element_link;
342 }
343 else {
344 ATH_MSG_ERROR("Unable to get a link to the parent jet! Returning a NULL pointer.");
345 return StatusCode::FAILURE;
346 }
347 }
349 float dRmin = 9999;
350 float oot_dRmin = 9999;
351 float it_dRmin = 9999;
352 float ghostFracNominal = 9;
353 const xAOD::Jet* matchTruthJet = nullptr;
354 const xAOD::Jet* oot_matchTruthJet = nullptr;
355 const xAOD::Jet* it_matchTruthJet = nullptr;
357 float dRminGroomed = 9999;
358 const xAOD::Jet* matchTruthGroomedJet = nullptr;
360 float sumPtMatchedHSJets = 0;
361 float sumPtMatchedOOTJets = 0;
362 float sumPtMatchedITJets = 0;
363 float bestHSpT = -9999;
364 float bestOOTpT = -9999;
365 float bestITpT = -9999;
366 float bestHSpTRatio = -9;
367 float bestOOTpTRatio = -9;
368 float bestITpTRatio = -9;
369 int nMatchedHSJets = 0;
370 int nMatchedOOTJets = 0;
371 int nMatchedITJets = 0;
372 int pileupTag = SmallRJetPileupLabel::enumToInt(SmallRJetPileupLabel::Unknown);
373
374 // Ensure that the reco jet has at least one constituent
375 // (and thus a well-defined four-vector)
376 if (jet->numConstituents() > 0) {
377 // Access ghostTruthPt now so it is available for pileup jets
378 static const SG::ConstAccessor<float> accGhostTruthPt("GhostTruthPt");
379 float ghostTruthPt = accGhostTruthPt(*jet);
380 for (const xAOD::Jet* truthJet : *truthJets) { // Truth jet loop
381 // Calculate DR
382 float dR = jet->p4().DeltaR(truthJet->p4(),true);
383 // If parent jet has been retrieved, calculate dR w.r.t. it instead
384 if (parent) dR = parent->p4().DeltaR(truthJet->p4(),true);
385 // Calculate GF
386 float ghostPtFraction = (ghostTruthPt / (truthJet->pt()));
387 if (m_useGhostJetMatch) { // GA matching. Upper bound applied for completeness, but realistically not needed.
388 if ((ghostPtFraction >= m_recoGhostFrac) && (ghostPtFraction <= (2 - m_recoGhostFrac))) { // All matches
389 nMatchedHSJets += 1;
390 sumPtMatchedHSJets += truthJet->pt();
391 if (std::abs(1 - ghostPtFraction) < std::abs(1 - ghostFracNominal)) { // Best match
392 matchTruthJet = truthJet;
393 ghostFracNominal = ghostPtFraction;
394 }
395 }
396 }
397 else { // If m_dRTruthJet < 0, the closest truth jet is used as matched jet. Otherwise, only match if dR < m_dRTruthJet
398 if (m_dRTruthJet < 0 || dR < m_dRTruthJet) { // All matches
399 nMatchedHSJets += 1;
400 sumPtMatchedHSJets += truthJet->pt();
401 if (dR < dRmin) { // Best match
402 dRmin = dR;
403 matchTruthJet = truthJet;
404 }
405 }
406 }
407 }
408 if (!m_doLargeRLabels && usePileupJets) {
409 for (const xAOD::Jet* ootJet : *outOfTimeTruthJets) { // Out of time pileup truth jet loop
410 float dR = jet->p4().DeltaR(ootJet->p4(), true);
411 float ghostPtFraction = (ghostTruthPt / (ootJet->pt()));
412 if (m_useGhostJetMatch) {
413 if ((ghostPtFraction >= m_recoGhostFrac) && (ghostPtFraction <= (2 - m_recoGhostFrac))) { // All matches
414 nMatchedOOTJets += 1;
415 sumPtMatchedOOTJets += ootJet->pt();
416 if (std::abs(1 - ghostPtFraction) < std::abs(1 - ghostFracNominal)) { // Best match
417 oot_matchTruthJet = ootJet;
418 }
419 }
420 }
421 else {
422 if (dR < m_dRTruthJet) { // All matches
423 nMatchedOOTJets += 1;
424 sumPtMatchedOOTJets += ootJet->pt();
425 if (dR < oot_dRmin) { // Best match
426 oot_dRmin = dR;
427 oot_matchTruthJet = ootJet;
428 }
429 }
430 }
431 }
432 for (const xAOD::Jet* itJet : *inTimeTruthJets) { // In time pileup truth jet loop
433 float dR = jet->p4().DeltaR(itJet->p4(), true);
434 float ghostPtFraction = (ghostTruthPt / (itJet->pt()));
435 if (m_useGhostJetMatch) {
436 if ((ghostPtFraction >= m_recoGhostFrac) && (ghostPtFraction <= (2 - m_recoGhostFrac))) { // All matches
437 nMatchedITJets += 1;
438 sumPtMatchedITJets += itJet->pt();
439 if (std::abs(1 - ghostPtFraction) < std::abs(1 - ghostFracNominal)) { // Best match
440 it_matchTruthJet = itJet;
441 }
442 }
443 }
444 else {
445 if (dR < m_dRTruthJet) { // All matches
446 nMatchedITJets += 1;
447 sumPtMatchedITJets += itJet->pt();
448 if (dR < it_dRmin) { // Best match
449 it_dRmin = dR;
450 it_matchTruthJet = itJet;
451 }
452 }
453 }
454 }
455
456 //#######################################################################################
457 //# PILEUP TAGGER KEY #
458 //# 0: Hard scatter ------------- Best truth jet match has >90% of the total matched pT #
459 //# 1: Mixed hard scatter-------- Match with multiple truth jets, none >90% (no PU) #
460 //# 2: Hard scatter with pileup - Best truth jet <90%, also has pileup matches #
461 //# 3: In time pileup---------- - Best it jet match has > 90 % of the total matched pT #
462 //# 4: Mixed pileup ------------- Match with multiple pileup jets, none >90% (no HS) #
463 //# 5: Out of time pileup------ - Best oot jet match has > 90 % of the total matched pT #
464 //# 6: Other/unknown ------------ Fails all above cases #
465 //#######################################################################################
466
467 //NOTE: HS has 5 GeV pT threshold, 10 GeV and 15 GeV for IT and OOT pileup.
468
469 int nMatchedPUJets = nMatchedOOTJets + nMatchedITJets;
470
471 float totalMatchedpT = sumPtMatchedHSJets + sumPtMatchedOOTJets + sumPtMatchedITJets;
472
473 if (matchTruthJet) {
474 bestHSpT = matchTruthJet->pt();
475 bestHSpTRatio = bestHSpT / totalMatchedpT;
476 }
477 if (oot_matchTruthJet) {
478 bestOOTpT = oot_matchTruthJet->pt();
479 bestOOTpTRatio = bestOOTpT / totalMatchedpT;
480 }
481 if (it_matchTruthJet) {
482 bestITpT = it_matchTruthJet->pt();
483 bestITpTRatio = bestITpT / totalMatchedpT;
484 }
485
486 if (bestHSpTRatio >= 0.9) { //HS
487 pileupTag = SmallRJetPileupLabel::HS;
488 }
489 else if (bestITpTRatio >= 0.9) { //IT
490 pileupTag = SmallRJetPileupLabel::ITPU;
491 }
492 else if (bestOOTpTRatio >= 0.9) { //OOT
493 pileupTag = SmallRJetPileupLabel::OOTPU;
494 }
495 else if (nMatchedPUJets == 0 && nMatchedHSJets > 1) { //Mixed HS
496 pileupTag = SmallRJetPileupLabel::MixHS;
497 }
498 else if (nMatchedPUJets > 0 && nMatchedHSJets > 0) { //HS with pileup
499 pileupTag = SmallRJetPileupLabel::HSPU;
500 }
501 else if (nMatchedPUJets > 1) {//Mixed PU
502 pileupTag = SmallRJetPileupLabel::MixPU;
503 }
504 else { //No match
505 pileupTag = SmallRJetPileupLabel::Unknown;
506 }
507
508 }
509
510 }
511
512 int label = LargeRJetTruthLabel::enumToInt( LargeRJetTruthLabel::notruth );
513 int truthJetNB = -1;
514 float truthJetSplit12 = -9999;
515 float truthJetSplit23 = -9999;
516
517 // Defaults to null EL
518 ElementLink<xAOD::JetContainer> truthJetEL{};
519 float truthJetMass = -9999;
520 float truthJetPt = -9999;
521 float truthJetRapidity = -9;
522 float truthJetPhi = -9999;
523 float deltaR = -2;
524
525 //If the best match is PU, reassign the truth jet to take variables from
526 if (pileupTag == SmallRJetPileupLabel::ITPU) {
527 matchTruthJet = it_matchTruthJet;
528 }
529 else if (pileupTag == SmallRJetPileupLabel::OOTPU) {
530 matchTruthJet = oot_matchTruthJet;
531 }
532 else if (pileupTag == SmallRJetPileupLabel::MixPU) {
533 if (bestITpTRatio >= bestOOTpTRatio) {
534 matchTruthJet = it_matchTruthJet;
535 }
536 else {
537 matchTruthJet = oot_matchTruthJet;
538 }
539 }
540
541 if ( matchTruthJet ) {
542
543 // Can't use the WriteDecorHandle to read --- the decoration may have
544 // been added and locked by a previous algorithm.
545 // Not saving Truth jet decorations for small R
546 if (m_doLargeRLabels) {
547 SG::ConstAccessor<int> labelAcc(dh.labelHandle->auxid());
548 label = labelAcc(*matchTruthJet);
549 if (m_truthLabelConfig == TruthLabelConfiguration::R21Precision_2022v1 || m_truthLabelConfig == TruthLabelConfiguration::R10TruthLabel_R22v1 || m_truthLabelConfig == TruthLabelConfiguration::R10WZTruthLabel_R22v1) {
550 SG::ReadDecorHandle<xAOD::JetContainer, float> split23Handle(m_split23_truthKey, ctx);
551 if (split23Handle.isAvailable()) truthJetSplit23 = split23Handle(*matchTruthJet);
552 SG::ReadDecorHandle<xAOD::JetContainer, float> split12Handle(m_split12_truthKey, ctx);
553 if (split12Handle.isAvailable()) truthJetSplit12 = split12Handle(*matchTruthJet);
554 }
555 if (nbAcc.isAvailable(*matchTruthJet)) truthJetNB = nbAcc(*matchTruthJet);
556 }
557 truthJetEL = ElementLink<xAOD::JetContainer>(*truthJets, matchTruthJet->index(), ctx);
558 truthJetMass = matchTruthJet->m();
559 truthJetPt = matchTruthJet->pt();
560 truthJetRapidity = matchTruthJet->rapidity();
561 truthJetPhi = matchTruthJet->phi();
562 deltaR = dRmin;
563 }
564
565 // Save Groomed Truth Jet variables
566 float truthGroomedJetMass = -9999;
567 float truthGroomedJetPt = -9999;
568 if ( m_getTruthGroomedJetValues ) {
569 if ( matchTruthJet ) {
570 for ( const xAOD::Jet* truthGroomedJet : *truthGroomedJets ) {
571 ElementLink<xAOD::JetContainer> element_link = ParentAcc (*truthGroomedJet);
572 if ( !element_link.isValid() ) { continue; }
573 if ( matchTruthJet == *element_link ) {
574 matchTruthGroomedJet = truthGroomedJet;
575 break;
576 }
577 }
578 }
579 // If no matched jet found or matched jet has no corresponding groomed jet, use dR matching
580 if ( !matchTruthGroomedJet && parent != nullptr) {
581 for ( const xAOD::Jet* truthGroomedJet : *truthGroomedJets ) {
582 float dR = parent->p4().DeltaR(truthGroomedJet->p4(),true);
584 if ( m_dRTruthJet < 0 || dR < m_dRTruthJet ) {
585 if ( dR < dRminGroomed ) {
586 dRminGroomed = dR;
587 matchTruthGroomedJet = truthGroomedJet;
588 }
589 }
590 }
591 }
592 if ( matchTruthGroomedJet ) {
593 truthGroomedJetMass = matchTruthGroomedJet->m();
594 truthGroomedJetPt = matchTruthGroomedJet->pt();
595 }
596 }
597
599 if (m_doLargeRLabels) {
600 (*dh.labelRecoHandle)(*jet) = label;
602 if (m_truthLabelConfig == TruthLabelConfiguration::R21Precision_2022v1 || m_truthLabelConfig == TruthLabelConfiguration::R10TruthLabel_R22v1 || m_truthLabelConfig == TruthLabelConfiguration::R10WZTruthLabel_R22v1) {
603 (*dh.split23Handle)(*jet) = truthJetSplit23;
604 (*dh.split12Handle)(*jet) = truthJetSplit12;
605 }
606
607 (*dh.nbRecoHandle)(*jet) = truthJetNB;
608 }
609
610 (*dh.matchedTruthJetHandle)(*jet) = truthJetEL;
611 (*dh.matchedTruthJetMassHandle)(*jet) = truthJetMass;
612 (*dh.matchedTruthJetPtHandle)(*jet) = truthJetPt;
613 (*dh.matchedTruthJetRapidityHandle)(*jet) = truthJetRapidity;
614 (*dh.matchedTruthJetPhiHandle)(*jet) = truthJetPhi;
615 (*dh.matchedTruthJetDRHandle)(*jet) = deltaR;
616
617 if (!m_doLargeRLabels && usePileupJets) {
618 (*dh.matchedPileupTagHandle)(*jet) = pileupTag;
619 (*dh.sumPtMatchedHSJetsHandle)(*jet) = sumPtMatchedHSJets;
620 (*dh.sumPtMatchedOOTJetsHandle)(*jet) = sumPtMatchedOOTJets;
621 (*dh.sumPtMatchedITJetsHandle)(*jet) = sumPtMatchedITJets;
622 }
623
624 if ( m_getTruthGroomedJetValues ) {
625 (*dh.matchedTruthGroomedMassHandle)(*jet) = truthGroomedJetMass;
626 (*dh.matchedTruthGroomedPtHandle)(*jet) = truthGroomedJetPt;
627 }
628 }
629
630 return StatusCode::SUCCESS;
631}
632
633StatusCode JetTruthLabelingTool::labelTruthJets(DecorHandles& dh,
634 const EventContext& ctx) const {
635
637 SG::ReadHandle<xAOD::JetContainer> truthJets(m_truthJetCollectionKey, ctx);
638
640 if ( !truthJets.isValid() ) {
641 ATH_MSG_ERROR("No truth jet container retrieved. Please make sure you are using a supported TruthLabelName.");
642 return StatusCode::FAILURE;
643 }
644
645 return labelTruthJets(dh, *truthJets, ctx);
646
647}
648
649StatusCode JetTruthLabelingTool::labelTruthJets( DecorHandles& dh,
650 const xAOD::JetContainer &truthJets,
651 const EventContext& ctx) const
652{
654 if ( !(truthJets.size()) ) return StatusCode::SUCCESS;
655
657 if(dh.labelHandle->isAvailable()){
658 // Beware: if we get here, the configuration is probably not MT-compatible.
659 ATH_MSG_DEBUG("labelTruthJets: Truth jet collection already labelled with " << m_truthLabelName);
660 return StatusCode::SUCCESS;
661 }
662
664 SG::ReadHandle<xAOD::EventInfo> eventInfo(m_evtInfoKey, ctx);
665 if(!eventInfo.isValid()){
666 ATH_MSG_ERROR("Failed to retrieve event information.");
667 return StatusCode::FAILURE;
668 }
669
670 if(m_doLargeRLabels) {
671 int label = LargeRJetTruthLabel::enumToInt(LargeRJetTruthLabel::notruth);
673 for ( const xAOD::Jet *jet : truthJets ) {
674 ATH_MSG_DEBUG("Getting truth label using ghost-association");
675 label = getTruthJetLabelGA(dh, *jet, ctx);
676 (*dh.labelHandle)(*jet) = label;
677 }
678 }
679
680 return StatusCode::SUCCESS;
681}
682
683float JetTruthLabelingTool::getWZSplit12Cut( float pt ) const {
684
687
688 float split12 = -999.0;
689
690 if ( m_truthLabelConfig == TruthLabelConfiguration::R21Precision_2022v1 || m_truthLabelConfig == TruthLabelConfiguration::R10TruthLabel_R22v1 || m_truthLabelConfig == TruthLabelConfiguration::R10WZTruthLabel_R22v1) {
691 const float c0 = 55.25;
692 const float c1 = -2.34e-3;
693
694 split12 = c0 * std::exp( c1 * pt );
695 }
696
697 return split12;
698
699}
700
701float JetTruthLabelingTool::getTopSplit23Cut( float pt ) const {
702
705
706 float split23 = -999.0;
707
708 if ( m_truthLabelConfig == TruthLabelConfiguration::R21Precision_2022v1 ||
709 m_truthLabelConfig == TruthLabelConfiguration::R10TruthLabel_R22v1 ||
710 m_truthLabelConfig == TruthLabelConfiguration::R10WZTruthLabel_R22v1) {
711
712 const float c0 = 3.3;
713 const float c1 = -6.98e-4;
714
715 split23 = std::exp( c0 + c1 * pt );
716
717 }
718
719 return split23;
720}
721
722int JetTruthLabelingTool::getNGhostParticles( const xAOD::Jet &jet, const std::string & collection ) const {
723
724 int nMatchPart = 0;
725
726 if( !jet.getAttribute<int>( collection+"Count", nMatchPart ) ){
727
728 std::vector<const xAOD::TruthParticle*> ghostParts;
729 if( !jet.getAssociatedObjects<xAOD::TruthParticle>( collection, ghostParts ) ){
730 ATH_MSG_ERROR( collection + " cannot be retrieved! Truth label definition might be wrong" );
731 }
732 nMatchPart = ghostParts.size();
733 }
734
735 return nMatchPart;
736}
737
738int JetTruthLabelingTool::getLabel( DecorHandles& dh,
739 const xAOD::Jet &jet,
740 bool matchH,
741 bool matchW,
742 bool matchZ,
743 bool matchTop,
744 const EventContext& ctx) const {
745
746 // store GhostBHadronsFinal count
747 int nMatchB = getNGhostParticles( jet, "GhostBHadronsFinal" );
748 (*dh.nbHandle)(jet) = nMatchB;
749
751 bool is_bb = false;
752 bool is_cc = false;
753 bool is_tautauEl = false;
754 bool is_tautauMu = false;
755 bool is_tautauHad = false;
756 bool isTop = false;
757 bool isW = false;
758 bool isZ = false;
759
760 // Use R21Precision_2022v1 definition
761 if ( m_truthLabelConfig == TruthLabelConfiguration::R21Precision_2022v1) {
762 SG::ReadDecorHandle<xAOD::JetContainer, float> split23Handle(m_split23_truthKey, ctx);
763 SG::ReadDecorHandle<xAOD::JetContainer, float> split12Handle(m_split12_truthKey, ctx);
764 is_bb = ( nMatchB > 1 );
765 isTop = ( matchTop && matchW && nMatchB > 0 && jet.m() / 1000. > m_mLowTop && split23Handle(jet) / 1000. > getTopSplit23Cut( jet.pt() / 1000. ) );
766 isW = matchW && nMatchB == 0 && jet.m() / 1000. > m_mLowW && split12Handle(jet) / 1000. > getWZSplit12Cut( jet.pt() / 1000. );
767 isZ = matchZ && jet.m() / 1000. > m_mLowZ && split12Handle(jet) / 1000. > getWZSplit12Cut( jet.pt() / 1000. );
768 }
769
770 // Use R10TruthLabel_R22v1 definition
771 if ( m_truthLabelConfig == TruthLabelConfiguration::R10TruthLabel_R22v1 || m_truthLabelConfig == TruthLabelConfiguration::R10WZTruthLabel_R22v1) {
772 // get extended ghost associated truth label
773 int extended_GA_label = -1;
774 if (not jet.getAttribute("HadronGhostExtendedTruthLabelID", extended_GA_label)) {
775 ATH_MSG_ERROR( "HadronGhostExtendedTruthLabelID not available for " + m_truthJetCollectionKey.key() );
776 }
777
778 SG::ReadDecorHandle<xAOD::JetContainer, float> split23Handle(m_split23_truthKey, ctx);
779 SG::ReadDecorHandle<xAOD::JetContainer, float> split12Handle(m_split12_truthKey, ctx);
780 is_bb = ( extended_GA_label == 55 );
781 is_cc = ( extended_GA_label == 44 );
782 is_tautauEl = ( extended_GA_label == 151511 );
783 is_tautauMu = ( extended_GA_label == 151513 );
784 is_tautauHad = ( extended_GA_label == 1515 );
785 isTop = ( matchTop && matchW && nMatchB > 0 && jet.m() / 1000. > m_mLowTop && split23Handle(jet) / 1000. > getTopSplit23Cut( jet.pt() / 1000. ) );
786 isW = matchW && nMatchB == 0 && jet.m() / 1000. > m_mLowW && split12Handle(jet) / 1000. > getWZSplit12Cut( jet.pt() / 1000. );
787 isZ = matchZ && jet.m() / 1000. > m_mLowZ && split12Handle(jet) / 1000. > getWZSplit12Cut( jet.pt() / 1000. );
788 }
789
790
792
793 /* The default priority of labels is:
794 * 1) Hbb/cc/tautau
795 * 2) Contained top
796 * 3) Contained W
797 * 4) Contained Zbb/cc/qq/tautau
798 * 5) Uncontained top
799 * 6) Uncontained V
800 */
801
803 if( !(matchTop || matchW || matchZ || matchH) ) {
804 return LargeRJetTruthLabel::qcd;
805 }
806
807 // Higgs
808 if ( matchH ) {
810 if ( is_bb ) return LargeRJetTruthLabel::Hbb;
812 if ( is_cc ) return LargeRJetTruthLabel::Hcc;
814 if ( is_tautauEl ) return LargeRJetTruthLabel::HtautauEl;
815 if ( is_tautauMu ) return LargeRJetTruthLabel::HtautauMu;
816 if ( is_tautauHad ) return LargeRJetTruthLabel::HtautauHad;
818 return LargeRJetTruthLabel::other_From_H;
819 }
820
822 if ( isTop ) return LargeRJetTruthLabel::tqqb;
823
824 if ( isW ) {
826 if ( matchTop ) return LargeRJetTruthLabel::Wqq_From_t;
828 return LargeRJetTruthLabel::Wqq;
829 }
830
831 if ( matchZ ) {
833 if ( is_bb ) return LargeRJetTruthLabel::Zbb;
835 if ( is_cc ) return LargeRJetTruthLabel::Zcc;
837 if ( is_tautauEl ) return LargeRJetTruthLabel::ZtautauEl;
838 if ( is_tautauMu ) return LargeRJetTruthLabel::ZtautauMu;
839 if ( is_tautauHad ) return LargeRJetTruthLabel::ZtautauHad;
840 }
841 if ( isZ ) {
843 return LargeRJetTruthLabel::Zqq;
844 }
845
847 if ( matchTop ) return LargeRJetTruthLabel::other_From_t;
848
850 return LargeRJetTruthLabel::other_From_V;
851
852}
deltaR
Scalar deltaR(const MatrixBase< Derived > &vec) const
Definition AmgMatrixBasePlugin.h:105
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_WARNING
#define ATH_MSG_WARNING(x)
Definition AthMsgStreamMacros.h:32
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
ReadDecorHandle.h
Handle class for reading a decoration on an object.
ReadHandle.h
Handle class for reading from StoreGate.
WriteDecorHandle.h
Handle class for adding a decoration to an object.
isW
bool isW(const T &p)
Definition AtlasPID.h:382
isZ
bool isZ(const T &p)
Definition AtlasPID.h:379
isTop
bool isTop(const T &p)
Definition AtlasPID.h:185
ConstAccessor.h
Helper class to provide constant type-safe access to aux data.
HepMCHelpers.h
ATLAS-specific HepMC functions.
h
Header file for AthHistogramAlgorithm.
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
JetTruthLabelingTool::m_jetContainerName
Gaudi::Property< std::string > m_jetContainerName
Definition JetTruthLabelingTool.h:50
JetTruthLabelingTool::m_truthLabelName
Gaudi::Property< std::string > m_truthLabelName
Definition JetTruthLabelingTool.h:51
JetTruthLabelingTool::m_forceDeltaRMatch
Gaudi::Property< bool > m_forceDeltaRMatch
Definition JetTruthLabelingTool.h:54
JetTruthLabelingTool::m_getTruthGroomedJetValues
bool m_getTruthGroomedJetValues
Use the ungroomed reco jet parent to match to truth jet.
Definition JetTruthLabelingTool.h:66
JetTruthLabelingTool::m_mLowZ
double m_mLowZ
Lower mass cut for W label.
Definition JetTruthLabelingTool.h:71
JetTruthLabelingTool::m_matchedTruthJetDR_recoKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_matchedTruthJetDR_recoKey
Definition JetTruthLabelingTool.h:167
JetTruthLabelingTool::m_NB_truthKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_NB_truthKey
Definition JetTruthLabelingTool.h:153
JetTruthLabelingTool::labelRecoJets
StatusCode labelRecoJets(DecorHandles &dh, const xAOD::JetContainer &jets, const EventContext &ctx) const
Apply labels to all jets in a container.
Definition JetTruthLabelingTool.cxx:306
JetTruthLabelingTool::getTopSplit23Cut
float getTopSplit23Cut(float pt) const
Get top label Split23 cut.
Definition JetTruthLabelingTool.cxx:701
JetTruthLabelingTool::m_matchedTruthJetPt_recoKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_matchedTruthJetPt_recoKey
Definition JetTruthLabelingTool.h:164
JetTruthLabelingTool::m_label_recoKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_label_recoKey
Definition JetTruthLabelingTool.h:157
JetTruthLabelingTool::labelTruthJets
StatusCode labelTruthJets(DecorHandles &dh, const EventContext &ctx) const
Label truth jet collection.
Definition JetTruthLabelingTool.cxx:633
JetTruthLabelingTool::m_matchedTruthJetPhi_recoKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_matchedTruthJetPhi_recoKey
Definition JetTruthLabelingTool.h:166
JetTruthLabelingTool::m_mLowTop
double m_mLowTop
Ghost pT fraction to match truth jet to reco jet.
Definition JetTruthLabelingTool.h:69
JetTruthLabelingTool::initialize
virtual StatusCode initialize() override
Dummy implementation of the initialisation function.
Definition JetTruthLabelingTool.cxx:46
JetTruthLabelingTool::m_truthGroomedJetCollectionKey
SG::ReadHandleKey< xAOD::JetContainer > m_truthGroomedJetCollectionKey
Definition JetTruthLabelingTool.h:62
JetTruthLabelingTool::print
void print() const override
Print configured parameters.
Definition JetTruthLabelingTool.cxx:197
JetTruthLabelingTool::getTruthJetLabelGA
int getTruthJetLabelGA(DecorHandles &dh, const xAOD::Jet &jet, const EventContext &ctx) const
Get truth label using ghost-associated particles.
Definition JetTruthLabelingTool.cxx:242
JetTruthLabelingTool::m_matchedTruthJetMass_recoKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_matchedTruthJetMass_recoKey
Definition JetTruthLabelingTool.h:163
JetTruthLabelingTool::m_recoGhostFrac
double m_recoGhostFrac
dR to match truth jet to reco jet
Definition JetTruthLabelingTool.h:68
JetTruthLabelingTool::m_matchedTruthJet_recoKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_matchedTruthJet_recoKey
Definition JetTruthLabelingTool.h:162
JetTruthLabelingTool::m_isTruthJetCol
Gaudi::Property< bool > m_isTruthJetCol
Definition JetTruthLabelingTool.h:53
JetTruthLabelingTool::m_truthLabelConfig
TruthLabelConfiguration m_truthLabelConfig
Definition JetTruthLabelingTool.h:150
JetTruthLabelingTool::m_doLargeRLabels
bool m_doLargeRLabels
Lower mass cut for Z label.
Definition JetTruthLabelingTool.h:72
JetTruthLabelingTool::getLabel
int getLabel(DecorHandles &dh, const xAOD::Jet &jet, bool matchH, bool matchW, bool matchZ, bool matchTop, const EventContext &ctx) const
Get label based on matching and containment criteria.
Definition JetTruthLabelingTool.cxx:738
JetTruthLabelingTool::m_truthSplit23_recoKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_truthSplit23_recoKey
Definition JetTruthLabelingTool.h:160
JetTruthLabelingTool::m_matchedPileupTag_recoKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_matchedPileupTag_recoKey
Definition JetTruthLabelingTool.h:168
JetTruthLabelingTool::m_sumPtMatchedOOTJets_recoKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_sumPtMatchedOOTJets_recoKey
Definition JetTruthLabelingTool.h:170
JetTruthLabelingTool::m_ITJetName
SG::ReadHandleKey< xAOD::JetContainer > m_ITJetName
Definition JetTruthLabelingTool.h:60
JetTruthLabelingTool::getWZSplit12Cut
float getWZSplit12Cut(float pt) const
Get W/Z label Split12 cut.
Definition JetTruthLabelingTool.cxx:683
JetTruthLabelingTool::m_split23_truthKey
SG::ReadDecorHandleKey< xAOD::JetContainer > m_split23_truthKey
Definition JetTruthLabelingTool.h:155
JetTruthLabelingTool::m_split12_truthKey
SG::ReadDecorHandleKey< xAOD::JetContainer > m_split12_truthKey
Definition JetTruthLabelingTool.h:154
JetTruthLabelingTool::getNGhostParticles
int getNGhostParticles(const xAOD::Jet &jet, const std::string &collection) const
Get number of ghost associated particles.
Definition JetTruthLabelingTool.cxx:722
JetTruthLabelingTool::m_OOTJetName
SG::ReadHandleKey< xAOD::JetContainer > m_OOTJetName
parameters for truth labeling
Definition JetTruthLabelingTool.h:59
JetTruthLabelingTool::m_truthSplit12_recoKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_truthSplit12_recoKey
Definition JetTruthLabelingTool.h:159
JetTruthLabelingTool::m_evtInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_evtInfoKey
Definition JetTruthLabelingTool.h:56
JetTruthLabelingTool::m_matchedTruthGroomedJetMass_recoKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_matchedTruthGroomedJetMass_recoKey
Definition JetTruthLabelingTool.h:173
JetTruthLabelingTool::m_matchUngroomedParent
bool m_matchUngroomedParent
Is the reco jet collection small or large R, default large.
Definition JetTruthLabelingTool.h:65
JetTruthLabelingTool::parseLabel
TruthLabelConfiguration parseLabel(const std::string &label)
Definition JetTruthLabelingTool.cxx:19
JetTruthLabelingTool::JetTruthLabelingTool
JetTruthLabelingTool(const std::string &name="JetTruthLabelingTool")
default constructor - to be used in all derived classes
Definition JetTruthLabelingTool.cxx:14
JetTruthLabelingTool::m_label_truthKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_label_truthKey
Definition JetTruthLabelingTool.h:152
JetTruthLabelingTool::decorate
StatusCode decorate(const xAOD::JetContainer &jets) const override
decorate truth label to a jet collection
Definition JetTruthLabelingTool.cxx:284
JetTruthLabelingTool::m_truthJetCollectionKey
SG::ReadHandleKey< xAOD::JetContainer > m_truthJetCollectionKey
Definition JetTruthLabelingTool.h:61
JetTruthLabelingTool::m_mLowW
double m_mLowW
Lower mass cut for top label.
Definition JetTruthLabelingTool.h:70
JetTruthLabelingTool::m_NB_recoKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_NB_recoKey
Definition JetTruthLabelingTool.h:158
JetTruthLabelingTool::m_matchedTruthGroomedJetPt_recoKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_matchedTruthGroomedJetPt_recoKey
Definition JetTruthLabelingTool.h:174
JetTruthLabelingTool::m_dRTruthJet
double m_dRTruthJet
When truth jet matching to ungroomed truth, allow saving properties of groomed truth jets.
Definition JetTruthLabelingTool.h:67
JetTruthLabelingTool::m_matchedTruthJetRapidity_recoKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_matchedTruthJetRapidity_recoKey
Definition JetTruthLabelingTool.h:165
JetTruthLabelingTool::m_sumPtMatchedHSJets_recoKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_sumPtMatchedHSJets_recoKey
Definition JetTruthLabelingTool.h:169
JetTruthLabelingTool::m_sumPtMatchedITJets_recoKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_sumPtMatchedITJets_recoKey
Definition JetTruthLabelingTool.h:171
SG::ConstAccessor
Helper class to provide constant type-safe access to aux data.
Definition ConstAccessor.h:55
SG::ReadDecorHandle
Handle class for reading a decoration on an object.
Definition StoreGate/StoreGate/ReadDecorHandle.h:94
SG::ReadDecorHandle::isAvailable
bool isAvailable()
Test to see if this variable exists in the store, for the referenced object.
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
SG::WriteDecorHandleKey
Property holding a SG store/key/clid/attr name from which a WriteDecorHandle is made.
Definition StoreGate/StoreGate/WriteDecorHandleKey.h:90
asg::AsgTool::AsgTool
AsgTool(const std::string &name)
Constructor specifying the tool instance's name.
Definition AsgTool.cxx:58
xAOD::Jet_v1::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
Definition Jet_v1.cxx:54
xAOD::Jet_v1::pt
virtual double pt() const
The transverse momentum ( ) of the particle.
Definition Jet_v1.cxx:44
xAOD::Jet_v1::rapidity
virtual double rapidity() const
The true rapidity (y) of the particle.
Definition Jet_v1.cxx:67
xAOD::Jet_v1::m
virtual double m() const
The invariant mass of the particle.
Definition Jet_v1.cxx:59
label
std::string label(const std::string &format, int i)
Definition label.h:19
LargeRJetTruthLabel::enumToInt
int enumToInt(const TypeEnum type)
Definition LargeRJetLabelEnum.h:37
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition ReadCondHandle.h:269
SmallRJetPileupLabel::enumToInt
int enumToInt(const TypeEnum type)
Definition SmallRJetPileupLabelEnum.h:24
xAOD::Jet
Jet_v1 Jet
Definition of the current "jet version".
Definition Event/xAOD/xAODJet/xAODJet/Jet.h:17
xAOD::TruthParticle
TruthParticle_v1 TruthParticle
Typedef to implementation.
Definition Event/xAOD/xAODTruth/xAODTruth/TruthParticle.h:15
xAOD::JetContainer
JetContainer_v1 JetContainer
Definition of the current "jet container version".
Definition JetContainer.h:17
JetTruthLabelingTool::DecorHandles
Track internally if the W,Z,Top labels should be done (for large-R).
Definition JetTruthLabelingTool.h:74
JetTruthLabelingTool::DecorHandles::DecorHandles
DecorHandles(const JetTruthLabelingTool &tool, const EventContext &ctx)
Definition JetTruthLabelingTool.cxx:212
Generated on for ATLAS Offline Software by doxygen 1.16.1