ATLAS Offline Software
TauSelectionTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 // Local include(s):
8 
9 // Framework include(s):
11 
12 // ROOT include(s)
13 #include "TEnv.h"
14 #include "THashList.h"
15 
16 // System include(s)
17 #include <atomic>
18 
19 using namespace TauAnalysisTools;
20 
21 //=================================PUBLIC-PART==================================
22 //______________________________________________________________________________
24  : asg::AsgMetadataTool( name )
25  , m_sJetIDWP("JETIDNONE")
26  , m_sEleIDWP("ELEIDNONE")
27  , m_fOutFile(nullptr)
28  , m_aAccept( "TauSelection" )
29 {}
30 
31 //______________________________________________________________________________
33 {
34  m_cMap.clear();
35 }
36 
37 //______________________________________________________________________________
39 {
40 
41  m_vPtRegion = m_vecPtRegion.value();
43  m_vAbsCharges = m_vecAbsCharges.value();
44  m_vNTracks = m_vecNTracks.value();
48 
49  bool bConfigViaConfigFile = !m_sConfigPath.empty();
50  bool bConfigViaProperties = false;
51  if (!bConfigViaProperties and !m_vPtRegion.empty()) bConfigViaProperties = true;
52  if (!bConfigViaProperties and !std::isnan(m_dPtMin.value())) bConfigViaProperties = true;
53  if (!bConfigViaProperties and !std::isnan(m_dPtMax.value())) bConfigViaProperties = true;
54  if (!bConfigViaProperties and !m_vAbsEtaRegion.empty()) bConfigViaProperties = true;
55  if (!bConfigViaProperties and !std::isnan(m_dAbsEtaMin.value())) bConfigViaProperties = true;
56  if (!bConfigViaProperties and !std::isnan(m_dAbsEtaMax.value())) bConfigViaProperties = true;
57  if (!bConfigViaProperties and !m_vAbsCharges.empty()) bConfigViaProperties = true;
58  if (!bConfigViaProperties and !std::isnan(m_iAbsCharge.value())) bConfigViaProperties = true;
59  if (!bConfigViaProperties and !m_vNTracks.empty()) bConfigViaProperties = true;
60  if (!bConfigViaProperties and !std::isnan(m_iNTrack.value())) bConfigViaProperties = true;
61  if (!bConfigViaProperties and !m_vJetRNNSigTransRegion.empty()) bConfigViaProperties = true;
62  if (!bConfigViaProperties and !std::isnan(m_dJetRNNSigTransMin.value())) bConfigViaProperties = true;
63  if (!bConfigViaProperties and !std::isnan(m_dJetRNNSigTransMax.value())) bConfigViaProperties = true;
64  if (!bConfigViaProperties and !m_vGNTauSigTransRegion.empty()) bConfigViaProperties = true;
65  if (!bConfigViaProperties and !std::isnan(m_dGNTauSigTransMin.value())) bConfigViaProperties = true;
66  if (!bConfigViaProperties and !std::isnan(m_dGNTauSigTransMax.value())) bConfigViaProperties = true;
67  if (!bConfigViaProperties and m_iJetIDWP != 0) bConfigViaProperties = true;
68  if (!bConfigViaProperties and !m_vEleRNNSigTransRegion.empty()) bConfigViaProperties = true;
69  if (!bConfigViaProperties and !std::isnan(m_dEleRNNSigTransMin.value())) bConfigViaProperties = true;
70  if (!bConfigViaProperties and !std::isnan(m_dEleRNNSigTransMax.value())) bConfigViaProperties = true;
71  if (!bConfigViaProperties and m_iEleIDWP != 0) bConfigViaProperties = true;
72  if (!bConfigViaProperties and m_bMuonOLR) bConfigViaProperties = true;
73 
74  if (bConfigViaConfigFile and bConfigViaProperties)
75  {
76  ATH_MSG_WARNING("Configured tool via setProperty and configuration file, which may lead to unexpected configuration.");
77  ATH_MSG_WARNING("In doubt check the configuration that is printed when the tool is initialized and the message level is set to debug");
78  ATH_MSG_WARNING("For further details please refer to the documentation:");
79  ATH_MSG_WARNING("https://gitlab.cern.ch/atlas/athena/blob/main/PhysicsAnalysis/TauID/TauAnalysisTools/doc/README-TauSelectionTool.rst");
80  }
81  if (!bConfigViaConfigFile and !bConfigViaProperties)
82  {
83  ATH_MSG_WARNING("No cut configuration provided, the tool will not do anything. For further details please refer to the documentation:");
84  ATH_MSG_WARNING("https://gitlab.cern.ch/atlas/athena/blob/main/PhysicsAnalysis/TauID/TauAnalysisTools/doc/README-TauSelectionTool.rst");
85  return StatusCode::SUCCESS;
86  }
87 
88  if (bConfigViaConfigFile)
89  {
90  TEnv rEnv;
91  std::string sInputFilePath = PathResolverFindCalibFile(m_sConfigPath);
92 
93  if (!testFileForEOFContainsCharacters(sInputFilePath))
94  ATH_MSG_WARNING("Config file for TauSelectionTool with path "<<sInputFilePath<<" does not contain an empty last line. The tool might not be properly configured!");
95 
96  rEnv.ReadFile(sInputFilePath.c_str(),
97  kEnvAll);
98 
99  std::vector<std::string> vCuts;
100  // if Cuts are specified in the config file take these ones, if not take all
101  // specified in the config
102  if (rEnv.Defined("SelectionCuts"))
103  TauAnalysisTools::split(rEnv, "SelectionCuts", ' ', vCuts);
104  else
105  {
106  auto lList = rEnv.GetTable();
107  for( Int_t i = 0; i < lList->GetEntries(); ++i )
108  {
109  vCuts.push_back( lList->At( i )->GetName() );
110  }
111  }
112 
113  int iSelectionCuts = 0;
114 
115  for (const std::string& sCut : vCuts)
116  {
117  if (sCut == "PtRegion")
118  {
119  iSelectionCuts = iSelectionCuts | CutPt;
120  if (m_vPtRegion.empty())
121  TauAnalysisTools::split(rEnv,"PtRegion", ';', m_vPtRegion);
122  }
123  else if (sCut == "PtMin")
124  {
125  iSelectionCuts = iSelectionCuts | CutPt;
126  if (std::isnan(m_dPtMin.value()))
127  m_dPtMin = rEnv.GetValue("PtMin",NAN);
128  }
129  else if (sCut == "PtMax")
130  {
131  iSelectionCuts = iSelectionCuts | CutPt;
132  if (std::isnan(m_dPtMax.value()))
133  m_dPtMax = rEnv.GetValue("PtMax",NAN);
134  }
135  else if (sCut == "AbsEtaRegion")
136  {
137  iSelectionCuts = iSelectionCuts | CutAbsEta;
138  if (m_vAbsEtaRegion.empty())
139  TauAnalysisTools::split(rEnv,"AbsEtaRegion", ';', m_vAbsEtaRegion);
140  }
141  else if (sCut == "AbsEtaMin")
142  {
143  iSelectionCuts = iSelectionCuts | CutAbsEta;
144  if (std::isnan(m_dAbsEtaMin.value()))
145  m_dAbsEtaMin = rEnv.GetValue("AbsEtaMin",NAN);
146  }
147  else if (sCut == "AbsEtaMax")
148  {
149  iSelectionCuts = iSelectionCuts | CutAbsEta;
150  if (std::isnan(m_dAbsEtaMax.value()))
151  m_dAbsEtaMax = rEnv.GetValue("AbsEtaMax",NAN);
152  }
153  else if (sCut == "AbsCharges")
154  {
155  iSelectionCuts = iSelectionCuts | CutAbsCharge;
156  if (m_vAbsCharges.empty())
157  TauAnalysisTools::split(rEnv,"AbsCharges", ';', m_vAbsCharges);
158  }
159  else if (sCut == "AbsCharge")
160  {
161  iSelectionCuts = iSelectionCuts | CutAbsCharge;
162  if (std::isnan(m_iAbsCharge.value()))
163  m_iAbsCharge = rEnv.GetValue("AbsCharge",NAN);
164  }
165  else if (sCut == "NTracks")
166  {
167  iSelectionCuts = iSelectionCuts | CutNTrack;
168  if (m_vNTracks.empty())
169  TauAnalysisTools::split(rEnv,"NTracks", ';', m_vNTracks);
170  }
171  else if (sCut == "NTrack")
172  {
173  iSelectionCuts = iSelectionCuts | CutNTrack;
174  if (std::isnan(m_iNTrack.value()))
175  m_iNTrack = rEnv.GetValue("NTrack",NAN);
176  }
177  else if (sCut == "JetRNNSigTransRegion")
178  {
179  iSelectionCuts = iSelectionCuts | CutJetRNNScoreSigTrans;
180  if (m_vJetRNNSigTransRegion.empty())
181  TauAnalysisTools::split(rEnv,"JetRNNSigTransRegion", ';', m_vJetRNNSigTransRegion);
182  }
183  else if (sCut == "JetRNNSigTransMin")
184  {
185  iSelectionCuts = iSelectionCuts | CutJetRNNScoreSigTrans;
186  if (std::isnan(m_dJetRNNSigTransMin.value()))
187  m_dJetRNNSigTransMin = rEnv.GetValue("JetRNNSigTransMin",NAN);
188  }
189  else if (sCut == "JetRNNSigTransMax")
190  {
191  iSelectionCuts = iSelectionCuts | CutJetRNNScoreSigTrans;
192  if (std::isnan(m_dJetRNNSigTransMax.value()))
193  m_dJetRNNSigTransMax = rEnv.GetValue("JetRNNSigTransMax",NAN);
194  }
195  else if (sCut == "GNTauSigTransRegion")
196  {
197  iSelectionCuts = iSelectionCuts | CutGNTauScoreSigTrans;
198  if (m_vGNTauSigTransRegion.empty())
199  TauAnalysisTools::split(rEnv,"GNTauSigTransRegion", ';', m_vGNTauSigTransRegion);
200 
201  // check if using GNTau
202  m_useGNTau = true;
203  }
204  else if (sCut == "GNTauSigTransMin")
205  {
206  iSelectionCuts = iSelectionCuts | CutGNTauScoreSigTrans;
207  if (std::isnan(m_dGNTauSigTransMin.value()))
208  m_dGNTauSigTransMin = rEnv.GetValue("GNTauSigTransMin",NAN);
209 
210  // check if using GNTau
211  m_useGNTau = true;
212  }
213  else if (sCut == "GNTauSigTransMax")
214  {
215  iSelectionCuts = iSelectionCuts | CutGNTauScoreSigTrans;
216  if (std::isnan(m_dGNTauSigTransMax.value()))
217  m_dGNTauSigTransMax = rEnv.GetValue("GNTauSigTransMax",NAN);
218 
219  // check if using GNTau
220  m_useGNTau = true;
221  }
222  else if (sCut == "EleRNNSigTransRegion")
223  {
224  iSelectionCuts = iSelectionCuts | CutEleRNNScoreSigTrans;
225  if (m_vEleRNNSigTransRegion.empty())
226  TauAnalysisTools::split(rEnv,"EleRNNRegion", ';', m_vEleRNNSigTransRegion);
227  }
228  else if (sCut == "EleRNNSigTransMin")
229  {
230  iSelectionCuts = iSelectionCuts | CutEleRNNScoreSigTrans;
231  if (std::isnan(m_dEleRNNSigTransMin.value()))
232  m_dEleRNNSigTransMin = rEnv.GetValue("EleRNNSigTransMin",NAN);
233  }
234  else if (sCut == "EleRNNSigTransMax")
235  {
236  iSelectionCuts = iSelectionCuts | CutEleRNNScoreSigTrans;
237  if (std::isnan(m_dEleRNNSigTransMax.value()))
238  m_dEleRNNSigTransMax = rEnv.GetValue("EleRNNSigTransMax",NAN);
239  }
240  else if (sCut == "JetIDWP")
241  {
242  iSelectionCuts = iSelectionCuts | CutJetIDWP;
244  m_iJetIDWP = convertStrToJetIDWP(rEnv.GetValue("JetIDWP","JETIDNONE"));
245  }
246 
247  // check for possible mis-config in Tau selection
248  for (const std::string& checkCut : vCuts){
249  if (checkCut.find("SigTrans") != std::string::npos) {
250  ATH_MSG_ERROR("Misconfig due to JetIDWP and SigTrans cuts both present in the config file. Please CHECK carefully config file again");
251  return StatusCode::FAILURE;
252  }
253  }
254  }
255  else if (sCut == "EleIDWP")
256  {
257  iSelectionCuts = iSelectionCuts | CutEleIDWP;
259  m_iEleIDWP = convertStrToEleIDWP(rEnv.GetValue("EleIDWP","ELEIDNONE"));
260  }
261  else if (sCut == "MuonOLR")
262  {
263  iSelectionCuts = iSelectionCuts | CutMuonOLR;
264  if (!m_bMuonOLR)
265  m_bMuonOLR = rEnv.GetValue("MuonOLR",false);
266  }
267  else ATH_MSG_WARNING("Cut " << sCut << " is not available");
268  }
269 
270  if (m_iSelectionCuts == NoCut)
271  m_iSelectionCuts = iSelectionCuts;
272  }
273 
276 
277  // check if using GNTau
278  if(m_sJetIDWP.find("GNTAU") != std::string::npos)
279  m_useGNTau = true;
280 
281  // initialise the ReadHandleKey of the muon container when the muon veto is applied
283 
284  ATH_CHECK( m_tauContainerKey.initialize() );
285 
286  // initialise the ReadDecorHandleKey if GNTau is applied
287  if (m_useGNTau) {
288  ATH_CHECK( m_GNTauDecorKey.assign(m_tauContainerKey.key()+".GNTauScoreSigTrans_v0prune"));
289  }
290  ATH_CHECK( m_GNTauDecorKey.initialize( m_useGNTau ) );
291 
292  // initialise the ReadDecorHandleKey if eVeto is applied
294  ATH_CHECK( m_eVetoDecorKey.assign(m_tauContainerKey.key()+".RNNEleScoreSigTrans_v"+std::to_string(m_iEleIDVersion)) );
295  }
297 
298  // specify all available cut descriptions
299  using map_type = std::map<SelectionCuts, std::unique_ptr<TauAnalysisTools::TauSelectionCut>>;
300  using pair_type = map_type::value_type;
301 
302  pair_type elements[] =
303  {
304  {CutPt, std::make_unique<TauAnalysisTools::TauSelectionCutPt>(this)},
305  {CutAbsEta, std::make_unique<TauAnalysisTools::TauSelectionCutAbsEta>(this)},
306  {CutAbsCharge, std::make_unique<TauAnalysisTools::TauSelectionCutAbsCharge>(this)},
307  {CutNTrack, std::make_unique<TauAnalysisTools::TauSelectionCutNTracks>(this)},
308  {CutJetRNNScoreSigTrans, std::make_unique<TauAnalysisTools::TauSelectionCutRNNJetScoreSigTrans>(this)},
309  {CutGNTauScoreSigTrans, std::make_unique<TauAnalysisTools::TauSelectionCutGNTauScoreSigTrans>(this)},
310  {CutJetIDWP, std::make_unique<TauAnalysisTools::TauSelectionCutJetIDWP>(this)},
311  {CutEleRNNScoreSigTrans, std::make_unique<TauAnalysisTools::TauSelectionCutRNNEleScoreSigTrans>(this)},
312  {CutEleIDWP, std::make_unique<TauAnalysisTools::TauSelectionCutEleIDWP>(this)},
313  {CutMuonOLR, std::make_unique<TauAnalysisTools::TauSelectionCutMuonOLR>(this)}
314  };
315 
316  m_cMap = { std::make_move_iterator( begin(elements) ), std::make_move_iterator( end(elements) ) };
317 
318  ATH_MSG_INFO( "Initializing TauSelectionTool" );
319  FillRegionVector(m_vPtRegion, m_dPtMin.value(), m_dPtMax.value());
326 
329  PrintConfigValue ("AbsCharge", m_vAbsCharges);
330  PrintConfigValue ("NTrack", m_vNTracks);
331  PrintConfigRegion ("RNNJetScoreSigTrans", m_vJetRNNSigTransRegion);
332  PrintConfigRegion ("GNTauScoreSigTrans", m_vGNTauSigTransRegion);
333  PrintConfigRegion ("RNNEleScoreSigTrans", m_vEleRNNSigTransRegion);
334  PrintConfigValue ("JetIDWP", m_sJetIDWP);
335  PrintConfigValue ("JetIDWP ENUM",m_iJetIDWP);
336  PrintConfigValue ("EleIDWP", m_sEleIDWP);
337  PrintConfigValue ("EleIDWP ENUM",m_iEleIDWP);
338  PrintConfigValue ("EleIDVersion",m_iEleIDVersion);
339  PrintConfigValue ("MuonOLR", m_bMuonOLR);
340 
341  std::string sCuts = "";
342  if (m_iSelectionCuts & CutPt) sCuts += "Pt ";
343  if (m_iSelectionCuts & CutAbsEta) sCuts += "AbsEta ";
344  if (m_iSelectionCuts & CutAbsCharge) sCuts += "AbsCharge ";
345  if (m_iSelectionCuts & CutNTrack) sCuts += "NTrack ";
346  if (m_iSelectionCuts & CutJetRNNScoreSigTrans) sCuts += "JetRNNScoreSigTrans ";
347  if (m_iSelectionCuts & CutGNTauScoreSigTrans) sCuts += "GNTauScoreSigTrans ";
348  if (m_iSelectionCuts & CutJetIDWP) sCuts += "JetIDWP ";
349  if (m_iSelectionCuts & CutEleRNNScoreSigTrans) sCuts += "EleRNNScoreSigTrans ";
350  if (m_iSelectionCuts & CutEleIDWP) sCuts += "EleIDWP ";
351  if (m_iSelectionCuts & CutMuonOLR) sCuts += "MuonOLR ";
352 
353  ATH_MSG_DEBUG( "cuts: " << sCuts);
354 
357 
358  for ( const auto& entry : m_cMap ) {
359  if ( m_iSelectionCuts &entry.first ) {
360  entry.second->setAcceptInfo(m_aAccept);
361  }
362  }
363 
364  return StatusCode::SUCCESS;
365 }
366 
367 
368 //______________________________________________________________________________
370 {
371  return StatusCode::SUCCESS;
372 }
373 
374 //______________________________________________________________________________
376 {
377  return m_aAccept;
378 }
379 
380 //______________________________________________________________________________
382 {
383  // Check if this is a tau:
384  if( xP->type() != xAOD::Type::Tau )
385  {
386  ATH_MSG_ERROR( "accept(...) Function received a non-tau" );
387  return asg::AcceptData (&m_aAccept);
388  }
389 
390  // Cast it to a tau:
391  const xAOD::TauJet* xTau = dynamic_cast< const xAOD::TauJet* >( xP );
392  if( ! xTau )
393  {
394  ATH_MSG_FATAL( "accept(...) Failed to cast particle to tau" );
395  return asg::AcceptData (&m_aAccept);
396  }
397 
398  // Let the specific function do the work:
399  return accept( *xTau );
400 }
401 
402 //______________________________________________________________________________
404 {
405  asg::AcceptData acceptData (&m_aAccept);
406 
407  int iNBin = 0;
408 
410  {
411  // fill cutflow 'All' bin
412  m_hCutFlow->Fill(iNBin);
413  // fill main distributions before all cuts
414  for (const auto& entry : m_cMap)
415  entry.second->fillHistogramCutPre(xTau);
416  }
417  try
418  {
419  for (const auto& entry : m_cMap)
420  {
421  if (m_iSelectionCuts & entry.first)
422  {
423  if (!entry.second->accept(xTau, acceptData))
424  return acceptData;
425  else
426  {
428  {
429  // fill cutflow after each passed cut
430  iNBin++;
431  m_hCutFlow->Fill(iNBin);
432  }
433  }
434  }
435  }
436  }
437  catch (const std::runtime_error& error)
438  {
439  // LEGACY: In practical terms this should probably just throw, not
440  // print a warning/error and then continue on. However, I leave
441  // that to the experts who probably had a reason not to let the
442  // exception escape. For now I just downgraded it from error to
443  // warning and limited the number of warnings (04 Jan 22).
444  static std::atomic<uint64_t> warning_count (0u);
445  auto mycount = ++ warning_count;
446  if (mycount < 10u)
447  {
448  ATH_MSG_WARNING(error.what());
449  if (mycount == 9u)
450  ATH_MSG_WARNING ("this is your last warning");
451  }
452  }
453 
454  // fill main distributions after all cuts
456  {
457  for (const auto& entry : m_cMap)
458  entry.second->fillHistogramCut(xTau);
459  }
460 
461  // // Return the result:
462  return acceptData;
463 }
464 
465 //______________________________________________________________________________
466 void TauSelectionTool::setOutFile( TFile* fOutFile )
467 {
468  m_fOutFile = fOutFile;
469 }
470 
471 //______________________________________________________________________________
473 {
475  ATH_MSG_WARNING("CreateControlPlots was set to true, but no valid file pointer was provided");
477  {
479  m_fOutFile->mkdir((this->name()+"_control").c_str());
480  m_fOutFile->cd((this->name()+"_control").c_str());
482  m_hCutFlow->Write();
483 
484  for (const auto& entry : m_cMap)
485  entry.second->writeControlHistograms();
486  }
487 }
488 
489 
490 //=================================PRIVATE-PART=================================
492 {
493  // count number of cuts
494  int iNBins = 0;
495  for (const auto& entry : m_cMap)
496  if (m_iSelectionCuts & entry.first)
497  iNBins++;
498  // create cutflow histogram with iNBins+1 bins, where first bin is 'All' bin
499  m_hCutFlow = std::make_shared<TH1F>("hCutFlow","CutFlow;; events",iNBins+1,0,iNBins+1);
500  m_hCutFlow->GetXaxis()->SetBinLabel(1,"All");
501 
502  // reusing this variable to reduce overhead
503  iNBins = 2;
504  // set bin labels
505  for (const auto& entry : m_cMap)
506  if (m_iSelectionCuts & entry.first)
507  {
508  m_hCutFlow->GetXaxis()->SetBinLabel(iNBins, entry.second->getName().c_str());
509  iNBins++;
510  }
511 }
512 
513 //______________________________________________________________________________
514 template<typename T, typename U>
515 void TauSelectionTool::FillRegionVector(std::vector<T>& vRegion, U tMin, U tMax) const
516 {
517  if (!vRegion.empty())
518  return;
519  if (tMin == tMin) // if tMin is NAN, then this assumption fails and -inf is added to the vector
520  vRegion.push_back(tMin);
521  else
522  vRegion.push_back(-std::numeric_limits<T>::infinity());
523 
524  if (tMax == tMax) // if tMax is NAN, then this assumption fails and inf is added to the vector
525  vRegion.push_back(tMax);
526  else
527  vRegion.push_back(std::numeric_limits<T>::infinity());
528 }
529 
530 //______________________________________________________________________________
531 template<typename T, typename U>
532 void TauSelectionTool::FillValueVector(std::vector<T>& vRegion, U tVal) const
533 {
534  if (!vRegion.empty())
535  return;
536  if (tVal == tVal) // if tMax is NAN, then this assumption fails and nothing is added to the vector
537  vRegion.push_back(tVal);
538 }
539 
540 //______________________________________________________________________________
541 template<typename T>
542 void TauSelectionTool::PrintConfigRegion(const std::string& sCutName, std::vector<T>& vRegion) const
543 {
544  unsigned int iNumRegion = vRegion.size()/2;
545  for( unsigned int iRegion = 0; iRegion < iNumRegion; iRegion++ )
546  {
547  ATH_MSG_DEBUG( sCutName<<": " << vRegion.at(iRegion*2) << " to " << vRegion.at(iRegion*2+1) );
548  }
549 }
550 
551 //______________________________________________________________________________
552 template<typename T>
553 void TauSelectionTool::PrintConfigValue(const std::string& sCutName, std::vector<T>& vRegion) const
554 {
555  for (auto tVal : vRegion)
556  ATH_MSG_DEBUG( sCutName<<": " << tVal );
557 }
558 
559 //______________________________________________________________________________
560 template<typename T>
561 void TauSelectionTool::PrintConfigValue(const std::string& sCutName, T& tVal) const
562 {
563  ATH_MSG_DEBUG( sCutName<<": " << tVal );
564 }
565 
566 //______________________________________________________________________________
567 int TauSelectionTool::convertStrToJetIDWP(const std::string& sJetIDWP) const
568 {
569  if (sJetIDWP == "JETIDNONE") return int(JETIDNONE);
570  else if (sJetIDWP == "JETIDRNNVERYLOOSE") return int(JETIDRNNVERYLOOSE);
571  else if (sJetIDWP == "JETIDRNNLOOSE") return int(JETIDRNNLOOSE);
572  else if (sJetIDWP == "JETIDRNNMEDIUM") return int(JETIDRNNMEDIUM);
573  else if (sJetIDWP == "JETIDRNNTIGHT") return int(JETIDRNNTIGHT);
574  else if (sJetIDWP == "JETIDGNTAUVERYLOOSE") return int(JETIDGNTAUVERYLOOSE);
575  else if (sJetIDWP == "JETIDGNTAULOOSE") return int(JETIDGNTAULOOSE);
576  else if (sJetIDWP == "JETIDGNTAUMEDIUM") return int(JETIDGNTAUMEDIUM);
577  else if (sJetIDWP == "JETIDGNTAUTIGHT") return int(JETIDGNTAUTIGHT);
578 
579  ATH_MSG_ERROR( "jet ID working point "<<sJetIDWP<<" is unknown, the JetIDWP cut will not accept any tau!" );
580  return -1;
581 }
582 
583 //______________________________________________________________________________
584 int TauSelectionTool::convertStrToEleIDWP(const std::string& sEleIDWP) const
585 {
586  if (sEleIDWP == "ELEIDNONE") return int(ELEIDNONE);
587  else if (sEleIDWP == "ELEIDRNNLOOSE") return int(ELEIDRNNLOOSE);
588  else if (sEleIDWP == "ELEIDRNNMEDIUM") return int(ELEIDRNNMEDIUM);
589  else if (sEleIDWP == "ELEIDRNNTIGHT") return int(ELEIDRNNTIGHT);
590 
591  ATH_MSG_ERROR( "electron ID working point " << sEleIDWP << " is unknown, the EleIDWP cut will not accept any tau!" );
592  return -1;
593 }
594 
595 //______________________________________________________________________________
596 std::string TauSelectionTool::convertJetIDWPToStr(int iJetIDWP) const
597 {
598  switch (iJetIDWP)
599  {
601  return "JETIDNONE";
602  case JETIDNONE:
603  return "JETIDNONE";
604  case JETIDRNNVERYLOOSE:
605  return "JETIDRNNVERYLOOSE";
606  case JETIDRNNLOOSE:
607  return "JETIDRNNLOOSE";
608  case JETIDRNNMEDIUM:
609  return "JETIDRNNMEDIUM";
610  case JETIDRNNTIGHT:
611  return "JETIDRNNTIGHT";
612  case JETIDGNTAUVERYLOOSE:
613  return "JETIDGNTAUVERYLOOSE";
614  case JETIDGNTAULOOSE:
615  return "JETIDGNTAULOOSE";
616  case JETIDGNTAUMEDIUM:
617  return "JETIDGNTAUMEDIUM";
618  case JETIDGNTAUTIGHT:
619  return "JETIDGNTAUTIGHT";
620 
621  default:
622  ATH_MSG_WARNING( "JetID working point with enum " << iJetIDWP << " is unknown, the JetIDWP cut will not accept any tau!" );
623  return "";
624  }
625 }
626 
627 //______________________________________________________________________________
628 std::string TauSelectionTool::convertEleIDWPToStr(int iEleIDWP) const
629 {
630  switch (iEleIDWP)
631  {
633  return "ELEIDNONE";
634  case ELEIDNONE:
635  return "ELEIDNONE";
636  case ELEIDRNNLOOSE:
637  return "ELEIDRNNLOOSE";
638  case ELEIDRNNMEDIUM:
639  return "ELEIDRNNMEDIUM";
640  case ELEIDRNNTIGHT:
641  return "ELEIDRNNTIGHT";
642  default:
643  ATH_MSG_WARNING( "EleID working point with enum " << iEleIDWP << " is unknown, the EleIDWP cut will not accept any tau!" );
644  return "";
645  }
646 }
TauAnalysisTools::TauSelectionTool::m_dAbsEtaMax
Gaudi::Property< float > m_dAbsEtaMax
Definition: TauSelectionTool.h:143
TauAnalysisTools::TauSelectionTool::m_vPtRegion
std::vector< float > m_vPtRegion
Definition: TauSelectionTool.h:119
TauAnalysisTools
Definition: TruthCollectionMakerTau.h:16
TauAnalysisTools::CutAbsEta
@ CutAbsEta
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:43
TauAnalysisTools::TauSelectionTool::convertStrToEleIDWP
int convertStrToEleIDWP(const std::string &sEleIDWP) const
Definition: TauSelectionTool.cxx:584
TauAnalysisTools::TauSelectionTool::m_bCreateControlPlots
Gaudi::Property< bool > m_bCreateControlPlots
Definition: TauSelectionTool.h:187
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
TauAnalysisTools::ELEIDNONEUNCONFIGURED
@ ELEIDNONEUNCONFIGURED
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:31
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
TauAnalysisTools::CutMuonOLR
@ CutMuonOLR
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:50
TauAnalysisTools::TauSelectionTool::setupCutFlowHistogram
void setupCutFlowHistogram()
Definition: TauSelectionTool.cxx:491
TauAnalysisTools::TauSelectionTool::m_sJetIDWP
std::string m_sJetIDWP
Definition: TauSelectionTool.h:131
TauAnalysisTools::JETIDRNNTIGHT
@ JETIDRNNTIGHT
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:22
TauAnalysisTools::TauSelectionTool::m_hCutFlow
std::shared_ptr< TH1F > m_hCutFlow
Definition: TauSelectionTool.h:167
TauAnalysisTools::JETIDRNNMEDIUM
@ JETIDRNNMEDIUM
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:21
TauAnalysisTools::CutEleRNNScoreSigTrans
@ CutEleRNNScoreSigTrans
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:48
TauAnalysisTools::TauSelectionTool::m_dPtMin
Gaudi::Property< float > m_dPtMin
Definition: TauSelectionTool.h:140
TauAnalysisTools::JETIDGNTAULOOSE
@ JETIDGNTAULOOSE
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:24
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
TauAnalysisTools::TauSelectionTool::FillRegionVector
void FillRegionVector(std::vector< T > &vRegion, U tMin, U tMax) const
Definition: TauSelectionTool.cxx:515
asg
Definition: DataHandleTestTool.h:28
TauAnalysisTools::TauSelectionTool::m_vJetRNNSigTransRegion
std::vector< float > m_vJetRNNSigTransRegion
Definition: TauSelectionTool.h:127
TauAnalysisTools::TauSelectionTool::setOutFile
virtual void setOutFile(TFile *fOutFile) override
Set output file for control histograms.
Definition: TauSelectionTool.cxx:466
TauAnalysisTools::TauSelectionTool::m_vGNTauSigTransRegion
std::vector< float > m_vGNTauSigTransRegion
Definition: TauSelectionTool.h:129
TauAnalysisTools::JETIDRNNLOOSE
@ JETIDRNNLOOSE
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:20
xAOD::IParticle::type
virtual Type::ObjectType type() const =0
The type of the object as a simple enumeration.
TauAnalysisTools::TauSelectionTool::initialize
virtual StatusCode initialize() override
Function initialising the tool.
Definition: TauSelectionTool.cxx:38
TauAnalysisTools::TauSelectionTool::m_vecEleRNNSigTransRegion
Gaudi::Property< std::vector< float > > m_vecEleRNNSigTransRegion
Definition: TauSelectionTool.h:163
TauAnalysisTools::TauSelectionTool::m_iNTrack
Gaudi::Property< float > m_iNTrack
Definition: TauSelectionTool.h:149
TauAnalysisTools::testFileForEOFContainsCharacters
bool testFileForEOFContainsCharacters(const std::string &sFileName)
returns true if last line in file is empty or the line starts with the number sign
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:280
TauAnalysisTools::TauSelectionTool::m_vecNTracks
Gaudi::Property< std::vector< unsigned > > m_vecNTracks
Definition: TauSelectionTool.h:160
xAOD::IParticle
Class providing the definition of the 4-vector interface.
Definition: Event/xAOD/xAODBase/xAODBase/IParticle.h:41
TauAnalysisTools::JETIDNONE
@ JETIDNONE
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:14
TauAnalysisTools::CutJetIDWP
@ CutJetIDWP
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:47
Trk::u
@ u
Enums for curvilinear frames.
Definition: ParamDefs.h:77
TauAnalysisTools::TauSelectionTool::m_iAbsCharge
Gaudi::Property< float > m_iAbsCharge
Definition: TauSelectionTool.h:144
TauAnalysisTools::TauSelectionTool::PrintConfigValue
void PrintConfigValue(const std::string &sCutName, std::vector< T > &vRegion) const
Definition: TauSelectionTool.cxx:553
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:92
TauAnalysisTools::TauSelectionTool::m_dEleRNNSigTransMax
Gaudi::Property< float > m_dEleRNNSigTransMax
Definition: TauSelectionTool.h:151
TauAnalysisTools::ELEIDRNNLOOSE
@ ELEIDRNNLOOSE
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:33
TauAnalysisTools::TauSelectionTool::m_cMap
std::map< SelectionCuts, std::unique_ptr< TauAnalysisTools::TauSelectionCut > > m_cMap
Definition: TauSelectionTool.h:177
TauAnalysisTools::TauSelectionTool::~TauSelectionTool
virtual ~TauSelectionTool()
Definition: TauSelectionTool.cxx:32
TauAnalysisTools::TauSelectionTool::m_iSelectionCuts
Gaudi::Property< int > m_iSelectionCuts
Definition: TauSelectionTool.h:139
TauAnalysisTools::TauSelectionTool::FillValueVector
void FillValueVector(std::vector< T > &vRegion, U tVal) const
Definition: TauSelectionTool.cxx:532
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
TauAnalysisTools::TauSelectionTool::m_bMuonOLR
Gaudi::Property< bool > m_bMuonOLR
Definition: TauSelectionTool.h:155
asg::AcceptInfo
Definition: AcceptInfo.h:28
TauSelectionCuts.h
TauAnalysisTools::JETIDGNTAUVERYLOOSE
@ JETIDGNTAUVERYLOOSE
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:23
TauAnalysisTools::TauSelectionTool::m_dAbsEtaMin
Gaudi::Property< float > m_dAbsEtaMin
Definition: TauSelectionTool.h:142
TauAnalysisTools::ELEIDNONE
@ ELEIDNONE
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:32
TauAnalysisTools::TauSelectionTool::m_dEleRNNSigTransMin
Gaudi::Property< float > m_dEleRNNSigTransMin
Definition: TauSelectionTool.h:150
lumiFormat.i
int i
Definition: lumiFormat.py:85
TauAnalysisTools::TauSelectionTool::m_vecGNTauSigTransRegion
Gaudi::Property< std::vector< float > > m_vecGNTauSigTransRegion
Definition: TauSelectionTool.h:162
TauAnalysisTools::TauSelectionTool::m_iEleIDVersion
Gaudi::Property< int > m_iEleIDVersion
Definition: TauSelectionTool.h:154
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
TauAnalysisTools::TauSelectionTool::convertEleIDWPToStr
std::string convertEleIDWPToStr(int iEleIDWP) const
Definition: TauSelectionTool.cxx:628
xAOD::TauJet_v3
Class describing a tau jet.
Definition: TauJet_v3.h:41
TauAnalysisTools::TauSelectionTool::m_vNTracks
std::vector< unsigned > m_vNTracks
Definition: TauSelectionTool.h:125
TauAnalysisTools::TauSelectionTool::m_useGNTau
bool m_useGNTau
Definition: TauSelectionTool.h:132
TauAnalysisTools::TauSelectionTool::m_fOutFile
TFile * m_fOutFile
Definition: TauSelectionTool.h:166
TauAnalysisTools::TauSelectionTool::beginEvent
virtual StatusCode beginEvent() override
Function called when a new events is loaded.
Definition: TauSelectionTool.cxx:369
TauAnalysisTools::TauSelectionTool::PrintConfigRegion
void PrintConfigRegion(const std::string &sCutName, std::vector< T > &vRegion) const
Definition: TauSelectionTool.cxx:542
TauAnalysisTools::CutGNTauScoreSigTrans
@ CutGNTauScoreSigTrans
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:52
TauAnalysisTools::TauSelectionTool::writeControlHistograms
virtual void writeControlHistograms() override
Write control histograms to output file.
Definition: TauSelectionTool.cxx:472
TauAnalysisTools::TauSelectionTool::m_sEleIDWP
std::string m_sEleIDWP
Definition: TauSelectionTool.h:136
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
TauAnalysisTools::ELEIDRNNMEDIUM
@ ELEIDRNNMEDIUM
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:34
GetAllXsec.entry
list entry
Definition: GetAllXsec.py:132
TauAnalysisTools::TauSelectionTool::m_dGNTauSigTransMax
Gaudi::Property< float > m_dGNTauSigTransMax
Definition: TauSelectionTool.h:148
TauAnalysisTools::TauSelectionTool::m_vAbsCharges
std::vector< int > m_vAbsCharges
Definition: TauSelectionTool.h:123
PathResolver.h
TauAnalysisTools::CutNTrack
@ CutNTrack
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:45
TauAnalysisTools::ELEIDRNNTIGHT
@ ELEIDRNNTIGHT
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:35
TauAnalysisTools::TauSelectionTool::m_eVetoDecorKey
SG::ReadDecorHandleKey< xAOD::TauJetContainer > m_eVetoDecorKey
Definition: TauSelectionTool.h:174
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
TauAnalysisTools::CutJetRNNScoreSigTrans
@ CutJetRNNScoreSigTrans
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:51
TauAnalysisTools::TauSelectionTool::accept
virtual asg::AcceptData accept(const xAOD::IParticle *p) const override
Get the decision using a generic IParticle pointer.
Definition: TauSelectionTool.cxx:381
TauAnalysisTools::TauSelectionTool::m_vecAbsEtaRegion
Gaudi::Property< std::vector< float > > m_vecAbsEtaRegion
Definition: TauSelectionTool.h:158
TauAnalysisTools::TauSelectionTool::m_vAbsEtaRegion
std::vector< float > m_vAbsEtaRegion
Definition: TauSelectionTool.h:121
TauSelectionTool.h
TauAnalysisTools::TauSelectionTool::convertStrToJetIDWP
int convertStrToJetIDWP(const std::string &sJetIDWP) const
Definition: TauSelectionTool.cxx:567
TauAnalysisTools::CutEleIDWP
@ CutEleIDWP
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:49
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:283
TauAnalysisTools::CutAbsCharge
@ CutAbsCharge
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:46
TauAnalysisTools::TauSelectionTool::getAcceptInfo
virtual const asg::AcceptInfo & getAcceptInfo() const override
Get an object describing the "selection steps" of the tool.
Definition: TauSelectionTool.cxx:375
TauAnalysisTools::TauSelectionTool::m_dJetRNNSigTransMax
Gaudi::Property< float > m_dJetRNNSigTransMax
Definition: TauSelectionTool.h:146
TauAnalysisTools::TauSelectionTool::m_muonContainerKey
SG::ReadHandleKey< xAOD::MuonContainer > m_muonContainerKey
Definition: TauSelectionTool.h:172
TauAnalysisTools::TauSelectionTool::m_GNTauDecorKey
SG::ReadDecorHandleKey< xAOD::TauJetContainer > m_GNTauDecorKey
Definition: TauSelectionTool.h:175
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
TauAnalysisTools::TauSelectionTool::TauSelectionTool
TauSelectionTool(const std::string &name)
Constructor for standalone usage.
Definition: TauSelectionTool.cxx:23
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
TauAnalysisTools::TauSelectionTool::m_dJetRNNSigTransMin
Gaudi::Property< float > m_dJetRNNSigTransMin
Definition: TauSelectionTool.h:145
TauAnalysisTools::TauSelectionTool::m_dPtMax
Gaudi::Property< float > m_dPtMax
Definition: TauSelectionTool.h:141
TauAnalysisTools::TauSelectionTool::m_dGNTauSigTransMin
Gaudi::Property< float > m_dGNTauSigTransMin
Definition: TauSelectionTool.h:147
TauAnalysisTools::TauSelectionTool::m_iJetIDWP
Gaudi::Property< int > m_iJetIDWP
Definition: TauSelectionTool.h:152
TauAnalysisTools::TauSelectionTool::m_tauContainerKey
SG::ReadHandleKey< xAOD::TauJetContainer > m_tauContainerKey
Definition: TauSelectionTool.h:173
TauAnalysisTools::TauSelectionTool::m_aAccept
asg::AcceptInfo m_aAccept
Object used to store selection information.
Definition: TauSelectionTool.h:190
xAODType::Tau
@ Tau
The object is a tau (jet)
Definition: ObjectType.h:49
TauAnalysisTools::JETIDGNTAUTIGHT
@ JETIDGNTAUTIGHT
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:26
TauAnalysisTools::JETIDGNTAUMEDIUM
@ JETIDGNTAUMEDIUM
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:25
TauAnalysisTools::NoCut
@ NoCut
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:41
TauAnalysisTools::JETIDRNNVERYLOOSE
@ JETIDRNNVERYLOOSE
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:19
TauAnalysisTools::TauSelectionTool::m_sConfigPath
Gaudi::Property< std::string > m_sConfigPath
Definition: TauSelectionTool.h:171
TauAnalysisTools::CutPt
@ CutPt
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:42
TauAnalysisTools::JETIDNONEUNCONFIGURED
@ JETIDNONEUNCONFIGURED
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:13
asg::AcceptData
Definition: AcceptData.h:30
error
Definition: IImpactPoint3dEstimator.h:70
TauAnalysisTools::TauSelectionTool::m_iEleIDWP
Gaudi::Property< int > m_iEleIDWP
Definition: TauSelectionTool.h:153
TauAnalysisTools::TauSelectionTool::convertJetIDWPToStr
std::string convertJetIDWPToStr(int iJetIDWP) const
Definition: TauSelectionTool.cxx:596
TauAnalysisTools::TauSelectionTool::m_vecAbsCharges
Gaudi::Property< std::vector< int > > m_vecAbsCharges
Definition: TauSelectionTool.h:159
TauAnalysisTools::TauSelectionTool::m_vecJetRNNSigTransRegion
Gaudi::Property< std::vector< float > > m_vecJetRNNSigTransRegion
Definition: TauSelectionTool.h:161
TauAnalysisTools::TauSelectionTool::m_vEleRNNSigTransRegion
std::vector< float > m_vEleRNNSigTransRegion
Definition: TauSelectionTool.h:134
TauAnalysisTools::TauSelectionTool::m_vecPtRegion
Gaudi::Property< std::vector< float > > m_vecPtRegion
Definition: TauSelectionTool.h:157
TauAnalysisTools::split
void split(const std::string &sInput, const char cDelim, std::vector< std::string > &vOut)
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:24