OfflineObjectDecorHelper.cxx

Go to the documentation of this file.

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


#include "OfflineObjectDecorHelper.h"
#include "AthContainers/ConstAccessor.h"
#include "TrackParametersHelper.h"
 
namespace IDTPM {

  const xAOD::Electron* getLinkedElectron( const xAOD::TrackParticle& track,
                                           const std::string& quality ) {
    std::string decoName = "LinkedElectron_" + quality;
    return getLinkedObject< xAOD::ElectronContainer >( track, decoName );
  }
 

  const xAOD::Muon* getLinkedMuon( const xAOD::TrackParticle& track,
                                   const std::string& quality ) {
    std::string decoName = "LinkedMuon_" + quality;
    return getLinkedObject< xAOD::MuonContainer >( track, decoName );
  }
 

  const xAOD::TauJet* getLinkedTau( const xAOD::TrackParticle& track,
                                    const int requiredNtracks,
                                    const std::string& type,
                                    const std::string& quality ) {
    std::string decoName = "LinkedTau" + type +
        std::to_string( requiredNtracks ) + "_" + quality;
    return getLinkedObject< xAOD::TauJetContainer >( track, decoName );
  }
 

  const xAOD::Jet* getLinkedJet( const xAOD::TrackParticle& track,
                                 const std::string& quality ) {
    std::string decoName = "LinkedJet_" + quality;
    return getLinkedObject< xAOD::JetContainer >( track, decoName );
  }
 

  float getD0TrackInJet( const xAOD::TrackParticle& track,
                         const std::string& quality ) {
    const xAOD::Jet* jet = getLinkedJet( track, quality );
    if( not jet ) return -999.;
 
    //Amg::Vector3D nullPos( 0, 0, 0 );
    Amg::Vector3D jetDirection( jet->px(), jet->py(), jet->pz() );
    Amg::Vector3D unit = jetDirection.unit();
 
    float vs = std::sin( std::atan2( unit.y(), unit.x() ) - track.phi() ) * track.d0();
    float signD0 = vs>=0. ? 1. : -1.;
    return signD0 * std::fabs( track.d0() );
  }
 

  bool isUnlinkedTruth( const xAOD::TrackParticle& track ) {
    const xAOD::TruthParticle* truth = getLinkedObject< xAOD::TruthParticleContainer >(
        track, "truthParticleLink" );
    return ( truth == nullptr );
  }
 

  float getTruthMatchProb( const xAOD::TrackParticle& track ) {
    static const SG::ConstAccessor< float > truthMatchProbabilityAcc( "truthMatchProbability" );
    float prob = truthMatchProbabilityAcc.withDefault( track, -1 );
    if( std::isnan(prob) ) return -1;
    return prob;
  }

  const xAOD::TruthParticle* getLinkedTruth( const xAOD::TrackParticle& track,
                                             const float truthProbCut ) {
    float prob = getTruthMatchProb( track );
    if( std::isnan(prob) ) return nullptr;
    if( prob <= truthProbCut ) return nullptr;
 
    return getLinkedObject< xAOD::TruthParticleContainer >(
        track, "truthParticleLink" );
  }
 
  template < typename PARTICLE >
  unsigned int getEtaBin (const PARTICLE& p, const std::vector<float>& etaBins)  {
    float absEta = std::abs(p.eta());
    absEta = std::clamp(absEta, etaBins.front(), etaBins.back());
    const auto pVal =  std::lower_bound(etaBins.begin(), etaBins.end(), absEta);
    const unsigned int bin = std::distance(etaBins.begin(), pVal) - 1;
    return bin;
  }
  template unsigned int getEtaBin < xAOD::TruthParticle >(const xAOD::TruthParticle& truth, const std::vector<float>& etaBins);
  template unsigned int getEtaBin < xAOD::TrackParticle >(const xAOD::TrackParticle& track, const std::vector<float>& etaBins);
 

  bool getVertexTracksAndWeights( const xAOD::Vertex& vtx,
                                  std::vector< const xAOD::TrackParticle* >& vtxTracks,
                                  std::vector< float >& vtxTrackWeights,
                                  const std::vector< const xAOD::TrackParticle* >& selTracks,
                                  bool useSelected )
  {
    bool success( true );

    vtxTracks.clear();
    vtxTrackWeights.clear();

    if( vtx.vertexType() == xAOD::VxType::NoVtx ) return success;

    size_t nTracks = vtx.nTrackParticles();
    xAOD::Vertex::TrackParticleLinks_t elVec = vtx.trackParticleLinks();
    std::vector< float > wVec = vtx.trackWeights();

    if( not( nTracks == elVec.size() and nTracks == wVec.size() ) ) return false; // shouldn't happen

    for( size_t it=0 ; it<nTracks ; it++ ) {
      if( not elVec[ it ].isValid() ) {
        success = false; // shouldn't happen
        continue;
      }
 
      const xAOD::TrackParticle* thisTrk = *elVec[ it ];
      float thisTrkW = wVec[ it ];

      if( useSelected and
          std::find( selTracks.begin(), selTracks.end(), thisTrk ) == selTracks.end() ) continue;

      vtxTracks.push_back( thisTrk );
      vtxTrackWeights.push_back( thisTrkW );
    } // close associated tracks loop
 
    return success;
  }
 
} // namespace IDTPM