TauEfficiencyCorrectionsTool.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
// EDM include(s):
#include "PATInterfaces/SystematicRegistry.h"
#include "xAODMetaData/FileMetaData.h"
 
// Local include(s):
#include "TauAnalysisTools/TauEfficiencyCorrectionsTool.h"
#include "TauAnalysisTools/Enums.h"
#include "TauAnalysisTools/SharedFilesVersion.h"
 
#include <AsgTools/AsgToolConfig.h>
 
namespace TauAnalysisTools
{
 
//______________________________________________________________________________
TauEfficiencyCorrectionsTool::TauEfficiencyCorrectionsTool( const std::string& sName )
  : asg::AsgMetadataTool( sName )
  , m_bIsData(false)
  , m_bIsConfigured(false)
  , m_iRunNumber(0)
{}
 
//______________________________________________________________________________
TauEfficiencyCorrectionsTool::~TauEfficiencyCorrectionsTool()
{}
 
//______________________________________________________________________________
StatusCode TauEfficiencyCorrectionsTool::initialize()
{
  ATH_MSG_INFO( "Initializing TauEfficiencyCorrectionsTool" );
 
  m_vEfficiencyCorrectionTypes = m_vecEfficiencyCorrectionTypes.value();
 
  if (m_bSkipTruthMatchCheck)
    ATH_MSG_WARNING("Truth match check will be skipped. This is ONLY FOR TESTING PURPOSE!");
 
  // check efficiency correction type
  if (m_vEfficiencyCorrectionTypes.empty())
  {
    ATH_MSG_ERROR("Could not retrieve any EfficiencyCorrectionType");
    return StatusCode::FAILURE;
  }
  
  if(m_sRecommendationTag == "2025-prerec") {
    ATH_CHECK(initializeTools_2025_prerec());
  } else {
    ATH_MSG_ERROR("Unknown RecommendationTag " << m_sRecommendationTag);
    return StatusCode::FAILURE;
  }
 
  // Add the affecting systematics to the global registry
  CP::SystematicRegistry& registry = CP::SystematicRegistry::getInstance();
  if (!registry.registerSystematics(*this))
  {
    ATH_MSG_ERROR ("Unable to register the systematics");
    return StatusCode::FAILURE;
  }
 
  printConfig();
 
  return StatusCode::SUCCESS;
}
 
StatusCode TauEfficiencyCorrectionsTool::firstEvent() 
{
  return StatusCode::SUCCESS;
}
 
StatusCode TauEfficiencyCorrectionsTool::beginEvent()
{
  if (!m_bIsConfigured)
  {
    const xAOD::EventInfo* xEventInfo = nullptr;
    ATH_CHECK(evtStore()->retrieve(xEventInfo,"EventInfo"));
    m_bIsData = !(xEventInfo->eventType( xAOD::EventInfo::IS_SIMULATION));
    m_bIsConfigured = true;
  }
 
  if (!m_firstEvent){
    ATH_CHECK(firstEvent());
    m_firstEvent = true;
      
  }
  if (m_bIsData && !m_applyToData)
    return StatusCode::SUCCESS;
 
  const xAOD::EventInfo* xEventInfo = nullptr;
  ATH_CHECK(evtStore()->retrieve(xEventInfo, "EventInfo"));
 
  if (m_bReadRandomRunNumber)
  {
    // Reset the number at the beginning of event
    m_iRunNumber = 0;
  }
 
  return StatusCode::SUCCESS;
}
 
//______________________________________________________________________________
void TauEfficiencyCorrectionsTool::printConfig() const
{
  ATH_MSG_DEBUG( "TauEfficiencyCorrectionsTool with name " << name() << " is configured as follows:" );
  for (auto iEfficiencyCorrectionType : m_vEfficiencyCorrectionTypes) {
    ATH_MSG_DEBUG( "  EfficiencyCorrectionTypes " << iEfficiencyCorrectionType );
  }
  ATH_MSG_DEBUG( "  InputFilePathRecoHadTau " << m_sInputFilePathRecoHadTau );
  ATH_MSG_DEBUG( "  InputFilePathEleIDHadTau " << m_sInputFilePathEleIDHadTau );
  ATH_MSG_DEBUG( "  InputFilePathEleIDElectron " << m_sInputFilePathEleIDElectron );
  ATH_MSG_DEBUG( "  InputFilePathJetIDHadTau " << m_sInputFilePathJetIDHadTau );
  ATH_MSG_DEBUG( "  InputFilePathDecayModeHadTau " << m_sInputFilePathDecayModeHadTau );
  ATH_MSG_DEBUG( "  InputFilePathTriggerHadTau " << m_sInputFilePathTriggerHadTau );
  ATH_MSG_DEBUG( "  RecommendationTag " << m_sRecommendationTag );
  ATH_MSG_DEBUG( "  TriggerName " << m_sTriggerName );
  ATH_MSG_DEBUG( "  UseTauSubstructure " << m_bUseTauSubstructure );
  ATH_MSG_DEBUG( "  JetIDLevel " << m_iJetIDLevel );
  ATH_MSG_DEBUG( "  EleIDLevel " << m_iEleIDLevel );
  ATH_MSG_DEBUG( "  Campaign " << m_sCampaign );
  ATH_MSG_DEBUG( "  useFastSim " << m_useFastSim);
}
 
//______________________________________________________________________________
CP::CorrectionCode TauEfficiencyCorrectionsTool::getEfficiencyScaleFactor( const xAOD::TauJet& xTau,
        double& eff, unsigned int /*iRunNumber*/)
{
  eff = 1.;
 
  if (m_bIsData && !m_applyToData)
    return CP::CorrectionCode::Ok;
 
  ANA_CHECK_SET_TYPE (CP::CorrectionCode);
  ANA_CHECK(readRandomRunNumber());
 
  if(!(m_tTool->isSupportedRunNumber(m_iRunNumber)))
    return CP::CorrectionCode::Ok;    
 
  double dToolEff = 1.;
  CP::CorrectionCode tmpCorrectionCode = m_tTool->getEfficiencyScaleFactor(xTau, dToolEff, m_iRunNumber);
  if (tmpCorrectionCode != CP::CorrectionCode::Ok)
    return tmpCorrectionCode;
 
  eff *= dToolEff;
  
  return CP::CorrectionCode::Ok;
}
 
//______________________________________________________________________________
CP::CorrectionCode TauEfficiencyCorrectionsTool::applyEfficiencyScaleFactor( const xAOD::TauJet& xTau, unsigned int /*iRunNumber*/)
{
  if (m_bIsData && !m_applyToData)
    return CP::CorrectionCode::Ok;
 
  ANA_CHECK_SET_TYPE (CP::CorrectionCode);
  ANA_CHECK(readRandomRunNumber());
 
  CP::CorrectionCode tmpCorrectionCode = m_tTool->applyEfficiencyScaleFactor(xTau, m_iRunNumber);
  if (tmpCorrectionCode != CP::CorrectionCode::Ok)
    return tmpCorrectionCode;
 
  return CP::CorrectionCode::Ok;
}

//______________________________________________________________________________
bool TauEfficiencyCorrectionsTool::isAffectedBySystematic( const CP::SystematicVariation& systematic ) const
{
   if (m_tTool->isAffectedBySystematic(systematic))
     return true;
 
   return false;
}

//______________________________________________________________________________
CP::SystematicSet TauEfficiencyCorrectionsTool::affectingSystematics() const
{
  CP::SystematicSet sAffectingSystematics;
  sAffectingSystematics.insert(m_tTool->affectingSystematics());
  return sAffectingSystematics;
}

//______________________________________________________________________________
CP::SystematicSet TauEfficiencyCorrectionsTool::recommendedSystematics() const
{
  CP::SystematicSet sRecommendedSystematics;
  sRecommendedSystematics.insert(m_tTool->recommendedSystematics());
  return sRecommendedSystematics;
}
 
//______________________________________________________________________________
StatusCode TauEfficiencyCorrectionsTool::applySystematicVariation ( const CP::SystematicSet& sSystematicSet)
{
  ATH_CHECK(m_tTool->applySystematicVariation(sSystematicSet));
  return StatusCode::SUCCESS;
}
 
//=================================PRIVATE-PART=================================
StatusCode TauEfficiencyCorrectionsTool::initializeTools_2025_prerec()
{
  std::string sDirectory = "TauAnalysisTools/" + std::string(sSharedFilesVersion) + "/EfficiencyCorrections/";
  for (auto iEfficiencyCorrectionType : m_vEfficiencyCorrectionTypes){
 
    if (iEfficiencyCorrectionType == SFJetIDHadTau)
    {
      if (m_sInputFilePathJetIDHadTau.empty()) {
        
    if(m_useGNTau){
          if(m_sCampaign=="mc23"){
              m_sInputFilePathJetIDHadTau = m_useFastSim ? sDirectory + "GNTauID_TrueHadTau_Run3_incl_AF3.root" : sDirectory + "GNTauID_TrueHadTau_Run3.root";
      } else if (m_sCampaign=="mc20"){
          m_sInputFilePathJetIDHadTau = m_useFastSim ? sDirectory + "GNTauID_TrueHadTau_Run2_incl_AF3.root" : sDirectory + "GNTauID_TrueHadTau_Run2.root";
      } else {  
              ATH_MSG_ERROR("GNTau ID correction not supported for campaign "<< m_sCampaign);
          return StatusCode::FAILURE;
      }       
    } else {    
 
          if(m_sCampaign=="mc23"){
          m_sInputFilePathJetIDHadTau = m_useFastSim ? sDirectory + "RNNID_TrueHadTau_mc23_v2_incl_AF3.root" :  sDirectory + "RNNID_TrueHadTau_mc23_v2.root";   
          } else if (m_sCampaign=="mc20"){
          m_sInputFilePathJetIDHadTau = m_useFastSim ? sDirectory + "RNNID_TrueHadTau_mc20_v1_incl_AF3.root" :  sDirectory + "RNNID_TrueHadTau_mc20_v1.root";       
          }
    }
      }
      m_sVarName = "TauScaleFactorJetIDHadTau";
 
      std::string sJetIDWP = ConvertJetIDToString(m_iJetIDLevel);
      if (sJetIDWP.empty()) {
        ATH_MSG_WARNING("Could not find valid ID working point. Skip ID efficiency corrections.");
        continue;
      }
 
      if (m_tTool.empty()){
        asg::AsgToolConfig config("TauAnalysisTools::CommonEfficiencyTool/JetIDHadTauTool_tauID_"+sJetIDWP);
        ATH_CHECK(config.setProperty("InputFilePath", m_sInputFilePathJetIDHadTau));
        ATH_CHECK(config.setProperty("VarName", m_sVarName));
        ATH_CHECK(config.setProperty("SkipTruthMatchCheck", m_bSkipTruthMatchCheck));
        ATH_CHECK(config.setProperty("WP", sJetIDWP));
        ATH_CHECK(config.setProperty("ApplyToData", m_applyToData));
        ATH_CHECK(config.makePrivateTool(m_tTool));
      }
      ATH_CHECK(m_tTool.retrieve());
    }
    else if (iEfficiencyCorrectionType == SFRecoHadTau)
    {
      if (m_sInputFilePathRecoHadTau.empty()) m_sInputFilePathRecoHadTau = sDirectory + "Reco_TrueHadTau_2026_v0.root";
      m_sVarName = "TauScaleFactorReconstructionHadTau";
 
      if (m_tTool.empty()){
        asg::AsgToolConfig config("TauAnalysisTools::CommonEfficiencyTool/RecoHadTauTool");
        ATH_CHECK(config.setProperty("InputFilePath", m_sInputFilePathRecoHadTau));
        ATH_CHECK(config.setProperty("VarName", m_sVarName));
        ATH_CHECK(config.setProperty("SkipTruthMatchCheck", m_bSkipTruthMatchCheck));
        ATH_CHECK(config.setProperty("ApplyToData", m_applyToData));
        ATH_CHECK(config.makePrivateTool(m_tTool));
      }
      ATH_CHECK(m_tTool.retrieve());   
    }
    else if (iEfficiencyCorrectionType == SFEleIDHadTau)
    {
      if (m_sInputFilePathEleIDHadTau.empty()) {
        if( m_iEleIDLevel == static_cast<int>(ELEIDRNNLOOSE)){         
      m_sInputFilePathEleIDHadTau = sDirectory + "EleRNN_TrueHadTau_2026_eRNNLoose.root";
        } else if( m_iEleIDLevel == static_cast<int>(ELEIDRNNMEDIUM)){
          m_sInputFilePathEleIDHadTau = sDirectory + "EleRNN_TrueHadTau_2026_eRNNMedium.root";      
    } else {
          ATH_MSG_ERROR("SFEleIDHadTau correction not supported for EleIDLevel="<<m_iEleIDLevel);
          return StatusCode::FAILURE;
        }
      } 
      m_sVarName = "TauScaleFactorEleIDHadTau";
      std::string ele_wp = ConvertEleIDToString(m_iEleIDLevel);
 
      if (m_tTool.empty()){
        asg::AsgToolConfig config("TauAnalysisTools::CommonEfficiencyTool/EleIDHadTauTool_eRNN_"+ele_wp);
        ATH_CHECK(config.setProperty("InputFilePath", m_sInputFilePathEleIDHadTau));
        ATH_CHECK(config.setProperty("VarName", m_sVarName));
        ATH_CHECK(config.setProperty("SkipTruthMatchCheck", m_bSkipTruthMatchCheck));
        ATH_CHECK(config.setProperty("WP", ele_wp));
        ATH_CHECK(config.setProperty("UseTauSubstructure", false));
        ATH_CHECK(config.setProperty("ApplyToData", m_applyToData));   
        ATH_CHECK(config.makePrivateTool(m_tTool));
      }
      ATH_CHECK(m_tTool.retrieve());
    }
    else if (iEfficiencyCorrectionType == SFEleIDElectron)
    {
      // the path must be updated once RNN eVeto SFs are available
      if (m_sInputFilePathEleIDElectron.empty()) {
        if(m_useFastSim) {
          ATH_MSG_WARNING("No fast-sim recommendation for tau electron veto, using full sim");
        }
 
        if(m_sCampaign=="mc23"){
            if(m_useGNTau){
              if( m_iJetIDLevel == static_cast<int>(JETIDGNTAULOOSE)){
                  m_sInputFilePathEleIDElectron = sDirectory + "EleRNN_TrueElectron_2026_looseGNTauID_1p.root";
              } else if( m_iJetIDLevel == static_cast<int>(JETIDGNTAUMEDIUM)){
                  m_sInputFilePathEleIDElectron = sDirectory + "EleRNN_TrueElectron_2026_mediumGNTauID_1p.root";
              }
              else {
                  ATH_MSG_ERROR("SFEleIDElectron correction not supported for JetIDLevel="<<m_iJetIDLevel);
                  return StatusCode::FAILURE;
              }
            } else {
              if( m_iJetIDLevel == static_cast<int>(JETIDRNNLOOSE)){
                  m_sInputFilePathEleIDElectron = sDirectory + "EleRNN_TrueElectron_2022_looseRNNTauID_1p.root"; 
              } else if( m_iJetIDLevel == static_cast<int>(JETIDRNNMEDIUM)){
                  m_sInputFilePathEleIDElectron = sDirectory + "EleRNN_TrueElectron_2022_mediumRNNTauID_1p.root";
              }
              else {
                  ATH_MSG_ERROR("SFEleIDElectron correction not supported for JetIDLevel="<<m_iJetIDLevel);
          return StatusCode::FAILURE;
              }
        }
        } else if(m_sCampaign=="mc20"){
            if(m_useGNTau){
          if( m_iJetIDLevel == static_cast<int>(JETIDGNTAULOOSE)){
                  m_sInputFilePathEleIDElectron = sDirectory + "EleRNN_TrueElectron_Run2_looseGNTauID_1p.root";
              } else if( m_iJetIDLevel == static_cast<int>(JETIDGNTAUMEDIUM)){
                  m_sInputFilePathEleIDElectron = sDirectory + "EleRNN_TrueElectron_Run2_mediumGNTauID_1p.root";
              }
              else {
                  ATH_MSG_ERROR("SFEleIDElectron correction not supported for JetIDLevel="<<m_iJetIDLevel);
                  return StatusCode::FAILURE;
              }         
        } else {
              if( m_iJetIDLevel == static_cast<int>(JETIDRNNLOOSE)){
                  m_sInputFilePathEleIDElectron = sDirectory + "EleRNN_TrueElectron_Run2_looseRNNTauID_1p.root";
              } else if( m_iJetIDLevel == static_cast<int>(JETIDRNNMEDIUM)){
                  m_sInputFilePathEleIDElectron = sDirectory + "EleRNN_TrueElectron_Run2_mediumRNNTauID_1p_v1.root";
              }
              else {
                  ATH_MSG_ERROR("SFEleIDElectron correction not supported for JetIDLevel="<<m_iJetIDLevel);
                  return StatusCode::FAILURE;
              }
       }
        }
      }
      m_sVarName = "TauScaleFactorEleIDElectron";
      std::string ele_wp = ConvertEleIDToString(m_iEleIDLevel);
      std::string sJetIDWP = ConvertJetIDToString(m_iJetIDLevel); 
 
      if (m_tTool.empty()){
        asg::AsgToolConfig config("TauAnalysisTools::CommonEfficiencyTool/EleIDHadTauTool_eRNN_"+ele_wp);
        ATH_CHECK(config.setProperty("InputFilePath", m_sInputFilePathEleIDElectron));
        ATH_CHECK(config.setProperty("VarName", m_sVarName));
        ATH_CHECK(config.setProperty("SkipTruthMatchCheck", m_bSkipTruthMatchCheck));
        ATH_CHECK(config.setProperty("WP", ele_wp));
        ATH_CHECK(config.setProperty("UseTauSubstructure", false));
        ATH_CHECK(config.setProperty("ApplyToData", m_applyToData));
        ATH_CHECK(config.makePrivateTool(m_tTool));
      }
      ATH_CHECK(m_tTool.retrieve());
 
    } else if (iEfficiencyCorrectionType == SFTriggerHadTau){
 
      if (m_sTriggerName.empty()) {
        ATH_MSG_ERROR("Property \"Trigger\" was not set, please provide a trigger name.");
        return StatusCode::FAILURE;
      }
      if (m_sInputFilePathTriggerHadTau.empty()) {
        // Determine the input file name from the given trigger name.
    if(m_sCampaign=="mc23a"){
          if (m_sTriggerName.value().find("mediumRNN_tracktwoMVA") != std::string::npos) {
            m_sInputFilePathTriggerHadTau = sDirectory+"Trigger/RNN/Trigger_TrueHadTau_data2022"+GetTriggerSFMeasurementString()+m_sTriggerName+".root";
          }
          else {
            ATH_MSG_ERROR("Trigger " << m_sTriggerName << " is not supported for " << m_sCampaign << " campaign. Please fix \"TriggerName\" property. In case of doubt please consult with TauTrigger coordinators");
            return StatusCode::FAILURE;
          }
    } else if(m_sCampaign=="mc23d"){
          if (m_sTriggerName.value().find("mediumRNN_tracktwoMVA") != std::string::npos) {
            m_sInputFilePathTriggerHadTau = sDirectory+"Trigger/RNN/Trigger_TrueHadTau_data2023"+GetTriggerSFMeasurementString()+m_sTriggerName+".root";
          }
          else {
            ATH_MSG_ERROR("Trigger " << m_sTriggerName << " is not supported for " << m_sCampaign << " campaign. Please fix \"TriggerName\" property. In case of doubt please consult with TauTrigger coordinators");
            return StatusCode::FAILURE;
          }
        } else if(m_sCampaign=="mc20"){
          if (m_sTriggerName.value().find("tracktwoEF") != std::string::npos) {
        // check explicitly tau160 as the root file for this trigger was renamed      
            if (m_sTriggerName.value().find("tau160") != std::string::npos) {         
               m_sInputFilePathTriggerHadTau = sDirectory+"Trigger/RNN_R22/Trigger_TrueHadTau_data2018_comb_HLT_tau160L1TAU100_medium1_tracktwoEF_v1.root";
        } else {
               m_sInputFilePathTriggerHadTau = sDirectory+"Trigger/RNN_R22/Trigger_TrueHadTau_data2018"+GetTriggerSFMeasurementString()+m_sTriggerName+".root";
        }   
          } else if (m_sTriggerName.value().find("tracktwo") != std::string::npos) {
            // check explicitly tau160 as the root file for this trigger was renamed      
            if (m_sTriggerName.value().find("tau160") != std::string::npos) {
           m_sInputFilePathTriggerHadTau = sDirectory+"Trigger/RNN_R22/Trigger_TrueHadTau_data161718_comb_HLT_tau160_medium1_tracktwo_v1.root";         
        } else if (m_sTriggerName.value().find("tau125") != std::string::npos) {
               // fall back to R21 recommendations for tau125 as currently SFs are not available for this trigger            
           m_sInputFilePathTriggerHadTau = sDirectory+"Trigger/RNN/Trigger_TrueHadTau_2019-summer_data161718_comb_HLT_tau125_medium1_tracktwo.root";
        } else if (m_sTriggerName.value().find("tau60") != std::string::npos) {  
           // SFs for tau60 are only for partial period 
               m_sInputFilePathTriggerHadTau = sDirectory+"Trigger/RNN_R22/Trigger_TrueHadTau_data1718"+GetTriggerSFMeasurementString()+m_sTriggerName+".root";
        } else {            
               m_sInputFilePathTriggerHadTau = sDirectory+"Trigger/RNN_R22/Trigger_TrueHadTau_data161718"+GetTriggerSFMeasurementString()+m_sTriggerName+".root";
        }
      } else {
            ATH_MSG_ERROR("Trigger " << m_sTriggerName << " is not supported. Please fix \"TriggerName\" property. If this is correct, then please contact the tau trigger coordinators");
            return StatusCode::FAILURE;
          }
    } else {
            ATH_MSG_ERROR("SFs are not available for " << m_sCampaign << " campaign. If the config is correct, then please contact the tau trigger coordinators");
        return StatusCode::FAILURE;
    }
      }
      m_sVarName = "TauScaleFactorTriggerHadTau";
      std::string sJetIDWP = ConvertTriggerIDToString(m_iJetIDLevel);
       
      if (m_tTool.empty()){  
        asg::AsgToolConfig config("TauAnalysisTools::CommonEfficiencyTool/TriggerHadTauTool_"+m_sTriggerName+"_tauID_"+sJetIDWP);
        ATH_CHECK(config.setProperty("InputFilePath", m_sInputFilePathTriggerHadTau));
        ATH_CHECK(config.setProperty("VarName", m_sVarName));
        ATH_CHECK(config.setProperty("SkipTruthMatchCheck", m_bSkipTruthMatchCheck));
        ATH_CHECK(config.setProperty("WP", sJetIDWP));
        ATH_CHECK(config.setProperty("DoTauTrig", true));
        ATH_CHECK(config.setProperty("ApplyToData", m_applyToData));
        ATH_CHECK(config.makePrivateTool(m_tTool));
      }
      ATH_CHECK(m_tTool.retrieve());
    }
    else {
      ATH_MSG_WARNING("unsupported EfficiencyCorrectionsType with enum " << iEfficiencyCorrectionType);
    }
  }
 
  return StatusCode::SUCCESS;
}
 
// auto detection of simulation flavour, used to cross check configuration of tool
//______________________________________________________________________________
StatusCode TauEfficiencyCorrectionsTool::beginInputFile()
{
  if (inputMetaStore()->contains<xAOD::FileMetaData>("FileMetaData")) {
    const xAOD::FileMetaData* fmd = nullptr;
    ATH_CHECK( inputMetaStore()->retrieve( fmd, "FileMetaData" ) );
    std::string simType("");
    bool result = fmd->value( xAOD::FileMetaData::simFlavour , simType );
    // if no result -> no simFlavor metadata, so must be data
    if(result)  std::transform(simType.begin(), simType.end(), simType.begin(), ::toupper);
    
    if( simType.find("ATLFAST3") != std::string::npos && !m_useFastSim){
      ATH_MSG_WARNING("Input file is AF3 sample but you are _not_ using AF3 corrections and uncertainties, you should set \"useFastSim\" to \"true\"");
    } else if (simType.find("FULLG4")!=std::string::npos && m_useFastSim){
      ATH_MSG_WARNING("Input file is full simulation but you are using AF3 corrections and uncertainties, you should set \"useFastSim\" to \"false\"");
    }
  }
 
  return StatusCode::SUCCESS;
}
 
//______________________________________________________________________________
std::string TauEfficiencyCorrectionsTool::ConvertJetIDToString(const int iLevel) const
{
  switch(iLevel)
    {
    case JETIDNONE:
      return "none";
    case JETIDRNNVERYLOOSE: 
      ATH_MSG_WARNING("Efficiency corrections for JETIDRNNVERYLOOSE working point are not supported.");
      return "";
    case JETIDRNNLOOSE: 
      return "jetrnnsigloose";
    case JETIDRNNMEDIUM: 
      return "jetrnnsigmedium";
    case JETIDRNNTIGHT: 
      return "jetrnnsigtight";
    case JETIDGNTAUVERYLOOSE:
      ATH_MSG_WARNING("Efficiency corrections for JETIDGNTAUVERYLOOSE working point are not supported.");
      return "";
    case JETIDGNTAULOOSE:
      return "jetgntausigloose";
    case JETIDGNTAUMEDIUM:
      return "jetgntausigmedium";
    case JETIDGNTAUTIGHT:
      return "jetgntausigtight";  
    default:
      ATH_MSG_WARNING("No valid JetID level passed.");
      return "";
    }
}
 
std::string TauEfficiencyCorrectionsTool::ConvertEleIDToString(const int iLevel) const
{
  switch(iLevel)
    {
    case ELEIDRNNTIGHT:
      return "eleRNNTight";
    case ELEIDRNNMEDIUM:
      return "eleRNNMedium";
    case ELEIDRNNLOOSE:
      return "eleRNNLoose";
    default:
      ATH_MSG_WARNING("No valid EleID level passed.");
      return "";
    }
}
 
//______________________________________________________________________________
std::string TauEfficiencyCorrectionsTool::ConvertTriggerIDToString(const int iLevel) const
{
  switch(iLevel)
    {
    case JETIDRNNLOOSE:
      return "loose";
    case JETIDRNNMEDIUM:
      return "medium";
    case JETIDRNNTIGHT:
      return "tight";
    default:
      ATH_MSG_WARNING("No valid TriggerID level passed.");
      return "";
    }
}
 
//______________________________________________________________________________
std::string TauEfficiencyCorrectionsTool::GetTriggerSFMeasurementString() const
{
  std::string sMeasurement = "_comb_";
 
  if (m_sTriggerSFMeasurement == "Ztautau")
    sMeasurement = "_Ztt_";
  else if (m_sTriggerSFMeasurement == "ttbar")
    sMeasurement = "_ttbar_";
  else if (m_sTriggerSFMeasurement != "combined")
    ATH_MSG_WARNING("Trigger scale factor measurement \'" << m_sTriggerSFMeasurement << "\' is not supported. \'combined\' is used instead.");
 
  return sMeasurement;
}
 
StatusCode TauEfficiencyCorrectionsTool::readRandomRunNumber()
{
  // read the random run rumber from the EventInfo  
  if (m_bReadRandomRunNumber && m_iRunNumber == 0)
  {
    static const SG::ConstAccessor<unsigned int> acc_rnd("RandomRunNumber");
    const xAOD::EventInfo* eventInfo = nullptr;
    if (!evtStore()->contains<xAOD::EventInfo>("EventInfo") || !evtStore()->retrieve(eventInfo, "EventInfo").isSuccess())
    {
      ANA_MSG_ERROR("Could not retrieve EventInfo");
      return StatusCode::FAILURE;
    }
 
    if (!acc_rnd.isAvailable(*eventInfo))
    {
      ANA_MSG_ERROR("Failed to find the RandomRunNumber decoration. Call the apply() method from the PileupReweightingTool beforehand to get period dependent SFs.");
      return StatusCode::FAILURE;
    }
 
    m_iRunNumber = acc_rnd(*eventInfo);
 
    ANA_MSG_VERBOSE("Read RandomRunNumber as " << m_iRunNumber);
  }
 
  return StatusCode::SUCCESS;
}
 
} // namespace TauAnalysisTools