TauSmearingTool.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
// EDM include(s):
#include "PATInterfaces/SystematicRegistry.h"
#include "xAODMetaData/FileMetaData.h"
 
// Local include(s):
#include "TauAnalysisTools/TauSmearingTool.h"
#include "TauAnalysisTools/SharedFilesVersion.h"
 
#include <AsgTools/AsgToolConfig.h>
 
namespace TauAnalysisTools
{
 
TauSmearingTool::TauSmearingTool( const std::string& sName )
  : asg::AsgMetadataTool( sName )
{}
 
TauSmearingTool::~TauSmearingTool()
{}
 
StatusCode TauSmearingTool::initialize()
{
  ATH_MSG_INFO( "Initializing TauSmearingTool" );
 
  if (m_bSkipTruthMatchCheck)
    ATH_MSG_WARNING("Truth match check will be skipped. This is ONLY FOR TESTING PURPOSE!");
 
  if (m_sInputFilePath.empty()) {
    std::string sDirectory = "TauAnalysisTools/" + std::string(sSharedFilesVersion) + "/Smearing/";
 
    if(m_sRecommendationTag == "2025-prerec") {
      
      if (m_sCampaign!="mc23" && m_sCampaign!="mc20"){
        ATH_MSG_ERROR("unknown campaign (mc20|mc23):" << m_sCampaign);
        return StatusCode::FAILURE;
      }
 
      if(m_useFastSim) {
        ATH_MSG_WARNING("No fast-sim recommendation for tau smearing is available, using full sim");
      }
 
     
      if(m_useGNTau){
        if (m_sCampaign=="mc23") {
          m_sInputFilePath = sDirectory+"TES_TrueHadTau_GNTau_mc23_v0.root";
        } else {
          ATH_MSG_ERROR("Tau Smearing recommendations with GNTau are not available for "<< m_sCampaign); 
        }  
      } else { 
        if (m_sCampaign=="mc23") {
          m_sInputFilePath = sDirectory+"TES_TrueHadTau_RNN_mc23_v3.root";
        } else {
          m_sInputFilePath = sDirectory+"TES_TrueHadTau_RNN_mc20_v2.root";
        }
      }
 
    } else {
      ATH_MSG_ERROR("unknown recommendation tag " << m_sRecommendationTag);
      return StatusCode::FAILURE;
    }
  }
 
  if (m_tCommonSmearingTool.empty()){ 
    asg::AsgToolConfig config("TauAnalysisTools::CommonSmearingTool/TauSmearingTool");  
    ATH_CHECK(config.setProperty("InputFilePath", m_sInputFilePath));
    ATH_CHECK(config.setProperty("SkipTruthMatchCheck", m_bSkipTruthMatchCheck));
    ATH_CHECK(config.setProperty("ApplyFading", m_bApplyFading));
    ATH_CHECK(config.setProperty("MVATESQualityCheck", m_bMVATESQualityCheck));
    ATH_CHECK(config.setProperty("ApplyInsituCorrection", m_bApplyInsituCorrection));
    ATH_CHECK(config.setProperty("OutputLevel", this->msg().level()));
    ATH_CHECK(config.makePrivateTool(m_tCommonSmearingTool));
  }
  ATH_CHECK(m_tCommonSmearingTool.retrieve()); 
   
 
  // 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;
  }
  
  return StatusCode::SUCCESS;
}
 
// auto detection of simulation flavour, used to cross check configuration of tool
//______________________________________________________________________________
StatusCode TauSmearingTool::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;
}
 
CP::CorrectionCode TauSmearingTool::applyCorrection( xAOD::TauJet& xTau ) const
{
  return m_tCommonSmearingTool->applyCorrection(xTau);
}
 
CP::CorrectionCode TauSmearingTool::correctedCopy( const xAOD::TauJet& input, xAOD::TauJet*& output ) const
{
  return m_tCommonSmearingTool->correctedCopy(input, output);
}

bool TauSmearingTool::isAffectedBySystematic( const CP::SystematicVariation& systematic ) const
{
  return m_tCommonSmearingTool->isAffectedBySystematic( systematic );
}

CP::SystematicSet TauSmearingTool::affectingSystematics() const
{
  return m_tCommonSmearingTool->affectingSystematics();
}

CP::SystematicSet TauSmearingTool::recommendedSystematics() const
{
  return m_tCommonSmearingTool->recommendedSystematics();
}
  
StatusCode TauSmearingTool::applySystematicVariation ( const CP::SystematicSet& sSystematicSet )
{
  return m_tCommonSmearingTool->applySystematicVariation( sSystematicSet );
}
 
 
} // namespace TauAnalysisTools