OfflineElectronDecoratorAlg.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#include "OfflineElectronDecoratorAlg.h"
 
#include "xAODEgamma/ElectronxAODHelpers.h" // xAOD::EgammaHelpers::getOriginalTrackParticle
 
 
IDTPM::OfflineElectronDecoratorAlg::OfflineElectronDecoratorAlg(
    const std::string& name,
    ISvcLocator* pSvcLocator ) :
  AthReentrantAlgorithm( name, pSvcLocator ) { }
 
 
StatusCode IDTPM::OfflineElectronDecoratorAlg::initialize() {
 
  ATH_CHECK( m_offlineTrkParticlesName.initialize(
                not m_offlineTrkParticlesName.key().empty() ) );
 
  ATH_CHECK( m_electronsName.initialize( not m_electronsName.key().empty() ) );
 
  IDTPM::createDecoratorKeysAndAccessor( 
      *this, m_offlineTrkParticlesName,
      m_prefix.value(), m_decor_ele_names, m_decor_ele );
 
  if( m_decor_ele.size() != NDecorations ) {
    ATH_MSG_ERROR( "Incorrect booking of electron decorations" );
    return StatusCode::FAILURE;
  }
 
  return StatusCode::SUCCESS;
}
 
 
StatusCode IDTPM::OfflineElectronDecoratorAlg::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::ElectronContainer > pelectrons( m_electronsName, ctx );
  if( not pelectrons.isValid() ) {
    ATH_MSG_ERROR( "Failed to retrieve electrons container" );
    return StatusCode::FAILURE;
  }
 
  std::vector< IDTPM::OptionalDecoration<xAOD::TrackParticleContainer, ElementElectronLink_t> >
      ele_decor( IDTPM::createDecoratorsIfNeeded( *ptracks, m_decor_ele, ctx ) );
 
  if( ele_decor.empty() ) {
    ATH_MSG_ERROR( "Failed to book electron decorations" );
    return StatusCode::FAILURE;
  }
 
  for( const xAOD::TrackParticle* track : *ptracks ) {
    ATH_CHECK( decorateElectronTrack( *track, ele_decor, *pelectrons.ptr() ) );
  }
 
  return StatusCode::SUCCESS;
}
 
 
StatusCode IDTPM::OfflineElectronDecoratorAlg::decorateElectronTrack(
                const xAOD::TrackParticle& track,
                std::vector< IDTPM::OptionalDecoration< xAOD::TrackParticleContainer,
                                                        ElementElectronLink_t > >& ele_decor,
                const xAOD::ElectronContainer& electrons ) const {
 
  for( const xAOD::Electron* electron : electrons ) {
 
    const xAOD::TrackParticle* eleTrack = m_useGSF.value() ?
                        electron->trackParticle() : // with GSF
                        xAOD::EgammaHelpers::getOriginalTrackParticle( electron ); // no GSF
 
    if( not eleTrack ) {
      ATH_MSG_ERROR( "Corrupted matching electron ID track" );
      return StatusCode::FAILURE;
    }
 
    if( eleTrack == &track ) {
      ElementElectronLink_t eleLink;
      eleLink.toContainedElement( electrons, electron );
 
      ATH_MSG_DEBUG( "Found matching electron (e=" << electron->e() << "). Decorating track." );
 
      IDTPM::decorateOrRejectQuietly( track, ele_decor[All], eleLink );
 
      if( electron->passSelection("Tight") ) {
        IDTPM::decorateOrRejectQuietly( track, ele_decor[Tight], eleLink );
      }
 
      if( electron->passSelection("Medium") ) {
        IDTPM::decorateOrRejectQuietly( track, ele_decor[Medium], eleLink );
      }
 
      if( electron->passSelection("Loose") ) {
        IDTPM::decorateOrRejectQuietly( track, ele_decor[Loose], eleLink );
      }
 
      if( electron->passSelection("LHTight") ) {
        IDTPM::decorateOrRejectQuietly( track, ele_decor[LHTight], eleLink );
      }
 
      if( electron->passSelection("LHMedium") ) {
        IDTPM::decorateOrRejectQuietly( track, ele_decor[LHMedium], eleLink );
      }
 
      if( electron->passSelection("LHLoose") ) {
        IDTPM::decorateOrRejectQuietly( track, ele_decor[LHLoose], eleLink );
      }
 
      return StatusCode::SUCCESS;
    } // if( eleTrack == &track ) 
 
  } // close electron loop
 
  return StatusCode::SUCCESS;
}