SharedHitCounter.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#include "src/detail/AtlasUncalibSourceLinkAccessor.h"
#include "ActsCalibrators/xAODUncalibMeasCalibrator.h"
#include <algorithm>
 
namespace ActsTrk::detail {
 
template <Acts::TrackContainerFrontend track_container_t>
inline auto SharedHitCounter::computeSharedHits(typename track_container_t::TrackProxy &track,
                                                track_container_t &tracks,
                                                const MeasurementIndex &measurementIndex,
                                                bool removeSharedHits) -> ReturnSharedAndBad {
  return computeSharedHits(track, tracks, measurementIndex.size(), [&measurementIndex](const xAOD::UncalibratedMeasurement &hit) -> std::size_t {
    return measurementIndex.index(hit);
  }, removeSharedHits);
}
 
template <Acts::TrackContainerFrontend track_container_t>
inline auto SharedHitCounter::computeSharedHitsDynamic(typename track_container_t::TrackProxy &track,
                                                       track_container_t &tracks,
                                                       MeasurementIndex &measurementIndex,
                                                       bool removeSharedHits) -> ReturnSharedAndBad {
  return computeSharedHits(track, tracks, measurementIndex.size(), [this, &measurementIndex](const xAOD::UncalibratedMeasurement &hit) -> std::size_t {
    auto [index, newContainer] = measurementIndex.newMeasurementIndex(hit);
    if (newContainer)
      m_firstTrackStateOnTheHit.resize(measurementIndex.size(), s_noTrackState);
    return index;
  },removeSharedHits);
}
 
 
  /**
     track  : the track under investigation and that will be updated with the shared hit information
     tracks : the track container. Used to check what hits are used. Both tracks that share hits will get the shared states set and nShared hits updated
     indexSize : the size of measurements to be used fo shared hit counting
     indexFun  : template param to get the index from the hit
     removeSharedHits : if true this function will remove the shared hits from the track and the matching tracks and reset the states sharedHit flag.
   */  
template <Acts::TrackContainerFrontend track_container_t, typename IndexFun>
inline auto SharedHitCounter::computeSharedHits(typename track_container_t::TrackProxy &track,
                                                track_container_t &tracks,
                                                std::size_t indexSize,
                                                IndexFun &&indexFun,
                                                bool removeSharedHits) -> ReturnSharedAndBad {
  // Based on ActsExamples::TrackFindingAlgorithm::computeSharedHits().
  // Finds shared hits in the reconstructed track and updates SharedHitFlag in both tracks.
  // Uses measurementIndex to convert hit to hitIndex, and then m_firstTrackStateOnTheHit[] to convert hitIndex -> TrackStateIndex
  // Returns stats: nShared and nBadTrackMeasurements
 
  if (m_firstTrackStateOnTheHit.size() < indexSize)
    m_firstTrackStateOnTheHit.resize(indexSize, s_noTrackState);
 
  std::size_t nShared = 0;
  std::size_t nBadTrackMeasurements = 0;
  for (auto state : track.trackStatesReversed()) {
    if (!state.typeFlags().hasMeasurement())
      continue;
 
    if (!state.hasUncalibratedSourceLink())
      continue;
    
    if (removeSharedHits and !state.typeFlags().isSharedHit())
      continue;
    
    auto hit = detail::xAODUncalibMeasCalibrator::unpack(state.getUncalibratedSourceLink());
    if (!hit) {
      continue;
    }
    std::size_t hitIndex = indexFun(*hit);
    if (!(hitIndex < m_firstTrackStateOnTheHit.size())) {
      state.typeFlags().setIsSharedHit(false);
      // Save ATH_MSG_ERROR() for the caller, since for simplicity and efficiency this class doesn't have access to AthMsgStream.
      //std::cout << "ERROR hit index " << hitIndex << " past end of " << m_firstTrackStateOnTheHit.size() << " hit indices\n";
      ++nBadTrackMeasurements;
      continue;
    }
 
    // Check if hit not already used
    if (m_firstTrackStateOnTheHit[hitIndex].trackIndex == s_noTrackState.trackIndex) {
      state.typeFlags().setIsSharedHit(false);
      m_firstTrackStateOnTheHit[hitIndex] = {track.index(), state.index()};
      continue;
    }
 
    // if already used, control if first track state has been marked as shared
    const TrackStateIndex& indexFirstTrackState = m_firstTrackStateOnTheHit[hitIndex];
    if (!(indexFirstTrackState.trackIndex < tracks.size())) {
      state.typeFlags().setIsSharedHit(false);
      //std::cout << "ERROR track index " << indexFirstTrackState.trackIndex << " past end of " << tracks.size() << " tracks in container\n";
      ++nBadTrackMeasurements;
      continue;
    }
 
    auto firstTrack = tracks.getTrack(indexFirstTrackState.trackIndex);
    auto& firstStateContainer = firstTrack.container().trackStateContainer();
    
    if (!(indexFirstTrackState.stateIndex < firstStateContainer.size())) {
      state.typeFlags().setIsSharedHit(false);
      //std::cout << "ERROR track state index " << indexFirstTrackState.stateIndex << " past end of " << firstStateContainer.size() << " track states in container\n";
      ++nBadTrackMeasurements;
      continue;
    }
    
    auto firstState = firstStateContainer.getTrackState(indexFirstTrackState.stateIndex);
 
    // if removeSharedHits is false, this is the nominal behaviour
    if (!removeSharedHits) {
      if (!firstState.typeFlags().isSharedHit()) {
        firstState.typeFlags().setIsSharedHit();
        firstTrack.nSharedHits()++;
        ++nShared;
      }
      // Decorate this track state
      state.typeFlags().setIsSharedHit();
      track.nSharedHits()++;
      ++nShared;
 
    } else { // remove shared hits mode
      if (firstState.typeFlags().isSharedHit()) {
        firstState.typeFlags().setIsSharedHit(false);
        
        //We should not find more shared measurements than initially attached to the track
        if (firstTrack.nSharedHits() == 0) {
          //std::cout << "ERROR inconsistency in removing shared hits for firstTrack " <<std::endl;
          ++nBadTrackMeasurements;
        }
        else {
          firstTrack.nSharedHits()--;
          ++nShared;
        }
      }
      // reset the flag for this track state
      state.typeFlags().setIsSharedHit(false);
      track.nSharedHits()--;
      ++nShared;
 
      // clear up the firstTrackStateOnTheHit vector from the update
      if (m_firstTrackStateOnTheHit[hitIndex].trackIndex == track.index() && m_firstTrackStateOnTheHit[hitIndex].stateIndex == state.index())
        m_firstTrackStateOnTheHit[hitIndex] = s_noTrackState;
    }
    
  } // loop on the track states
  
  return {nShared, nBadTrackMeasurements};
}
 
}  // namespace ActsTrk::detail