VertexRoiSelectionTool.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 "VertexRoiSelectionTool.h"
#include "TrackAnalysisCollections.h"
#include "TrackParametersHelper.h" // includes VertexParametersHelper.h
 
#include <algorithm> // for std::find
 
 
IDTPM::VertexRoiSelectionTool::VertexRoiSelectionTool(
    const std::string& name ) :
  asg::AsgTool( name ) { }
 
 
StatusCode IDTPM::VertexRoiSelectionTool::initialize() {
 
  ATH_CHECK( asg::AsgTool::initialize() );
 
  ATH_MSG_DEBUG( "Initializing " << name() );
 
  ATH_CHECK( m_triggerVertexContainerName.initialize( 
      not m_triggerVertexContainerName.key().empty() ) );
 
  ATH_CHECK( m_trigDecTool.retrieve() );
 
  return StatusCode::SUCCESS;
}
 
 
template< class V >
bool IDTPM::VertexRoiSelectionTool::accept(
    const V& v, 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( v, (const TrigRoiDescriptor*)r->at(i) ) ) {
        return true;
      }
 
  } else {
    if( r->isFullscan() ) return true;
 
    bool contained_zed = posZ(v) >= r->zedMinus() and 
                         posZ(v) <= r->zedPlus();
 
    if( contained_zed ) return true;
  }
 
  return false;
}
 
template bool IDTPM::VertexRoiSelectionTool::accept(
    const xAOD::Vertex& v, const TrigRoiDescriptor* r ) const;
 
template bool IDTPM::VertexRoiSelectionTool::accept(
    const xAOD::TruthVertex& v, const TrigRoiDescriptor* r ) const;
 
 
template< class V >
std::vector< const V* > IDTPM::VertexRoiSelectionTool::getVertices(
    const std::vector< const V* >& vvec,
    const TrigRoiDescriptor* r ) const {
 
  std::vector< const V* > selectedVertices;
 
  for( const V* thisVertex : vvec ) {
    if( accept<V>( *thisVertex, r ) ) {
      selectedVertices.push_back( thisVertex );
    }
  }
 
  return selectedVertices;
}
 
template std::vector< const xAOD::Vertex* >
IDTPM:: VertexRoiSelectionTool::getVertices< xAOD::Vertex >(
    const std::vector< const xAOD::Vertex* >& vvec,
    const TrigRoiDescriptor* r ) const;
 
template std::vector< const xAOD::TruthVertex* >
IDTPM::VertexRoiSelectionTool::getVertices< xAOD::TruthVertex >(
    const std::vector< const xAOD::TruthVertex* >& vvec,
    const TrigRoiDescriptor* r ) const;
 
 
std::vector< const xAOD::Vertex* >
IDTPM::VertexRoiSelectionTool::getTrigVertices( 
    const std::vector< const xAOD::Vertex* >& vvec,
    const ElementLink< TrigRoiDescriptorCollection >& roiLink ) const
{
  SG::ReadHandle< xAOD::VertexContainer > handle( m_triggerVertexContainerName );
 
  std::pair< xAOD::VertexContainer::const_iterator,
             xAOD::VertexContainer::const_iterator > trigVtxItrPair =
                 m_trigDecTool->associateToEventView( handle, roiLink );
 
  std::vector< const xAOD::Vertex* > selectedTrigVertices;
  xAOD::VertexContainer::const_iterator vtxItr;
  for( vtxItr = trigVtxItrPair.first ; vtxItr != trigVtxItrPair.second ; ++vtxItr ) {
    if( std::find( vvec.begin(), vvec.end(), *vtxItr ) == vvec.end() ) {
      ATH_MSG_DEBUG( "Trigger vertex does not pass quality selection. Skipping." );
      continue;
    }
    selectedTrigVertices.push_back( *vtxItr );
  }
 
  return selectedTrigVertices;
}
 
 
StatusCode IDTPM::VertexRoiSelectionTool::selectVerticesInRoI(
    TrackAnalysisCollections& trkAnaColls,
    const ElementLink< TrigRoiDescriptorCollection >& roiLink ) {
 
  ATH_MSG_DEBUG( "Selecting vertices 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_triggerVertexContainerName.key().empty() ) {
    ATH_CHECK( trkAnaColls.fillTrigVertexVec(
        getTrigVertices(
            trkAnaColls.trigVertexVec( TrackAnalysisCollections::FS ),
            roiLink ),
        TrackAnalysisCollections::InRoI ) );
  }
 
  if( trkAnaDefSvc->useOffline() ) {
    ATH_CHECK( trkAnaColls.fillOfflVertexVec(
        getVertices(
            trkAnaColls.offlVertexVec( TrackAnalysisCollections::FS ),
            *roi ),
        TrackAnalysisCollections::InRoI ) );
  }
 
  if( trkAnaDefSvc->useTruth() ) {
    ATH_CHECK( trkAnaColls.fillTruthVertexVec(
        getVertices(
            trkAnaColls.truthVertexVec( TrackAnalysisCollections::FS ),
            *roi ),
        TrackAnalysisCollections::InRoI ) );
  }
 
  ATH_MSG_DEBUG( "Vertices after RoI selection: " << 
      trkAnaColls.printVertexInfo( TrackAnalysisCollections::InRoI ) );
 
  return StatusCode::SUCCESS;
}