ATLAS Offline Software
JetMatcherAlg.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "JetMonitoring/JetMatcherAlg.h"
6 #include "AsgDataHandles/WriteDecorHandle.h"
7 
8 //**********************************************************************
9 
10 JetMatcherAlg::JetMatcherAlg( const std::string& name, ISvcLocator* pSvcLocator ) : AthReentrantAlgorithm(name,pSvcLocator)
11 {
12  declareProperty("JetContainerName1" ,m_jetContainerKey1="");
13  declareProperty("JetContainerName2" ,m_jetContainerKey2="");
14 
15  declareProperty("L1JetContainerName1",m_l1jetContainerKey1="");
16  declareProperty("L1jFexSRJetRoIContainerName",m_jFexSRJetRoIKey="");
17  declareProperty("L1jFexLRJetRoIContainerName",m_jFexLRJetRoIKey="");
18  declareProperty("L1gFexJetRoIContainerName",m_gFexJetRoIKey="");
19 }
20 
21 //**********************************************************************
22 
23 StatusCode JetMatcherAlg::initialize() {
24  /* Initialise ReadHandle keys for the two xAOD jet containers
25  and various L1 xAOD jet containers.
26 
27  xAOD jet containers are produced by the both hlt and offline
28  reconstruction programs. The L1 trigger system produces various
29  container types.
30 
31  The attribute m_jetContainerKey2 must not be initialised to "NONE".
32 
33  An instance of JetMatcher Alg will work with two containers only.
34  However, all ReadHandles must be initialised.
35 
36 
37 
38  */
39 
40  ATH_MSG_INFO(" Initializing " << name());
41 
42  if ( m_jetContainerKey2.key().empty() ) {
43 
44  std::string msg = "JetContainerKey2 has not been configured correctly - "
45  "has value NONE";
46  ATH_MSG_ERROR(msg);
47 
48  return StatusCode::FAILURE;
49  }
50 
51  int key_count{0};
52 
53  if (!m_jetContainerKey1.key().empty()) {
54  ++key_count;
55  m_matchType = MatchType::xAODJet;
56  ATH_MSG_INFO("will match xAODJet to xAODJet");
57  }
58 
59  if (!m_l1jetContainerKey1.key().empty()) {
60  ++key_count;
61  m_matchType = MatchType::JetRoI;
62  ATH_MSG_INFO("will match JetRoI (L1) to xAODJet");
63  }
64 
65  if (!m_jFexSRJetRoIKey.key().empty()) {
66  ++key_count;
67  m_matchType = MatchType::jFexSRJetRoI;
68  ATH_MSG_INFO("will match jFexSRJetRoI (L1) to xAODJet");
69  }
70 
71 
72  if (!m_jFexLRJetRoIKey.key().empty()) {
73  ++key_count;
74  m_matchType = MatchType::jFexLRJetRoI;
75  ATH_MSG_INFO("will match jFexLRJetRoI (L1) to xAODJet");
76  }
77 
78 
79  if (!m_gFexJetRoIKey.key().empty()) {
80  ++key_count;
81  m_matchType = MatchType::gFexJetRoI;
82  ATH_MSG_INFO("will match gFexSRJetRoI (L1) to xAODJet");
83  }
84 
85  if (key_count != 1) {
86  ATH_MSG_ERROR(key_count <<
87  " containers requested. This should be exactly 1");
88  return StatusCode::FAILURE;
89  }
90 
91  // code was originally written to use m_matchL1 to determine
92  // if matching was to be done with the L1 jet container. At that
93  // time, there was a single L1 jet container type.
94  // The existence of m_matchL1 has been maintained to allow
95  // older configuration code to continue to work.
96  //
97  bool l1_match =
98  m_matchType == MatchType::JetRoI ||
99  m_matchType == MatchType::jFexSRJetRoI ||
100  m_matchType == MatchType::jFexLRJetRoI ||
101  m_matchType == MatchType::gFexJetRoI;
102 
103  if (l1_match != m_matchL1) {
104  ATH_MSG_ERROR("m_matchL1 is misconfigured");
105  return StatusCode::FAILURE;
106  }
107 
108 
109  ATH_CHECK( m_jetContainerKey1.initialize( SG::AllowEmpty ) );
110  ATH_CHECK( m_jetContainerKey2.initialize( SG::AllowEmpty ) );
111  ATH_CHECK( m_l1jetContainerKey1.initialize( SG::AllowEmpty ) );
112  ATH_CHECK( m_jFexSRJetRoIKey.initialize( SG::AllowEmpty ) );
113  ATH_CHECK( m_jFexLRJetRoIKey.initialize( SG::AllowEmpty ) );
114  ATH_CHECK( m_gFexJetRoIKey.initialize( SG::AllowEmpty ) );
115 
116  ATH_CHECK(set_xAODJet_varHandleKeys());
117  ATH_CHECK(set_JetRoI_varHandleKeys());
118  ATH_CHECK(set_jFexSRJetRoI_varHandleKeys());
119  ATH_CHECK(set_jFexLRJetRoI_varHandleKeys());
120  ATH_CHECK(set_gFexJetRoI_varHandleKeys());
121 
122  ATH_CHECK(initialize_varHandleKeys());
123 
124  return StatusCode::SUCCESS;
125 }
126 
127 //**********************************************************************
128 
129 StatusCode JetMatcherAlg::finalize() {
130  ATH_MSG_INFO ("Finalizing " << name());
131  return StatusCode::SUCCESS;
132 }
133 
134 //**********************************************************************
135 
136 StatusCode JetMatcherAlg::GetTLV(const xAOD::Jet* jet, TLorentzVector& tlv) const {
137 
138  if (m_calibScale == "" ) {
139  tlv.SetPtEtaPhiE(jet->pt(),jet->eta(),jet->phi(),jet->e());
140  } else { //retrieve fourmomentum at specified calibration scale
141  xAOD::JetFourMom_t fourVec;
142  bool status = jet->getAttribute<xAOD::JetFourMom_t>( "Jet"+m_calibScale+"Momentum", fourVec );
143  if(!status) {
144  ATH_MSG_WARNING("evtStore() cannot retrieve JetFourMomentum at " << m_calibScale);
145  return StatusCode::FAILURE;
146  }
147  tlv.SetPtEtaPhiE(fourVec.Pt(),fourVec.Eta(),fourVec.Phi(),fourVec.E());
148  }
149  return StatusCode::SUCCESS;
150 }
151 
152 StatusCode JetMatcherAlg::GetTLV(const xAOD::JetRoI* jet, TLorentzVector& tlv) const {
153 
154  tlv.SetPtEtaPhiM(jet->et8x8(),jet->eta(),jet->phi(),0.);
155  return StatusCode::SUCCESS;
156 }
157 
158 StatusCode JetMatcherAlg::GetTLV(const xAOD::jFexSRJetRoI* jet, TLorentzVector& tlv) const {
159 
160  tlv.SetPtEtaPhiM(jet->et(),jet->eta(),jet->phi(),0.);
161  return StatusCode::SUCCESS;
162 }
163 
164 StatusCode JetMatcherAlg::GetTLV(const xAOD::jFexLRJetRoI* jet, TLorentzVector& tlv) const {
165 
166  tlv.SetPtEtaPhiM(jet->et(),jet->eta(),jet->phi(),0.);
167  return StatusCode::SUCCESS;
168 }
169 
170 StatusCode JetMatcherAlg::GetTLV(const xAOD::gFexJetRoI* jet, TLorentzVector& tlv) const {
171 
172  tlv.SetPtEtaPhiM(jet->et(),jet->eta(),jet->phi(),0.);
173  return StatusCode::SUCCESS;
174 }
175 
176 
177 
178 //**********************************************************************
179 
180 template <typename T>
181 StatusCode JetMatcherAlg::jetMatching(SG::ReadHandle<DataVector<T>> jets1,
182  SG::ReadHandle<xAOD::JetContainer> jets2,
183  SG::WriteDecorHandleKey<DataVector<T>> matchedHandleKey,
184  std::vector<std::reference_wrapper<SG::WriteDecorHandleKey<DataVector<T>>>> varHandleKeys,
185  const EventContext& ctx) const{
186 
187  SG::WriteDecorHandle<DataVector<T>, double> ptDiffHandle(varHandleKeys[0].get(), ctx);
188  SG::WriteDecorHandle<DataVector<T>, double> energyDiffHandle(varHandleKeys[1].get(), ctx);
189  SG::WriteDecorHandle<DataVector<T>, double> massDiffHandle(varHandleKeys[2].get(), ctx);
190  SG::WriteDecorHandle<DataVector<T>, double> ptRespHandle(varHandleKeys[3].get(), ctx);
191  SG::WriteDecorHandle<DataVector<T>, double> energyRespHandle(varHandleKeys[4].get(), ctx);
192  SG::WriteDecorHandle<DataVector<T>, double> massRespHandle(varHandleKeys[5].get(), ctx);
193  SG::WriteDecorHandle<DataVector<T>, double> ptRefHandle(varHandleKeys[6].get(), ctx);
194  SG::WriteDecorHandle<DataVector<T>, double> etaRefHandle(varHandleKeys[7].get(), ctx);
195  SG::WriteDecorHandle<DataVector<T>, char> matchedHandle(matchedHandleKey, ctx);
196 
197  std::vector<int> matchedIndices; //remembers which jets in jets2 are already matched, so they are not considered in future matching
198  // Loop over first jet collection
199  for (const T *j1 : *jets1) {
200  TLorentzVector tlvjet1 = TLorentzVector();
201  StatusCode status = GetTLV(j1, tlvjet1);
202  if (!status) {
203  ATH_MSG_WARNING("Could not retrieve full jet 4-momentum. Skipping jet matching.");
204  return StatusCode::SUCCESS;
205  }
206  bool j1matched = false;
207  double ptDiff = -999., energyDiff = -999., massDiff = -999., ptResp = -999., energyResp = -999., massResp = -999., ptRef = -999., etaRef = -999.;
208  if (tlvjet1.Pt() < 10000.) { // minimum pT cut of 10 GeV for jet matching
209  matchedHandle(*j1) = j1matched; // set default values for match decorations and move to next jet
210  ptDiffHandle(*j1) = ptDiff;
211  energyDiffHandle(*j1) = energyDiff;
212  massDiffHandle(*j1) = massDiff;
213  ptRespHandle(*j1) = ptResp;
214  energyRespHandle(*j1) = energyResp;
215  massRespHandle(*j1) = massResp;
216  ptRefHandle(*j1) = ptRef;
217  etaRefHandle(*j1) = etaRef;
218  continue;
219  }
220  double Rmin = 1E8;
221  int jetIndex = 0, jetMatchIndex = 0;
222  // Loop over second jet collection
223  for(const xAOD::Jet* j2 : *jets2){
224  if (j2->pt() < 10000.) { jetIndex++; continue; } // minimum pT cut of 10 GeV for jet matching
225  bool alreadymatched = false;
226  for (int jetIndexIterator : matchedIndices) { //Loop over indices of already matched jets to skip them
227  if (jetIndex == jetIndexIterator) { alreadymatched = true; break; }
228  }
229  if (alreadymatched) { jetIndex++; continue; }
230  TLorentzVector tlvjet2 = TLorentzVector();
231  tlvjet2.SetPtEtaPhiE(j2->pt(),j2->eta(),j2->phi(),j2->e());
232  // calculate DeltaR(jet1,jet2)
233  double dr = tlvjet1.DeltaR(tlvjet2);
234  if(dr<m_Rmatch && dr<Rmin){ // decorate matching jets
235  j1matched = true;
236  ptDiff = tlvjet1.Pt()-tlvjet2.Pt();
237  energyDiff = tlvjet1.E()-tlvjet2.E();
238  massDiff = tlvjet1.M()-tlvjet2.M();
239  ptResp = ptDiff/tlvjet2.Pt();
240  if (tlvjet2.E() == 0.) energyResp = -999.;
241  else energyResp = energyDiff/tlvjet2.E();
242  if (tlvjet2.M() == 0.) massResp = -999.;
243  else massResp = massDiff/tlvjet2.M();
244  ptRef = tlvjet2.Pt(); //second jet collection (=offline) is taken for reference pT and eta
245  etaRef = tlvjet2.Eta();
246  Rmin = dr;
247  jetMatchIndex = jetIndex;
248  }
249  jetIndex++;
250  }//End Loop over second jet collection
251  matchedHandle(*j1) = j1matched;
252  ptDiffHandle(*j1) = ptDiff;
253  energyDiffHandle(*j1) = energyDiff;
254  massDiffHandle(*j1) = massDiff;
255  ptRespHandle(*j1) = ptResp;
256  energyRespHandle(*j1) = energyResp;
257  massRespHandle(*j1) = massResp;
258  ptRefHandle(*j1) = ptRef;
259  etaRefHandle(*j1) = etaRef;
260  if (j1matched) matchedIndices.push_back(jetMatchIndex);
261  }
262  return StatusCode::SUCCESS;
263 
264 }
265 
266 //**********************************************************************
267 
268 
269 StatusCode JetMatcherAlg::execute(const EventContext& ctx) const {
270 
271  // Retrieve jet containers and call appropriate matching function
272  SG::ReadHandle<xAOD::JetContainer> jets2(m_jetContainerKey2, ctx);
273  if (!jets2.isValid() ) {
274  ATH_MSG_ERROR("evtStore() does not contain jet Collection with name "<< m_jetContainerKey2);
275  return StatusCode::FAILURE;
276  }
277 
278  if (m_matchType == MatchType::xAODJet) { // perform jet matching for online/offline xAODJet containers
279  SG::ReadHandle<xAOD::JetContainer> jets1(m_jetContainerKey1, ctx);
280  if (!jets1.isValid() ) {
281  ATH_MSG_ERROR("evtStore() does not contain jet Collection with name "<< m_jetContainerKey1);
282  return StatusCode::FAILURE;
283  }
284  return jetMatching(jets1, jets2, m_matchedKey, m_jetVarHandleKeys, ctx);
285 
286  } else if(m_matchType == MatchType::JetRoI) { // perform jet matching for L1 JetRoI container
287  SG::ReadHandle<xAOD::JetRoIContainer> jets1(m_l1jetContainerKey1, ctx);
288  if (!jets1.isValid() ) {
289  ATH_MSG_ERROR("evtStore() does not contain L1 jet Collection with name "<< m_l1jetContainerKey1);
290  return StatusCode::FAILURE;
291  }
292  return jetMatching(jets1, jets2, m_l1matchedKey, m_l1JetVarHandleKeys, ctx);
293 
294  } else if (m_matchType == MatchType::jFexSRJetRoI) { // perform jet matching for L1 jFexSRJetRoI container
295  SG::ReadHandle<xAOD::jFexSRJetRoIContainer> jets1(m_jFexSRJetRoIKey, ctx);
296  if (!jets1.isValid() ) {
297  ATH_MSG_ERROR("evtStore() does not contain L1 jet Collection with name "<< m_jFexSRJetRoIKey);
298  return StatusCode::FAILURE;
299  }
300  return jetMatching(jets1, jets2, m_l1jFexSRmatchedKey, m_l1jFexSRJetVarHandleKeys, ctx);
301 
302 
303  } else if (m_matchType == MatchType::jFexLRJetRoI) { // perform jet matching for L1 jFexLRJetRoI container
304  SG::ReadHandle<xAOD::jFexLRJetRoIContainer> jets1(m_jFexLRJetRoIKey, ctx);
305  if (!jets1.isValid() ) {
306  ATH_MSG_ERROR("evtStore() does not contain L1 jet Collection with name "<< m_jFexSRJetRoIKey);
307  return StatusCode::FAILURE;
308  }
309  return jetMatching(jets1, jets2, m_l1jFexLRmatchedKey, m_l1jFexLRJetVarHandleKeys, ctx);
310 
311  } else if (m_matchType == MatchType::gFexJetRoI) { // perform jet matching for L1 gFexJetRoI container
312  SG::ReadHandle<xAOD::gFexJetRoIContainer> jets1(m_gFexJetRoIKey, ctx);
313  if (!jets1.isValid() ) {
314  ATH_MSG_ERROR("evtStore() does not contain L1 jet Collection with name "<< m_gFexJetRoIKey);
315  return StatusCode::FAILURE;
316  }
317  return jetMatching(jets1, jets2, m_l1gFexmatchedKey, m_l1gFexJetVarHandleKeys, ctx);
318  }
319 
320  ATH_MSG_ERROR("unsupported type for jet matching targe");
321  return StatusCode::FAILURE;
322 
323 }
324 
325 
326 StatusCode JetMatcherAlg::set_xAODJet_varHandleKeys() {
327 
328 
329  if (m_matchType == MatchType::xAODJet) {
330  std::string prepend{m_jetContainerKey1.key()};
331  std::string keyAppendix{m_jetContainerKey2.key()};
332  if (m_calibScale != "") {
333  keyAppendix = m_calibScale + "_" + m_jetContainerKey2.key();
334  }
335 
336  m_ptDiffKey = prepend+".ptdiff_" + keyAppendix;
337  m_energyDiffKey = prepend+".energydiff_" + keyAppendix;
338  m_massDiffKey = prepend+".massdiff_" + keyAppendix;
339  m_ptRespKey = prepend+".ptresp_" + keyAppendix;
340  m_energyRespKey = prepend+".energyresp_" + keyAppendix;
341  m_massRespKey = prepend+".massresp_" + keyAppendix;
342  m_ptRefKey = prepend+".ptRef_" + keyAppendix;
343  m_etaRefKey = prepend+".etaRef_" + keyAppendix;
344  m_matchedKey = prepend+".matched_" + keyAppendix;
345  }
346 
347  m_jetVarHandleKeys = {
348  m_ptDiffKey,
349  m_energyDiffKey,
350  m_massDiffKey,
351  m_ptRespKey,
352  m_energyRespKey,
353  m_massRespKey,
354  m_ptRefKey,
355  m_etaRefKey
356  };
357 
358 
359  return StatusCode::SUCCESS;
360 
361 }
362 
363 
364 StatusCode JetMatcherAlg::set_JetRoI_varHandleKeys() {
365 
366 
367  if (m_matchType == MatchType::JetRoI) {
368  std::string keyAppendix{m_jetContainerKey2.key()};
369  std::string prepend{m_l1jetContainerKey1.key()};
370 
371  m_l1ptDiffKey = prepend+".ptdiff_" + keyAppendix;
372  m_l1energyDiffKey = prepend+".energydiff_" + keyAppendix;
373  m_l1massDiffKey = prepend+".massdiff_" + keyAppendix;
374  m_l1ptRespKey = prepend+".ptresp_" + keyAppendix;
375  m_l1energyRespKey = prepend+".energyresp_" + keyAppendix;
376  m_l1massRespKey = prepend+".massresp_" + keyAppendix;
377  m_l1ptRefKey = prepend+".ptRef_" + keyAppendix;
378  m_l1etaRefKey = prepend+".etaRef_" + keyAppendix;
379  m_l1matchedKey = prepend+".matched_" + keyAppendix;
380  }
381 
382  m_l1JetVarHandleKeys = {
383  m_l1ptDiffKey,
384  m_l1energyDiffKey,
385  m_l1massDiffKey,
386  m_l1ptRespKey,
387  m_l1energyRespKey,
388  m_l1massRespKey,
389  m_l1ptRefKey,
390  m_l1etaRefKey
391  };
392 
393  return StatusCode::SUCCESS;
394 
395 }
396 
397 
398 StatusCode JetMatcherAlg::set_jFexSRJetRoI_varHandleKeys() {
399 
400  if (m_matchType == MatchType::jFexSRJetRoI) {
401 
402  std::string keyAppendix = m_jetContainerKey2.key();
403  std::string prepend = m_jFexSRJetRoIKey.key();
404 
405  m_l1jFexSRptDiffKey = prepend+".ptdiff_" + keyAppendix;
406  m_l1jFexSRenergyDiffKey = prepend+".energydiff_" + keyAppendix;
407  m_l1jFexSRmassDiffKey = prepend+".massdiff_" + keyAppendix;
408  m_l1jFexSRptRespKey = prepend+".ptresp_" + keyAppendix;
409  m_l1jFexSRenergyRespKey = prepend+".energyresp_" + keyAppendix;
410  m_l1jFexSRmassRespKey = prepend+".massresp_" + keyAppendix;
411  m_l1jFexSRptRefKey = prepend+".ptRef_" + keyAppendix;
412  m_l1jFexSRetaRefKey = prepend+".etaRef_" + keyAppendix;
413  m_l1jFexSRmatchedKey = prepend+".matched_" + keyAppendix;
414  }
415 
416 
417  m_l1jFexSRJetVarHandleKeys = {
418  m_l1jFexSRptDiffKey,
419  m_l1jFexSRenergyDiffKey,
420  m_l1jFexSRmassDiffKey,
421  m_l1jFexSRptRespKey,
422  m_l1jFexSRenergyRespKey,
423  m_l1jFexSRmassRespKey,
424  m_l1jFexSRptRefKey,
425  m_l1jFexSRetaRefKey};
426 
427  return StatusCode::SUCCESS;
428 }
429 
430 StatusCode JetMatcherAlg::set_jFexLRJetRoI_varHandleKeys() {
431 
432  if (m_matchType == MatchType::jFexLRJetRoI) {
433 
434  std::string keyAppendix = m_jetContainerKey2.key();
435  std::string prepend = m_jFexLRJetRoIKey.key();
436 
437  m_l1jFexLRptDiffKey = prepend+".ptdiff_" + keyAppendix;
438  m_l1jFexLRenergyDiffKey = prepend+".energydiff_" + keyAppendix;
439  m_l1jFexLRmassDiffKey = prepend+".massdiff_" + keyAppendix;
440  m_l1jFexLRptRespKey = prepend+".ptresp_" + keyAppendix;
441  m_l1jFexLRenergyRespKey = prepend+".energyresp_" + keyAppendix;
442  m_l1jFexLRmassRespKey = prepend+".massresp_" + keyAppendix;
443  m_l1jFexLRptRefKey = prepend+".ptRef_" + keyAppendix;
444  m_l1jFexLRetaRefKey = prepend+".etaRef_" + keyAppendix;
445  m_l1jFexLRmatchedKey = prepend+".matched_" + keyAppendix;
446  }
447 
448 
449  m_l1jFexLRJetVarHandleKeys = {
450  m_l1jFexLRptDiffKey,
451  m_l1jFexLRenergyDiffKey,
452  m_l1jFexLRmassDiffKey,
453  m_l1jFexLRptRespKey,
454  m_l1jFexLRenergyRespKey,
455  m_l1jFexLRmassRespKey,
456  m_l1jFexLRptRefKey,
457  m_l1jFexLRetaRefKey};
458 
459  return StatusCode::SUCCESS;
460 }
461 
462 StatusCode JetMatcherAlg::set_gFexJetRoI_varHandleKeys() {
463 
464  if (m_matchType == MatchType::gFexJetRoI) {
465 
466  std::string keyAppendix = m_jetContainerKey2.key();
467  std::string prepend = m_gFexJetRoIKey.key();
468 
469  m_l1gFexptDiffKey = prepend+".ptdiff_" + keyAppendix;
470  m_l1gFexenergyDiffKey = prepend+".energydiff_" + keyAppendix;
471  m_l1gFexmassDiffKey = prepend+".massdiff_" + keyAppendix;
472  m_l1gFexptRespKey = prepend+".ptresp_" + keyAppendix;
473  m_l1gFexenergyRespKey = prepend+".energyresp_" + keyAppendix;
474  m_l1gFexmassRespKey = prepend+".massresp_" + keyAppendix;
475  m_l1gFexptRefKey = prepend+".ptRef_" + keyAppendix;
476  m_l1gFexetaRefKey = prepend+".etaRef_" + keyAppendix;
477  m_l1gFexmatchedKey = prepend+".matched_" + keyAppendix;
478  }
479 
480 
481  m_l1gFexJetVarHandleKeys = {
482  m_l1gFexptDiffKey,
483  m_l1gFexenergyDiffKey,
484  m_l1gFexmassDiffKey,
485  m_l1gFexptRespKey,
486  m_l1gFexenergyRespKey,
487  m_l1gFexmassRespKey,
488  m_l1gFexptRefKey,
489  m_l1gFexetaRefKey};
490 
491  return StatusCode::SUCCESS;
492 }
493 
494 StatusCode JetMatcherAlg::initialize_varHandleKeys(){
495 
496  if (m_matchType == MatchType::xAODJet) {
497  ATH_CHECK(initialize_xAODJet_varHandleKeys(true));
498  ATH_CHECK(initialize_JetRoI_varHandleKeys(false));
499  ATH_CHECK(initialize_jFexSRJetRoI_varHandleKeys(false));
500  ATH_CHECK(initialize_jFexLRJetRoI_varHandleKeys(false));
501  ATH_CHECK(initialize_gFexJetRoI_varHandleKeys(false));
502  } else if (m_matchType == MatchType::JetRoI) {
503  ATH_CHECK(initialize_xAODJet_varHandleKeys(false));
504  ATH_CHECK(initialize_JetRoI_varHandleKeys(true));
505  ATH_CHECK(initialize_jFexSRJetRoI_varHandleKeys(false));
506  ATH_CHECK(initialize_jFexLRJetRoI_varHandleKeys(false));
507  ATH_CHECK(initialize_gFexJetRoI_varHandleKeys(false));
508  } else if (m_matchType == MatchType::jFexSRJetRoI) {
509  ATH_CHECK(initialize_xAODJet_varHandleKeys(false));
510  ATH_CHECK(initialize_JetRoI_varHandleKeys(false));
511  ATH_CHECK(initialize_jFexSRJetRoI_varHandleKeys(true));
512  ATH_CHECK(initialize_jFexLRJetRoI_varHandleKeys(false));
513  ATH_CHECK(initialize_gFexJetRoI_varHandleKeys(false));
514  } else if (m_matchType == MatchType::jFexLRJetRoI) {
515  ATH_CHECK(initialize_xAODJet_varHandleKeys(false));
516  ATH_CHECK(initialize_JetRoI_varHandleKeys(false));
517  ATH_CHECK(initialize_jFexSRJetRoI_varHandleKeys(false));
518  ATH_CHECK(initialize_jFexLRJetRoI_varHandleKeys(true));
519  ATH_CHECK(initialize_gFexJetRoI_varHandleKeys(false));
520  } else if (m_matchType == MatchType::gFexJetRoI) {
521  ATH_CHECK(initialize_xAODJet_varHandleKeys(false));
522  ATH_CHECK(initialize_JetRoI_varHandleKeys(false));
523  ATH_CHECK(initialize_jFexSRJetRoI_varHandleKeys(false));
524  ATH_CHECK(initialize_jFexLRJetRoI_varHandleKeys(false));
525  ATH_CHECK(initialize_gFexJetRoI_varHandleKeys(true));
526  } else {
527  ATH_MSG_FATAL("uknown match type");
528  return StatusCode::FAILURE;
529  }
530  return StatusCode::SUCCESS;
531 }
532 
533 StatusCode JetMatcherAlg::initialize_xAODJet_varHandleKeys(bool do_it){
534  for (auto& key : m_jetVarHandleKeys) {
535  ATH_CHECK(key.get().initialize(do_it));
536  ATH_CHECK(m_matchedKey.initialize(do_it));
537 
538  }
539  return StatusCode::SUCCESS;
540 }
541 
542 StatusCode JetMatcherAlg::initialize_JetRoI_varHandleKeys(bool do_it){
543  for (auto& key : m_l1JetVarHandleKeys) {
544  ATH_CHECK(key.get().initialize(do_it));
545  ATH_CHECK(m_l1matchedKey.initialize(do_it));
546  }
547  return StatusCode::SUCCESS;
548 }
549 
550 
551 StatusCode JetMatcherAlg::initialize_jFexSRJetRoI_varHandleKeys(bool do_it){
552  for (auto& key : m_l1jFexSRJetVarHandleKeys) {
553  ATH_CHECK(key.get().initialize(do_it));
554  ATH_CHECK(m_l1jFexSRmatchedKey.initialize(do_it));
555  }
556  return StatusCode::SUCCESS;
557 }
558 
559 StatusCode JetMatcherAlg::initialize_jFexLRJetRoI_varHandleKeys(bool do_it){
560  for (auto& key : m_l1jFexLRJetVarHandleKeys) {
561  ATH_CHECK(key.get().initialize(do_it));
562  ATH_CHECK(m_l1jFexLRmatchedKey.initialize(do_it));
563  }
564  return StatusCode::SUCCESS;
565 }
566 
567 
568 StatusCode JetMatcherAlg::initialize_gFexJetRoI_varHandleKeys(bool do_it){
569  for (auto& key : m_l1gFexJetVarHandleKeys) {
570  ATH_CHECK(key.get().initialize(do_it));
571  ATH_CHECK(m_l1gFexmatchedKey.initialize(do_it));
572  }
573  return StatusCode::SUCCESS;
574 }
575 
JetMatcherAlg::finalize
StatusCode finalize() override
Definition: JetMatcherAlg.cxx:129
SG::WriteDecorHandleKey
Property holding a SG store/key/clid/attr name from which a WriteDecorHandle is made.
Definition: StoreGate/StoreGate/WriteDecorHandleKey.h:89
xAOD::jFexSRJetRoI_v1
Class describing properties of a LVL1 jFEX global Trigger Object (TOB) in the xAOD format.
Definition: jFexSRJetRoI_v1.h:22
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
JetMatcherAlg::MatchType::gFexJetRoI
@ gFexJetRoI
JetMatcherAlg::m_ptRefKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_ptRefKey
Definition: JetMatcherAlg.h:79
JetMatcherAlg::initialize_JetRoI_varHandleKeys
StatusCode initialize_JetRoI_varHandleKeys(bool)
Definition: JetMatcherAlg.cxx:542
JetMatcherAlg::m_ptDiffKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_ptDiffKey
Definition: JetMatcherAlg.h:73
JetMatcherAlg.h
JetMatcherAlg::m_l1gFexmatchedKey
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainer > m_l1gFexmatchedKey
Definition: JetMatcherAlg.h:120
JetMatcherAlg::initialize_jFexSRJetRoI_varHandleKeys
StatusCode initialize_jFexSRJetRoI_varHandleKeys(bool)
Definition: JetMatcherAlg.cxx:551
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
JetMatcherAlg::m_l1jFexLRenergyDiffKey
SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainer > m_l1jFexLRenergyDiffKey
Definition: JetMatcherAlg.h:110
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
JetMatcherAlg::MatchType::JetRoI
@ JetRoI
JetMatcherAlg::set_jFexSRJetRoI_varHandleKeys
StatusCode set_jFexSRJetRoI_varHandleKeys()
Definition: JetMatcherAlg.cxx:398
JetMatcherAlg::m_l1gFexetaRefKey
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainer > m_l1gFexetaRefKey
Definition: JetMatcherAlg.h:128
JetMatcherAlg::set_gFexJetRoI_varHandleKeys
StatusCode set_gFexJetRoI_varHandleKeys()
Definition: JetMatcherAlg.cxx:462
JetMatcherAlg::initialize_varHandleKeys
StatusCode initialize_varHandleKeys()
Definition: JetMatcherAlg.cxx:494
JetMatcherAlg::m_l1jFexLRmatchedKey
SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainer > m_l1jFexLRmatchedKey
Definition: JetMatcherAlg.h:108
JetMatcherAlg::m_jetContainerKey2
SG::ReadHandleKey< xAOD::JetContainer > m_jetContainerKey2
Definition: JetMatcherAlg.h:54
JetMatcherAlg::m_l1jFexSRptRespKey
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > m_l1jFexSRptRespKey
Definition: JetMatcherAlg.h:100
JetMatcherAlg::m_l1gFexJetVarHandleKeys
std::vector< std::reference_wrapper< SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainer > > > m_l1gFexJetVarHandleKeys
Definition: JetMatcherAlg.h:129
JetMatcherAlg::m_l1energyRespKey
SG::WriteDecorHandleKey< xAOD::JetRoIContainer > m_l1energyRespKey
Definition: JetMatcherAlg.h:89
JetMatcherAlg::jetMatching
StatusCode jetMatching(SG::ReadHandle< DataVector< T >> jets1, SG::ReadHandle< xAOD::JetContainer > jets2, SG::WriteDecorHandleKey< DataVector< T >> matchedHandleKey, std::vector< std::reference_wrapper< SG::WriteDecorHandleKey< DataVector< T >>>> varHandleKeys, const EventContext &ctx) const
Definition: JetMatcherAlg.cxx:181
python.TurnDataReader.dr
dr
Definition: TurnDataReader.py:112
JetMatcherAlg::m_calibScale
Gaudi::Property< std::string > m_calibScale
Definition: JetMatcherAlg.h:45
JetMatcherAlg::m_l1jFexLRptRespKey
SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainer > m_l1jFexLRptRespKey
Definition: JetMatcherAlg.h:112
JetMatcherAlg::m_matchType
MatchType m_matchType
Definition: JetMatcherAlg.h:63
JetMatcherAlg::m_l1jFexSRmatchedKey
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > m_l1jFexSRmatchedKey
Definition: JetMatcherAlg.h:96
JetMatcherAlg::m_l1ptRefKey
SG::WriteDecorHandleKey< xAOD::JetRoIContainer > m_l1ptRefKey
Definition: JetMatcherAlg.h:91
JetMatcherAlg::m_matchL1
Gaudi::Property< bool > m_matchL1
Definition: JetMatcherAlg.h:50
JetMatcherAlg::m_massRespKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_massRespKey
Definition: JetMatcherAlg.h:78
AthReentrantAlgorithm
An algorithm that can be simultaneously executed in multiple threads.
Definition: AthReentrantAlgorithm.h:83
JetMatcherAlg::m_jetContainerKey1
SG::ReadHandleKey< xAOD::JetContainer > m_jetContainerKey1
Definition: JetMatcherAlg.h:53
JetMatcherAlg::initialize
StatusCode initialize() override
Definition: JetMatcherAlg.cxx:23
JetMatcherAlg::m_l1ptRespKey
SG::WriteDecorHandleKey< xAOD::JetRoIContainer > m_l1ptRespKey
Definition: JetMatcherAlg.h:88
xAOD::jFexLRJetRoI_v1
Class describing properties of a LVL1 jFEX global Trigger Object (TOB) in the xAOD format.
Definition: jFexLRJetRoI_v1.h:22
JetMatcherAlg::set_JetRoI_varHandleKeys
StatusCode set_JetRoI_varHandleKeys()
Definition: JetMatcherAlg.cxx:364
jet
Definition: JetCalibTools_PlotJESFactors.cxx:23
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
doubleTestComp.j1
j1
Definition: doubleTestComp.py:21
JetMatcherAlg::m_l1gFexenergyDiffKey
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainer > m_l1gFexenergyDiffKey
Definition: JetMatcherAlg.h:122
JetMatcherAlg::m_gFexJetRoIKey
SG::ReadHandleKey< xAOD::gFexJetRoIContainer > m_gFexJetRoIKey
Definition: JetMatcherAlg.h:69
JetMatcherAlg::m_l1jFexSRenergyDiffKey
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > m_l1jFexSRenergyDiffKey
Definition: JetMatcherAlg.h:98
JetMatcherAlg::m_l1jFexSRmassRespKey
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > m_l1jFexSRmassRespKey
Definition: JetMatcherAlg.h:102
JetMatcherAlg::m_l1jFexSRetaRefKey
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > m_l1jFexSRetaRefKey
Definition: JetMatcherAlg.h:104
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
SG::WriteDecorHandle
Handle class for adding a decoration to an object.
Definition: StoreGate/StoreGate/WriteDecorHandle.h:99
xAOD::gFexJetRoI_v1
Class describing properties of a LVL1 gFEX jet Trigger Object (TOB) in the xAOD format.
Definition: gFexJetRoI_v1.h:25
JetMatcherAlg::initialize_jFexLRJetRoI_varHandleKeys
StatusCode initialize_jFexLRJetRoI_varHandleKeys(bool)
Definition: JetMatcherAlg.cxx:559
JetMatcherAlg::m_l1ptDiffKey
SG::WriteDecorHandleKey< xAOD::JetRoIContainer > m_l1ptDiffKey
Definition: JetMatcherAlg.h:85
JetMatcherAlg::m_matchedKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_matchedKey
Definition: JetMatcherAlg.h:72
JetMatcherAlg::m_jFexLRJetRoIKey
SG::ReadHandleKey< xAOD::jFexLRJetRoIContainer > m_jFexLRJetRoIKey
Definition: JetMatcherAlg.h:68
JetMatcherAlg::m_l1jFexSRptDiffKey
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > m_l1jFexSRptDiffKey
Definition: JetMatcherAlg.h:97
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
JetMatcherAlg::m_l1jFexLRetaRefKey
SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainer > m_l1jFexLRetaRefKey
Definition: JetMatcherAlg.h:116
JetMatcherAlg::m_energyDiffKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_energyDiffKey
Definition: JetMatcherAlg.h:74
JetMatcherAlg::m_l1etaRefKey
SG::WriteDecorHandleKey< xAOD::JetRoIContainer > m_l1etaRefKey
Definition: JetMatcherAlg.h:92
JetMatcherAlg::m_l1jFexSRmassDiffKey
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > m_l1jFexSRmassDiffKey
Definition: JetMatcherAlg.h:99
DataVector< T >
JetMatcherAlg::m_l1jFexLRptRefKey
SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainer > m_l1jFexLRptRefKey
Definition: JetMatcherAlg.h:115
WriteDecorHandle.h
Handle class for adding a decoration to an object.
JetMatcherAlg::GetTLV
StatusCode GetTLV(const xAOD::Jet *jet, TLorentzVector &) const
Definition: JetMatcherAlg.cxx:136
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
JetMatcherAlg::m_l1jFexSRenergyRespKey
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > m_l1jFexSRenergyRespKey
Definition: JetMatcherAlg.h:101
JetMatcherAlg::m_l1energyDiffKey
SG::WriteDecorHandleKey< xAOD::JetRoIContainer > m_l1energyDiffKey
Definition: JetMatcherAlg.h:86
xAOD::JetFourMom_t
ROOT::Math::LorentzVector< ROOT::Math::PtEtaPhiM4D< double > > JetFourMom_t
Base 4 Momentum type for Jet.
Definition: JetTypes.h:17
JetMatcherAlg::m_energyRespKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_energyRespKey
Definition: JetMatcherAlg.h:77
JetMatcherAlg::m_l1jFexSRptRefKey
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > m_l1jFexSRptRefKey
Definition: JetMatcherAlg.h:103
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
JetMatcherAlg::m_l1jetContainerKey1
SG::ReadHandleKey< xAOD::JetRoIContainer > m_l1jetContainerKey1
Definition: JetMatcherAlg.h:66
JetMatcherAlg::m_l1gFexptDiffKey
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainer > m_l1gFexptDiffKey
Definition: JetMatcherAlg.h:121
JetMatcherAlg::m_l1gFexptRefKey
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainer > m_l1gFexptRefKey
Definition: JetMatcherAlg.h:127
JetMatcherAlg::m_l1jFexSRJetVarHandleKeys
std::vector< std::reference_wrapper< SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > > > m_l1jFexSRJetVarHandleKeys
Definition: JetMatcherAlg.h:105
JetMatcherAlg::m_Rmatch
Gaudi::Property< float > m_Rmatch
Definition: JetMatcherAlg.h:43
JetMatcherAlg::m_massDiffKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_massDiffKey
Definition: JetMatcherAlg.h:75
xAOD::JetRoI_v2
Class describing a LVL1 jet region of interest.
Definition: JetRoI_v2.h:35
JetMatcherAlg::m_etaRefKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_etaRefKey
Definition: JetMatcherAlg.h:80
xAOD::Jet_v1
Class describing a jet.
Definition: Jet_v1.h:57
JetMatcherAlg::MatchType::jFexSRJetRoI
@ jFexSRJetRoI
JetMatcherAlg::JetMatcherAlg
JetMatcherAlg(const std::string &name, ISvcLocator *pSvcLocator)
Definition: JetMatcherAlg.cxx:10
JetMatcherAlg::m_ptRespKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_ptRespKey
Definition: JetMatcherAlg.h:76
JetMatcherAlg::m_l1JetVarHandleKeys
std::vector< std::reference_wrapper< SG::WriteDecorHandleKey< xAOD::JetRoIContainer > > > m_l1JetVarHandleKeys
Definition: JetMatcherAlg.h:93
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
JetMatcherAlg::m_l1jFexLRenergyRespKey
SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainer > m_l1jFexLRenergyRespKey
Definition: JetMatcherAlg.h:113
JetMatcherAlg::m_l1gFexmassRespKey
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainer > m_l1gFexmassRespKey
Definition: JetMatcherAlg.h:126
JetMatcherAlg::set_jFexLRJetRoI_varHandleKeys
StatusCode set_jFexLRJetRoI_varHandleKeys()
Definition: JetMatcherAlg.cxx:430
AthCommonMsg< Gaudi::Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
get
T * get(TKey *tobj)
get a TObject* from a TKey* (why can't a TObject be a TKey?)
Definition: hcg.cxx:127
Rmin
double Rmin
Definition: LArDetectorConstructionTBEC.cxx:54
JetMatcherAlg::initialize_xAODJet_varHandleKeys
StatusCode initialize_xAODJet_varHandleKeys(bool)
Definition: JetMatcherAlg.cxx:533
JetMatcherAlg::MatchType::jFexLRJetRoI
@ jFexLRJetRoI
merge.status
status
Definition: merge.py:17
JetMatcherAlg::m_l1massRespKey
SG::WriteDecorHandleKey< xAOD::JetRoIContainer > m_l1massRespKey
Definition: JetMatcherAlg.h:90
JetMatcherAlg::m_l1jFexLRJetVarHandleKeys
std::vector< std::reference_wrapper< SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainer > > > m_l1jFexLRJetVarHandleKeys
Definition: JetMatcherAlg.h:117
JetMatcherAlg::m_l1jFexLRmassDiffKey
SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainer > m_l1jFexLRmassDiffKey
Definition: JetMatcherAlg.h:111
JetMatcherAlg::m_l1massDiffKey
SG::WriteDecorHandleKey< xAOD::JetRoIContainer > m_l1massDiffKey
Definition: JetMatcherAlg.h:87
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:30
JetMatcherAlg::m_jFexSRJetRoIKey
SG::ReadHandleKey< xAOD::jFexSRJetRoIContainer > m_jFexSRJetRoIKey
Definition: JetMatcherAlg.h:67
JetMatcherAlg::initialize_gFexJetRoI_varHandleKeys
StatusCode initialize_gFexJetRoI_varHandleKeys(bool)
Definition: JetMatcherAlg.cxx:568
JetMatcherAlg::execute
StatusCode execute(const EventContext &ctx) const override
Definition: JetMatcherAlg.cxx:269
JetMatcherAlg::m_l1matchedKey
SG::WriteDecorHandleKey< xAOD::JetRoIContainer > m_l1matchedKey
Definition: JetMatcherAlg.h:84
JetMatcherAlg::m_l1jFexLRptDiffKey
SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainer > m_l1jFexLRptDiffKey
Definition: JetMatcherAlg.h:109
JetMatcherAlg::m_l1jFexLRmassRespKey
SG::WriteDecorHandleKey< xAOD::jFexLRJetRoIContainer > m_l1jFexLRmassRespKey
Definition: JetMatcherAlg.h:114
JetMatcherAlg::m_l1gFexenergyRespKey
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainer > m_l1gFexenergyRespKey
Definition: JetMatcherAlg.h:125
JetMatcherAlg::m_l1gFexptRespKey
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainer > m_l1gFexptRespKey
Definition: JetMatcherAlg.h:124
doubleTestComp.j2
j2
Definition: doubleTestComp.py:22
TSU::T
unsigned long long T
Definition: L1TopoDataTypes.h:35
JetMatcherAlg::m_jetVarHandleKeys
std::vector< std::reference_wrapper< SG::WriteDecorHandleKey< xAOD::JetContainer > > > m_jetVarHandleKeys
Definition: JetMatcherAlg.h:82
JetMatcherAlg::set_xAODJet_varHandleKeys
StatusCode set_xAODJet_varHandleKeys()
Definition: JetMatcherAlg.cxx:326
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
JetMatcherAlg::MatchType::xAODJet
@ xAODJet
JetMatcherAlg::m_l1gFexmassDiffKey
SG::WriteDecorHandleKey< xAOD::gFexJetRoIContainer > m_l1gFexmassDiffKey
Definition: JetMatcherAlg.h:123
Generated on Thu Jul 4 2024 21:18:51 for ATLAS Offline Software by   doxygen 1.8.18