OfflineTauDecoratorAlg.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/


#include "OfflineTauDecoratorAlg.h"
 

IDTPM::OfflineTauDecoratorAlg::OfflineTauDecoratorAlg(
    const std::string& name,
    ISvcLocator* pSvcLocator ) :
  AthReentrantAlgorithm( name, pSvcLocator ) { }
 

StatusCode IDTPM::OfflineTauDecoratorAlg::initialize() {
 
  ATH_CHECK( m_offlineTrkParticlesName.initialize(
                not m_offlineTrkParticlesName.key().empty() ) );
 
  ATH_CHECK( m_tausName.initialize( not m_tausName.key().empty() ) );

  IDTPM::createDecoratorKeysAndAccessor( 
      *this, m_offlineTrkParticlesName,
      m_prefix.value(), m_decor_tau_names, m_decor_tau );
 
  if( m_decor_tau.size() != NDecorations ) {
    ATH_MSG_ERROR( "Incorrect booking of tau " <<
                   m_tauType.value() << " " <<
                   m_tauNprongs.value() << 
                   "prong decorations" );
    return StatusCode::FAILURE;
  }
 
  return StatusCode::SUCCESS;
}
 

StatusCode IDTPM::OfflineTauDecoratorAlg::execute( const EventContext& ctx ) const {

  SG::ReadHandle< xAOD::TrackParticleContainer > ptracks( m_offlineTrkParticlesName, ctx );
  if( not ptracks.isValid() ) {
    ATH_MSG_ERROR( "Failed to retrieve track particles container" );
    return StatusCode::FAILURE;
  }

  SG::ReadHandle< xAOD::TauJetContainer > ptaus( m_tausName, ctx );
  if( not ptaus.isValid() ) {
    ATH_MSG_ERROR( "Failed to retrieve taus container" );
    return StatusCode::FAILURE;
  }

  if( IDTPM::decorationsAllExist( *ptracks, m_decor_tau ) ) {
    ATH_MSG_DEBUG( "All decorations already exist. Exiting gracefully" );
    return StatusCode::SUCCESS;
  }

  std::vector< IDTPM::OptionalDecoration<xAOD::TrackParticleContainer, ElementTauLink_t> >
      tau_decor( IDTPM::createDecoratorsIfNeeded( *ptracks, m_decor_tau, ctx ) );
 
  if( tau_decor.empty() ) {
    ATH_MSG_ERROR( "Failed to book tau " <<
                   m_tauType.value() << " " <<
                   m_tauNprongs.value() << 
                   "prong decorations" );
    return StatusCode::FAILURE;
  }
 
  for( const xAOD::TrackParticle* track : *ptracks ) {
    ATH_CHECK( decorateTauTrack( *track, tau_decor, *ptaus.ptr() ) );
  }
 
  return StatusCode::SUCCESS;
}
 

StatusCode IDTPM::OfflineTauDecoratorAlg::decorateTauTrack(
                const xAOD::TrackParticle& track,
                std::vector< IDTPM::OptionalDecoration< xAOD::TrackParticleContainer,
                                                        ElementTauLink_t > >& tau_decor,
                const xAOD::TauJetContainer& taus ) const { 

  for( const xAOD::TauJet* tau : taus ) {

    int NTauTracks = tau->nTracks();
    if( m_tauNprongs.value() > 0 and NTauTracks != (int)m_tauNprongs.value() ) continue;

    std::vector< const xAOD::TrackParticle* > tauTracks;
    for( size_t iprong=0; iprong<(size_t)NTauTracks; iprong++ ) {
 
      std::vector< ElementTrackLink_t > tracklink = tau->track( iprong )->trackLinks();
      ATH_MSG_DEBUG( "TauLinkVec size (" << m_tauNprongs.value() <<
                     "prong " << m_tauType.value() << "tau) = " << tracklink.size() );

      for( size_t ilink=0; ilink<tracklink.size() ; ilink++ ) {
        if( tracklink.at(ilink).isValid() ) tauTracks.push_back( *(tracklink.at(ilink)) );
      }
 
    } // close NTauTracks loop
 
    ATH_MSG_DEBUG( "TauVec size (" << m_tauNprongs.value() << "prong " <<
                   m_tauType.value() << "tau) = " << tauTracks.size() );

    for( const xAOD::TrackParticle* tauTrack : tauTracks ) {
 
      if( not tauTrack ) {
        ATH_MSG_ERROR( "Corrupted matching tau ID track" );
        continue;
      }
 
      if( tauTrack == &track ) {
        ElementTauLink_t tauLink;
        tauLink.toContainedElement( taus, tau );
 
        bool isTight( false ), isMedium( false );
        bool isLoose( false ), isVeryLoose( false );
 
        if( m_tauType.value() == "BDT" ) {
          isTight     = tau->isTau( xAOD::TauJetParameters::JetBDTSigTight );
          isMedium    = tau->isTau( xAOD::TauJetParameters::JetBDTSigMedium );
          isLoose     = tau->isTau( xAOD::TauJetParameters::JetBDTSigLoose );
          isVeryLoose = tau->isTau( xAOD::TauJetParameters::JetBDTSigVeryLoose );
 
        } else if( m_tauType.value() == "RNN" ) {
          isTight     = tau->isTau( xAOD::TauJetParameters::JetRNNSigTight );
          isMedium    = tau->isTau( xAOD::TauJetParameters::JetRNNSigMedium );
          isLoose     = tau->isTau( xAOD::TauJetParameters::JetRNNSigLoose );
          isVeryLoose = tau->isTau( xAOD::TauJetParameters::JetRNNSigVeryLoose );
 
        } else {
          ATH_MSG_ERROR( "Unknown Tau type: " << m_tauType.value() );
          return StatusCode::FAILURE;
        }

        if( isTight or isMedium or isLoose or isVeryLoose ) {
          ATH_MSG_DEBUG( "Found matching tau " <<
                         m_tauType.value() << " " <<
                         m_tauNprongs.value() << 
                         "prong (pt=" << tau->pt() <<
                         "). Decorating track." );
          IDTPM::decorateOrRejectQuietly( track, tau_decor[All], tauLink );
          return StatusCode::SUCCESS;
        }

        if( isTight ) {
          IDTPM::decorateOrRejectQuietly( track, tau_decor[Tight], tauLink );
        }

        if( isMedium ) {
          IDTPM::decorateOrRejectQuietly( track, tau_decor[Medium], tauLink );
        }

        if( isLoose ) {
          IDTPM::decorateOrRejectQuietly( track, tau_decor[Loose], tauLink );
        }

        if( isVeryLoose ) {
          IDTPM::decorateOrRejectQuietly( track, tau_decor[VeryLoose], tauLink );
        }
 
      } // if( tauTrack == &track ) 
 
    } // close tauTracks loop
 
  } // close tau loop
 
  return StatusCode::SUCCESS;
}