ActsTrackStateOnSurfaceDecoratorAlg.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#include "src/ActsTrackStateOnSurfaceDecoratorAlg.h"
#include "StoreGate/WriteDecorHandle.h"
#include "StoreGate/ReadDecorHandle.h"
#include "TrkEventPrimitives/TrackStateDefs.h"
#include "ActsGeometry/ATLASSourceLink.h"
#include "ActsEvent/Decoration.h"
 
namespace ActsTrk {
 
  ActsTrackStateOnSurfaceDecoratorAlg::ActsTrackStateOnSurfaceDecoratorAlg(const std::string& name,
                                       ISvcLocator *pSvcLocator)
    : AthReentrantAlgorithm(name, pSvcLocator)
  {}
  
  StatusCode ActsTrackStateOnSurfaceDecoratorAlg::initialize()
  {
    ATH_MSG_DEBUG("Initializing " << name() << " ...");
 
    ATH_CHECK(m_trackParticlesKey.initialize());
    ATH_CHECK(m_decorator_actsTracks.initialize());
    ATH_CHECK(m_trackMsosLink.initialize());
    
    ATH_CHECK(m_pixelMsosKey.initialize());
    ATH_CHECK(m_stripMsosKey.initialize());
    
    return StatusCode::SUCCESS;
  }
  
  StatusCode ActsTrackStateOnSurfaceDecoratorAlg::execute(const EventContext& ctx) const
  {
    ATH_MSG_DEBUG("Executing " << name() << " ...");
 
    SG::ReadHandle<xAOD::TrackParticleContainer> trackParticleHandle = SG::makeHandle( m_trackParticlesKey, ctx );
    ATH_CHECK(trackParticleHandle.isValid());
    const xAOD::TrackParticleContainer* trackParticles = trackParticleHandle.cptr();
 
    SG::WriteHandle<xAOD::TrackStateValidationContainer> pixelMsosHandle = SG::makeHandle( m_pixelMsosKey, ctx );
    ATH_CHECK( pixelMsosHandle.record(std::make_unique<xAOD::TrackStateValidationContainer>(),
                      std::make_unique<xAOD::TrackStateValidationAuxContainer>()) );
    xAOD::TrackStateValidationContainer* pixelMsos = pixelMsosHandle.ptr();
    
    SG::WriteHandle<xAOD::TrackStateValidationContainer> stripMsosHandle = SG::makeHandle( m_stripMsosKey, ctx );
    ATH_CHECK( stripMsosHandle.record(std::make_unique<xAOD::TrackStateValidationContainer>(),
                      std::make_unique<xAOD::TrackStateValidationAuxContainer>()) );
    xAOD::TrackStateValidationContainer* stripMsos = stripMsosHandle.ptr();
 
    SG::WriteDecorHandle<xAOD::TrackParticleContainer,
             std::vector< ElementLink< xAOD::TrackStateValidationContainer > > > decorator_msos_link( m_trackMsosLink, ctx );
    ATH_CHECK(decorator_msos_link.isValid());
 
 
    
    for (const xAOD::TrackParticle* trackParticle : *trackParticles) {
     
      std::optional<ActsTrk::TrackContainer::ConstTrackProxy> optional_track = getActsTrack(*trackParticle);
      if ( not optional_track.has_value() ) {
    ATH_MSG_ERROR("Invalid track link for particle  " << trackParticle->index());
    return StatusCode::FAILURE;
      }
      ActsTrk::TrackContainer::ConstTrackProxy track = optional_track.value();
 
      std::vector< typename ActsTrk::TrackContainer::ConstTrackStateProxy > tsos {};
      tsos.reserve( track.nTrackStates() );
 
 
      // loop on track states
      track.container().trackStateContainer()
    .visitBackwards(track.tipIndex(),
            [&tsos]
            (const typename ActsTrk::TrackContainer::ConstTrackStateProxy& state)
            {
              auto flags = state.typeFlags();
              if (not flags.isMeasurement() and
                  not flags.isOutlier() and
                  not flags.isHole()) return;
              tsos.push_back( state );
            });
 
      std::vector< ElementLink< xAOD::TrackStateValidationContainer > > msos {};
      msos.reserve( tsos.size() );
 
      for (const typename ActsTrk::TrackContainer::ConstTrackStateProxy& state : tsos) {
    const Acts::Surface& surface = state.referenceSurface();
    xAOD::UncalibMeasType detectorTypeFromId = getDetectorType( surface.geometryId().volume() );
 
    if ( detectorTypeFromId == xAOD::UncalibMeasType::PixelClusterType ) {
      ATH_CHECK( storeTrackState(state,
                     msos,
                     *pixelMsos) );
      pixelMsos->back()->setDetType( Trk::TrackState::Pixel );  
    }
    else if ( detectorTypeFromId == xAOD::UncalibMeasType::StripClusterType ) {
      ATH_CHECK( storeTrackState(state,
                     msos,
                     *stripMsos) );
      stripMsos->back()->setDetType( Trk::TrackState::SCT );
    }
    else {
      ATH_MSG_DEBUG("Skipping unsupported Acts volume id "
            << surface.geometryId().volume()
            << " in " << name()
            << "; state is not written to the standard Pixel/Strip MSOS containers");
      continue;
    }
    
      } // loop on states
 
      decorator_msos_link(*trackParticle) = std::move(msos);
    } // loop on track particles
 
    return StatusCode::SUCCESS;
  }
 
  StatusCode ActsTrackStateOnSurfaceDecoratorAlg::storeTrackState(const typename ActsTrk::TrackContainer::ConstTrackStateProxy& state,
                                  std::vector< ElementLink< xAOD::TrackStateValidationContainer > >& msosLinks,
                                  xAOD::TrackStateValidationContainer& msosContainer) const
  {
    msosContainer.push_back( new xAOD::TrackStateValidation() );
 
    ElementLink< xAOD::TrackStateValidationContainer > elink( &msosContainer, msosContainer.back()->index() );
    ATH_CHECK( elink.isValid() );
    msosLinks.push_back( std::move(elink) );
 
    static const SG::ConstAccessor< ElementLink< xAOD::TrackMeasurementValidationContainer > > decorator_measurement_link("validationMeasurementLink");
    
    auto flags = state.typeFlags();
    if (not flags.isHole() ) {
      auto sl = state.getUncalibratedSourceLink().template get<ATLASUncalibSourceLink>();
      ATH_CHECK( sl != nullptr );
      const xAOD::UncalibratedMeasurement &cluster = getUncalibratedMeasurement(sl);
 
      if (not decorator_measurement_link.isAvailable(cluster)) {
    ATH_MSG_ERROR("xAOD Cluster does not have a link to TrackMeasurementValidation element");
    return StatusCode::FAILURE;
      }
      const auto& el = decorator_measurement_link(cluster);
      ATH_CHECK( el.isValid() );
      const xAOD::TrackMeasurementValidation *measurement = *el;
 
      ElementLink<xAOD::TrackMeasurementValidationContainer> tmvc_el( *static_cast<const xAOD::TrackMeasurementValidationContainer*>(measurement->container()),
                                      measurement->index() );
      msosContainer.back()->setTrackMeasurementValidationLink( std::move(tmvc_el) );
    }
    
    if (flags.isHole()) {
      msosContainer.back()->setType( Trk::TrackStateOnSurface::Hole );
    } else if (flags.isOutlier()) {
      msosContainer.back()->setType( Trk::TrackStateOnSurface::Outlier );
    } else {
      msosContainer.back()->setType( Trk::TrackStateOnSurface::Measurement );
    }
    
    return StatusCode::SUCCESS;
  }
  
  xAOD::UncalibMeasType ActsTrackStateOnSurfaceDecoratorAlg::getDetectorType(std::uint64_t volumeId) const
  {
    if (m_isITk) {
      switch (volumeId) {
      case 2:
      case 25:
        return xAOD::UncalibMeasType::HGTDClusterType;
      case 22:
      case 23:
      case 24:
        return xAOD::UncalibMeasType::StripClusterType;
      case 8:
      case 9:
      case 10:
      case 13:
      case 14:
      case 15:
      case 16:
      case 18:
      case 19:
      case 20:
        return xAOD::UncalibMeasType::PixelClusterType;
      default:
        return xAOD::UncalibMeasType::Other;
      }
    } else {
      switch (volumeId) {
      case 9:
      case 10:
      case 11:
        return xAOD::UncalibMeasType::StripClusterType;
      case 5:
      case 6:
      case 7:
        return xAOD::UncalibMeasType::PixelClusterType;
      default:
        return xAOD::UncalibMeasType::Other;
      }
    }
  }
}