ATLAS Offline Software
Jets.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 // This source file implements all of the functions related to Jets
6 // in the SUSYObjDef_xAOD class
7 
8 // Local include(s):
10 
13 
21 
25 
27 
30 #ifndef XAOD_STANDALONE // For now metadata is Athena-only
32 #endif
33 
34 namespace ST {
35 
36  const static SG::Decorator<char> dec_bad("bad");
37 
38  const static SG::Decorator<char> dec_passJvt("passJvt");
39  const static SG::ConstAccessor<char> acc_passJvt("passJvt");
40  const static SG::Decorator<char> dec_passFJvt("passFJvt");
41  const static SG::ConstAccessor<char> acc_passFJvt("passFJvt");
42 
43  const static SG::Decorator<float> dec_jvt("Jvt");
44  const static SG::ConstAccessor<float> acc_jvt("NNJvt");
45  const static SG::Decorator<float> dec_fjvt("fJvt");
46  const static SG::ConstAccessor<float> acc_fjvt("DFCommonJets_fJvt");
47 
48  const static SG::Decorator<char> dec_bjet("bjet");
49 
50  const static SG::Decorator<char> dec_bjet_jetunc("bjet_jetunc"); //added for JetUncertainties usage
51  const static SG::Decorator<char> dec_bjet_loose("bjet_loose");
52 
53  const static SG::Decorator<double> dec_btag_weight("btag_weight");
54  const static SG::Decorator<float> dec_btag_pb("btag_pb");
55  const static SG::Decorator<float> dec_btag_pc("btag_pc");
56  const static SG::Decorator<float> dec_btag_pu("btag_pu");
57  const static SG::Decorator<float> dec_btag_ptau("btag_ptau");
58  // for backwards compatibility
59  const static SG::Decorator<float> dec_btag_dl1pb("btag_dl1pb");
60  const static SG::Decorator<float> dec_btag_dl1pc("btag_dl1pc");
61  const static SG::Decorator<float> dec_btag_dl1pu("btag_dl1pu");
62 
63 
64  const static SG::Decorator<float> dec_VRradius("VRradius");
65  const static SG::ConstAccessor<float> acc_VRradius("VRradius");
66 
67  const static SG::Decorator<char> dec_passDRcut("passDRcut");
68  const static SG::ConstAccessor<char> acc_passDRcut("passDRcut");
69 
70  const static SG::Decorator<int> dec_wtagged("wtagged");
71  const static SG::Decorator<int> dec_ztagged("ztagged");
72  const static SG::Decorator<int> dec_toptagged("toptagged");
73 
74  StatusCode SUSYObjDef_xAOD::GetJets(xAOD::JetContainer*& copy, xAOD::ShallowAuxContainer*& copyaux, bool recordSG, const std::string& jetkey, const xAOD::JetContainer* containerToBeCopied)
75  {
76  if (!m_tool_init) {
77  ATH_MSG_ERROR("SUSYTools was not initialized!!");
78  return StatusCode::FAILURE;
79  }
80 
81  if (m_isPHYSLITE && jetkey.find("AnalysisJets") == std::string::npos){
82  ATH_MSG_ERROR("You are running on PHYSLITE derivation. Please change the Jets container to 'AnalysisJets'");
83  return StatusCode::FAILURE;
84  }
85 
86  ATH_MSG_DEBUG("Default jetkey: " << m_defaultJets);
87  ATH_MSG_DEBUG("Function argument jetkey: " << jetkey);
88 
89  // load default regular & btag jet keys
90  std::string jetkey_tmp = m_defaultJets; // use default for regular jetkey_tmp
91 
92  // override default if user is passing a jetkey
93  if (!jetkey.empty()) {
94  jetkey_tmp = jetkey;
95  }
96 
97  // final settings
98  ATH_MSG_DEBUG("Key for retrieving jet collection: jetkey = " << jetkey_tmp);
99 
100  const xAOD::JetContainer* jets = nullptr;
101  if (copy==nullptr) { // empty container provided
102  if (containerToBeCopied != nullptr) {
103  jets = containerToBeCopied;
104  }
105  else {
106  ATH_MSG_DEBUG("Retrieve jet collection: " << jetkey_tmp);
107  ATH_CHECK( evtStore()->retrieve(jets, jetkey_tmp) );
108  }
109  std::pair<xAOD::JetContainer*, xAOD::ShallowAuxContainer*> shallowcopy = xAOD::shallowCopyContainer(*jets);
110  copy = shallowcopy.first;
111  copyaux = shallowcopy.second;
112  bool setLinks = xAOD::setOriginalObjectLink(*jets, *copy);
113  if (!setLinks) {
114  ATH_MSG_WARNING("Failed to set original object links on " << jetkey_tmp);
115  }
116  } else { // use the user-supplied collection instead
117  ATH_MSG_DEBUG("Not retrieving jet collecton, using existing one provided by user");
118  jets = copy;
119  }
120 
121  // Calibrate the jets
123 
124  // Add isHS labels to jets (required for JvtEfficiencyTools)
125  if (!isData()) {
127  }
128 
129  // Calculate Jvt scores (required by METSignificance)
130  for (const auto& jet : *copy) {
131  dec_jvt(*jet) = m_jetJvtMomentTool->updateJvt(*jet);
132  }
133 
134  // Re-calculate NNJvt scores
136 
137  // Update the jets
138  for (const auto& jet : *copy) {
139  ATH_CHECK( this->FillJet(*jet) );
140  }
141 
142  for (const auto& jet : *copy) {
143  // Update the JVT decorations if needed
144  if( m_doFwdJVT){
145  dec_passJvt(*jet) = acc_passFJvt(*jet) && acc_passJvt(*jet);
146  dec_fjvt(*jet) = acc_fjvt(*jet);
147 
148  //new state for OR . 0=non-baseline objects, 1=for baseline jets not passing JVT, 2=for any other baseline object
149  if ( acc_baseline(*jet) ){
150  if( acc_passJvt(*jet) ) dec_selected(*jet) = 2;
151  else dec_selected(*jet) = 1;
152  }
153  else{
154  dec_selected(*jet) = 0;
155  }
156  }
157  this->IsBadJet(*jet);
158  this->IsSignalJet(*jet, m_jetPt, m_jetEta);
159  if (!isData())this->IsTruthBJet(*jet);
160  }
161  if (recordSG) {
162  std::string auxname = copyaux->name();
163  if (auxname.compare("UNKNOWN")==0) copyaux->setName(std::string("STCalib" + jetkey_tmp + m_currentSyst.name() + "AuxCopy").c_str());
164  ATH_CHECK( evtStore()->record(copy, "STCalib" + jetkey_tmp + m_currentSyst.name()) );
165  ATH_CHECK( evtStore()->record(copyaux, "STCalib" + jetkey_tmp + m_currentSyst.name() + "Aux.") );
166  }
167  return StatusCode::SUCCESS;
168  }
169 
170  StatusCode SUSYObjDef_xAOD::GetTrackJets(xAOD::JetContainer*& copy, xAOD::ShallowAuxContainer*& copyaux, bool recordSG, const std::string& jetkey, const xAOD::JetContainer* containerToBeCopied)
171  {
172  if (!m_tool_init) {
173  ATH_MSG_ERROR("SUSYTools was not initialized!!");
174  return StatusCode::FAILURE;
175  }
176 
177  ATH_MSG_DEBUG("Default jetkey (trkjet): " << m_defaultTrackJets);
178  ATH_MSG_DEBUG("Function argument jetkey (trkjet): " << jetkey);
179 
180  // load default regular & btag jet keys
181  std::string jetkey_tmp = m_defaultTrackJets;
182 
183  // override default if user is passing a jetkey
184  if (!jetkey.empty()) {
185  jetkey_tmp = jetkey;
186  }
187 
188  // final settings
189  ATH_MSG_DEBUG("Key for retrieving trkjet collection (as well as bjet info): jetkey = " << jetkey_tmp);
190 
191  const xAOD::JetContainer* jets = nullptr;
192  if (copy==nullptr) { // empty container provided
193  if (containerToBeCopied != nullptr) {
194  jets = containerToBeCopied;
195  }
196  else {
197  ATH_MSG_DEBUG("Retrieve jet collection: " << jetkey_tmp);
198  ATH_CHECK( evtStore()->retrieve(jets, jetkey_tmp) );
199  }
200  std::pair<xAOD::JetContainer*, xAOD::ShallowAuxContainer*> shallowcopy = xAOD::shallowCopyContainer(*jets);
201  copy = shallowcopy.first;
202  copyaux = shallowcopy.second;
203  bool setLinks = xAOD::setOriginalObjectLink(*jets, *copy);
204  if (!setLinks) {
205  ATH_MSG_WARNING("Failed to set original object links on " << jetkey_tmp);
206  }
207  } else { // use the user-supplied collection instead
208  ATH_MSG_DEBUG("Not retrieving jet collection, using existing one provided by user");
209  jets = copy;
210  }
211 
212  //disable - notfortrackjets? // Calibrate the jets
213  //disable - notfortrackjets? ATH_CHECK(m_jetCalibTool->applyCalibration(*copy));
214 
215  // Update the jets
216  for (const auto& jet : *copy) {
217  ATH_CHECK( this->FillTrackJet(*jet) );
218  }
219 
220  if (copy->size() > 1 && m_defaultTrackJets == "AntiKtVR30Rmax4Rmin02TrackJets") {
221  // Use iterators to avoid pairing the jets twice
222  for (xAOD::JetContainer::const_iterator j1 = copy->begin()+1; j1!= copy->end();++j1) {
223  const xAOD::Jet* jet1 = (*j1);
224  if (!acc_signal(*jet1)) continue;
225  for (xAOD::JetContainer::const_iterator j2 = copy->begin(); j2 != j1; ++j2) {
226  const xAOD::Jet* jet2 = (*j2);
227  if (!acc_baseline(*jet2)) continue;
228  //Reference to the use method in P4Helper: deltaR2( const xAOD::IParticle& p4, const xAOD::IParticle& , bool useRapidity=true )
229  float dr_jets = xAOD::P4Helpers::deltaR(jet1,jet2, false);
230  const xAOD::Jet* to_check = acc_VRradius(*jet1) < acc_VRradius(*jet2) ? jet1 : jet2;
231  if( dr_jets < acc_VRradius(*to_check)) dec_passDRcut(*to_check) = false;
232  //break the loop at this point???
233  }
234  }
235  }
236  if (recordSG) {
237  ATH_CHECK( evtStore()->record(copy, "STCalib" + jetkey_tmp + m_currentSyst.name()) );
238  ATH_CHECK( evtStore()->record(copyaux, "STCalib" + jetkey_tmp + m_currentSyst.name() + "Aux.") );
239  }
240  return StatusCode::SUCCESS;
241  }
242 
243  StatusCode SUSYObjDef_xAOD::GetFatJets(xAOD::JetContainer*& copy, xAOD::ShallowAuxContainer*& copyaux, bool recordSG, const std::string& jetkey, const bool doLargeRdecorations, const xAOD::JetContainer* containerToBeCopied)
244  {
245  if (!m_tool_init) {
246  ATH_MSG_ERROR("SUSYTools was not initialized!!");
247  return StatusCode::FAILURE;
248  }
249 
250  if (m_fatJets.empty()) {
251  ATH_MSG_ERROR("JetFatCalibTool was not initialized for largeR jet!!");
252  return StatusCode::FAILURE;
253  }
254 
255  std::string jetkey_tmp = jetkey;
256  if (jetkey.empty()) {
257  jetkey_tmp = m_fatJets;
258  }
259 
260  const xAOD::JetContainer* jets = nullptr;
261  if (copy==nullptr) { // empty container provided
262  if (containerToBeCopied != nullptr) {
263  jets = containerToBeCopied;
264  }
265  else {
266  ATH_MSG_DEBUG("Retrieve jet collection: " << jetkey_tmp);
267  ATH_CHECK( evtStore()->retrieve(jets, jetkey_tmp) );
268  }
269 
270  std::pair<xAOD::JetContainer*, xAOD::ShallowAuxContainer*> shallowcopy = xAOD::shallowCopyContainer(*jets);
271  copy = shallowcopy.first;
272  copyaux = shallowcopy.second;
273  bool setLinks = xAOD::setOriginalObjectLink(*jets, *copy);
274  if (!setLinks) {
275  ATH_MSG_WARNING("Failed to set original object links on " << jetkey_tmp);
276  }
277  } else { // use the user-supplied collection instead
278  ATH_MSG_DEBUG("Not retrieving jet collection, using existing one provided by user");
279  jets=copy;
280  }
281 
282  if(jets->size()==0) {
283  ATH_MSG_DEBUG("Large R jet collection is empty");
284  return StatusCode::SUCCESS;
285  }
286 
287  // Calibrate the jets - only insitu for data for now
289 
290 
291  if (!isData() && !m_JetTruthLabelName.empty()){
292  ATH_MSG_DEBUG("Checking if decorator for JetTruthLabelingTool is available:");
293  std::string fatjetcoll = m_fatJets;
294  m_label_truthKey = fatjetcoll+"."+m_JetTruthLabelName;
296  ATH_MSG_DEBUG("Reading JetTruthLabelingTool truthKey:" << m_label_truthKey << " isAvailable " << labelHandle_truthKey.isAvailable());
297  // Truth Labeling (MC only)
298  if (!labelHandle_truthKey.isAvailable() && !m_isPHYSLITE) ATH_CHECK(m_jetTruthLabelingTool->decorate(*copy));
299  }
300 
301 
302  for (const auto& jet : *copy) {
303 
304  ATH_CHECK( this->FillJet(*jet, true, true, doLargeRdecorations) );
305  //
306  // For OR, selected if it passed cuts
307  if ( acc_baseline(*jet) ){
308  dec_selected(*jet) = 1;
309  }
310  else{
311  dec_selected(*jet) = 0;
312  }
313  }
314  if (recordSG) {
315  ATH_CHECK( evtStore()->record(copy, "STCalib" + jetkey_tmp + m_currentSyst.name()) );
316  ATH_CHECK( evtStore()->record(copyaux, "STCalib" + jetkey_tmp + m_currentSyst.name() + "Aux.") );
317  }
318  return StatusCode::SUCCESS;
319  }
320 
321 
322  StatusCode SUSYObjDef_xAOD::GetJetsSyst(const xAOD::JetContainer& calibjets, xAOD::JetContainer*& copy, xAOD::ShallowAuxContainer*& copyaux, bool recordSG, const std::string& jetkey)
323  {
324  if (!m_tool_init) {
325  ATH_MSG_ERROR("SUSYTools was not initialized!!");
326  return StatusCode::FAILURE;
327  }
328 
329  std::string jetkey_tmp = jetkey;
330  if (jetkey.empty()) {
331  jetkey_tmp = m_defaultJets;
332  }
333 
334  std::pair<xAOD::JetContainer*, xAOD::ShallowAuxContainer*> shallowcopy = xAOD::shallowCopyContainer(calibjets);
335  copy = shallowcopy.first;
336  copyaux = shallowcopy.second;
337 
338  bool setLinks = xAOD::setOriginalObjectLink(calibjets, *copy);
339  if (!setLinks) {
340  ATH_MSG_WARNING("Failed to set original object links on " << jetkey_tmp);
341  }
342 
343  // ghost associate the muons to the jets (needed by MET muon-jet OR later)
344  ATH_MSG_VERBOSE("Run muon-to-jet ghost association");
345  const xAOD::MuonContainer* muons = nullptr;
346  // Do a little guessing
347  if (jetkey!="AnalysisJets"){
348  ATH_CHECK( evtStore()->retrieve(muons, "Muons") );
349  } else {
350  ATH_CHECK( evtStore()->retrieve(muons, "AnalysisMuons") );
351  }
352  met::addGhostMuonsToJets(*muons, *copy);
353 
354  // Update the jets
355  for (const auto& jet : *copy) {
356  ATH_CHECK( this->FillJet(*jet, false) );
357  }
358 
359  for (const auto& jet : *copy) {
360  // Update the JVT decorations if needed
361  if( m_doFwdJVT){
362  dec_passJvt(*jet) = acc_passFJvt(*jet) && acc_passJvt(*jet);
363 
364  //new state for OR . 0=non-baseline objects, 1=for baseline jets not passing JVT, 2=for any other baseline object
365  if ( acc_baseline(*jet) ){
366  if( acc_passJvt(*jet) ) dec_selected(*jet) = 2;
367  else dec_selected(*jet) = 1;
368  }
369  else{
370  dec_selected(*jet) = 0;
371  }
372  }
373  this->IsBadJet(*jet);
374  this->IsSignalJet(*jet, m_jetPt, m_jetEta);
375  if (!isData())this->IsTruthBJet(*jet);
376  }
377  if (recordSG) {
378  ATH_CHECK( evtStore()->record(copy, "STCalib" + jetkey_tmp + m_currentSyst.name()) );
379  ATH_CHECK( evtStore()->record(copyaux, "STCalib" + jetkey_tmp + m_currentSyst.name() + "Aux.") );
380  }
381  return StatusCode::SUCCESS;
382  }
383 
384  StatusCode SUSYObjDef_xAOD::FillJet(xAOD::Jet& input, bool doCalib, bool isFat, bool doLargeRdecorations) {
385 
386  ATH_MSG_VERBOSE( "Starting FillJet on jet with pt=" << input.pt() );
387  ATH_MSG_VERBOSE( "jet (pt,eta,phi) before calibration " << input.pt() << " " << input.eta() << " " << input.phi() );
388 
389  static const SG::ConstAccessor<bool> acc_wValidKinRange(m_WDecorName+"_ValidKinRange");
390  static const SG::ConstAccessor<bool> acc_zValidKinRange(m_ZDecorName+"_ValidKinRange");
391  static const SG::ConstAccessor<bool> acc_topValidKinRange(m_TopDecorName+"_ValidKinRange");
392  static const SG::ConstAccessor<bool> acc_wtagged(m_WDecorName+"_Tagged");
393  static const SG::ConstAccessor<bool> acc_ztagged(m_ZDecorName+"_Tagged");
394  static const SG::ConstAccessor<bool> acc_toptagged(m_TopDecorName+"_Tagged");
395 
396  if (doCalib) {
397  if(!isFat){
398  //disable - obsoleted ATH_CHECK( m_jetCalibTool->applyCalibration(input) );
399  }
400  else {
401  //disable - obsoleted ATH_CHECK( m_jetFatCalibTool->applyCalibration(input) );
402  dec_baseline(input) = ( input.pt() > m_jetPt ) || ( input.pt() > 20e3 ); // Allows for setting m_jetPt < 20e3
403  dec_bad(input) = false;
404  dec_signal(input) = false;
405  dec_bjet_loose(input) = false;
406  dec_effscalefact(input) = 1.;
407  dec_passOR(input) = true;
408  dec_bjet_jetunc(input) = false;
409  dec_btag_weight(input) = -999.;
410 
411  dec_wtagged(input) = -1;
412  dec_ztagged(input) = -1;
413  dec_toptagged(input) = -1;
414  if (doLargeRdecorations) {
418 
419  // Retrieve large-R tagging results for W/Z/top
420  if (!m_WtagConfig.empty()) {
421  // Only tag jets if they are inside the kinematic range
422  if ( !acc_wValidKinRange(input) ) {
423  ATH_MSG_VERBOSE("Large-R W candidate jet outside of recommended tagging range. Will set score to 0.");
424  dec_wtagged(input) = 0;
425  }
426  else dec_wtagged(input) = acc_wtagged(input);
427  }
428  if (!m_ZtagConfig.empty()) {
429  // Only tag jets if they are inside the kinematic range
430  if ( !acc_zValidKinRange(input) ) {
431  ATH_MSG_VERBOSE("Large-R Z candidate jet outside of recommended tagging range. Will set score to 0.");
432  dec_ztagged(input) = 0;
433  }
434  else dec_ztagged(input) = acc_ztagged(input);
435  }
436  if (!m_ToptagConfig.empty()) {
437  // Only tag jets if they are inside the kinematic range
438  if ( !acc_topValidKinRange(input) ) {
439  ATH_MSG_VERBOSE("Large-R Top candidate jet outside of recommended tagging range. Will set score to 0.");
440  dec_toptagged(input) = 0;
441  }
442  else dec_toptagged(input) = acc_toptagged(input);
443  }
444 
445  }
446 
447  // If a user hasn't specified an uncertainty config, then this tool will be empty
448  // for large R jets
449  if (!m_WTagjetUncertaintiesTool.empty() && !m_WTagUncConfig.empty() && !m_WtagConfig.empty() && doLargeRdecorations) {
451  switch (result) {
453  ATH_MSG_ERROR( "Failed to apply largeR W-tag jet scale uncertainties.");
454  return StatusCode::FAILURE;
455  //break;
457  ATH_MSG_VERBOSE( "No valid pt/eta/m range for largeR W-tag jet scale uncertainties. ");
458  break;
459  default:
460  break;
461  }
462  } else {
463  ATH_MSG_DEBUG( "No valid large-R W-tagged fat jet uncertainty, but FillJet called with a fat jet. Skipping uncertainties." );
464  }
465 
466  if (!m_ZTagjetUncertaintiesTool.empty() && !m_ZTagUncConfig.empty() && !m_ZtagConfig.empty() && doLargeRdecorations) {
468  switch (result) {
470  ATH_MSG_ERROR( "Failed to apply largeR Z-tag jet scale uncertainties.");
471  return StatusCode::FAILURE;
472  //break;
474  ATH_MSG_VERBOSE( "No valid pt/eta/m range for largeR Z-tag jet scale uncertainties. ");
475  break;
476  default:
477  break;
478  }
479  } else {
480  ATH_MSG_DEBUG( "No valid large-R Z-tagged fat jet uncertainty, but FillJet called with a fat jet. Skipping uncertainties." );
481  }
482 
483  if (!m_TopTagjetUncertaintiesTool.empty() && !m_TopTagUncConfig.empty() && !m_ToptagConfig.empty() && doLargeRdecorations) {
485  switch (result) {
487  ATH_MSG_ERROR( "Failed to apply largeR Top-tag jet scale uncertainties.");
488  return StatusCode::FAILURE;
489  //break;
491  ATH_MSG_VERBOSE( "No valid pt/eta/m range for largeR Top-tag jet scale uncertainties. ");
492  break;
493  default:
494  break;
495  }
496  } else {
497  ATH_MSG_DEBUG( "No valid large-R Top-tagged fat jet uncertainty, but FillJet called with a fat jet. Skipping uncertainties." );
498  }
499 
502  switch (result) {
504  ATH_MSG_ERROR( "Failed to apply largeR jet scale uncertainties.");
505  return StatusCode::FAILURE;
506  //break;
508  ATH_MSG_VERBOSE( "No valid pt/eta/m range for largeR jet scale uncertainties. ");
509  break;
510  default:
511  break;
512  }
513  } else {
514  ATH_MSG_DEBUG( "No valid fat jet uncertainty, but FillJet called with a fat jet. Skipping uncertainties." );
515  }
516  ATH_MSG_VERBOSE( "Large-R jet (pt,eta,phi) after calibration " << input.pt() << " " << input.eta() << " " << input.phi() );
517 
518  return StatusCode::SUCCESS;
519  }
520  ATH_MSG_VERBOSE( "jet (pt,eta,phi) after calibration " << input.pt() << " " << input.eta() << " " << input.phi() );
521 
522  }
523 
524  dec_passOR(input) = true;
525  dec_bjet_jetunc(input) = false;
526 
527  if (m_useBtagging) {
528  if (m_BtagWP != "Continuous") this->IsBJet(input);
529  else this->IsBJetContinuous(input);
530  }
531 
532  if ( (input.pt() > m_jetPt) || (input.pt() > 15e3) ) {
533  if(!isFat && m_currentSyst.name().find("__2") == std::string::npos) {
534  // Use the normal jet uncertainties tool for this systematic and do not use the PDSmeared initialised tool
536  switch (result) {
538  ATH_MSG_ERROR( "Failed to apply JES correction" );
539  break;
541  ATH_MSG_WARNING( "JES correction OutOfValidity range."); // Jet (pt,eta,phi) = (" << input.pt() << ", " << input.eta() << ", " << input.phi() << ")");
542  break;
543  default:
544  break;
545  }
546  }
547  }
548 
550  if ( (input.pt() > m_jetPt) || (input.pt() > 15e3) ) {
551  if(!isFat && m_currentSyst.name().find("__2") != std::string::npos){
552  // Use the PDSmeared uncertainties tool on the systematic with PDsmear in the name
554  switch (result) {
556  ATH_MSG_ERROR( "Failed to apply JES correction" );
557  break;
559  ATH_MSG_WARNING( "JES correction OutOfValidity range."); // Jet (pt,eta,phi) = (" << input.pt() << ", " << input.eta() << ", " << input.phi() << ")");
560  break;
561  default:
562  break;
563  }
564  }
565  }
566  }
567 
568 
569  ATH_MSG_VERBOSE( "jet (pt,eta,phi) after JES correction " << input.pt() << " " << input.eta() << " " << input.phi() );
570 
572  dec_passFJvt(input) = !m_doFwdJVT || m_jetfJvtSelectionTool->accept(&input);
573  dec_baseline(input) = ( input.pt() > m_jetPt ) || ( input.pt() > 20e3 ); // Allows for setting m_jetPt < 20e3
574  dec_bad(input) = false;
575  dec_signal_less_JVT(input) = false;
576  dec_signal(input) = false;
577  dec_bjet_loose(input) = false;
578  dec_effscalefact(input) = 1.;
579 
580  //new state for OR . 0=non-baseline objects, 1=for baseline jets not passing JVT, 2=for any other baseline object
581  if (acc_baseline(input) ){
582  if( acc_passJvt(input) ) dec_selected(input) = 2;
583  else dec_selected(input) = 1;
584  }
585  else{
586  dec_selected(input) = 0;
587  }
588 
589  if (m_useBtagging && !m_orBtagWP.empty()) {
590  dec_bjet_loose(input) = this->IsBJetLoose(input);
591  }
592 
593  if (m_debug) {
594  ATH_MSG_INFO( "JET pt: " << input.pt() );
595  ATH_MSG_INFO( "JET eta: " << input.eta() );
596  ATH_MSG_INFO( "JET phi: " << input.phi() );
597  ATH_MSG_INFO( "JET E: " << input.e() );
598  ATH_MSG_INFO( "JET Ceta: " << input.jetP4(xAOD::JetConstitScaleMomentum).eta() );
599  ATH_MSG_INFO( "JET Cphi: " << input.jetP4(xAOD::JetConstitScaleMomentum).phi() );
600  ATH_MSG_INFO( "JET CE: " << input.jetP4(xAOD::JetConstitScaleMomentum).e() );
601  ATH_MSG_INFO( "JET Cm: " << input.jetP4(xAOD::JetConstitScaleMomentum).M() ); // fix-me M
602 
603  }
604 
605  return StatusCode::SUCCESS;
606  }
607 
609 
610  ATH_MSG_VERBOSE( "Starting FillTrackJet on jet with pt=" << input.pt() );
611 
612  dec_btag_weight(input) = -999.;
613  dec_effscalefact(input) = 1.;
614 
615  if (m_defaultTrackJets == "AntiKtVR30Rmax4Rmin02TrackJets") {
616  // VR recommendation
617  // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/BTagCalib2017#Recommendations_for_variable_rad
618  dec_baseline(input) = input.pt() >= 5e3 && input.numConstituents() >= 2;
619  if (m_trkJetPt < 10e3)
620  ATH_MSG_WARNING ("The pt threshold of VR jets you set is: " << m_trkJetPt/1000. << " GeV. But VR jets with pt < 10GeV are uncalibrated.");
621  dec_signal(input) = acc_baseline(input) && input.pt() >= m_trkJetPt && std::abs(input.eta()) <= m_trkJetEta;
622  dec_VRradius(input) = std::max(0.02,std::min(0.4,30000./input.pt()));
623  dec_passDRcut(input) = acc_signal(input);
624  } else {
625  dec_baseline(input) = input.pt() >= m_trkJetPt && std::abs(input.eta()) <= m_trkJetEta;
626  dec_signal(input) = acc_baseline(input);
627  }
628 
629  if (m_useBtagging_trkJet) {
630  if (m_BtagWP_trkJet != "Continuous") this->IsTrackBJet(input);
631  else this->IsTrackBJetContinuous(input);
632  }
633 
634  if (m_debug) {
635  ATH_MSG_INFO( "TRK JET pt: " << input.pt() );
636  ATH_MSG_INFO( "TRK JET eta: " << input.eta() );
637  ATH_MSG_INFO( "TRK JET phi: " << input.phi() );
638  ATH_MSG_INFO( "TRK JET E: " << input.e() );
639  }
640 
641  return StatusCode::SUCCESS;
642  }
643 
644 
646  bool isbjet_loose = false;
647  if (m_orBJetPtUpperThres < 0 || m_orBJetPtUpperThres > input.pt())
648  isbjet_loose = bool(m_btagSelTool_OR->accept(input)); //note : b-tag applies only to jet with eta < 2.5
649  return isbjet_loose;
650  }
651 
653  char pass_jvt = !m_applyJVTCut || m_jetNNJvtSelectionTool->accept(&input);
654  dec_passJvt(input) = pass_jvt;
655  return pass_jvt;
656  }
657 
658  bool SUSYObjDef_xAOD::IsSignalJet(const xAOD::Jet& input, float ptcut, float etacut) const {
659  if ( !acc_baseline(input) || !acc_passOR(input) ) return false;
660 
661  if ( input.pt() <= ptcut || std::abs(input.eta()) >= etacut) return false;
662 
663  bool isgoodjet = !acc_bad(input) && acc_passJvt(input);
664 
665  dec_signal(input) = isgoodjet;
666 
667  // For JVT calculation
668  dec_signal_less_JVT(input) = !acc_bad(input);
669 
670 
671  if (m_debug) {
672  float emfrac, hecf, LArQuality, HECQuality, Timing, fracSamplingMax, NegativeE, AverageLArQF;
673  std::vector<float> sumpttrk_vec;
674 
675  input.getAttribute(xAOD::JetAttribute::EMFrac, emfrac);
676  input.getAttribute(xAOD::JetAttribute::HECFrac, hecf);
677  input.getAttribute(xAOD::JetAttribute::LArQuality, LArQuality);
678  input.getAttribute(xAOD::JetAttribute::HECQuality, HECQuality);
679  input.getAttribute(xAOD::JetAttribute::Timing, Timing);
680  input.getAttribute(xAOD::JetAttribute::SumPtTrkPt500, sumpttrk_vec);
681  input.getAttribute(xAOD::JetAttribute::FracSamplingMax, fracSamplingMax);
682  input.getAttribute(xAOD::JetAttribute::NegativeE, NegativeE);
683  input.getAttribute(xAOD::JetAttribute::AverageLArQF, AverageLArQF);
684 
685  float sumpttrk;
686  if (!sumpttrk_vec.empty() && this->GetPrimVtx()) {
687  sumpttrk = sumpttrk_vec[this->GetPrimVtx()->index()];
688  } else {
689  sumpttrk = 0.;
690  }
691 
692  ATH_MSG_INFO( "JET pt: " << input.pt() );
693  ATH_MSG_INFO( "JET eta: " << input.eta() );
694  ATH_MSG_INFO( "JET emfrac: " << emfrac );
695  ATH_MSG_INFO( "JET hecfrac: " << hecf );
696  ATH_MSG_INFO( "JET LArQuality: " << LArQuality );
697  ATH_MSG_INFO( "JET HECQuality: " << HECQuality );
698  ATH_MSG_INFO( "JET Timing: " << Timing );
699  ATH_MSG_INFO( "JET sumpttrk: " << sumpttrk );
700  ATH_MSG_INFO( "JET fracSamplingMax: " << fracSamplingMax );
701  ATH_MSG_INFO( "JET AverageLArQF: " << AverageLArQF );
702  }
703 
704  ATH_MSG_VERBOSE( "JET isbad?: " << static_cast<int>(acc_bad(input)));
705 
706  return isgoodjet;
707  }
708 
709 
711 
712  if ( !acc_passOR(input) ) return false;
713 
714  float ptcut = 20e3;
715  if ( m_jetPt < ptcut ) ptcut = m_jetPt;
716 
717  bool isPileup = !acc_passJvt(input);
718 
719  if ( input.pt() <= ptcut || isPileup ) return false;
720 
722  dec_bad(input) = !m_acc_jetClean(input);
723  } else {
724  ATH_MSG_VERBOSE("DFCommon jet cleaning variable not available ... setting 'bad' decorator to 0.");
725  dec_bad(input) = 0;
726  // the jet cleaning decisions are only calculable at AOD now
727  // dec_bad(input) = m_jetCleaningTool.empty() ? false : !m_jetCleaningTool->keep(input);
728  }
729 
730  ATH_MSG_VERBOSE( "JET isbad?: " << static_cast<int>(acc_bad(input)));
731 
732  return acc_bad(input);
733  }
734 
735 
737 
738  bool isbjet = bool(m_btagSelTool->accept(input));
739  dec_bjet(input) = isbjet;
740 
742  ANA_MSG_ERROR("Couldn't set b-tag decorations for jet, is-b = " << (isbjet?"true":"false") << ", pT = " << input.pt()/1000.);
743 
744  return isbjet;
745  }
746 
748 
749  bool isbjet = bool(m_btagSelTool_trkJet->accept(input));
750  dec_bjet(input) = isbjet;
751 
753  ANA_MSG_ERROR("Couldn't set b-tag decorations for trackjet, is-b = " << (isbjet?"true":"false") << ", pT = " << input.pt()/1000.);
754 
755  return isbjet;
756  }
757 
760  // Cheatsheet:
761  // returns 6 if between 65% and 0%
762  // returns 5 if between 70% and 65%
763  // returns 4 if between 77% and 70%
764  // returns 3 if between 85% and 77%
765  // returns 2 if between 90% and 85%
766  // returns 1 if between 100% and 90%
767  // returns 0 if smaller than -1e4-> should never happen
768  // return -1 if bigger than 1e4 or not in b-tagging acceptance
770 
771  int isbjet = m_btagSelTool->getQuantile(input);
772  dec_bjet(input) = isbjet;
773 
775  ANA_MSG_ERROR("Couldn't set continuous b-tag decorations for jet, is-b = " << isbjet << ", pT = " << input.pt()/1000.);
776 
777  return isbjet;
778  }
779 
781 
782  int isbjet = m_btagSelTool_trkJet->getQuantile(input);
783  dec_bjet(input) = isbjet;
784 
786  ANA_MSG_ERROR("Couldn't set continuous b-tag decorations for trackjet, is-b = " << isbjet << ", pT = " << input.pt()/1000.);
787 
788  return isbjet;
789  }
790 
792 
793  float totalSF = 1.;
794  for ( const xAOD::Jet* jet : *jets ) {
795 
796  float sf = 1.;
797 
798  if ( std::abs(jet->eta()) > 2.5 ) {
799  ATH_MSG_VERBOSE( "Trying to retrieve b-tagging SF for jet with |eta|>2.5 (jet eta=" << jet->eta() << "), jet will be skipped");
800  } else if ( jet->pt() < 20e3 ){
801  ATH_MSG_VERBOSE( "Trying to retrieve b-tagging SF for jet with invalid pt (jet pt=" << jet->pt() << "), jet will be skipped");
802  } else {
803 
805  int truthlabel(-1);
806  if (!jet->getAttribute("HadronConeExclTruthLabelID", truthlabel)) {
807  ATH_MSG_ERROR("Failed to get jet truth label!");
808  }
809  ATH_MSG_VERBOSE("This jet is " << (acc_bjet(*jet) ? "" : "not ") << "b-tagged.");
810  ATH_MSG_VERBOSE("This jet's truth label is " << truthlabel);
811 
812  if ( acc_bjet(*jet) or m_BtagWP == "Continuous") {
814 
815  switch (result) {
817  ATH_MSG_ERROR( "Failed to retrieve SF for b-tagged jets in SUSYTools_xAOD::BtagSF" );
818  break;
820  ATH_MSG_VERBOSE( "No valid SF for b-tagged jets in SUSYTools_xAOD::BtagSF" );
821  break;
822  default:
823  ATH_MSG_VERBOSE( "Retrieve SF for b-tagged jets in SUSYTools_xAOD::BtagSF with value " << sf );
824  }
825  } else {
826 
828 
829  switch (result) {
831  ATH_MSG_ERROR( "Failed to retrieve SF for non-b-tagged jets in SUSYTools_xAOD::BtagSF" );
832  break;
834  ATH_MSG_VERBOSE( "No valid inefficiency SF for non-b-tagged jets in SUSYTools_xAOD::BtagSF" );
835  break;
836  default:
837  ATH_MSG_VERBOSE( "Retrieve SF for non-b-tagged jets in SUSYTools_xAOD::BtagSF with value " << sf );
838  }
839  }
840  }
841 
842  dec_effscalefact(*jet) = sf;
843 
844  if( acc_signal(*jet) && acc_passOR(*jet) ) totalSF *= sf; //consider goodjets only
845 
846  }
847 
848  return totalSF;
849  }
850 
851 
853  {
854  float totalSF = 1.;
855 
856  //Set the new systematic variation
858  if ( ret != StatusCode::SUCCESS) {
859  ATH_MSG_ERROR("Cannot configure BTaggingEfficiencyTool for systematic var. " << systConfig.name() );
860  }
861 
862  totalSF = BtagSF( jets );
863 
865  if ( ret != StatusCode::SUCCESS) {
866  ATH_MSG_ERROR("Cannot configure BTaggingEfficiencyTool for systematic var. " << systConfig.name() );
867  }
868 
869  return totalSF;
870  }
871 
873 
874  float totalSF = 1.;
875  for ( const xAOD::Jet* trkjet : *trkjets ) {
876 
877  float sf = 1.;
878 
879  if ( std::abs(trkjet->eta()) > 2.5 ) {
880  ATH_MSG_VERBOSE( "Trying to retrieve b-tagging SF for trkjet with |eta|>2.5 (trkjet eta=" << trkjet->eta() << "), trkjet will be skipped");
881  } else if ( trkjet->pt() < 10e3 ){
882  ATH_MSG_VERBOSE( "Trying to retrieve b-tagging SF for trkjet with invalid pt (trkjet pt=" << trkjet->pt() << "), jet will be skipped");
883  } else {
884 
886  int truthlabel(-1);
887  if (!trkjet->getAttribute("HadronConeExclTruthLabelID", truthlabel)) {
888  ATH_MSG_ERROR("Failed to get jet truth label!");
889  }
890  ATH_MSG_VERBOSE("This jet is " << (acc_bjet(*trkjet) ? "" : "not ") << "b-tagged.");
891  ATH_MSG_VERBOSE("This jet's truth label is " << truthlabel);
892 
893  if ( acc_bjet(*trkjet) ) {
895 
896  switch (result) {
898  ATH_MSG_ERROR( "Failed to retrieve SF for b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet" );
899  break;
901  ATH_MSG_VERBOSE( "No valid SF for b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet" );
902  break;
903  default:
904  ATH_MSG_VERBOSE( "Retrieve SF for b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet with value " << sf );
905  }
906  } else {
907 
909 
910  switch (result) {
912  ATH_MSG_ERROR( "Failed to retrieve SF for non-b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet" );
913  break;
915  ATH_MSG_VERBOSE( "No valid inefficiency SF for non-b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet" );
916  break;
917  default:
918  ATH_MSG_VERBOSE( "Retrieve SF for non-b-tagged trk jets in SUSYTools_xAOD::BtagSF_trkJet with value " << sf );
919  }
920  }
921  }
922 
923  dec_effscalefact(*trkjet) = sf;
924 
925  if( acc_signal(*trkjet) ) totalSF *= sf;
926 
927  }
928 
929  return totalSF;
930  }
931 
932 
934  {
935  float totalSF = 1.;
936 
937  //Set the new systematic variation
939  if ( ret != StatusCode::SUCCESS) {
940  ATH_MSG_ERROR("Cannot configure BTaggingEfficiencyTool (track jets) for systematic var. " << systConfig.name() );
941  }
942 
943  totalSF = BtagSF_trkJet( trkjets );
944 
946  if ( ret != StatusCode::SUCCESS) {
947  ATH_MSG_ERROR("Cannot configure BTaggingEfficiencyTool (track jets) for systematic var. " << systConfig.name() );
948  }
949 
950  return totalSF;
951  }
952 
954 
955  float totalSF = 1.;
956  if (!m_applyJVTCut) return totalSF;
957 
959  for (const xAOD::Jet* jet : *jets) {
960  // Only jets that were good for every cut except JVT
961  if (acc_signal_less_JVT(*jet) && acc_passOR(*jet)) {
962  jvtjets.push_back(jet);
963  }
964  }
965 
966  for (const xAOD::Jet* jet : jvtjets) {
967  float current_sf = 0;
968 
969  // the SF are only applied for HS jets and implicitely requires the presence of the isHS decoration
971  if (acc_passJvt(*jet)) {
973  }
974  else {
976  }
977 
978  switch (result) {
980  // this is probably not right, should report an error here
981  ATH_MSG_ERROR("Inexplicably failed JVT calibration" );
982  break;
984  // no NNJvt SF for jet, that is ok e.g. for jets with |eta| > 2.5
985  ATH_MSG_VERBOSE( "Skip SF application in SUSYTools_xAOD::JVT_SF as jet outside validate range" );
986  break;
987  default:
988  ATH_MSG_VERBOSE( "Retrieve SF for jet in SUSYTools_xAOD::JVT_SF with value " << current_sf );
989  totalSF *= current_sf;
990  }
991 
992  }
993 
994  ATH_MSG_VERBOSE( "Retrieve total SF for jet container in SUSYTools_xAOD::JVT_SF with value " << totalSF );
995 
996  return totalSF;
997  }
998 
999 
1001 
1002  float totalSF = 1.;
1003  if (!m_applyJVTCut) return totalSF;
1004 
1005  //Set the new systematic variation
1007  if ( ret != StatusCode::SUCCESS) {
1008  ATH_MSG_ERROR("Cannot configure NNjvtEfficiencyTool for systematic var. " << systConfig.name() );
1009  }
1010 
1011  // Delegate
1012  totalSF = SUSYObjDef_xAOD::JVT_SF( jets );
1013 
1014  // }
1015  if (m_applyJVTCut) {
1017  if ( ret != StatusCode::SUCCESS) {
1018  ATH_MSG_ERROR("Cannot configure NNjvtEfficiencyTool for systematic var. " << systConfig.name() );
1019  }
1020  }
1021 
1022  return totalSF;
1023  }
1024 
1026 
1027  float totalSF = 1.;
1028  if (!m_doFwdJVT) return totalSF;
1029 
1031  for (const xAOD::Jet* jet : *jets) {
1032  // Only jets that were good for every cut except JVT
1033  if (acc_signal_less_JVT(*jet) && acc_passOR(*jet)) {
1034  fjvtjets.push_back(jet);
1035  }
1036  }
1037 
1038  for (const xAOD::Jet* jet : fjvtjets) {
1039  float current_sf = 0;
1040 
1041  // the SF are only applied for HS jets and implicitely requires the presense of the isHS decoration
1043  if (acc_passFJvt(*jet)) {
1045  }
1046  else {
1048  }
1049 
1050  switch (result) {
1052  // this is probably not right, should report an error here
1053  ATH_MSG_ERROR("Inexplicably failed fJVT calibration" );
1054  break;
1056  // no fJvt SF for jet, that is ok e.g. for jets with |eta| < 2.5
1057  ATH_MSG_VERBOSE( "Skip SF application in SUSYTools_xAOD::FJVT_SF as jet outside validate range" );
1058  break;
1059  default:
1060  ATH_MSG_VERBOSE( "Retrieve SF for jet in SUSYTools_xAOD::FJVT_SF with value " << current_sf );
1061  totalSF *= current_sf;
1062  }
1063 
1064  }
1065 
1066  ATH_MSG_VERBOSE( "Retrieve total SF for jet container in SUSYTools_xAOD::FJVT_SF with value " << totalSF );
1067 
1068  return totalSF;
1069  }
1070 
1072 
1073  float totalSF = 1.;
1074  if (!m_doFwdJVT) return totalSF;
1075 
1076  //Set the new systematic variation
1078  if ( ret != StatusCode::SUCCESS) {
1079  ATH_MSG_ERROR("Cannot configure fJvtEfficiencyTool for systematic var. " << systConfig.name() );
1080  }
1081 
1082  // Delegate
1083  totalSF = SUSYObjDef_xAOD::FJVT_SF( jets );
1084 
1085  if (m_doFwdJVT) {
1087  if ( ret != StatusCode::SUCCESS) {
1088  ATH_MSG_ERROR("Cannot configure fJvtEfficiencyTool for systematic var. " << systConfig.name() );
1089  }
1090  }
1091 
1092  return totalSF;
1093  }
1094 
1095  double SUSYObjDef_xAOD::GetTotalJetSF(const xAOD::JetContainer* jets, const bool btagSF, const bool jvtSF, const bool fjvtSF) {
1096 
1097  double totalSF = 1.;
1098  if (btagSF) totalSF *= BtagSF(jets);
1099 
1100  if (jvtSF && m_applyJVTCut) totalSF *= JVT_SF(jets);
1101 
1102  if (fjvtSF) totalSF *= FJVT_SF(jets);
1103 
1104  return totalSF;
1105  }
1106 
1107 
1108  double SUSYObjDef_xAOD::GetTotalJetSFsys(const xAOD::JetContainer* jets, const CP::SystematicSet& systConfig, const bool btagSF, const bool jvtSF, const bool fjvtSF) {
1109 
1110  double totalSF = 1.;
1111  if (btagSF) totalSF *= BtagSFsys(jets, systConfig);
1112 
1113  if (jvtSF && m_applyJVTCut) totalSF *= JVT_SFsys(jets, systConfig);
1114 
1115  if (fjvtSF) totalSF *= FJVT_SFsys(jets, systConfig);
1116 
1117  return totalSF;
1118  }
1119 
1121  double weight = 0.;
1122  if ( btagSelTool->getTaggerWeight(input, weight, false/*useVetoWP=false*/) != CP::CorrectionCode::Ok ) {
1123  ATH_MSG_ERROR( btagSelTool->name() << ": could not retrieve b-tag weight (" << btagTagger << ")." );
1124  return StatusCode::FAILURE;
1125  }
1126  dec_btag_weight(input) = weight;
1127  ATH_MSG_DEBUG( btagSelTool->name() << " b-tag weight: " << weight );
1128 
1129  double btag_pb(-10), btag_pc(-10), btag_pu(-10), btag_ptau(-10);
1130  // following name change is needed given different name is used for GN2v00 in derivation and in CDI
1131  std::string actualTagger = btagTagger;
1132  if (btagTagger == "GN2v00LegacyWP" || btagTagger == "GN2v00NewAliasWP"){
1133  actualTagger = "GN2v00";
1134  }
1135  xAOD::BTaggingUtilities::getBTagging(input)->pb(actualTagger, btag_pb);
1136  xAOD::BTaggingUtilities::getBTagging(input)->pc(actualTagger, btag_pc);
1137  xAOD::BTaggingUtilities::getBTagging(input)->pu(actualTagger, btag_pu);
1138  xAOD::BTaggingUtilities::getBTagging(input)->pu(actualTagger, btag_ptau);
1139  dec_btag_pb(input) = btag_pb;
1140  dec_btag_pc(input) = btag_pc;
1141  dec_btag_pu(input) = btag_pu;
1142  dec_btag_ptau(input) = btag_ptau;
1143  ATH_MSG_DEBUG( btagSelTool->name() << " b-tag " << btagTagger << "-type pb: " << btag_pb );
1144  ATH_MSG_DEBUG( btagSelTool->name() << " b-tag " << btagTagger << "-type pc: " << btag_pc );
1145  ATH_MSG_DEBUG( btagSelTool->name() << " b-tag " << btagTagger << "-type pu: " << btag_pu );
1146  ATH_MSG_DEBUG( btagSelTool->name() << " b-tag " << btagTagger << "-type ptau: " << btag_ptau );
1147  // backwards compatibility
1148  if ( btagSelTool->name().find("DL1")!=std::string::npos ) {
1149  dec_btag_dl1pb(input) = btag_pb;
1150  dec_btag_dl1pc(input) = btag_pc;
1151  dec_btag_dl1pu(input) = btag_pu;
1152  }
1153  else {
1154  dec_btag_dl1pb(input) = -10;
1155  dec_btag_dl1pc(input) = -10;
1156  dec_btag_dl1pu(input) = -10;
1157  }
1158  return StatusCode::SUCCESS;
1159  }
1160 }
ST::SUSYObjDef_xAOD::m_WDecorName
std::string m_WDecorName
Definition: SUSYObjDef_xAOD.h:545
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
ST::SUSYObjDef_xAOD::m_applyJVTCut
bool m_applyJVTCut
Definition: SUSYObjDef_xAOD.h:812
JetPileupLabelingTool::decorate
StatusCode decorate(const xAOD::JetContainer &jets) const override
Decorate hard-scatter and pileup labels to a jet collection.
Definition: JetPileupLabelingTool.cxx:43
BTaggingUtilities.h
ST::SUSYObjDef_xAOD::m_jetfJvtEfficiencyTool
asg::AnaToolHandle< CP::IJvtEfficiencyTool > m_jetfJvtEfficiencyTool
Definition: SUSYObjDef_xAOD.h:832
ST::SUSYObjDef_xAOD::GetJets
StatusCode GetJets(xAOD::JetContainer *&copy, xAOD::ShallowAuxContainer *&copyaux, const bool recordSG=true, const std::string &jetkey="", const xAOD::JetContainer *containerToBeCopied=nullptr) override final
Definition: Jets.cxx:74
asg::AnaToolHandle< IBTaggingSelectionTool >
ST::SUSYObjDef_xAOD::BtagSF
float BtagSF(const xAOD::JetContainer *jets) override final
Definition: Jets.cxx:791
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
ST::SUSYObjDef_xAOD::m_ZTagjetUncertaintiesTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_ZTagjetUncertaintiesTool
Definition: SUSYObjDef_xAOD.h:839
ST::SUSYObjDef_xAOD::IsTrackBJetContinuous
int IsTrackBJetContinuous(const xAOD::Jet &input) const override final
Definition: Jets.cxx:780
ST::SUSYObjDef_xAOD::IsTruthBJet
bool IsTruthBJet(const xAOD::Jet &input) const override final
Definition: Truth.cxx:309
get_generator_info.result
result
Definition: get_generator_info.py:21
xAOD::JetAttribute::LArQuality
@ LArQuality
Definition: JetAttributes.h:83
TrackParticlexAODHelpers.h
ST::SUSYObjDef_xAOD::JVT_SFsys
double JVT_SFsys(const xAOD::JetContainer *jets, const CP::SystematicSet &systConfig) override final
Definition: Jets.cxx:1000
ST::SUSYObjDef_xAOD::m_BtagWP
std::string m_BtagWP
Definition: SUSYObjDef_xAOD.h:667
xAOD::JetAttribute::FracSamplingMax
@ FracSamplingMax
Definition: JetAttributes.h:116
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
CP::IJvtEfficiencyTool::getEfficiencyScaleFactor
virtual CorrectionCode getEfficiencyScaleFactor(const xAOD::Jet &jet, float &sf) const =0
Calculate the efficiency scale factor for the provided jet.
ST::SUSYObjDef_xAOD::m_label_truthKey
SG::ReadDecorHandleKey< xAOD::JetContainer > m_label_truthKey
Definition: SUSYObjDef_xAOD.h:842
ST::SUSYObjDef_xAOD::IsBJet
bool IsBJet(const xAOD::Jet &input) const override final
Definition: Jets.cxx:736
ST::SUSYObjDef_xAOD::m_ZTagUncConfig
std::string m_ZTagUncConfig
Definition: SUSYObjDef_xAOD.h:554
SG::VIEW_ELEMENTS
@ VIEW_ELEMENTS
this data object is a view, it does not own its elmts
Definition: OwnershipPolicy.h:18
ConstDataVector.h
DataVector adapter that acts like it holds const pointers.
xAODP4Helpers.h
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
ST::SUSYObjDef_xAOD::m_jetNNJvtMomentTool
asg::AnaToolHandle< JetPileupTag::JetVertexNNTagger > m_jetNNJvtMomentTool
Definition: SUSYObjDef_xAOD.h:828
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
CP::IJvtEfficiencyTool::getInefficiencyScaleFactor
virtual CorrectionCode getInefficiencyScaleFactor(const xAOD::Jet &jet, float &sf) const =0
Calculate the inefficiency scale factor for the provided jet.
ST
Definition: Electrons.cxx:41
xAOD::ShallowAuxContainer
Class creating a shallow copy of an existing auxiliary container.
Definition: ShallowAuxContainer.h:54
CP::SystematicSet
Class to wrap a set of SystematicVariations.
Definition: SystematicSet.h:31
ST::SUSYObjDef_xAOD::m_TopTaggerTool
asg::AnaToolHandle< JSSWTopTaggerDNN > m_TopTaggerTool
Definition: SUSYObjDef_xAOD.h:836
ST::SUSYObjDef_xAOD::m_orBtagWP
std::string m_orBtagWP
Definition: SUSYObjDef_xAOD.h:774
CP::SystematicSet::name
std::string name() const
returns: the systematics joined into a single string.
Definition: SystematicSet.cxx:278
ANA_MSG_ERROR
#define ANA_MSG_ERROR(xmsg)
Macro printing error messages.
Definition: Control/AthToolSupport/AsgMessaging/AsgMessaging/MessageCheck.h:294
SUSYObjDef_xAOD.h
xAOD::ShallowAuxContainer::name
const char * name() const
Get the name of the container instance.
Definition: ShallowAuxContainer.cxx:595
IBTaggingSelectionTool::getTaggerWeight
virtual CP::CorrectionCode getTaggerWeight(const xAOD::Jet &jet, double &tagweight) const =0
ST::SUSYObjDef_xAOD::m_WTaggerTool
asg::AnaToolHandle< SmoothedWZTagger > m_WTaggerTool
Definition: SUSYObjDef_xAOD.h:834
SG::ConstAccessor< char >
ST::SUSYObjDef_xAOD::GetPrimVtx
const xAOD::Vertex * GetPrimVtx() const override final
Definition: SUSYObjDef_xAOD.cxx:2877
ST::SUSYObjDef_xAOD::GetFatJets
StatusCode GetFatJets(xAOD::JetContainer *&copy, xAOD::ShallowAuxContainer *&copyaux, const bool recordSG=false, const std::string &jetkey="", const bool doLargeRdecorations=false, const xAOD::JetContainer *containerToBeCopied=nullptr) override final
Definition: Jets.cxx:243
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
ST::SUSYObjDef_xAOD::m_jetUncertaintiesPDSmearTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_jetUncertaintiesPDSmearTool
Definition: SUSYObjDef_xAOD.h:822
ST::SUSYObjDef_xAOD::FillJet
StatusCode FillJet(xAOD::Jet &input, const bool doCalib=true, bool isFat=false, bool doLargeRdecorations=false) override final
Definition: Jets.cxx:384
IJetSelector.h
ST::SUSYObjDef_xAOD::m_debug
bool m_debug
Definition: SUSYObjDef_xAOD.h:533
IJetModifier.h
IJetDecorator.h
Pythia8_A14_NNPDF23LO_forMGHT_EvtGen.ptcut
float ptcut
Definition: Pythia8_A14_NNPDF23LO_forMGHT_EvtGen.py:9
ST::SUSYObjDef_xAOD::m_tool_init
bool m_tool_init
Definition: SUSYObjDef_xAOD.h:558
ST::SUSYObjDef_xAOD::m_jetJvtMomentTool
asg::AnaToolHandle< JetVertexTaggerTool > m_jetJvtMomentTool
Definition: SUSYObjDef_xAOD.h:827
IJetCalibrationTool.h
ST::SUSYObjDef_xAOD::BtagSF_trkJet
float BtagSF_trkJet(const xAOD::JetContainer *trkjets) override final
Definition: Jets.cxx:872
ST::SUSYObjDef_xAOD::m_acc_jetClean
SG::ConstAccessor< char > m_acc_jetClean
Definition: SUSYObjDef_xAOD.h:985
dqt_zlumi_pandas.weight
int weight
Definition: dqt_zlumi_pandas.py:189
ST::SUSYObjDef_xAOD::IsTrackBJet
bool IsTrackBJet(const xAOD::Jet &input) const override final
Definition: Jets.cxx:747
ST::SUSYObjDef_xAOD::m_btagEffTool_trkJet
asg::AnaToolHandle< IBTaggingEfficiencyTool > m_btagEffTool_trkJet
Definition: SUSYObjDef_xAOD.h:915
ST::SUSYObjDef_xAOD::FillTrackJet
StatusCode FillTrackJet(xAOD::Jet &input) override final
Definition: Jets.cxx:608
ST::SUSYObjDef_xAOD::FJVT_SFsys
double FJVT_SFsys(const xAOD::JetContainer *jets, const CP::SystematicSet &systConfig) override final
Definition: Jets.cxx:1071
ST::SUSYObjDef_xAOD::m_trkJetPt
double m_trkJetPt
Definition: SUSYObjDef_xAOD.h:737
xAOD::JetConstitScaleMomentum
@ JetConstitScaleMomentum
Definition: JetTypes.h:29
ST::SUSYObjDef_xAOD::GetJetsSyst
StatusCode GetJetsSyst(const xAOD::JetContainer &calibjets, xAOD::JetContainer *&copy, xAOD::ShallowAuxContainer *&copyaux, const bool recordSG=true, const std::string &jetkey="") override final
Definition: Jets.cxx:322
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
ST::SUSYObjDef_xAOD::m_isPHYSLITE
bool m_isPHYSLITE
Definition: SUSYObjDef_xAOD.h:796
IBTaggingEfficiencyTool.h
CP::CorrectionCode::OutOfValidityRange
@ OutOfValidityRange
Input object is out of validity range.
Definition: CorrectionCode.h:37
CP::CorrectionCode::Error
@ Error
Some error happened during the object correction.
Definition: CorrectionCode.h:36
ST::SUSYObjDef_xAOD::m_defaultJets
std::string m_defaultJets
Definition: SUSYObjDef_xAOD.h:802
ST::SUSYObjDef_xAOD::m_useBtagging
bool m_useBtagging
Definition: SUSYObjDef_xAOD.h:531
xAOD::JetAttribute::HECQuality
@ HECQuality
Definition: JetAttributes.h:80
METHelpers.h
met::addGhostMuonsToJets
void addGhostMuonsToJets(const xAOD::MuonContainer &muons, xAOD::JetContainer &jets)
Definition: METHelpers.cxx:34
jet
Definition: JetCalibTools_PlotJESFactors.cxx:23
ST::SUSYObjDef_xAOD::m_jetEta
double m_jetEta
Definition: SUSYObjDef_xAOD.h:730
IBTaggingSelectionTool.h
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
ST::SUSYObjDef_xAOD::IsBJetContinuous
int IsBJetContinuous(const xAOD::Jet &input) const override final
Definition: Jets.cxx:758
IAsgSelectionTool::accept
virtual asg::AcceptData accept(const xAOD::IParticle *) const =0
The main accept method: the actual cuts are applied here.
CheckAppliedSFs.e3
e3
Definition: CheckAppliedSFs.py:264
SG::ReadDecorHandle
Handle class for reading a decoration on an object.
Definition: StoreGate/StoreGate/ReadDecorHandle.h:94
xAOD::BTagging_v1::pc
bool pc(const std::string &taggername, double &value) const
Definition: BTagging_v1.cxx:367
doubleTestComp.j1
j1
Definition: doubleTestComp.py:21
SG::Decorator< char >
ST::SUSYObjDef_xAOD::m_jetCalibTool
asg::AnaToolHandle< IJetCalibrationTool > m_jetCalibTool
Definition: SUSYObjDef_xAOD.h:819
ST::SUSYObjDef_xAOD::m_BtagTagger
std::string m_BtagTagger
Definition: SUSYObjDef_xAOD.h:668
xAOD::P4Helpers::deltaR
double deltaR(double rapidity1, double phi1, double rapidity2, double phi2)
from bare bare rapidity,phi
Definition: xAODP4Helpers.h:150
xAOD::JetAttribute::EMFrac
@ EMFrac
Definition: JetAttributes.h:112
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
ST::SUSYObjDef_xAOD::m_jetUncertaintiesTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_jetUncertaintiesTool
Definition: SUSYObjDef_xAOD.h:821
ST::SUSYObjDef_xAOD::IsSignalJet
bool IsSignalJet(const xAOD::Jet &input, const float ptcut, const float etacut) const override final
Definition: Jets.cxx:658
PlotPulseshapeFromCool.input
input
Definition: PlotPulseshapeFromCool.py:106
ST::SUSYObjDef_xAOD::m_ZTaggerTool
asg::AnaToolHandle< SmoothedWZTagger > m_ZTaggerTool
Definition: SUSYObjDef_xAOD.h:835
ST::SUSYObjDef_xAOD::FJVT_SF
double FJVT_SF(const xAOD::JetContainer *jets) override final
Definition: Jets.cxx:1025
xAOD::JetAttribute::Timing
@ Timing
Definition: JetAttributes.h:90
ST::SUSYObjDef_xAOD::m_jetfJvtSelectionTool
asg::AnaToolHandle< IAsgSelectionTool > m_jetfJvtSelectionTool
Definition: SUSYObjDef_xAOD.h:831
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
ST::SUSYObjDef_xAOD::m_jetUncertaintiesPDsmearing
bool m_jetUncertaintiesPDsmearing
Definition: SUSYObjDef_xAOD.h:529
ST::SUSYObjDef_xAOD::GetTrackJets
StatusCode GetTrackJets(xAOD::JetContainer *&copy, xAOD::ShallowAuxContainer *&copyaux, const bool recordSG=true, const std::string &jetkey="", const xAOD::JetContainer *containerToBeCopied=nullptr) override final
Definition: Jets.cxx:170
ST::SUSYObjDef_xAOD::m_jetPileupLabelingTool
asg::AnaToolHandle< JetPileupLabelingTool > m_jetPileupLabelingTool
Definition: SUSYObjDef_xAOD.h:826
ST::SUSYObjDef_xAOD::m_WTagjetUncertaintiesTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_WTagjetUncertaintiesTool
Definition: SUSYObjDef_xAOD.h:838
ST::SUSYObjDef_xAOD::isData
bool isData() const override final
Definition: SUSYObjDef_xAOD.h:156
ST::SUSYObjDef_xAOD::IsBadJet
bool IsBadJet(const xAOD::Jet &input) const override final
Definition: Jets.cxx:710
ST::SUSYObjDef_xAOD::m_btagSelTool_trkJet
asg::AnaToolHandle< IBTaggingSelectionTool > m_btagSelTool_trkJet
Definition: SUSYObjDef_xAOD.h:916
SG::AuxElement::index
size_t index() const
Return the index of this element within its container.
ST::SUSYObjDef_xAOD::m_fatjetUncertaintiesTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_fatjetUncertaintiesTool
Definition: SUSYObjDef_xAOD.h:823
ICPJetUncertaintiesTool::applyCorrection
virtual CP::CorrectionCode applyCorrection(xAOD::Jet &input) const =0
IBTaggingEfficiencyTool::getScaleFactor
virtual CP::CorrectionCode getScaleFactor(const xAOD::Jet &jet, float &sf)=0
Declare the interface that the class provides.
ST::SUSYObjDef_xAOD::m_WTagUncConfig
std::string m_WTagUncConfig
Definition: SUSYObjDef_xAOD.h:553
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
ST::SUSYObjDef_xAOD::SetBtagWeightDecorations
StatusCode SetBtagWeightDecorations(const xAOD::Jet &input, const asg::AnaToolHandle< IBTaggingSelectionTool > &btagSelTool, const std::string &btagTagger) const override final
Definition: Jets.cxx:1120
ST::SUSYObjDef_xAOD::m_jetPt
double m_jetPt
Definition: SUSYObjDef_xAOD.h:729
xAOD::BTagging_v1::pu
bool pu(const std::string &taggername, double &value) const
Definition: BTagging_v1.cxx:353
ST::SUSYObjDef_xAOD::m_ToptagConfig
std::string m_ToptagConfig
Definition: SUSYObjDef_xAOD.h:550
xAOD::JetAttribute::AverageLArQF
@ AverageLArQF
Definition: JetAttributes.h:85
xAOD::JetAttribute::SumPtTrkPt500
@ SumPtTrkPt500
Definition: JetAttributes.h:108
ST::SUSYObjDef_xAOD::m_useBtagging_trkJet
bool m_useBtagging_trkJet
Definition: SUSYObjDef_xAOD.h:532
ST::SUSYObjDef_xAOD::m_doFwdJVT
bool m_doFwdJVT
Definition: SUSYObjDef_xAOD.h:740
ICPJetUncertaintiesTool.h
ST::SUSYObjDef_xAOD::m_btagSelTool_OR
asg::AnaToolHandle< IBTaggingSelectionTool > m_btagSelTool_OR
Definition: SUSYObjDef_xAOD.h:914
ConstDataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
SmoothedWZTagger::tag
virtual StatusCode tag(const xAOD::Jet &jet) const override
Decorate single jet with tagging info.
Definition: SmoothedWZTagger.cxx:177
IBTaggingSelectionTool::getQuantile
virtual int getQuantile(const xAOD::IParticle *) const =0
Decide in which quantile of the tagger weight distribution the jet belongs The return value represent...
ST::SUSYObjDef_xAOD::m_trkJetEta
double m_trkJetEta
Definition: SUSYObjDef_xAOD.h:738
ST::SUSYObjDef_xAOD::m_BtagWP_trkJet
std::string m_BtagWP_trkJet
Definition: SUSYObjDef_xAOD.h:675
xAOD::ShallowAuxContainer::setName
void setName(const char *name)
Set the name of the container instance.
Definition: ShallowAuxContainer.cxx:600
xAOD::shallowCopyContainer
std::pair< std::unique_ptr< T >, std::unique_ptr< ShallowAuxContainer > > shallowCopyContainer(const T &cont, [[maybe_unused]] const EventContext &ctx)
Function making a shallow copy of a constant container.
Definition: ShallowCopy.h:110
ST::SUSYObjDef_xAOD::GetTotalJetSFsys
double GetTotalJetSFsys(const xAOD::JetContainer *jets, const CP::SystematicSet &systConfig, const bool btagSF=true, const bool jvtSF=true, const bool fjvtSF=false) override final
Definition: Jets.cxx:1108
InDet::TrkOrigin::isPileup
bool isPileup(int origin)
from pileup
Definition: InDetTrackTruthOriginDefs.h:49
AthAnalysisHelper.h
xAOD::BTaggingUtilities::getBTagging
const BTagging * getBTagging(const SG::AuxElement &part)
Access the default xAOD::BTagging object associated to an object.
Definition: BTaggingUtilities.cxx:37
ST::SUSYObjDef_xAOD::m_btagSelTool
asg::AnaToolHandle< IBTaggingSelectionTool > m_btagSelTool
Definition: SUSYObjDef_xAOD.h:913
ST::SUSYObjDef_xAOD::m_jetNNJvtSelectionTool
asg::AnaToolHandle< IAsgSelectionTool > m_jetNNJvtSelectionTool
Definition: SUSYObjDef_xAOD.h:829
xAOD::Jet_v1
Class describing a jet.
Definition: Jet_v1.h:57
CP::CorrectionCode::Ok
@ Ok
The correction was done successfully.
Definition: CorrectionCode.h:38
ST::SUSYObjDef_xAOD::m_btagEffTool
asg::AnaToolHandle< IBTaggingEfficiencyTool > m_btagEffTool
Definition: SUSYObjDef_xAOD.h:912
ST::SUSYObjDef_xAOD::m_fatJets
std::string m_fatJets
Definition: SUSYObjDef_xAOD.h:804
ST::SUSYObjDef_xAOD::m_BtagTagger_trkJet
std::string m_BtagTagger_trkJet
Definition: SUSYObjDef_xAOD.h:676
mapkey::sf
@ sf
Definition: TElectronEfficiencyCorrectionTool.cxx:38
JetTruthLabelingTool::decorate
StatusCode decorate(const xAOD::JetContainer &jets) const override
decorate truth label to a jet collection
Definition: JetTruthLabelingTool.cxx:317
ST::SUSYObjDef_xAOD::m_JetTruthLabelName
std::string m_JetTruthLabelName
Definition: SUSYObjDef_xAOD.h:556
ST::SUSYObjDef_xAOD::JVT_SF
double JVT_SF(const xAOD::JetContainer *jets) override final
Definition: Jets.cxx:953
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
ConstDataVector
DataVector adapter that acts like it holds const pointers.
Definition: ConstDataVector.h:76
ST::SUSYObjDef_xAOD::BtagSFsys_trkJet
float BtagSFsys_trkJet(const xAOD::JetContainer *trkjets, const CP::SystematicSet &systConfig) override final
Definition: Jets.cxx:933
xAOD::setOriginalObjectLink
bool setOriginalObjectLink(const IParticle &original, IParticle &copy)
This function should be used by CP tools when they make a deep copy of an object in their correctedCo...
Definition: IParticleHelpers.cxx:30
ST::SUSYObjDef_xAOD::m_defaultTrackJets
std::string m_defaultTrackJets
Definition: SUSYObjDef_xAOD.h:803
ST::SUSYObjDef_xAOD::m_TopTagUncConfig
std::string m_TopTagUncConfig
Definition: SUSYObjDef_xAOD.h:555
IJetCalibrationTool::applyCalibration
virtual StatusCode applyCalibration(xAOD::JetContainer &jets) const =0
Apply calibration to a jet container.
IJetUpdateJvt.h
CP::CorrectionCode
Return value from object correction CP tools.
Definition: CorrectionCode.h:31
ST::SUSYObjDef_xAOD::m_currentSyst
CP::SystematicSet m_currentSyst
Definition: SUSYObjDef_xAOD.h:808
ST::SUSYObjDef_xAOD::m_jetFatCalibTool
asg::AnaToolHandle< IJetCalibrationTool > m_jetFatCalibTool
Definition: SUSYObjDef_xAOD.h:820
ST::SUSYObjDef_xAOD::m_jetNNJvtEfficiencyTool
asg::AnaToolHandle< CP::IJvtEfficiencyTool > m_jetNNJvtEfficiencyTool
Definition: SUSYObjDef_xAOD.h:830
ST::SUSYObjDef_xAOD::BtagSFsys
float BtagSFsys(const xAOD::JetContainer *jets, const CP::SystematicSet &systConfig) override final
Definition: Jets.cxx:852
ST::SUSYObjDef_xAOD::m_jetTruthLabelingTool
asg::AnaToolHandle< JetTruthLabelingTool > m_jetTruthLabelingTool
Definition: SUSYObjDef_xAOD.h:837
ST::SUSYObjDef_xAOD::m_ZDecorName
std::string m_ZDecorName
Definition: SUSYObjDef_xAOD.h:546
SG::ConstAccessor::isAvailable
bool isAvailable(const ELT &e) const
Test to see if this variable exists in the store.
IBTaggingSelectionTool::accept
virtual asg::AcceptData accept(const xAOD::IParticle *p) const =0
Declare the interface that the class provides.
xAOD::JetAttribute::HECFrac
@ HECFrac
Definition: JetAttributes.h:113
defineDB.jets
list jets
Definition: JetTagCalibration/share/defineDB.py:24
IParticleHelpers.h
ST::SUSYObjDef_xAOD::GetTotalJetSF
double GetTotalJetSF(const xAOD::JetContainer *jets, const bool btagSF=true, const bool jvtSF=true, const bool fjvtSF=false) override final
Definition: Jets.cxx:1095
ST::SUSYObjDef_xAOD::JetPassJVT
bool JetPassJVT(xAOD::Jet &input) override final
Definition: Jets.cxx:652
calibdata.copy
bool copy
Definition: calibdata.py:27
ST::SUSYObjDef_xAOD::m_TopTagjetUncertaintiesTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_TopTagjetUncertaintiesTool
Definition: SUSYObjDef_xAOD.h:840
IBTaggingEfficiencyTool::getInefficiencyScaleFactor
virtual CP::CorrectionCode getInefficiencyScaleFactor(const xAOD::Jet &jet, float &sf)=0
JetVertexTaggerTool::updateJvt
float updateJvt(const xAOD::Jet &jet) const override
Calculate the updated JVT.
Definition: JetVertexTaggerTool.cxx:200
JetPileupTag::JetVertexNNTagger::decorate
virtual StatusCode decorate(const xAOD::JetContainer &jetCont) const override
Decorate a jet collection without otherwise modifying it.
Definition: JetVertexNNTagger.cxx:146
ST::SUSYObjDef_xAOD::m_ZtagConfig
std::string m_ZtagConfig
Definition: SUSYObjDef_xAOD.h:549
xAOD::bool
setBGCode setTAP setLVL2ErrorBits bool
Definition: TrigDecision_v1.cxx:60
SG::ReadDecorHandle::isAvailable
bool isAvailable()
Test to see if this variable exists in the store, for the referenced object.
CP::ISystematicsTool::applySystematicVariation
virtual StatusCode applySystematicVariation(const SystematicSet &systConfig)=0
effects: configure this tool for the given list of systematic variations.
asg::AnaToolHandle::empty
bool empty() const
whether this ToolHandle is completely empty, i.e.
IJetJvtEfficiency.h
ST::SUSYObjDef_xAOD::m_TopDecorName
std::string m_TopDecorName
Definition: SUSYObjDef_xAOD.h:547
doubleTestComp.j2
j2
Definition: doubleTestComp.py:22
xAOD::JetAttribute::NegativeE
@ NegativeE
Definition: JetAttributes.h:84
ST::SUSYObjDef_xAOD::m_WtagConfig
std::string m_WtagConfig
Definition: SUSYObjDef_xAOD.h:548
JSSWTopTaggerDNN::tag
virtual StatusCode tag(const xAOD::Jet &jet) const override
Decorate single jet with tagging info.
Definition: JSSWTopTaggerDNN.cxx:381
xAOD::BTagging_v1::pb
bool pb(const std::string &taggername, double &value) const
Definition: BTagging_v1.cxx:360
ST::SUSYObjDef_xAOD::IsBJetLoose
bool IsBJetLoose(const xAOD::Jet &input) const override final
Definition: Jets.cxx:645