TrackRoiSelectionTool.cxx

Go to the documentation of this file.

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


#include "TrigSteeringEvent/TrigRoiDescriptor.h"

#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/Service.h"

#include "TrackRoiSelectionTool.h"
#include "TrackAnalysisCollections.h"
#include "TrackParametersHelper.h"

#include <cmath> // std::fabs
#include <algorithm> // for std::find
 

IDTPM::TrackRoiSelectionTool::TrackRoiSelectionTool(
    const std::string& name ) :
  asg::AsgTool( name ) { }
 

StatusCode IDTPM::TrackRoiSelectionTool::initialize() {
 
  ATH_CHECK( asg::AsgTool::initialize() );
 
  ATH_MSG_DEBUG( "Initializing " << name() );
 
  ATH_CHECK( m_triggerTrkParticleName.initialize( 
      not m_triggerTrkParticleName.key().empty() ) );
 
  ATH_CHECK( m_trigDecTool.retrieve() );
 
  return StatusCode::SUCCESS;
}
 

template< class T >
bool IDTPM::TrackRoiSelectionTool::accept(
    const T& t, const TrigRoiDescriptor* r ) const {
 
  if( r==0 ) { 
    ATH_MSG_ERROR( "Called with null RoiDescriptor" );
    return true;
  }
 
  if( r->composite() ) {       
 
    for( unsigned i=r->size() ; i-- ; )
      if( accept( t, (const TrigRoiDescriptor*)r->at(i) ) )
        return true;
 
  } else { 
 
    if( r->isFullscan() ) return true;

    bool contained_phi = ( r->phiMinus() < r->phiPlus() ) ?
                         ( phi(t) > r->phiMinus() && phi(t) < r->phiPlus() ) :
                         ( phi(t) > r->phiMinus() || phi(t) < r->phiPlus() ); 
                            
    bool contained_zed = ( z0(t) > r->zedMinus() && z0(t) < r->zedPlus() ); 
    
    bool contained_eta = ( eta(t) < r->etaPlus() && eta(t) > r->etaMinus() );
                                                         
    exitPoint_t exit = getExitPoint( z0(t), eta(t) );

    exitPoint_t exitPlus  = getExitPoint( r->zedPlus(),  r->etaPlus() );
    exitPoint_t exitMinus = getExitPoint( r->zedMinus(), r->etaMinus() );
 
    float cross0 = exit.z * exitMinus.r - exit.r * exitMinus.z;
    float cross1 = exit.z * exitPlus.r  - exit.r * exitPlus.z; 
 
    contained_eta = ( cross0>0 && cross1<0 ) ? true : false;

    float newphi = getOuterPhi( pTsig(t), phi(t), exit.r );
  
    if( newphi < -999. ) return false;
  
    if( r->phiMinus() < r->phiPlus() ) contained_phi &= ( newphi > r->phiMinus() && newphi < r->phiPlus() );
    else                               contained_phi &= ( newphi > r->phiMinus() || newphi < r->phiPlus() );
 
    if( contained_eta && contained_phi && contained_zed ) return true;
  }
 
  return false;
}

template bool IDTPM::TrackRoiSelectionTool::accept(
    const xAOD::TrackParticle& t, const TrigRoiDescriptor* r ) const;

template bool IDTPM::TrackRoiSelectionTool::accept(
    const xAOD::TruthParticle& t, const TrigRoiDescriptor* r ) const;
 

float IDTPM::TrackRoiSelectionTool::getOuterPhi(
    float pt, float phi, float r ) const {


  float mqR = 10 * pt / ( 2.99792458 * 2 ); // 2.998=speed of light, 2=Atlas B field   
  float ratio = 0.5 * r / mqR;    
  float newphi = phi;

  if( std::fabs( ratio ) > 1 ) return -9999.;

  newphi -= std::asin( ratio );  
                          
  while( newphi < -M_PI ) newphi += 2 * M_PI;
  while( newphi > M_PI  ) newphi -= 2 * M_PI;
 
  return newphi;
}
 

IDTPM::exitPoint_t IDTPM::TrackRoiSelectionTool::getExitPoint( 
    float tz0, float teta ) const {
 
  exitPoint_t exitPoint;
  float rexit(0.), zexit(0.);
  const float maxRadius = 1000.;
  const float maxZed    = 2700.;
 
  if      ( teta < 0 ) zexit = -maxZed;
  else if ( teta > 0 ) zexit =  maxZed;
  else { 
    exitPoint.z = tz0;
    exitPoint.r = maxRadius; 
    exitPoint.tantheta = 1e16; // don't really want to use nan
    return exitPoint;
  }
  
  float tantheta = std::tan( 2 * std::atan( std::exp( -teta ) ) );
  
  rexit = ( zexit - tz0 ) * tantheta;

  if ( std::fabs(rexit) > maxRadius ) {
 
    zexit = maxRadius / tantheta + tz0;
    rexit = maxRadius;
  }
 
  exitPoint.z = zexit;
  exitPoint.r = rexit;
  exitPoint.tantheta = tantheta;
  return exitPoint;
}
 

template< class T >
std::vector< const T* > IDTPM::TrackRoiSelectionTool::getTracks(
    const std::vector< const T* >& tvec,
    const TrigRoiDescriptor* r ) const {
 
  std::vector< const T* > selectedTracks;
 
  for( size_t it=0 ; it<tvec.size() ; it++ ) {
    const T* thisTrack = tvec.at(it);
    if( accept<T>( *thisTrack, r ) ) {
      selectedTracks.push_back( thisTrack );
    }
  }
 
  return selectedTracks;
}

template std::vector< const xAOD::TrackParticle* >
IDTPM::TrackRoiSelectionTool::getTracks< xAOD::TrackParticle >(
    const std::vector< const xAOD::TrackParticle* >& tvec,
    const TrigRoiDescriptor* r ) const;

template std::vector< const xAOD::TruthParticle* >
IDTPM::TrackRoiSelectionTool::getTracks< xAOD::TruthParticle >(
    const std::vector< const xAOD::TruthParticle* >& tvec,
    const TrigRoiDescriptor* r ) const;
 

std::vector< const xAOD::TrackParticle* >
IDTPM::TrackRoiSelectionTool::getTrigTracks(
    const std::vector< const xAOD::TrackParticle* >& tvec,
    const ElementLink< TrigRoiDescriptorCollection >& roiLink ) const
{
  SG::ReadHandle< xAOD::TrackParticleContainer > handle( m_triggerTrkParticleName );

  std::pair< xAOD::TrackParticleContainer::const_iterator,
             xAOD::TrackParticleContainer::const_iterator > trigTrkItrPair =
                 m_trigDecTool->associateToEventView( handle, roiLink );

  std::vector< const xAOD::TrackParticle* > selectedTrigTracks;
  xAOD::TrackParticleContainer::const_iterator trkItr;
  for( trkItr = trigTrkItrPair.first ; trkItr != trigTrkItrPair.second ; ++trkItr ) {
    if( std::find( tvec.begin(), tvec.end(), *trkItr ) == tvec.end() ) {
      ATH_MSG_DEBUG( "Trigger track does not pass quality selection. Skipping." );
      continue;
    }
    selectedTrigTracks.push_back( *trkItr );
  }
 
  return selectedTrigTracks;
}
 

StatusCode IDTPM::TrackRoiSelectionTool::selectTracksInRoI(
    TrackAnalysisCollections& trkAnaColls,
    const ElementLink< TrigRoiDescriptorCollection >& roiLink ) {
 
  ATH_MSG_DEBUG( "Selecting tracks in RoI" );

  ISvcLocator* svcLoc = Gaudi::svcLocator();
  SmartIF< ITrackAnalysisDefinitionSvc > trkAnaDefSvc(
      svcLoc->service( "TrkAnaDefSvc"+trkAnaColls.anaTag() ) );
  ATH_CHECK( trkAnaDefSvc.isValid() );
 
  const TrigRoiDescriptor* const* roi = roiLink.cptr();

  if( not m_triggerTrkParticleName.key().empty() ) {
    ATH_CHECK( trkAnaColls.fillTrigTrackVec(
        getTrigTracks(
            trkAnaColls.trigTrackVec( TrackAnalysisCollections::FS ),
            roiLink ),
        TrackAnalysisCollections::InRoI ) );
  }

  if( trkAnaDefSvc->useOffline() ) {
    ATH_CHECK( trkAnaColls.fillOfflTrackVec(
        getTracks(
            trkAnaColls.offlTrackVec( TrackAnalysisCollections::FS ),
            *roi ),
        TrackAnalysisCollections::InRoI ) );
  }

  if( trkAnaDefSvc->useTruth() ) {
    ATH_CHECK( trkAnaColls.fillTruthPartVec(
        getTracks(
            trkAnaColls.truthPartVec( TrackAnalysisCollections::FS ),
            *roi ),
        TrackAnalysisCollections::InRoI ) );
  }

  ATH_MSG_DEBUG( "Tracks after RoI selection: " << 
      trkAnaColls.printInfo( TrackAnalysisCollections::InRoI, false ) );
 
  return StatusCode::SUCCESS;
}