ActsToTrkConverterTool.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#include "ActsToTrkConverterTool.h"
 
// Trk
#include "TRT_ReadoutGeometry/TRT_BaseElement.h"
#include "TrkSurfaces/AnnulusBounds.h"
#include "TrkSurfaces/Surface.h"
#include "TrkTrack/Track.h"
 
// ATHENA
#include "GaudiKernel/IInterface.h"
#include "InDetReadoutGeometry/SiDetectorElementCollection.h"
#include "TrkExUtils/RungeKuttaUtils.h"
#include "TrkMeasurementBase/MeasurementBase.h"
#include "TrkSurfaces/PerigeeSurface.h"
#include "TrkSurfaces/Surface.h"
#include "xAODMeasurementBase/UncalibratedMeasurement.h"
 
#include "InDetPrepRawData/PixelClusterCollection.h"
#include "InDetPrepRawData/SCT_ClusterCollection.h"
 
#include "MuonReadoutGeometryR4/MuonDetectorManager.h"
#include "MuonReadoutGeometry/MuonReadoutElement.h"
#include "xAODMuonPrepData/MuonMeasurement.h"
#include "xAODMuonPrepData/CombinedMuonStrip.h"
#include "MuonCompetingRIOsOnTrack/CompetingMuonClustersOnTrack.h"
// PACKAGE
#include "ActsCalibBase/CalibrationContext.h"
#include "ActsGeometry/ActsDetectorElement.h"
#include "ActsGeometryInterfaces/GeometryContext.h"
#include "ActsGeometry/ActsTrackingGeometryTool.h"
#include "ActsGeometryInterfaces/ITrackingGeometryTool.h"
#include "ActsGeoUtils/SurfaceCache.h"
#include "ActsInterop/IdentityHelper.h"
#include "ActsEvent/ParticleHypothesisEncoding.h"
 
// ACTS
#include "Acts/Surfaces/StrawSurface.hpp"
#include "Acts/Surfaces/PerigeeSurface.hpp"
#include "Acts/Surfaces/PlaneSurface.hpp"
 
#include "Acts/Surfaces/RectangleBounds.hpp"
#include "Acts/Surfaces/TrapezoidBounds.hpp"
#include "Acts/Surfaces/CylinderBounds.hpp"
#include "Acts/Surfaces/DiscBounds.hpp"
#include "Acts/Surfaces/LineBounds.hpp"
#include "Acts/Surfaces/RadialBounds.hpp"
 
#include "Acts/Definitions/Units.hpp"
#include "Acts/EventData/BoundTrackParameters.hpp"
#include "Acts/EventData/VectorTrackContainer.hpp"
#include "Acts/EventData/TransformationHelpers.hpp"
#include "Acts/Geometry/TrackingGeometry.hpp"
#include "Acts/Propagator/detail/JacobianEngine.hpp"
#include "Acts/Surfaces/detail/PlanarHelper.hpp"
 
#include "ActsEvent/MultiTrajectory.h"
#include "Acts/EventData/TrackStatePropMask.hpp"
#include "Acts/EventData/SourceLink.hpp"
 
 
 
 
#include "TrkSurfaces/DiscBounds.h"
#include "TrkSurfaces/TrapezoidBounds.h"
#include "TrkSurfaces/CylinderBounds.h"
#include "TrkSurfaces/RectangleBounds.h"
#include "TrkSurfaces/StraightLineSurface.h"
#include "TrkSurfaces/CylinderSurface.h"
 
// STL
#include <cmath>
#include <iostream>
#include <memory>
#include <random>
#include <format>
 
namespace ActsTrk {
 
using namespace Acts::UnitLiterals;
 
using SurfacePtr_t = ActsToTrkConverterTool::SurfacePtr_t;
 
// Forward definitions of local functions
// @TODO unused, remove ?
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-function"
static void ActsMeasurementCheck(const Acts::GeometryContext &gctx,
                                 const Trk::MeasurementBase &measurement,
                                 const Acts::Surface &surface,
                                 const Acts::BoundVector &loc);
#pragma GCC diagnostic pop
 
static void ActsTrackParameterCheck(
    const Acts::BoundTrackParameters &actsParameter,
    const Acts::GeometryContext &gctx, const Acts::BoundMatrix &covpc,
    const Acts::BoundVector &targetPars, const Acts::BoundMatrix &targetCov,
    const Trk::PlaneSurface *planeSurface);
 
 
std::unique_ptr<Trk::TrackParameters> rotateParams(const Trk::TrackParameters& inPars,
                                                   const Trk::Surface&  target) {
    const Amg::Vector3D& pos = inPars.position();
    const Amg::Vector3D& mom = inPars.momentum();
    using namespace Acts::PlanarHelper;
    
    const auto isect = intersectPlane(pos, mom.normalized(), target.normal(), target.center());
    std::optional<AmgSymMatrix(5)> cov{};
    if (inPars.covariance()) {
        AmgSymMatrix(5) rot {AmgSymMatrix(5)::Identity()};
        rot.block<2,2>(0,0) = AmgSymMatrix(2){Eigen::Rotation2D{90._degree}};
        cov = rot.transpose() * (*inPars.covariance()) * rot;
    }
    return target.createUniqueTrackParameters(isect.position(), mom,
                                              std::copysign(1., inPars.parameters()[Trk::qOverP]),
                                              std::move(cov));                     
}
 
 
StatusCode ActsToTrkConverterTool::initialize() {
  ATH_MSG_DEBUG("Initializing ACTS to ATLAS converter tool");
  if (!m_trackingGeometryTool.empty()) {
    ATH_CHECK(m_trackingGeometryTool.retrieve());
    m_trackingGeometry = m_trackingGeometryTool->trackingGeometry();
 
    m_trackingGeometry->visitSurfaces([&](const Acts::Surface *surface) {
      // find acts surface with the same detector element ID
      if (!surface)
        return;
      const auto *actsElement = dynamic_cast<const IDetectorElementBase*>(
          surface->surfacePlacement());
      if (!actsElement) {
        return;
      }
      // Conversion from Acts to ATLAS surface impossible for the TRT so the TRT
      // surfaces are not stored in this map
      if (actsElement->detectorType() == DetectorType::Trt) {
          return;
      }
 
      auto [it, ok] =  m_actsSurfaceMap.insert(std::make_pair(actsElement->identify(), surface->getSharedPtr()));
      if (!ok) {
        ATH_MSG_WARNING("ATLAS ID " << actsElement->identify()
                                    << " has two ACTS surfaces: "
                                    << it->second->geometryId() << " and "
                                    << surface->geometryId());
      }
    });
  }
 
  ATH_CHECK(m_trkSummaryTool.retrieve());
  ATH_CHECK(m_ROTcreator.retrieve());
  m_prdCalib = detail::TrkPrepRawDataCalibrator{this, m_ROTcreator.get()};
  m_slType = static_cast<detail::SourceLinkType>(m_sourceLinkType.value());
  ATH_CHECK(m_muonMgrKey.initialize(m_extractMuonSurfaces));
  ATH_CHECK(m_keyMdt.initialize(SG::AllowEmpty));
  ATH_CHECK(m_keyRpc.initialize(SG::AllowEmpty));
  ATH_CHECK(m_keyTgc.initialize(SG::AllowEmpty));
  ATH_CHECK(m_keyMm.initialize(SG::AllowEmpty));
  ATH_CHECK(m_keyStgc.initialize(SG::AllowEmpty));
  ATH_CHECK(m_compRotCreator.retrieve(EnableTool{!m_keyRpc.empty() || !m_keyTgc.empty()}));
  if (m_extractMuonSurfaces){
    ATH_CHECK(m_idHelperSvc.retrieve());
    const MuonGMR4::MuonDetectorManager* muonMgr{nullptr};    
    ATH_CHECK(detStore()->retrieve(muonMgr));
    unsigned int mapSize = m_actsSurfaceMap.size(); // For debugging message later
    for (auto readoutElement : muonMgr->getAllReadoutElements()) {
      std::vector<std::shared_ptr<Acts::Surface>> reSurfaces = readoutElement->getSurfaces();
      for ( const auto& surf : reSurfaces) {
        const Identifier id = static_cast<const SurfaceCache*>(surf->surfacePlacement())->identify();
        m_actsSurfaceMap.insert(std::make_pair(id, surf));
      }
    }
    ATH_MSG_VERBOSE("After adding muon surfaces, the map has grown from "<<mapSize<<" to "<<m_actsSurfaceMap.size());
  }
  return StatusCode::SUCCESS;
}
 
SurfacePtr_t ActsToTrkConverterTool::translateFreeSurface(const Acts::Surface& surface) const {
  const ActsTrk::GeometryContext gctx{};
  const Amg::Transform3D& trf{surface.localToGlobalTransform(gctx.context())};
  switch (surface.type()) {
      using enum Acts::Surface::SurfaceType;
      case Plane:
        return SurfacePtr_t{new Trk::PlaneSurface(trf, translateBounds(surface.bounds()))};
      case Cylinder:
          return SurfacePtr_t{new Trk::CylinderSurface(trf,
                 std::dynamic_pointer_cast<Trk::CylinderBounds>(translateBounds(surface.bounds())))};
      case Perigee:
          return SurfacePtr_t{new Trk::PerigeeSurface(trf)};
      case Disc:
          return SurfacePtr_t{new Trk::DiscSurface(trf,
                 std::dynamic_pointer_cast<Trk::DiscBounds>(translateBounds(surface.bounds())))};
      case Straw: {
          auto bounds = std::dynamic_pointer_cast<Trk::CylinderBounds>(translateBounds(surface.bounds()));
          return SurfacePtr_t{new Trk::StraightLineSurface(trf, bounds->r(), bounds->halflengthZ())};
      } default:
        break;
 
  }
  THROW_EXCEPTION("ActsToTrkConverterTool() - Surface cannot be translated " 
                  <<surface.toString(gctx.context()));
 
  return nullptr;
}
 
SurfacePtr_t ActsToTrkConverterTool::actsSurfaceToTrkSurface(const EventContext& ctx,
                                                             const Acts::Surface &actsSurface) const {
 
  const auto *detEleBase= dynamic_cast<const IDetectorElementBase*>(actsSurface.surfacePlacement());
  if (!detEleBase) {
     return translateFreeSurface(actsSurface);
  }
  switch (detEleBase->detectorType()) {
      using enum DetectorType;
      case Pixel:
      case Sct:
      case Hgtd:
      case Trt: {
        const auto actsElement = dynamic_cast<const ActsDetectorElement*>(detEleBase);
        if (actsElement) {
            return SurfacePtr_t{&actsElement->atlasSurface()};
        }
        break;
      }
      case Mdt:
      case Rpc:
      case Tgc:
      case Csc:
      case sTgc:
      case Mm: {
        const MuonGM::MuonDetectorManager* detMgr{nullptr};
        if (!SG::get(detMgr, m_muonMgrKey, ctx).isSuccess() || !detMgr) {
            THROW_EXCEPTION("Failed to retrieve the muon detector manager");
        }
        return SurfacePtr_t{&detMgr->getReadoutElement(detEleBase->identify())->surface(detEleBase->identify())};
      
      } default:
        break;
  }
  return translateFreeSurface(actsSurface);
}
 
std::shared_ptr<const Acts::Surface> 
  ActsToTrkConverterTool::trkSurfaceToActsSurface(const Trk::Surface &atlasSurface) const {
 
  Identifier atlasID = atlasSurface.associatedDetectorElementIdentifier();
  auto it = m_actsSurfaceMap.find(atlasID);
  if (it != m_actsSurfaceMap.end()) {
    return it->second;
  }
  const Amg::Transform3D& trf{atlasSurface.transform()};
  switch (atlasSurface.type()){
      using enum Trk::SurfaceType;
      case Plane:
        return Acts::Surface::makeShared<Acts::PlaneSurface>(trf);
      case Perigee:
        return Acts::Surface::makeShared<Acts::PerigeeSurface>(trf);
      case Line:
        return Acts::Surface::makeShared<Acts::StrawSurface>(trf);
      // TODO - implement the missing types?
      default: {
        break;
      }
  }
  std::stringstream surfStr{};
  atlasSurface.dump(surfStr);  
  throw std::domain_error(std::format("Failed to translate surface {:}", surfStr.str()));
}
 
std::vector<Acts::SourceLink>
ActsToTrkConverterTool::trkTrackToSourceLinks(const Trk::Track &track) const {
  std::vector<Acts::SourceLink> sourceLinks{};
  sourceLinks.reserve(track.measurementsOnTrack()->size() +
                      track.outliersOnTrack()->size());
  toSourceLinks(track.measurementsOnTrack()->stdcont(), sourceLinks);
  toSourceLinks(track.outliersOnTrack()->stdcont(), sourceLinks);
  return sourceLinks;
}
 
 
void ActsToTrkConverterTool::toSourceLinks(const std::vector<const Trk::MeasurementBase*>& measSet,
                                           std::vector<Acts::SourceLink>& sourceLinks) const{
    if (sourceLinks.capacity() < sourceLinks.size() + measSet.size()) {
      sourceLinks.reserve(sourceLinks.size() + measSet.size());
    }
    std::ranges::transform(measSet, std::back_inserter(sourceLinks), [](const Trk::MeasurementBase* meas) {
                             return detail::TrkMeasurementCalibrator::pack(meas);
                          });
}
void ActsToTrkConverterTool::toSourceLinks(const std::vector<const Trk::PrepRawData*>& prdSet,
                                           std::vector<Acts::SourceLink>& links) const {
    if (links.capacity() < links.size() + prdSet.size()) {
      links.reserve(links.size() + prdSet.size());
    }
    std::ranges::transform(prdSet, std::back_inserter(links), [](const Trk::PrepRawData* prd) {
                            return detail::TrkPrepRawDataCalibrator::pack(prd);
                          });
}
 
const Acts::BoundTrackParameters
ActsToTrkConverterTool::trkTrackParametersToActsParameters(const Trk::TrackParameters &atlasParameter, 
                                                           const Acts::GeometryContext & gctx, 
                                                           Trk::ParticleHypothesis hypothesis) const {
 
  std::shared_ptr<const Acts::Surface> actsSurface{};
  Acts::BoundVector params;
 
  // get the associated surface
  try {
      actsSurface = trkSurfaceToActsSurface(atlasParameter.associatedSurface());
  } catch (const std::exception &e) {
      ATH_MSG_ERROR("Could not find ACTS detector surface for this TrackParameter:");
      ATH_MSG_ERROR(atlasParameter);
      throw;  // Nothing we can do, so just pass exception on...
  }
 
  // Construct track parameters
  const auto& atlasParam{atlasParameter.parameters()};
  if (actsSurface->bounds().type() == Acts::SurfaceBounds::BoundsType::eAnnulus) {
    // Annulus surfaces are constructed differently in Acts/Trk so we need to
    // convert local coordinates
    const Amg::Vector3D& position{atlasParameter.position()};
    auto result = actsSurface->globalToLocal(gctx, position, atlasParameter.momentum());
    if (result.ok()) {
      params << (*result)[0], (*result)[1], atlasParam[Trk::phi0],
          atlasParam[Trk::theta],
          atlasParameter.charge() / (atlasParameter.momentum().mag() * 1_MeV),
          0.;
    } else {
      ATH_MSG_WARNING("Unable to convert annulus surface - globalToLocal failed");
    }
  } else {
    params << atlasParam[Trk::locX], atlasParam[Trk::locY],
             atlasParam[Trk::phi0], atlasParam[Trk::theta],
             atlasParameter.charge() / (atlasParameter.momentum().mag() * 1_MeV), 0.;
  }
 
  Acts::BoundMatrix cov = Acts::BoundMatrix::Identity();
  if (atlasParameter.covariance()) {
    cov.topLeftCorner(5, 5) = *atlasParameter.covariance();
 
    // Convert the covariance matrix from MeV
    // FIXME: This needs to handle the annulus case as well - currently the cov
    // is wrong for annulus surfaces
    for (int i = 0; i < cov.rows(); i++) {
      cov(i, 4) = cov(i, 4) / 1_MeV;
    }
    for (int i = 0; i < cov.cols(); i++) {
      cov(4, i) = cov(4, i) / 1_MeV;
    }
  }
 
  return Acts::BoundTrackParameters(actsSurface, params,cov, 
                                    ParticleHypothesis::convert(hypothesis));
}
 
std::unique_ptr<Trk::TrackParameters>
ActsToTrkConverterTool::actsTrackParametersToTrkParameters(
    const EventContext& ctx,
    const Acts::BoundTrackParameters &actsParameter,
    const Acts::GeometryContext &gctx) const {
 
  std::optional<AmgSymMatrix(5)> cov = std::nullopt;
  if (actsParameter.covariance()) {
    AmgSymMatrix(5) newcov(actsParameter.covariance()->topLeftCorner<5, 5>());
    // Convert the covariance matrix to GeV
    for (int i = 0; i < newcov.rows(); i++) {
      newcov(i, 4) = newcov(i, 4) * 1_MeV;
    }
    for (int i = 0; i < newcov.cols(); i++) {
      newcov(4, i) = newcov(4, i) * 1_MeV;
    }
    cov = newcov;
  }
 
  const Acts::Surface &actsSurface = actsParameter.referenceSurface();
  SurfacePtr_t trkSurface = actsSurfaceToTrkSurface(ctx, actsSurface);
  switch (actsSurface.type()) {
    case Acts::Surface::SurfaceType::Cone: {
      const auto &coneSurface = static_cast<const Trk::ConeSurface&>(*trkSurface);
      return std::make_unique<Trk::AtaCone>(
          actsParameter.get<Acts::eBoundLoc0>(),
          actsParameter.get<Acts::eBoundLoc1>(),
          actsParameter.get<Acts::eBoundPhi>(),
          actsParameter.get<Acts::eBoundTheta>(),
          actsParameter.get<Acts::eBoundQOverP>() * 1_MeV, coneSurface, cov);
    } case Acts::Surface::SurfaceType::Cylinder: {
      const auto &cylSurface{static_cast<const Trk::CylinderSurface&>(*trkSurface)};
      return std::make_unique<Trk::AtaCylinder>(
          actsParameter.get<Acts::eBoundLoc0>(),
          actsParameter.get<Acts::eBoundLoc1>(),
          actsParameter.get<Acts::eBoundPhi>(),
          actsParameter.get<Acts::eBoundTheta>(),
          actsParameter.get<Acts::eBoundQOverP>() * 1_MeV, cylSurface, cov);
    } case Acts::Surface::SurfaceType::Disc: {
      if (trkSurface->type() == Trk::SurfaceType::Disc) {
         const auto& discSurface{static_cast<const Trk::DiscSurface&>(*trkSurface)};
         return std::make_unique<Trk::AtaDisc>(
              actsParameter.get<Acts::eBoundLoc0>(),
              actsParameter.get<Acts::eBoundLoc1>(),
              actsParameter.get<Acts::eBoundPhi>(),
              actsParameter.get<Acts::eBoundTheta>(),
              actsParameter.get<Acts::eBoundQOverP>() * 1_MeV, discSurface, cov);
      } else if (trkSurface->type() == Trk::SurfaceType::Plane) {
        auto& planeSurface{static_cast<const Trk::PlaneSurface&>(*trkSurface)};
        // need to convert to plane position on plane surface (annulus bounds)
        auto helperSurface = Acts::Surface::makeShared<Acts::PlaneSurface>(planeSurface.transform());
 
        auto covpc = actsParameter.covariance().value();
        Acts::FreeVector freePars = Acts::transformBoundToFreeParameters(actsSurface, gctx, 
                                                                         actsParameter.parameters());

        Acts::BoundVector targetPars = Acts::transformFreeToBoundParameters(freePars,
                                                  *helperSurface, gctx).value();
        
        Acts::FreeMatrix freeTransportJacobian{Acts::FreeMatrix::Identity()};
 
        Acts::FreeVector freeToPathDerivatives{Acts::FreeVector::Zero()};
        freeToPathDerivatives.head<3>() = freePars.segment<3>(Acts::eFreeDir0);
 
        auto boundToFreeJacobian = actsSurface.boundToFreeJacobian(gctx, freePars.segment<3>(Acts::eFreePos0),
                                                                   freePars.segment<3>(Acts::eFreeDir0));
 
        Acts::BoundMatrix boundToBoundJac = Acts::detail::boundToBoundTransportJacobian(gctx, freePars, 
                  boundToFreeJacobian, freeTransportJacobian, freeToPathDerivatives, *helperSurface);
 
        Acts::BoundMatrix targetCov{boundToBoundJac * covpc * boundToBoundJac.transpose()};
 
        auto pars = std::make_unique<Trk::AtaPlane>(
            targetPars[Acts::eBoundLoc0], targetPars[Acts::eBoundLoc1],
            targetPars[Acts::eBoundPhi], targetPars[Acts::eBoundTheta],
            targetPars[Acts::eBoundQOverP] * 1_MeV, planeSurface,
            targetCov.topLeftCorner<5, 5>());
 
        if (m_visualDebugOutput) {
          ActsTrackParameterCheck(actsParameter, gctx, covpc, targetPars,
                                  targetCov, &planeSurface);
        }
        return pars;
 
      } else {
        throw std::domain_error("Acts::DiscSurface is not associated with ATLAS disc or plane surface");
      }
      break;
    } case Acts::Surface::SurfaceType::Perigee: {
      const auto& perSurface = static_cast<const Trk::PerigeeSurface&>(*trkSurface);
      return std::make_unique<Trk::Perigee>(
          actsParameter.get<Acts::eBoundLoc0>(),
          actsParameter.get<Acts::eBoundLoc1>(),
          actsParameter.get<Acts::eBoundPhi>(),
          actsParameter.get<Acts::eBoundTheta>(),
          actsParameter.get<Acts::eBoundQOverP>() * 1_MeV, perSurface, cov);
    } case Acts::Surface::SurfaceType::Plane: {
      auto &plaSurface{static_cast<const Trk::PlaneSurface&>(*trkSurface)};
      return std::make_unique<Trk::AtaPlane>(
          actsParameter.get<Acts::eBoundLoc0>(),
          actsParameter.get<Acts::eBoundLoc1>(),
          actsParameter.get<Acts::eBoundPhi>(),
          actsParameter.get<Acts::eBoundTheta>(),
          actsParameter.get<Acts::eBoundQOverP>() * 1_MeV, plaSurface, cov);
    } case Acts::Surface::SurfaceType::Straw: {
      auto& lineSurface{static_cast<const Trk::StraightLineSurface&>(*trkSurface)};
      return std::make_unique<Trk::AtaStraightLine>(
          actsParameter.get<Acts::eBoundLoc0>(),
          actsParameter.get<Acts::eBoundLoc1>(),
          actsParameter.get<Acts::eBoundPhi>(),
          actsParameter.get<Acts::eBoundTheta>(),
          actsParameter.get<Acts::eBoundQOverP>() * 1_MeV, lineSurface, cov);
    } case Acts::Surface::SurfaceType::Curvilinear: {
      return std::make_unique<Trk::CurvilinearParameters>(
          actsParameter.position(gctx), actsParameter.get<Acts::eBoundPhi>(),
          actsParameter.get<Acts::eBoundTheta>(),
          actsParameter.get<Acts::eBoundQOverP>() * 1_MeV, cov);
    } case Acts::Surface::SurfaceType::Other: {
      break;
    }
  }
  throw std::domain_error("Surface type not found");
}
 
void ActsToTrkConverterTool::trkTrackCollectionToActsTrackContainer(MutableTrackContainer &tc,
                                                                    const TrackCollection &trackColl,
                                                                    const Acts::GeometryContext & gctx) const {
  ATH_MSG_VERBOSE("Calling trkTrackCollectionToActsTrackContainer with "
                  << trackColl.size() << " tracks.");
  unsigned int trkCount = 0;
  std::vector<Identifier> failedIds; // Keep track of Identifiers of failed conversions
  for (const Trk::Track* trk : trackColl) {
    // Do conversions!
    const Trk::TrackStates *trackStates = trk->trackStateOnSurfaces();
   
    auto actsTrack = tc.getTrack(tc.addTrack());
    auto& trackStateContainer = tc.trackStateContainer();
 
    ATH_MSG_VERBOSE("Track "<<trkCount++<<" has " << trackStates->size()
                                 << " track states on surfaces.");
    // basic quantities copy
    actsTrack.chi2() = trk->fitQuality()->chiSquared();
    actsTrack.nDoF() = trk->fitQuality()->numberDoF();
 
    // loop over track states on surfaces, convert and add them to the ACTS
    // container
    bool first_tsos = true;  // We need to handle the first one differently
    int measurementsCount = 0;
    for (const Trk::TrackStateOnSurface* tsos : *trackStates) {
 
      // Setup the mask
      Acts::TrackStatePropMask mask = Acts::TrackStatePropMask::None;
      if (tsos->measurementOnTrack()) {
        mask |= Acts::TrackStatePropMask::Calibrated;
      }
      if (tsos->trackParameters()) {
        mask |= Acts::TrackStatePropMask::Smoothed;
      }
 
      // Setup the index of the trackstate
      auto index = Acts::kTrackIndexInvalid;
      if (!first_tsos) {
        index = actsTrack.tipIndex();
      }
      auto actsTSOS = trackStateContainer.getTrackState(trackStateContainer.addTrackState(mask, index));
      ATH_MSG_VERBOSE("TipIndex: " << actsTrack.tipIndex() << " TSOS index within trajectory: "<< actsTSOS.index());
      actsTrack.tipIndex() = actsTSOS.index();
 
      if (tsos->trackParameters()) {
        // TODO This try/catch is temporary and should be removed once the sTGC problem is fixed.
        try {
          ATH_MSG_VERBOSE("Converting track parameters.");
          // TODO - work out whether we should set predicted, filtered, smoothed
          const Acts::BoundTrackParameters parameters =
              trkTrackParametersToActsParameters(*(tsos->trackParameters()), gctx);
          ATH_MSG_VERBOSE("Track parameters: " << parameters.parameters());
          // Sanity check on positions
          if (!actsTrackParameterPositionCheck(parameters, *(tsos->trackParameters()), gctx)){
            failedIds.push_back(tsos->trackParameters()->associatedSurface().associatedDetectorElementIdentifier());
          }
 
          if (first_tsos) {
            // This is the first track state, so we need to set the track
            // parameters
            actsTrack.parameters() = parameters.parameters();
            actsTrack.covariance() = *parameters.covariance();
            actsTrack.setReferenceSurface(parameters.referenceSurface().getSharedPtr());
            first_tsos = false;
          } else {
            actsTSOS.setReferenceSurface(parameters.referenceSurface().getSharedPtr());
            // Since we're converting final Trk::Tracks, let's assume they're smoothed
            actsTSOS.smoothed() = parameters.parameters();
            actsTSOS.smoothedCovariance() = *parameters.covariance();
            // Not yet implemented in MultiTrajectory.icc
            // actsTSOS.typeFlags().setHasParameters();
            if (!(actsTSOS.hasSmoothed() && actsTSOS.hasReferenceSurface())) {
              ATH_MSG_WARNING("TrackState does not have smoothed state ["
                              << actsTSOS.hasSmoothed()
                              << "] or reference surface ["
                              << actsTSOS.hasReferenceSurface() << "].");
            } else {
              ATH_MSG_VERBOSE("TrackState has smoothed state and reference surface.");
            }
          }
        } catch (const std::exception& e){
          ATH_MSG_ERROR("Unable to convert TrackParameter with exception ["<<e.what()<<"]. Will be missing from ACTS track."
                        <<(*tsos->trackParameters()));
        }
      }
      if (tsos->measurementOnTrack()) {
        auto &measurement = *(tsos->measurementOnTrack());
 
        measurementsCount++;
        // const Acts::Surface &surface =
        //     trkSurfaceToActsSurface(measurement.associatedSurface());
        //  Commented for the moment because Surfaces not yet implemented in
        //  MultiTrajectory.icc
 
        int dim = measurement.localParameters().dimension();
        actsTSOS.allocateCalibrated(dim); 
        if (dim == 1) {
          actsTSOS.calibrated<1>() = measurement.localParameters();
          actsTSOS.calibratedCovariance<1>() = measurement.localCovariance();
        } else if (dim == 2) {
          actsTSOS.calibrated<2>() = measurement.localParameters();
          actsTSOS.calibratedCovariance<2>() = measurement.localCovariance();
        } else {
          throw std::domain_error("Cannot handle measurement dim>2");
        }
        actsTSOS.setUncalibratedSourceLink(detail::TrkMeasurementCalibrator::pack(tsos->measurementOnTrack()));
 
      }  // end if measurement
    }    // end loop over track states
    actsTrack.nMeasurements() = measurementsCount;
    ATH_MSG_VERBOSE("TrackProxy has " << actsTrack.nTrackStates()
                                 << " track states on surfaces.");
  }
  ATH_MSG_VERBOSE("Finished converting " << trackColl.size() << " tracks.");
 
  if (!failedIds.empty()){
    ATH_MSG_WARNING("Failed to convert "<<failedIds.size()<<" track parameters.");
    for (auto id : failedIds){
      ATH_MSG_WARNING("-> Failed for Identifier "<<m_idHelperSvc->toString(id));
    }
  }
  ATH_MSG_VERBOSE("ACTS Track container has " << tc.size() << " tracks.");
}
 
std::shared_ptr<Trk::SurfaceBounds> 
    ActsToTrkConverterTool::translateBounds(const Acts::SurfaceBounds& bounds) const {
    switch (bounds.type()) {
      using enum Acts::SurfaceBounds::BoundsType;
      case eRectangle:{
        using ParEnum_t = Acts::RectangleBounds::BoundValues;
        const auto& cBounds = static_cast<const Acts::RectangleBounds&>(bounds);
        return std::make_shared<Trk::RectangleBounds>(cBounds.get(ParEnum_t::eMaxX), 
                                                      cBounds.get(ParEnum_t::eMaxY));
      } case eTrapezoid: {
        using ParEnum_t = Acts::TrapezoidBounds::BoundValues;
        const auto& cBounds = static_cast<const Acts::TrapezoidBounds&>(bounds);
        return std::make_shared<Trk::TrapezoidBounds>(cBounds.get(ParEnum_t::eHalfLengthXnegY),
                                                      cBounds.get(ParEnum_t::eHalfLengthXposY),
                                                      cBounds.get(ParEnum_t::eHalfLengthY));
   
      } case eDisc: {
        using ParEnum_t = Acts::RadialBounds::BoundValues;
        const auto& cBounds = static_cast<const Acts::RadialBounds&>(bounds);
        return std::make_shared<Trk::DiscBounds>(cBounds.get(ParEnum_t::eMinR),
                                                 cBounds.get(ParEnum_t::eMaxR),
                                                 cBounds.get(ParEnum_t::eAveragePhi),
                                                 cBounds.get(ParEnum_t::eHalfPhiSector));
 
      } case eCylinder: {
        using ParEnum_t = Acts::CylinderBounds::BoundValues;
        const auto& cBounds = static_cast<const Acts::CylinderBounds&>(bounds);
        return std::make_shared<Trk::CylinderBounds>(cBounds.get(ParEnum_t::eR),
                                                     cBounds.get(ParEnum_t::eHalfPhiSector),
                                                     cBounds.get(ParEnum_t::eAveragePhi),
                                                     cBounds.get(ParEnum_t::eHalfLengthZ));
      } case eLine: {
        using ParEnum_t = Acts::LineBounds::BoundValues;
        const auto& cBounds = static_cast<const Acts::LineBounds&>(bounds);
        return std::make_shared<Trk::CylinderBounds>(cBounds.get(ParEnum_t::eR),
                                                     cBounds.get(ParEnum_t::eHalfLengthZ));
      } default:
          break;
      
    }
    THROW_EXCEPTION("The bounds "<<bounds<<" cannot be translated");
    return nullptr;
}
 
 
bool ActsToTrkConverterTool::actsTrackParameterPositionCheck(
    const Acts::BoundTrackParameters &parameters,
    const Trk::TrackParameters &trkparameters,
    const Acts::GeometryContext &gctx) const {
  auto actsPos = parameters.position(gctx);
  // ATH_MSG_VERBOSE("Acts position: \n"
  //                   << actsPos << " vs trk position: \n"
  //                   << trkparameters.position());
  // ATH_MSG_VERBOSE(parameters.referenceSurface().toString(gctx));
  // ATH_MSG_VERBOSE("GeometryId "<<parameters.referenceSurface().geometryId().value());  
 
  if ( (actsPos - trkparameters.position()).mag() > 0.1) {
    ATH_MSG_WARNING("Parameter position mismatch. Acts \n"
                    << actsPos << " vs Trk \n"
                    << trkparameters.position());
    ATH_MSG_WARNING("Acts surface:");
    ATH_MSG_WARNING(parameters.referenceSurface().toString(gctx));
    ATH_MSG_WARNING("Trk surface:");
    ATH_MSG_WARNING(trkparameters.associatedSurface());
    return false;
  }
  return true;
}
 
// Local functions to check/debug Annulus bounds
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-function"
static void ActsMeasurementCheck(
    const Acts::GeometryContext &gctx, const Trk::MeasurementBase &measurement,
    const Acts::Surface &surface, const Acts::BoundVector &loc) {
  const Trk::Surface &surf = measurement.associatedSurface();
  // only check Annulus for the moment
  if (surf.bounds().type() != Trk::SurfaceBounds::Annulus) {
    return;
  }
  const auto *bounds = dynamic_cast<const Trk::AnnulusBounds *>(&surf.bounds());
  if (bounds == nullptr) {
    throw std::runtime_error{"Annulus but not XY"};
  }
 
  Amg::Vector2D locxy = loc.head<2>();
 
  Acts::Matrix<2, 2> covxy = measurement.localCovariance();
 
  Amg::Vector3D global = surf.localToGlobal(locxy, Amg::Vector3D{});
  Acts::Vector2 locpc;
  if (auto res = surface.globalToLocal(gctx, global, Acts::Vector3{});
      res.ok()) {
    locpc = *res;
  } else {
    throw std::runtime_error{"Global position not on target surface"};
  }
 
  // use ACTS jacobian math to convert cluster covariance from cartesian to
  // polar
  auto planeSurface =
      Acts::Surface::makeShared<Acts::PlaneSurface>(surf.transform());
  Acts::BoundVector locxypar;
  locxypar.head<2>() = locxy;
  locxypar[2] = 0;
  locxypar[3] = M_PI_2;
  locxypar[4] = 1;
  locxypar[5] = 1;
  Acts::FreeVector globalxypar = Acts::transformBoundToFreeParameters(
  *planeSurface, gctx, locxypar);
  auto boundToFree = planeSurface->boundToFreeJacobian(
        gctx, globalxypar.segment<3>(Acts::eFreePos0),
        globalxypar.segment<3>(Acts::eFreeDir0));
  Acts::SquareMatrix<2> xyToXyzJac = boundToFree.topLeftCorner<2, 2>();
 
  Acts::BoundVector locpcpar;
  locpcpar.head<2>() = locpc;
  locpcpar[2] = 0;
  locpcpar[3] = M_PI_2;
  locpcpar[4] = 1;
  locpcpar[5] = 1;
  Acts::FreeVector globalpcpar = Acts::transformBoundToFreeParameters(
  surface, gctx, locpcpar);
 
  boundToFree = surface.boundToFreeJacobian(
        gctx, globalpcpar.segment<3>(Acts::eFreePos0),
  globalpcpar.segment<3>(Acts::eFreeDir0));
  Acts::SquareMatrix<2> pcToXyzJac = boundToFree.topLeftCorner<2, 2>();
  Acts::SquareMatrix<2> xyzToPcJac = pcToXyzJac.inverse();
 
  // convert cluster covariance
  Acts::SquareMatrix<2> covpc = covxy;
  covpc = xyToXyzJac * covpc * xyToXyzJac.transpose();
  covpc = xyzToPcJac * covpc * xyzToPcJac.transpose();
 
  std::mt19937 gen{42 + surface.geometryId().value()};
  std::normal_distribution<double> normal{0, 1};
  std::uniform_real_distribution<double> uniform{-1, 1};
 
  Acts::SquareMatrix<2> lltxy = covxy.llt().matrixL();
  Acts::SquareMatrix<2> lltpc = covpc.llt().matrixL();
 
  for (size_t i = 0; i < 1e4; i++) {
    std::cout << "ANNULUS COV: ";
    std::cout << surface.geometryId();
 
    Amg::Vector2D rnd{normal(gen), normal(gen)};
 
    // XY
    {
      Amg::Vector2D xy = lltxy * rnd + locxy;
      Amg::Vector3D xyz = surf.localToGlobal(xy);
      std::cout << "," << xy.x() << "," << xy.y();
      std::cout << "," << xyz.x() << "," << xyz.y() << "," << xyz.z();
    }
    // PC
    {
      // Amg::Vector2D xy = lltpc * rnd + loc.head<2>();
      Amg::Vector2D rt = lltpc * rnd + locpc;
      Amg::Vector3D xyz = surface.localToGlobal(gctx, rt, Acts::Vector3{});
      // Amg::Vector3D xyz = surface.transform(gctx).rotation() *
      // Acts::Vector3{rt.x(), rt.y(), 0};
 
      std::cout << "," << rt.x() << "," << rt.y();
      std::cout << "," << xyz.x() << "," << xyz.y() << "," << xyz.z();
    }
 
    std::cout << std::endl;
  }
}
#pragma GCC diagnostic pop
 
void ActsTrackParameterCheck(
    const Acts::BoundTrackParameters &actsParameter,
    const Acts::GeometryContext &gctx, const Acts::BoundMatrix &covpc,
    const Acts::BoundVector &targetPars, const Acts::BoundMatrix &targetCov,
    const Trk::PlaneSurface *planeSurface) {
 
  std::cout << "ANNULUS PAR COV: ";
  std::cout << actsParameter.referenceSurface().geometryId();
  for (unsigned int i = 0; i < 5; i++) {
    for (unsigned int j = 0; j < 5; j++) {
      std::cout << "," << covpc(i, j);
    }
  }
  for (unsigned int i = 0; i < 5; i++) {
    for (unsigned int j = 0; j < 5; j++) {
      std::cout << "," << targetCov(i, j);
    }
  }
  std::cout << std::endl;
 
  std::mt19937 gen{4242 +
                   actsParameter.referenceSurface().geometryId().value()};
  std::normal_distribution<double> normal{0, 1};
 
  Acts::SquareMatrix<2> lltxy =
      targetCov.topLeftCorner<2, 2>().llt().matrixL();
  Acts::SquareMatrix<2> lltpc = covpc.topLeftCorner<2, 2>().llt().matrixL();
 
  for (size_t i = 0; i < 1e4; i++) {
    std::cout << "ANNULUS PAR: ";
    std::cout << actsParameter.referenceSurface().geometryId();
 
    Acts::Vector<2> rnd;
    rnd << normal(gen), normal(gen);
 
    // XY
    {
      Acts::Vector<2> xy =
          lltxy.topLeftCorner<2, 2>() * rnd + targetPars.head<2>();
      Amg::Vector3D xyz;
      planeSurface->localToGlobal(Amg::Vector2D{xy.head<2>()}, Amg::Vector3D{},
                                  xyz);
      for (unsigned int i = 0; i < 2; i++) {
        std::cout << "," << xy[i];
      }
      std::cout << "," << xyz.x() << "," << xyz.y() << "," << xyz.z();
    }
    // PC
    {
      Acts::Vector<2> rt = lltpc.topLeftCorner<2, 2>() * rnd +
                               actsParameter.parameters().head<2>();
      Amg::Vector3D xyz = actsParameter.referenceSurface().localToGlobal(
          gctx, Acts::Vector2{rt.head<2>()}, Acts::Vector3{});
 
      for (unsigned int i = 0; i < 2; i++) {
        std::cout << "," << rt[i];
      }
      std::cout << "," << xyz.x() << "," << xyz.y() << "," << xyz.z();
    }
 
    std::cout << std::endl;
  }
}
 
std::unique_ptr<Trk::Track> ActsToTrkConverterTool::convertFitResult(const EventContext& ctx,
                                                                     TrackFitResult_t& fitResult,
                                                                     const Trk::TrackInfo::TrackFitter fitAuthor,
                                                                     const detail::SourceLinkType slType) const {
 
    if (not fitResult.ok()) {
      ATH_MSG_VERBOSE("Fit did not converge");  
      return nullptr;    
    }
    return convertActsTrack(ctx, fitResult.value(), fitAuthor, slType);
}
 
template <typename Proxy_t>
  std::unique_ptr<Trk::Track> 
    ActsToTrkConverterTool::convertActsTrack(const EventContext& ctx,
                                             const Proxy_t& acts_track,
                                             const Trk::TrackInfo::TrackFitter fitAuthor,
                                             const detail::SourceLinkType slType) const{
 
 
    const Acts::CalibrationContext cctx{getCalibrationContext(ctx)};
    const Acts::GeometryContext gctx{m_trackingGeometryTool->getGeometryContext(ctx).context()};
   
    auto finalTrajectory = std::make_unique<Trk::TrackStates>();
    int nDoF{0};
 
    double chi2{0};
 
    // Loop over all the output state to create track state
    acts_track.container().trackStateContainer().visitBackwards(acts_track.tipIndex(), 
      [&] (const auto &state) -> void {
        if (!state.hasReferenceSurface()) {
          return;
        }
        // First only consider state with an associated detector element
        if (!m_convertMaterial && !state.referenceSurface().isSensitive()) {
          return;
        }
 
        if (const auto* associatedDetEl = dynamic_cast<const IDetectorElementBase*>(
                                        state.referenceSurface().surfacePlacement());
            associatedDetEl != nullptr) {
            ATH_MSG_VERBOSE("Associated det: "<<associatedDetEl->detectorType());
        }
 
        auto flag = state.typeFlags();
    
        // We need to determine the type of state 
        TrkTSOSMask typePattern;
        std::unique_ptr<Trk::TrackParameters> trkPars = actsTrackParametersToTrkParameters(ctx, 
                                                              acts_track.createParametersFromState(state), gctx);
        std::unique_ptr<Trk::MeasurementBase> trkMeasurement{};
    
        // State is a hole (no associated measurement), use predicted parameters   
        if (flag.isHole()) {
          if (!m_convertHoles) { return; }
          typePattern.set(Trk::TrackStateOnSurface::Hole);
        } if (flag.isOutlier()) {
          if (!m_convertOutliers) { return; }
          typePattern.set(Trk::TrackStateOnSurface::Outlier);
        } if (flag.hasMeasurement()) {
          typePattern.set(Trk::TrackStateOnSurface::Measurement);
          nDoF = state.calibratedSize();
          chi2 = state.chi2();
          switch (slType) {
              using enum detail::SourceLinkType;
              case TrkMeasurement: 
                trkMeasurement = m_measCalib.unpack(state.getUncalibratedSourceLink())->uniqueClone();
                break;
              case TrkPrepRawData:
                trkMeasurement = m_prdCalib.createROT(gctx, cctx, state.getUncalibratedSourceLink(), state);
                break;
              case xAODUnCalibMeas:
                  appendMeasTSOS(ctx, detail::xAODUncalibMeasCalibrator::unpack(state.getUncalibratedSourceLink()),
                                 typePattern, Trk::FitQualityOnSurface{chi2, nDoF}, 
                                 std::move(trkPars), *finalTrajectory);
                  return;
              default:
                THROW_EXCEPTION("Invalid "<<slType<<" type parsed.");
          }
        }
        auto perState = std::make_unique<Trk::TrackStateOnSurface>(Trk::FitQualityOnSurface{chi2, nDoF},
                                                                   std::move(trkMeasurement), 
                                                                   std::move(trkPars), nullptr, typePattern);
        // If a state was succesfully created add it to the trajectory 
        ATH_MSG_VERBOSE("State succesfully created, adding it to the trajectory");
        finalTrajectory->insert(finalTrajectory->begin(), std::move(perState));
      });
      // Convert the perigee state and add it to the trajectory
      std::unique_ptr<Trk::TrackParameters> per = actsTrackParametersToTrkParameters(ctx, acts_track.createParametersAtReference(), gctx);
      TrkTSOSMask typePattern;
      typePattern.set(Trk::TrackStateOnSurface::Perigee);
      finalTrajectory->insert(finalTrajectory->begin(), 
                              std::make_unique<Trk::TrackStateOnSurface>(nullptr, std::move(per), nullptr, typePattern));
    
      // Create the track using the states
      Trk::TrackInfo newInfo{fitAuthor, ParticleHypothesis::convertTrk(acts_track.particleHypothesis())};
      auto newtrack = std::make_unique<Trk::Track>(newInfo, std::move(finalTrajectory), nullptr);
      constexpr bool suppressHoleSearch = false;
      m_trkSummaryTool->updateTrackSummary(ctx, *newtrack, suppressHoleSearch);
      return newtrack;
  }
 
  std::unique_ptr<TrackCollection> 
    ActsToTrkConverterTool::convertActsToTrkContainer(const EventContext& ctx,
                                                      const ActsTrk::TrackContainer& trackCont) const {
      auto outColl = std::make_unique<TrackCollection>();
      for (const ActsTrk::TrackContainer::ConstTrackProxy& trk : trackCont) {
          outColl->push_back(convertActsTrack(ctx, trk, m_fitAuthor, m_slType));
      }
      return outColl;
  }
  void ActsToTrkConverterTool::appendMeasTSOS(const EventContext& ctx,
                                              const xAOD::UncalibratedMeasurement* meas,
                                              const TrkTSOSMask typePattern,
                                              Trk::FitQualityOnSurface&& quality,
                                              std::unique_ptr<Trk::TrackParameters> trkPars,
                                              Trk::TrackStates& states) const {
    std::unique_ptr<Trk::MeasurementBase> rot{};
    switch (meas->type()) {
        using enum xAOD::UncalibMeasType;
        case PixelClusterType: {
          static const SG::AuxElement::ConstAccessor<ElementLink<InDet::PixelClusterCollection>> acc_pixelLink("pixelClusterLink");
          if (acc_pixelLink.isAvailable(*meas) && acc_pixelLink(*meas).isValid()) {
              rot.reset(m_ROTcreator->correct(**acc_pixelLink(*meas), *trkPars, ctx));
          }
          break;
        } case StripClusterType: {
          static const SG::AuxElement::ConstAccessor<ElementLink<InDet::SCT_ClusterCollection>> acc_stripLink("sctClusterLink");
          if (acc_stripLink.isAvailable(*meas) && acc_stripLink(*meas).isValid()) {
              rot.reset(m_ROTcreator->correct(**acc_stripLink(*meas), *trkPars, ctx));
          }
          break;
        } case MdtDriftCircleType:
        case MMClusterType: {
            const Identifier& id = static_cast<const xAOD::MuonMeasurement*>(meas)->identify();
            const IdentifierHash modHash = m_idHelperSvc->moduleHash(id);
            const auto* prd =  meas->type() == MdtDriftCircleType ?  fetchPrd(ctx, m_keyMdt, id, modHash) 
                                                                  :  fetchPrd(ctx, m_keyMm, id, modHash);
            assert(prd != nullptr);
            rot.reset(m_ROTcreator->correct(*prd, *trkPars, ctx));
            break;
        } case TgcStripType:
          case RpcStripType:
          case sTgcStripType: {
            const Identifier& id = static_cast<const xAOD::MuonMeasurement*>(meas)->identify();
            const IdentifierHash modHash = m_idHelperSvc->moduleHash(id);
            const Trk::PrepRawData* prd{nullptr}, *prd1{nullptr};
 
            if (meas->numDimensions() == 0) {
              const auto* muonMeas = static_cast<const xAOD::CombinedMuonStrip*>(meas);
              if (meas->type() == RpcStripType) {
                prd  = fetchPrd(ctx, m_keyRpc, id, modHash);
                prd1 = fetchPrd(ctx, m_keyRpc, muonMeas->secondaryStrip()->identify(), modHash);
              } else if (meas->type() == TgcStripType) {
                prd = fetchPrd(ctx, m_keyTgc, id, modHash);
                prd1 = fetchPrd(ctx, m_keyTgc, muonMeas->secondaryStrip()->identify(), modHash);
              } else {
                prd  = fetchPrd(ctx, m_keyStgc, id, modHash);
                prd1 = fetchPrd(ctx, m_keyStgc, muonMeas->secondaryStrip()->identify(), modHash);
              }
              assert(prd != nullptr);
              assert(prd1 != nullptr);

              const Trk::Surface& phiSurface = prd1->detectorElement()->surface(prd1->identify());
              auto phiPars = rotateParams(*trkPars, phiSurface);
              assert(phiPars != nullptr);
              std::unique_ptr<Trk::MeasurementBase> phiRot{};
              if (meas->type() != sTgcStripType) {
                phiRot = m_compRotCreator->createBroadCluster(std::list{prd1}, 1.);
                rot = m_compRotCreator->createBroadCluster(std::list{prd}, 1.);
              } else {
                phiRot.reset(m_ROTcreator->correct(*prd1, *phiPars, ctx));
                rot.reset(m_ROTcreator->correct(*prd, *trkPars, ctx));
              }
              assert(phiRot != nullptr);
              states.insert(states.begin(),
                            std::make_unique<Trk::TrackStateOnSurface>(quality, 
                                                                       std::move(phiRot), 
                                                                       std::move(phiPars), nullptr, typePattern));
            } else {
              const auto* prd  = meas->type() == RpcStripType ? fetchPrd(ctx, m_keyRpc, id, modHash)
                                                              :
                                meas->type() == TgcStripType ? fetchPrd(ctx, m_keyTgc, id, modHash)
                                                             : fetchPrd(ctx, m_keyStgc, id, modHash);
              assert(prd != nullptr);
              // Track parameter representation needs to change towards a phi surface
              if (m_idHelperSvc->measuresPhi(id)) {
                  ATH_MSG_VERBOSE("Convert the track parameters "<<m_idHelperSvc->toString(id)
                                <<", "<<m_idHelperSvc->toStringDetEl(prd->detectorElement()->identify()));
                  const Trk::Surface& target = prd->detectorElement()->surface(id);
                  trkPars = rotateParams(*trkPars, target);
              }
              rot.reset(m_ROTcreator->correct(*prd, *trkPars, ctx));
            }
            break;
        } default:
          ATH_MSG_WARNING("Measurement type "<<meas->type()<<" is not implemented");
          return;
    }
    assert(rot != nullptr);
    assert(trkPars != nullptr);
    states.insert(states.begin(),
                  std::make_unique<Trk::TrackStateOnSurface>(std::move(quality), std::move(rot), 
                                                             std::move(trkPars), nullptr, typePattern));
 
  }
  template <typename PrdType_t>
  const Trk::PrepRawData* ActsToTrkConverterTool::fetchPrd(const EventContext& ctx,
                                                           const SG::ReadHandleKey<PrdType_t>& key,
                                                           const Identifier& prdId,
                                                           const IdentifierHash& hash) const{
      const PrdType_t* container{nullptr};
      if (key.empty() || !SG::get(container, key, ctx).isSuccess()) {
          THROW_EXCEPTION("Failed to retrieve container "<<key.fullKey());
      }
      const auto* coll = container->indexFindPtr(hash);
      if (coll == nullptr){
          ATH_MSG_WARNING("fetchPrd() - Failed to find a valid collection for "<<prdId.getString()<<", key: "<<key.fullKey());
          return nullptr;
      }
      for (const Trk::PrepRawData* prd : *coll) {
          if (prd->identify() == prdId) {
              return prd;
          }
      }
      ATH_MSG_WARNING("fetchPrd() - Prep data object "<<prdId.getString()<<" is not in "<<key.fullKey());
      return nullptr;
  }
}  // namespace ActsTrk