Taus.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
// This source file implements all of the functions related to TauJets
// in the SUSYObjDef_xAOD class
 
// Local include(s):
#include "SUSYTools/SUSYObjDef_xAOD.h"
 
#include "xAODBase/IParticleHelpers.h"
#include "xAODTracking/TrackParticlexAODHelpers.h"
 
#include "TauAnalysisTools/Enums.h"
#include "TauAnalysisTools/ITauSelectionTool.h"
#include "TauAnalysisTools/ITauEfficiencyCorrectionsTool.h"
#include "TauAnalysisTools/ITauSmearingTool.h"
#include "TauAnalysisTools/ITauTruthMatchingTool.h"
#include "tauRecTools/ITauToolBase.h"
#include "TriggerMatchingTool/IMatchingTool.h"
#include <string_view>
#include <ranges>
 
#ifndef XAOD_STANDALONE // For now metadata is Athena-only
#include "AthAnalysisBaseComps/AthAnalysisHelper.h"
#endif
 
namespace ST {
 
 
StatusCode SUSYObjDef_xAOD::GetTaus(xAOD::TauJetContainer*& copy, xAOD::ShallowAuxContainer*& copyaux, bool recordSG,
                                    const std::string& taukey, const xAOD::TauJetContainer* containerToBeCopied)
{
  if (!m_tool_init) {
    ATH_MSG_ERROR("SUSYTools was not initialized!!");
    return StatusCode::FAILURE;
  }
 
  if (m_isPHYSLITE && taukey.find("AnalysisTauJets")==std::string::npos){
    ATH_MSG_ERROR("You are running on PHYSLITE derivation. Please change the Taus container to 'AnalysisTauJets'");
    return StatusCode::FAILURE;
  }
 
  const xAOD::TauJetContainer* taus = nullptr;
  if (copy==nullptr) { // empty container provided
    if (containerToBeCopied != nullptr) {
      taus = containerToBeCopied;
    }
    else {
      ATH_CHECK( evtStore()->retrieve(taus, taukey) );
    }
    xAOD::ShallowCopyResult_t<xAOD::TauJetContainer> shallowcopy = xAOD::shallowCopy(*taus);
    copy = shallowcopy.first.get();
    copyaux = shallowcopy.second.get();
    bool setLinks = xAOD::setOriginalObjectLink(*taus, *copy);
    if (!setLinks) {
      ATH_MSG_WARNING("Failed to set original object links on " << taukey);
    }
    if (recordSG) {
      ATH_CHECK( evtStore()->record(std::move(shallowcopy.first), "STCalib" + taukey + m_currentSyst.name()) );
      ATH_CHECK( evtStore()->record(std::move(shallowcopy.second), "STCalib" + taukey + m_currentSyst.name() + "Aux.") );
    } else {
      ATH_MSG_ERROR("Shallow copy not recorded in StoreGate!");
      return StatusCode::FAILURE;
    }
  } else { // use the user-supplied collection instead
    ATH_MSG_DEBUG("Not retrieving tau collecton, using existing one provided by user");
    taus=copy;
  }
 
  for (const auto tau : *copy) {
    ATH_CHECK( this->FillTau(*tau) );
    this->IsSignalTau(*tau, m_tauPt, m_tauEta);
  }
 
  return StatusCode::SUCCESS;
}
 
 
// Can't be const due to applyCorrection on the smearing tool
StatusCode SUSYObjDef_xAOD::FillTau(xAOD::TauJet& input) {
 
  ATH_MSG_VERBOSE( "Starting FillTau on tau with pT = " << input.pt()/1000 << " GeV" );
  ATH_MSG_VERBOSE( "TAU pT before smearing " << input.pt()/1000 << " GeV");
 
  // do truth matching first (required unless already done in AOD->DAOD and truth matching info kept in DAOD)
  if (m_tauDoTTM && !isData()) m_tauTruthMatch->getTruth(input);
  ATH_MSG_VERBOSE("Tau truth matching done");
 
  // apply the calibration to data as well (not needed in R22, unless MVA TES gets updated)
  if (std::abs(input.eta()) <= 2.5 && input.nTracks() > 0) {
    if (m_tauSmearingTool->applyCorrection(input) != CP::CorrectionCode::Ok) {
      ATH_MSG_ERROR(" Tau smearing failed " );
    } else { ATH_MSG_VERBOSE("Tau smearing done"); }
  }
 
  ATH_MSG_VERBOSE( "TAU pt after smearing " << input.pt()/1000. );
 
  // if tauPrePtCut set, apply min pT cut here before calling tau selection tool
  // (avoid exceptions when running on derivations with removed tracks for low-pT taus, e.g. HIGG4D2)
  if (input.pt() > m_tauPrePtCut) {
    dec_baseline(input) = bool(m_tauSelToolBaseline->accept( input ));
  }
  else {
    dec_baseline(input) = false;
  }
  if (acc_baseline(input)) dec_selected(input) = 2;
  else                     dec_selected(input) = 0;
 
  if (acc_baseline(input)) ATH_MSG_VERBOSE("FillTau: passed baseline selection");
  else ATH_MSG_VERBOSE("FillTau: failed baseline selection");
  return StatusCode::SUCCESS;
}
 
 
bool SUSYObjDef_xAOD::IsSignalTau(const xAOD::TauJet& input, float ptcut, float etacut) const {
 
  dec_signal(input) = false;
 
  if ( !acc_baseline(input) ) return false;
 
  if (input.pt() <= ptcut) return false;
 
  if (std::abs(input.eta()) >= etacut) return false;
 
  if (!m_tauSelTool->accept( input )) return false;
 
  dec_signal(input) = true;
 
  return true;
}
 
 
double SUSYObjDef_xAOD::GetSignalTauSF(const xAOD::TauJet& tau,
                                      const bool idSF,
                                      const bool triggerSF,
                                      const std::string& trigExpr)
{
  double sf(1.);
 
  // TEMPORARY: no recommendations yet for 2024+
  if (acc_signal(tau) && this->treatAsYear()<2024) {
    if (idSF) {
      if (m_tauEffTool->getEfficiencyScaleFactor(tau, sf) != CP::CorrectionCode::Ok) {
        ATH_MSG_WARNING("Failed to retrieve tau efficiency scale factor.");
      }
      ATH_MSG_VERBOSE(" Retrieved tau SF  " << sf);
    }
 
    if (triggerSF) {
      double trig_sf = GetTauTriggerEfficiencySF(tau, trigExpr);
 
      if (trig_sf > -90) {
        sf *= trig_sf;
        ATH_MSG_VERBOSE(" Retrieved tau trig SF  " << trig_sf);
      }
    }
  }
 
  dec_effscalefact(tau) = sf;
  return sf;
}
 
 
double SUSYObjDef_xAOD::GetSignalTauSFsys(const xAOD::TauJet& tau,
                                         const CP::SystematicSet& systConfig,
                                         const bool idSF,
                                         const bool triggerSF,
                                         const std::string& trigExpr)
{
  double sf(1.);
 
  // TEMPORARY: no recommendations yet for 2024+
  if (this->treatAsYear()<2024) {
    //Set the new systematic variation
    StatusCode ret = m_tauEffTool->applySystematicVariation(systConfig);
    if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure TauEfficiencyCorrectionsTool for systematic var. " << systConfig.name() ); }
 
    for (auto& tool : m_tauTrigEffTool) {
      ret = tool->applySystematicVariation(systConfig);
      if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure " << tool->name() << " for systematic var. " << systConfig.name()); }
    }
 
    sf *= GetSignalTauSF(tau, idSF, triggerSF, trigExpr);
 
    //Roll back to default
    ret = m_tauEffTool->applySystematicVariation(m_currentSyst);
    if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure TauEfficiencyCorrectionsTool back to default"); }
 
    for (auto& tool : m_tauTrigEffTool) {
      ret = tool->applySystematicVariation(m_currentSyst);
      if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure " << tool->name() << " back to default"); }
    }
  }
 
  dec_effscalefact(tau) = sf;
 
  return sf;
}
 
 
double SUSYObjDef_xAOD::GetTauTriggerEfficiencySF(const xAOD::TauJet& tau, const std::string& trigExpr) {
 
  double eff(1.);
 
  auto map_it = m_tau_trig_support.find(trigExpr);
  if (map_it == m_tau_trig_support.end()) {
    ATH_MSG_WARNING("The trigger item requested ("  << trigExpr << ") is not supported! Please check. Setting SF to 1.");
    return eff;
  }
 
  // trigger matching (dR=0.2)
  std::vector<std::string> chains;
  for (auto part : std::views::split(map_it->second, ','))  chains.emplace_back(&*part.begin(), std::ranges::distance(part));
  bool match = false;
  for (const std::string& chain : chains)
    if (m_trigMatchingTool->match({&tau}, chain, 0.2)) {
      match = true;
      break;
    }
  if (!match) {
    ATH_MSG_VERBOSE("Tau did not match trigger " << trigExpr);
    return eff;
  }
 
  int trigIdx = std::distance(std::begin(m_tau_trig_support), map_it);
  if (m_tauTrigEffTool.at(trigIdx)->getEfficiencyScaleFactor(tau, eff) != CP::CorrectionCode::Ok) {
    ATH_MSG_ERROR("Some problem found to retrieve SF for trigger item  requested ("  << trigExpr << ")");
    eff = -99;
  }
 
  return eff;
}
 
 
double SUSYObjDef_xAOD::GetTotalTauSF(const xAOD::TauJetContainer& taus, const bool idSF, const bool triggerSF, const std::string& trigExpr) {
 
  double sf(1.);
 
  for (const xAOD::TauJet* tau : taus) {
    // check existence of OR information
    if (!acc_passOR.isAvailable(*tau)) {
      ATH_MSG_WARNING("Tau does not have Overlap Removal decision set. You should only call GetTotalTauSF with taus that have been passed through OR. SF will NOT be applied!");
      break;
    }
 
    // Call this for all taus, which will add the decoration
    double tmpSF = GetSignalTauSF(*tau, idSF, triggerSF, trigExpr);
    if (acc_signal(*tau) && acc_passOR(*tau)) {
      sf *= tmpSF;
    }
  }
 
  return sf;
}
 
 
double SUSYObjDef_xAOD::GetTotalTauSFsys(const xAOD::TauJetContainer& taus, const CP::SystematicSet& systConfig, const bool idSF, const bool triggerSF, const std::string& trigExpr){
  double sf(1.);
 
  //Set the new systematic variation
  StatusCode ret = m_tauEffTool->applySystematicVariation(systConfig);
  if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure TauEfficiencyCorrectionsTool for systematic var. " << systConfig.name() ); }
 
  for (auto& tool : m_tauTrigEffTool) {
    ret = tool->applySystematicVariation(systConfig);
    if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure " << tool->name() << " for systematic var. " << systConfig.name()); }
  }
 
  sf = GetTotalTauSF(taus, idSF, triggerSF, trigExpr);
 
  //Roll back to default
  ret = m_tauEffTool->applySystematicVariation(m_currentSyst);
  if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure TauEfficiencyCorrectionsTool back to default"); }
 
  for (auto& tool : m_tauTrigEffTool) {
    ret = tool->applySystematicVariation(m_currentSyst);
    if (ret != StatusCode::SUCCESS) { ATH_MSG_ERROR("Cannot configure " << tool->name() << " back to default"); }
  }
 
  return sf;
}
 
}