diff --git a/Core/include/Acts/EventData/MultiTrajectory.hpp b/Core/include/Acts/EventData/MultiTrajectory.hpp
index fa9824abe97..0caf463913c 100644
--- a/Core/include/Acts/EventData/MultiTrajectory.hpp
+++ b/Core/include/Acts/EventData/MultiTrajectory.hpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2019-2020 CERN for the benefit of the Acts project
+// Copyright (C) 2019-2024 CERN for the benefit of the Acts project
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -148,6 +148,7 @@ struct IsReadOnlyMultiTrajectory;
 /// iterating over specific sub-components.
 template <typename derived_t>
 class MultiTrajectory {
+ public:
   using Derived = derived_t;
 
   static constexpr bool ReadOnly = IsReadOnlyMultiTrajectory<Derived>::value;
@@ -161,7 +162,6 @@ class MultiTrajectory {
   template <typename T>
   friend class MultiTrajectory;
 
- public:
   /// Alias for the const version of a track state proxy, with the same
   /// backends as this container
   using ConstTrackStateProxy =
@@ -461,62 +461,103 @@ class MultiTrajectory {
   }
 
   /// Retrieve a jacobian proxy instance for a jacobian at a given index
-  /// @param jacIdx Index into the jacobian column
+  /// @param istate The track state
   /// @return Mutable proxy
   template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
-  typename TrackStateProxy::Covariance jacobian(IndexType jacIdx) {
-    return self().jacobian_impl(jacIdx);
+  typename TrackStateProxy::Covariance jacobian(IndexType istate) {
+    return self().jacobian_impl(istate);
   }
 
   /// Retrieve a jacobian proxy instance for a jacobian at a given index
-  /// @param jacIdx Index into the jacobian column
+  /// @param istate The track state
   /// @return Const proxy
-  typename ConstTrackStateProxy::Covariance jacobian(IndexType jacIdx) const {
-    return self().jacobian_impl(jacIdx);
+  typename ConstTrackStateProxy::Covariance jacobian(IndexType istate) const {
+    return self().jacobian_impl(istate);
   }
 
-  /// Retrieve a measurement proxy instance for a measurement at a given index
+  /// Retrieve a calibrated measurement proxy instance for a measurement at a
+  /// given index
   /// @tparam measdim the measurement dimension
-  /// @param measIdx Index into the measurement column
+  /// @param istate The track state
   /// @return Mutable proxy
   template <std::size_t measdim, bool RO = ReadOnly,
             typename = std::enable_if_t<!RO>>
-  typename TrackStateProxy::template Measurement<measdim> measurement(
-      IndexType measIdx) {
-    return self().template measurement_impl<measdim>(measIdx);
+  typename TrackStateProxy::template Calibrated<measdim> calibrated(
+      IndexType istate) {
+    return self().template calibrated_impl<measdim>(istate);
   }
 
-  /// Retrieve a measurement proxy instance for a measurement at a given index
+  /// Retrieve a calibrated measurement proxy instance for a measurement at a
+  /// given index
   /// @tparam measdim the measurement dimension
-  /// @param measIdx Index into the measurement column
+  /// @param istate The track state
   /// @return Const proxy
   template <std::size_t measdim>
-  typename ConstTrackStateProxy::template Measurement<measdim> measurement(
-      IndexType measIdx) const {
-    return self().template measurement_impl<measdim>(measIdx);
+  typename ConstTrackStateProxy::template Calibrated<measdim> calibrated(
+      IndexType istate) const {
+    return self().template calibrated_impl<measdim>(istate);
   }
 
-  /// Retrieve a measurement covariance proxy instance for a measurement at a
-  /// given index
+  /// Retrieve a calibrated measurement covariance proxy instance for a
+  /// measurement at a given index
   /// @tparam measdim the measurement dimension
-  /// @param covIdx Index into the measurement covariance column
+  /// @param istate The track state
   /// @return Mutable proxy
   template <std::size_t measdim, bool RO = ReadOnly,
             typename = std::enable_if_t<!RO>>
-  typename TrackStateProxy::template MeasurementCovariance<measdim>
-  measurementCovariance(IndexType covIdx) {
-    return self().template measurementCovariance_impl<measdim>(covIdx);
+  typename TrackStateProxy::template CalibratedCovariance<measdim>
+  calibratedCovariance(IndexType istate) {
+    return self().template calibratedCovariance_impl<measdim>(istate);
   }
 
-  /// Retrieve a measurement covariance proxy instance for a measurement at a
-  /// given index
-  /// @param covIdx Index into the measurement covariance column
+  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
+  typename TrackStateProxy::EffectiveCalibrated effectiveCalibrated(
+      IndexType istate) {
+    // This abuses an incorrectly sized vector / matrix to access the
+    // data pointer! This works (don't use the matrix as is!), but be
+    // careful!
+    return typename TrackStateProxy::EffectiveCalibrated{
+        calibrated<eBoundSize>(istate).data(), calibratedSize(istate)};
+  }
+
+  typename ConstTrackStateProxy::EffectiveCalibrated effectiveCalibrated(
+      IndexType istate) const {
+    // This abuses an incorrectly sized vector / matrix to access the
+    // data pointer! This works (don't use the matrix as is!), but be
+    // careful!
+    return typename ConstTrackStateProxy::EffectiveCalibrated{
+        calibrated<eBoundSize>(istate).data(), calibratedSize(istate)};
+  }
+
+  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
+  typename TrackStateProxy::EffectiveCalibratedCovariance
+  effectiveCalibratedCovariance(IndexType istate) {
+    // This abuses an incorrectly sized vector / matrix to access the
+    // data pointer! This works (don't use the matrix as is!), but be
+    // careful!
+    return typename TrackStateProxy::EffectiveCalibratedCovariance{
+        calibratedCovariance<eBoundSize>(istate).data(), calibratedSize(istate),
+        calibratedSize(istate)};
+  }
+
+  typename ConstTrackStateProxy::EffectiveCalibratedCovariance
+  effectiveCalibratedCovariance(IndexType istate) const {
+    // This abuses an incorrectly sized vector / matrix to access the
+    // data pointer! This works (don't use the matrix as is!), but be
+    // careful!
+    return typename ConstTrackStateProxy::EffectiveCalibratedCovariance{
+        calibratedCovariance<eBoundSize>(istate).data(), calibratedSize(istate),
+        calibratedSize(istate)};
+  }
+
+  /// Retrieve a calibrated measurement covariance proxy instance for a
+  /// measurement at a given index
+  /// @param istate The track state
   /// @return Const proxy
   template <std::size_t measdim>
-  constexpr
-      typename ConstTrackStateProxy::template MeasurementCovariance<measdim>
-      measurementCovariance(IndexType covIdx) const {
-    return self().template measurementCovariance_impl<measdim>(covIdx);
+  typename ConstTrackStateProxy::template CalibratedCovariance<measdim>
+  calibratedCovariance(IndexType istate) const {
+    return self().template calibratedCovariance_impl<measdim>(istate);
   }
 
   /// Get the calibrated measurement size for a track state
diff --git a/Core/include/Acts/EventData/MultiTrajectoryBackendConcept.hpp b/Core/include/Acts/EventData/MultiTrajectoryBackendConcept.hpp
index 06f46a4137d..5e5b41ed75d 100644
--- a/Core/include/Acts/EventData/MultiTrajectoryBackendConcept.hpp
+++ b/Core/include/Acts/EventData/MultiTrajectoryBackendConcept.hpp
@@ -21,11 +21,13 @@
 #include <type_traits>
 
 #if defined(__cpp_concepts)
+
 #include <concepts>
 
 namespace Acts {
 
 namespace detail {
+
 using Parameters = Eigen::Map<BoundVector>;
 using Covariance = Eigen::Map<BoundMatrix>;
 
@@ -59,11 +61,11 @@ concept CommonMultiTrajectoryBackend = requires(const T& cv, HashedString key,
   { cv.jacobian_impl(istate) } -> std::same_as<detail::ConstCovariance>;
 
   {
-    cv.template measurement_impl<2>(istate)
+    cv.template calibrated_impl<2>(istate)
     } -> std::same_as<Eigen::Map<const ActsVector<2>>>;
 
   {
-    cv.template measurementCovariance_impl<2>(istate)
+    cv.template calibratedCovariance_impl<2>(istate)
     } -> std::same_as<Eigen::Map<const ActsSquareMatrix<2>>>;
 
   { cv.has_impl(key, istate) } -> std::same_as<bool>;
@@ -88,11 +90,11 @@ concept ConstMultiTrajectoryBackend = CommonMultiTrajectoryBackend<T> &&
   { v.jacobian_impl(istate) } -> std::same_as<detail::ConstCovariance>;
 
   {
-    v.template measurement_impl<2>(istate)
+    v.template calibrated_impl<2>(istate)
     } -> std::same_as<Eigen::Map<const ActsVector<2>>>;
 
   {
-    v.template measurementCovariance_impl<2>(istate)
+    v.template calibratedCovariance_impl<2>(istate)
     } -> std::same_as<Eigen::Map<const ActsSquareMatrix<2>>>;
 };
 
@@ -108,11 +110,11 @@ concept MutableMultiTrajectoryBackend = CommonMultiTrajectoryBackend<T> &&
   { v.jacobian_impl(istate) } -> std::same_as<detail::Covariance>;
 
   {
-    v.template measurement_impl<2>(istate)
+    v.template calibrated_impl<2>(istate)
     } -> std::same_as<Eigen::Map<ActsVector<2>>>;
 
   {
-    v.template measurementCovariance_impl<2>(istate)
+    v.template calibratedCovariance_impl<2>(istate)
     } -> std::same_as<Eigen::Map<ActsSquareMatrix<2>>>;
 
   { v.addTrackState_impl() } -> std::same_as<TrackIndexType>;
@@ -142,4 +144,5 @@ concept MutableMultiTrajectoryBackend = CommonMultiTrajectoryBackend<T> &&
 };
 
 }  // namespace Acts
+
 #endif
diff --git a/Core/include/Acts/EventData/TrackProxy.hpp b/Core/include/Acts/EventData/TrackProxy.hpp
index 9a19cf88ace..38e4348c1a0 100644
--- a/Core/include/Acts/EventData/TrackProxy.hpp
+++ b/Core/include/Acts/EventData/TrackProxy.hpp
@@ -193,20 +193,20 @@ class TrackProxy {
   /// Map-type for a bound parameter vector. This has reference semantics, i.e.
   /// points at a matrix by an internal pointer.
   using Parameters =
-      typename detail_lt::Types<eBoundSize, false>::CoefficientsMap;
+      typename detail_lt::FixedSizeTypes<eBoundSize, false>::CoefficientsMap;
 
   /// Same as @ref Parameters, but with const semantics
   using ConstParameters =
-      typename detail_lt::Types<eBoundSize, true>::CoefficientsMap;
+      typename detail_lt::FixedSizeTypes<eBoundSize, true>::CoefficientsMap;
 
   /// Map-type for a bound covariance. This has reference semantics, i.e.
   /// points at a matrix by an internal pointer.
   using Covariance =
-      typename detail_lt::Types<eBoundSize, false>::CovarianceMap;
+      typename detail_lt::FixedSizeTypes<eBoundSize, false>::CovarianceMap;
 
   /// Same as @ref Covariance, but with const semantics
   using ConstCovariance =
-      typename detail_lt::Types<eBoundSize, true>::CovarianceMap;
+      typename detail_lt::FixedSizeTypes<eBoundSize, true>::CovarianceMap;
 
 #ifndef DOXYGEN
   friend TrackContainer<Container, Trajectory, holder_t>;
diff --git a/Core/include/Acts/EventData/TrackStateProxy.hpp b/Core/include/Acts/EventData/TrackStateProxy.hpp
index ee0bdc6696f..5e56524007a 100644
--- a/Core/include/Acts/EventData/TrackStateProxy.hpp
+++ b/Core/include/Acts/EventData/TrackStateProxy.hpp
@@ -75,14 +75,14 @@ class TransitiveConstPointer {
   T* m_ptr;
 };
 
-/// Type construction helper for coefficients and associated covariances.
+/// Type construction helper for fixed size coefficients and associated
+/// covariances.
 template <std::size_t Size, bool ReadOnlyMaps = true>
-struct Types {
-  enum {
-    Flags = Eigen::ColMajor | Eigen::AutoAlign,
-  };
+struct FixedSizeTypes {
+  constexpr static auto Flags = Eigen::ColMajor | Eigen::AutoAlign;
 
   using Scalar = ActsScalar;
+
   // single items
   using Coefficients = Eigen::Matrix<Scalar, Size, 1, Flags>;
   using Covariance = Eigen::Matrix<Scalar, Size, Size, Flags>;
@@ -97,28 +97,52 @@ struct Types {
   using DynamicCovarianceMap =
       Eigen::Map<ConstIf<DynamicCovariance, ReadOnlyMaps>>;
 };
+
+// Type construction helper for dynamic sized coefficients and associated
+/// covariances.
+template <bool ReadOnlyMaps = true>
+struct DynamicSizeTypes {
+  constexpr static auto Flags = Eigen::ColMajor | Eigen::AutoAlign;
+
+  using Scalar = ActsScalar;
+
+  using Coefficients = Eigen::Matrix<Scalar, Eigen::Dynamic, 1, Flags>;
+  using Covariance =
+      Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Flags>;
+  using CoefficientsMap = Eigen::Map<ConstIf<Coefficients, ReadOnlyMaps>>;
+  using CovarianceMap = Eigen::Map<ConstIf<Covariance, ReadOnlyMaps>>;
+};
+
 }  // namespace detail_lt
 
 // This is public
 template <std::size_t M, bool ReadOnly = true>
 struct TrackStateTraits {
+  using Scalar = ActsScalar;
+
   using Parameters =
-      typename detail_lt::Types<eBoundSize, ReadOnly>::CoefficientsMap;
+      typename detail_lt::FixedSizeTypes<eBoundSize, ReadOnly>::CoefficientsMap;
   using Covariance =
-      typename detail_lt::Types<eBoundSize, ReadOnly>::CovarianceMap;
-  using Measurement = typename detail_lt::Types<M, ReadOnly>::CoefficientsMap;
-  using MeasurementCovariance =
-      typename detail_lt::Types<M, ReadOnly>::CovarianceMap;
+      typename detail_lt::FixedSizeTypes<eBoundSize, ReadOnly>::CovarianceMap;
+  using Calibrated =
+      typename detail_lt::FixedSizeTypes<M, ReadOnly>::CoefficientsMap;
+  using CalibratedCovariance =
+      typename detail_lt::FixedSizeTypes<M, ReadOnly>::CovarianceMap;
+  using EffectiveCalibrated =
+      typename detail_lt::DynamicSizeTypes<ReadOnly>::CoefficientsMap;
+  using EffectiveCalibratedCovariance =
+      typename detail_lt::DynamicSizeTypes<ReadOnly>::CovarianceMap;
 
   constexpr static auto ProjectorFlags = Eigen::RowMajor | Eigen::AutoAlign;
-  using Projector =
-      Eigen::Matrix<typename Covariance::Scalar, M, eBoundSize, ProjectorFlags>;
+  using Projector = Eigen::Matrix<Scalar, M, eBoundSize, ProjectorFlags>;
+  using EffectiveProjector = Eigen::Matrix<Scalar, Eigen::Dynamic, eBoundSize,
+                                           ProjectorFlags, M, eBoundSize>;
 };
 
 /// Proxy object to access a single point on the trajectory.
 ///
 /// @tparam SourceLink Type to link back to an original measurement
-/// @tparam M         Maximum number of measurement dimensions
+/// @tparam M          Maximum number of measurement dimensions
 /// @tparam read_only  true for read-only access to underlying storage
 template <typename trajectory_t, std::size_t M, bool read_only = true>
 class TrackStateProxy {
@@ -144,25 +168,43 @@ class TrackStateProxy {
   /// Same as @ref Covariance, but with const semantics
   using ConstCovariance = typename TrackStateTraits<M, true>::Covariance;
 
-  /// Map-type for a measurement vector, where the local measurement dimension
-  /// is variable.
+  /// Map-type for a calibrated measurement vector, where the local measurement
+  /// dimension is variable.
   template <std::size_t N>
-  using Measurement = typename TrackStateTraits<N, ReadOnly>::Measurement;
+  using Calibrated = typename TrackStateTraits<N, ReadOnly>::Calibrated;
 
-  /// Same as @c Measurement, but with const semantics
+  /// Same as @c Calibrated, but with const semantics
   template <std::size_t N>
-  using ConstMeasurement = typename TrackStateTraits<N, true>::Measurement;
+  using ConstCalibrated = typename TrackStateTraits<N, true>::Calibrated;
 
-  /// Map-type for a measurement covariance matrix, where the local measurement
-  /// dimension is variable.
+  /// Map-type for a calibrated measurement covariance matrix, where the local
+  /// measurement dimension is variable.
   template <std::size_t N>
-  using MeasurementCovariance =
-      typename TrackStateTraits<N, ReadOnly>::MeasurementCovariance;
+  using CalibratedCovariance =
+      typename TrackStateTraits<N, ReadOnly>::CalibratedCovariance;
 
-  /// Same as @ref MeasurementCovariance, but with const semantics
+  /// Same as @ref CalibratedCovariance, but with const semantics
   template <std::size_t N>
-  using ConstMeasurementCovariance =
-      typename TrackStateTraits<N, true>::MeasurementCovariance;
+  using ConstCalibratedCovariance =
+      typename TrackStateTraits<N, true>::CalibratedCovariance;
+
+  /// Map-type for a measurement vector, where the local measurement dimension
+  /// is variable.
+  using EffectiveCalibrated =
+      typename TrackStateTraits<M, ReadOnly>::EffectiveCalibrated;
+
+  /// Same as @c EffectiveCalibrated, but with const semantics
+  using ConstEffectiveCalibrated =
+      typename TrackStateTraits<M, true>::EffectiveCalibrated;
+
+  /// Map-type for a measurement covariance matrix, where the local measurement
+  /// dimension is variable.
+  using EffectiveCalibratedCovariance =
+      typename TrackStateTraits<M, ReadOnly>::EffectiveCalibratedCovariance;
+
+  /// Same as @ref EffectiveCalibratedCovariance, but with const semantics
+  using ConstEffectiveCalibratedCovariance =
+      typename TrackStateTraits<M, true>::EffectiveCalibratedCovariance;
 
   /// The index type of the track state container
   using IndexType = TrackIndexType;
@@ -179,9 +221,7 @@ class TrackStateProxy {
   /// Dynamic variant of the projector matrix
   /// @warning Using this type is discouraged, as it has a runtime overhead
   using EffectiveProjector =
-      Eigen::Matrix<typename Projector::Scalar, Eigen::Dynamic, Eigen::Dynamic,
-                    TrackStateTraits<M, ReadOnly>::ProjectorFlags, M,
-                    eBoundSize>;
+      typename TrackStateTraits<M, ReadOnly>::EffectiveProjector;
 
   /// The track state container backend given as a template parameter
   using Trajectory = trajectory_t;
@@ -559,9 +599,6 @@ class TrackStateProxy {
   /// The projector matrix is packed as a bitset, which is converted to a matrix
   /// on-demand (and therefore returned by value).
   ///
-  /// A convenience function to assign this from the @ref Measurement class
-  /// is provided, although it's use is discouraged.
-  ///
   /// The track state also includes a @ref SourceLink which acts as a proxy
   /// to the original uncalibrated measurement that the calibrated measurement
   /// was derived from. It is set and returned by value, to allow unpacking /
@@ -674,9 +711,9 @@ class TrackStateProxy {
   /// @return The measurement vector
   /// @note Const version
   template <std::size_t measdim>
-  ConstMeasurement<measdim> calibrated() const {
+  ConstCalibrated<measdim> calibrated() const {
     assert(has<hashString("calibrated")>());
-    return m_traj->self().template measurement<measdim>(m_istate);
+    return m_traj->self().template calibrated<measdim>(m_istate);
   }
 
   /// Full calibrated measurement vector. Might contain additional zeroed
@@ -685,18 +722,18 @@ class TrackStateProxy {
   /// @note Mutable version
   template <std::size_t measdim, bool RO = ReadOnly,
             typename = std::enable_if_t<!RO>>
-  Measurement<measdim> calibrated() {
+  Calibrated<measdim> calibrated() {
     assert(has<hashString("calibrated")>());
-    return m_traj->self().template measurement<measdim>(m_istate);
+    return m_traj->self().template calibrated<measdim>(m_istate);
   }
 
   /// Const full calibrated measurement covariance matrix. The effective
   /// covariance is located in the top left corner, everything else is zeroed.
   /// @return The measurement covariance matrix
   template <std::size_t measdim>
-  ConstMeasurementCovariance<measdim> calibratedCovariance() const {
+  ConstCalibratedCovariance<measdim> calibratedCovariance() const {
     assert(has<hashString("calibratedCov")>());
-    return m_traj->self().template measurementCovariance<measdim>(m_istate);
+    return m_traj->self().template calibratedCovariance<measdim>(m_istate);
   }
 
   /// Mutable full calibrated measurement covariance matrix. The effective
@@ -704,77 +741,44 @@ class TrackStateProxy {
   /// @return The measurement covariance matrix
   template <std::size_t measdim, bool RO = ReadOnly,
             typename = std::enable_if_t<!RO>>
-  MeasurementCovariance<measdim> calibratedCovariance() {
+  CalibratedCovariance<measdim> calibratedCovariance() {
     assert(has<hashString("calibratedCov")>());
-    return m_traj->self().template measurementCovariance<measdim>(m_istate);
+    return m_traj->self().template calibratedCovariance<measdim>(m_istate);
   }
 
   /// Mutable dynamic measurement vector with only the valid dimensions.
   /// @warning The dynamic vector has a runtime overhead!
   /// @return The effective calibrated measurement vector
   template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
-  auto effectiveCalibrated() {
-    // repackage the data pointer to a dynamic map type
-    // workaround for gcc8 bug:
-    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=86594
-    auto* self = this;
-    return visit_measurement(calibratedSize(), [&](auto N) {
-      constexpr int kMeasurementSize = decltype(N)::value;
-      return typename detail_lt::Types<M, ReadOnly>::DynamicCoefficientsMap{
-          self->template calibrated<kMeasurementSize>().data(),
-          kMeasurementSize};
-    });
+  EffectiveCalibrated effectiveCalibrated() {
+    assert(has<hashString("calibrated")>());
+    return m_traj->self().effectiveCalibrated(m_istate);
   }
 
   /// Const dynamic measurement vector with only the valid dimensions.
   /// @warning The dynamic matrix has a runtime overhead!
   /// @return The effective calibrated measurement vector
-  auto effectiveCalibrated() const {
-    // repackage the data pointer to a dynamic map type
-    // workaround for gcc8 bug:
-    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=86594
-    auto* self = this;
-    return visit_measurement(calibratedSize(), [&](auto N) {
-      constexpr int kMeasurementSize = decltype(N)::value;
-      return typename detail_lt::Types<M, true>::DynamicCoefficientsMap{
-          self->template calibrated<kMeasurementSize>().data(),
-          kMeasurementSize};
-    });
+  ConstEffectiveCalibrated effectiveCalibrated() const {
+    assert(has<hashString("calibrated")>());
+    return m_traj->self().effectiveCalibrated(m_istate);
   }
 
   /// Mutable dynamic measurement covariance matrix with only the valid
   /// dimensions.
   /// @warning The dynamic matrix has a runtime overhead!
   /// @return The effective calibrated covariance matrix
-  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
-  auto effectiveCalibratedCovariance() {
-    // repackage the data pointer to a dynamic map type
-    // workaround for gcc8 bug:
-    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=86594
-    auto* self = this;
-    return visit_measurement(calibratedSize(), [&](auto N) {
-      constexpr int kMeasurementSize = decltype(N)::value;
-      return typename detail_lt::Types<M, ReadOnly>::DynamicCovarianceMap{
-          self->template calibratedCovariance<kMeasurementSize>().data(),
-          kMeasurementSize, kMeasurementSize};
-    });
+  EffectiveCalibratedCovariance effectiveCalibratedCovariance() {
+    assert(has<hashString("calibratedCov")>());
+    return m_traj->self().effectiveCalibratedCovariance(m_istate);
   }
 
   /// Const dynamic measurement covariance matrix with only the valid
   /// dimensions.
   /// @warning The dynamic matrix has a runtime overhead!
   /// @return The effective calibrated covariance matrix
-  auto effectiveCalibratedCovariance() const {
-    // repackage the data pointer to a dynamic map type
-    // workaround for gcc8 bug:
-    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=86594
-    auto* self = this;
-    return visit_measurement(calibratedSize(), [&](auto N) {
-      constexpr int kMeasurementSize = decltype(N)::value;
-      return typename detail_lt::Types<M, true>::DynamicCovarianceMap{
-          self->template calibratedCovariance<kMeasurementSize>().data(),
-          kMeasurementSize, kMeasurementSize};
-    });
+  ConstEffectiveCalibratedCovariance effectiveCalibratedCovariance() const {
+    assert(has<hashString("calibratedCov")>());
+    return m_traj->self().effectiveCalibratedCovariance(m_istate);
   }
 
   /// Return the (dynamic) number of dimensions stored for this measurement.
diff --git a/Core/include/Acts/EventData/TrackStateProxyConcept.hpp b/Core/include/Acts/EventData/TrackStateProxyConcept.hpp
index f1696c1f4fe..2cf1971ea63 100644
--- a/Core/include/Acts/EventData/TrackStateProxyConcept.hpp
+++ b/Core/include/Acts/EventData/TrackStateProxyConcept.hpp
@@ -54,9 +54,8 @@ using ConstDynamicMeasurementCovariance = Eigen::Map<
 constexpr static auto ProjectorFlags = Eigen::RowMajor | Eigen::AutoAlign;
 using Projector = Eigen::Matrix<typename Covariance::Scalar, eBoundSize,
                                 eBoundSize, ProjectorFlags>;
-
 using EffectiveProjector =
-    Eigen::Matrix<typename Projector::Scalar, Eigen::Dynamic, Eigen::Dynamic,
+    Eigen::Matrix<typename Projector::Scalar, Eigen::Dynamic, eBoundSize,
                   ProjectorFlags, eBoundSize, eBoundSize>;
 
 }  // namespace detail
diff --git a/Core/include/Acts/EventData/VectorMultiTrajectory.hpp b/Core/include/Acts/EventData/VectorMultiTrajectory.hpp
index 6c7ae3257da..6707525c7f8 100644
--- a/Core/include/Acts/EventData/VectorMultiTrajectory.hpp
+++ b/Core/include/Acts/EventData/VectorMultiTrajectory.hpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2022 CERN for the benefit of the Acts project
+// Copyright (C) 2022-2024 CERN for the benefit of the Acts project
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -316,15 +316,16 @@ class VectorMultiTrajectoryBase {
   std::vector<IndexData> m_index;
   std::vector<IndexType> m_previous;
   std::vector<IndexType> m_next;
-  std::vector<typename detail_lt::Types<eBoundSize>::Coefficients> m_params;
-  std::vector<typename detail_lt::Types<eBoundSize>::Covariance> m_cov;
+  std::vector<typename detail_lt::FixedSizeTypes<eBoundSize>::Coefficients>
+      m_params;
+  std::vector<typename detail_lt::FixedSizeTypes<eBoundSize>::Covariance> m_cov;
 
   std::vector<double> m_meas;
   std::vector<MultiTrajectoryTraits::IndexType> m_measOffset;
   std::vector<double> m_measCov;
   std::vector<MultiTrajectoryTraits::IndexType> m_measCovOffset;
 
-  std::vector<typename detail_lt::Types<eBoundSize>::Covariance> m_jac;
+  std::vector<typename detail_lt::FixedSizeTypes<eBoundSize>::Covariance> m_jac;
   std::vector<std::optional<SourceLink>> m_sourceLinks;
   std::vector<ProjectorBitset> m_projectors;
 
@@ -394,30 +395,30 @@ class VectorMultiTrajectory final
   }
 
   template <std::size_t measdim>
-  TrackStateProxy::Measurement<measdim> measurement_impl(IndexType istate) {
+  TrackStateProxy::Calibrated<measdim> calibrated_impl(IndexType istate) {
     IndexType offset = m_measOffset[istate];
-    return TrackStateProxy::Measurement<measdim>{&m_meas[offset]};
+    return TrackStateProxy::Calibrated<measdim>{&m_meas[offset]};
   }
 
   template <std::size_t measdim>
-  ConstTrackStateProxy::Measurement<measdim> measurement_impl(
+  ConstTrackStateProxy::Calibrated<measdim> calibrated_impl(
       IndexType istate) const {
     IndexType offset = m_measOffset[istate];
-    return ConstTrackStateProxy::Measurement<measdim>{&m_meas[offset]};
+    return ConstTrackStateProxy::Calibrated<measdim>{&m_meas[offset]};
   }
 
   template <std::size_t measdim>
-  TrackStateProxy::MeasurementCovariance<measdim> measurementCovariance_impl(
+  TrackStateProxy::CalibratedCovariance<measdim> calibratedCovariance_impl(
       IndexType istate) {
     IndexType offset = m_measCovOffset[istate];
-    return TrackStateProxy::MeasurementCovariance<measdim>{&m_measCov[offset]};
+    return TrackStateProxy::CalibratedCovariance<measdim>{&m_measCov[offset]};
   }
 
   template <std::size_t measdim>
-  ConstTrackStateProxy::MeasurementCovariance<measdim>
-  measurementCovariance_impl(IndexType istate) const {
+  ConstTrackStateProxy::CalibratedCovariance<measdim> calibratedCovariance_impl(
+      IndexType istate) const {
     IndexType offset = m_measCovOffset[istate];
-    return ConstTrackStateProxy::MeasurementCovariance<measdim>{
+    return ConstTrackStateProxy::CalibratedCovariance<measdim>{
         &m_measCov[offset]};
   }
 
@@ -548,17 +549,17 @@ class ConstVectorMultiTrajectory final
   }
 
   template <std::size_t measdim>
-  ConstTrackStateProxy::Measurement<measdim> measurement_impl(
+  ConstTrackStateProxy::Calibrated<measdim> calibrated_impl(
       IndexType istate) const {
     IndexType offset = m_measOffset[istate];
-    return ConstTrackStateProxy::Measurement<measdim>{&m_meas[offset]};
+    return ConstTrackStateProxy::Calibrated<measdim>{&m_meas[offset]};
   }
 
   template <std::size_t measdim>
-  ConstTrackStateProxy::MeasurementCovariance<measdim>
-  measurementCovariance_impl(IndexType istate) const {
+  ConstTrackStateProxy::CalibratedCovariance<measdim> calibratedCovariance_impl(
+      IndexType istate) const {
     IndexType offset = m_measCovOffset[istate];
-    return ConstTrackStateProxy::MeasurementCovariance<measdim>{
+    return ConstTrackStateProxy::CalibratedCovariance<measdim>{
         &m_measCov[offset]};
   }
 
diff --git a/Core/include/Acts/EventData/VectorTrackContainer.hpp b/Core/include/Acts/EventData/VectorTrackContainer.hpp
index 4fbfeb569dd..2f9d1e3ef1b 100644
--- a/Core/include/Acts/EventData/VectorTrackContainer.hpp
+++ b/Core/include/Acts/EventData/VectorTrackContainer.hpp
@@ -44,14 +44,14 @@ class VectorTrackContainerBase {
       MultiTrajectoryTraits::MeasurementSizeMax;
 
   using Parameters =
-      typename detail_lt::Types<eBoundSize, false>::CoefficientsMap;
+      typename detail_lt::FixedSizeTypes<eBoundSize, false>::CoefficientsMap;
   using Covariance =
-      typename detail_lt::Types<eBoundSize, false>::CovarianceMap;
+      typename detail_lt::FixedSizeTypes<eBoundSize, false>::CovarianceMap;
 
   using ConstParameters =
-      typename detail_lt::Types<eBoundSize, true>::CoefficientsMap;
+      typename detail_lt::FixedSizeTypes<eBoundSize, true>::CoefficientsMap;
   using ConstCovariance =
-      typename detail_lt::Types<eBoundSize, true>::CovarianceMap;
+      typename detail_lt::FixedSizeTypes<eBoundSize, true>::CovarianceMap;
 
  protected:
   VectorTrackContainerBase() = default;
@@ -174,8 +174,9 @@ class VectorTrackContainerBase {
   std::vector<IndexType> m_tipIndex;
   std::vector<IndexType> m_stemIndex;
   std::vector<ParticleHypothesis> m_particleHypothesis;
-  std::vector<typename detail_lt::Types<eBoundSize>::Coefficients> m_params;
-  std::vector<typename detail_lt::Types<eBoundSize>::Covariance> m_cov;
+  std::vector<typename detail_lt::FixedSizeTypes<eBoundSize>::Coefficients>
+      m_params;
+  std::vector<typename detail_lt::FixedSizeTypes<eBoundSize>::Covariance> m_cov;
   std::vector<std::shared_ptr<const Surface>> m_referenceSurfaces;
 
   std::vector<unsigned int> m_nMeasurements;
diff --git a/Core/include/Acts/EventData/detail/GenerateParameters.hpp b/Core/include/Acts/EventData/detail/GenerateParameters.hpp
index 955d92e15fe..4042ef5bba6 100644
--- a/Core/include/Acts/EventData/detail/GenerateParameters.hpp
+++ b/Core/include/Acts/EventData/detail/GenerateParameters.hpp
@@ -56,7 +56,7 @@ inline auto generateParametersCovariance(generator_t& rng)
     params[i] = stddev[i] * distNormal(rng);
   }
 
-  return std::make_pair(params, cov);
+  return {params, cov};
 }
 
 /// Generate a random bound parameters vector and covariance matrix.
diff --git a/Core/include/Acts/TrackFinding/MeasurementSelector.ipp b/Core/include/Acts/TrackFinding/MeasurementSelector.ipp
index 902c12d90d8..49b03e4730e 100644
--- a/Core/include/Acts/TrackFinding/MeasurementSelector.ipp
+++ b/Core/include/Acts/TrackFinding/MeasurementSelector.ipp
@@ -62,19 +62,16 @@ MeasurementSelector::select(
   for (std::size_t i(0ul); i < candidates.size(); ++i) {
     auto& trackState = candidates[i];
 
-    // This abuses an incorrectly sized vector / matrix to access the
-    // data pointer! This works (don't use the matrix as is!), but be
-    // careful!
-    double chi2 = calculateChi2(
-        trackState
-            .template calibrated<MultiTrajectoryTraits::MeasurementSizeMax>()
-            .data(),
-        trackState
-            .template calibratedCovariance<
-                MultiTrajectoryTraits::MeasurementSizeMax>()
-            .data(),
-        trackState.predicted(), trackState.predictedCovariance(),
-        trackState.projector(), trackState.calibratedSize());
+    // We access the dynamic size of the matrix here but use them later
+    // through a template function which accesses the data pointer
+    // with compile time size. That way the Eigen math operations are
+    // still done with compile time size and no dynamic memory allocation
+    // is needed.
+    double chi2 =
+        calculateChi2(trackState.effectiveCalibrated().data(),
+                      trackState.effectiveCalibratedCovariance().data(),
+                      trackState.predicted(), trackState.predictedCovariance(),
+                      trackState.projector(), trackState.calibratedSize());
     trackState.chi2() = chi2;
 
     if (chi2 < minChi2) {
diff --git a/Core/src/TrackFinding/MeasurementSelector.cpp b/Core/src/TrackFinding/MeasurementSelector.cpp
index 51d0064dbf1..946ca981949 100644
--- a/Core/src/TrackFinding/MeasurementSelector.cpp
+++ b/Core/src/TrackFinding/MeasurementSelector.cpp
@@ -39,10 +39,10 @@ double MeasurementSelector::calculateChi2(
        &predictedCovariance, &projector](auto N) -> double {
         constexpr std::size_t kMeasurementSize = decltype(N)::value;
 
-        typename TrackStateTraits<kMeasurementSize, true>::Measurement
+        typename TrackStateTraits<kMeasurementSize, true>::Calibrated
             calibrated{fullCalibrated};
 
-        typename TrackStateTraits<kMeasurementSize, true>::MeasurementCovariance
+        typename TrackStateTraits<kMeasurementSize, true>::CalibratedCovariance
             calibratedCovariance{fullCalibratedCovariance};
 
         using ParametersVector = ActsVector<kMeasurementSize>;
diff --git a/Core/src/TrackFitting/GainMatrixUpdater.cpp b/Core/src/TrackFitting/GainMatrixUpdater.cpp
index b46ba62dbe5..bea3cf46594 100644
--- a/Core/src/TrackFitting/GainMatrixUpdater.cpp
+++ b/Core/src/TrackFitting/GainMatrixUpdater.cpp
@@ -33,9 +33,9 @@ std::tuple<double, std::error_code> GainMatrixUpdater::visitMeasurement(
     using ParametersVector = ActsVector<kMeasurementSize>;
     using CovarianceMatrix = ActsSquareMatrix<kMeasurementSize>;
 
-    typename TrackStateTraits<kMeasurementSize, true>::Measurement calibrated{
+    typename TrackStateTraits<kMeasurementSize, true>::Calibrated calibrated{
         trackState.calibrated};
-    typename TrackStateTraits<kMeasurementSize, true>::MeasurementCovariance
+    typename TrackStateTraits<kMeasurementSize, true>::CalibratedCovariance
         calibratedCovariance{trackState.calibratedCovariance};
 
     ACTS_VERBOSE("Measurement dimension: " << kMeasurementSize);
diff --git a/Core/src/TrackFitting/GsfUtils.cpp b/Core/src/TrackFitting/GsfUtils.cpp
index 13043c603e2..56ed204fcd4 100644
--- a/Core/src/TrackFitting/GsfUtils.cpp
+++ b/Core/src/TrackFitting/GsfUtils.cpp
@@ -25,7 +25,7 @@ ActsScalar calculateDeterminant(
     constexpr std::size_t kMeasurementSize = decltype(N)::value;
 
     typename Acts::TrackStateTraits<
-        kMeasurementSize, true>::MeasurementCovariance calibratedCovariance{
+        kMeasurementSize, true>::CalibratedCovariance calibratedCovariance{
         fullCalibratedCovariance};
 
     const auto H =
diff --git a/Plugins/Podio/include/Acts/Plugins/Podio/PodioTrackContainer.hpp b/Plugins/Podio/include/Acts/Plugins/Podio/PodioTrackContainer.hpp
index 1a75473efca..028d289a6d7 100644
--- a/Plugins/Podio/include/Acts/Plugins/Podio/PodioTrackContainer.hpp
+++ b/Plugins/Podio/include/Acts/Plugins/Podio/PodioTrackContainer.hpp
@@ -11,6 +11,7 @@
 #include "Acts/EventData/MultiTrajectory.hpp"
 #include "Acts/EventData/ParticleHypothesis.hpp"
 #include "Acts/EventData/TrackContainer.hpp"
+#include "Acts/EventData/TrackStateProxy.hpp"
 #include "Acts/EventData/detail/DynamicColumn.hpp"
 #include "Acts/Plugins/Podio/PodioDynamicColumns.hpp"
 #include "Acts/Plugins/Podio/PodioUtil.hpp"
@@ -45,14 +46,14 @@ class PodioTrackContainerBase {
       MultiTrajectoryTraits::MeasurementSizeMax;
 
   using Parameters =
-      typename detail_lt::Types<eBoundSize, false>::CoefficientsMap;
+      typename detail_lt::FixedSizeTypes<eBoundSize, false>::CoefficientsMap;
   using Covariance =
-      typename detail_lt::Types<eBoundSize, false>::CovarianceMap;
+      typename detail_lt::FixedSizeTypes<eBoundSize, false>::CovarianceMap;
 
   using ConstParameters =
-      typename detail_lt::Types<eBoundSize, true>::CoefficientsMap;
+      typename detail_lt::FixedSizeTypes<eBoundSize, true>::CoefficientsMap;
   using ConstCovariance =
-      typename detail_lt::Types<eBoundSize, true>::CovarianceMap;
+      typename detail_lt::FixedSizeTypes<eBoundSize, true>::CovarianceMap;
 
  protected:
   PodioTrackContainerBase(const PodioUtil::ConversionHelper& helper)
diff --git a/Plugins/Podio/include/Acts/Plugins/Podio/PodioTrackStateContainer.hpp b/Plugins/Podio/include/Acts/Plugins/Podio/PodioTrackStateContainer.hpp
index 1714fe9e770..7fd7ba11a6e 100644
--- a/Plugins/Podio/include/Acts/Plugins/Podio/PodioTrackStateContainer.hpp
+++ b/Plugins/Podio/include/Acts/Plugins/Podio/PodioTrackStateContainer.hpp
@@ -43,14 +43,14 @@ class ConstPodioTrackStateContainer;
 class PodioTrackStateContainerBase {
  public:
   using Parameters =
-      typename detail_lt::Types<eBoundSize, false>::CoefficientsMap;
+      typename detail_lt::FixedSizeTypes<eBoundSize, false>::CoefficientsMap;
   using Covariance =
-      typename detail_lt::Types<eBoundSize, false>::CovarianceMap;
+      typename detail_lt::FixedSizeTypes<eBoundSize, false>::CovarianceMap;
 
   using ConstParameters =
-      typename detail_lt::Types<eBoundSize, true>::CoefficientsMap;
+      typename detail_lt::FixedSizeTypes<eBoundSize, true>::CoefficientsMap;
   using ConstCovariance =
-      typename detail_lt::Types<eBoundSize, true>::CovarianceMap;
+      typename detail_lt::FixedSizeTypes<eBoundSize, true>::CovarianceMap;
 
  protected:
   template <typename T>
@@ -286,16 +286,16 @@ class ConstPodioTrackStateContainer final
   }
 
   template <std::size_t measdim>
-  ConstTrackStateProxy::Measurement<measdim> measurement_impl(
+  ConstTrackStateProxy::Calibrated<measdim> calibrated_impl(
       IndexType index) const {
-    return ConstTrackStateProxy::Measurement<measdim>{
+    return ConstTrackStateProxy::Calibrated<measdim>{
         m_collection->at(index).getData().measurement.data()};
   }
 
   template <std::size_t measdim>
-  ConstTrackStateProxy::MeasurementCovariance<measdim>
-  measurementCovariance_impl(IndexType index) const {
-    return ConstTrackStateProxy::MeasurementCovariance<measdim>{
+  ConstTrackStateProxy::CalibratedCovariance<measdim> calibratedCovariance_impl(
+      IndexType index) const {
+    return ConstTrackStateProxy::CalibratedCovariance<measdim>{
         m_collection->at(index).getData().measurementCovariance.data()};
   }
 
@@ -392,29 +392,29 @@ class MutablePodioTrackStateContainer final
   }
 
   template <std::size_t measdim>
-  ConstTrackStateProxy::Measurement<measdim> measurement_impl(
+  ConstTrackStateProxy::Calibrated<measdim> calibrated_impl(
       IndexType index) const {
-    return ConstTrackStateProxy::Measurement<measdim>{
+    return ConstTrackStateProxy::Calibrated<measdim>{
         m_collection->at(index).getData().measurement.data()};
   }
 
   template <std::size_t measdim>
-  TrackStateProxy::Measurement<measdim> measurement_impl(IndexType index) {
-    return TrackStateProxy::Measurement<measdim>{
+  TrackStateProxy::Calibrated<measdim> calibrated_impl(IndexType index) {
+    return TrackStateProxy::Calibrated<measdim>{
         m_collection->at(index).data().measurement.data()};
   }
 
   template <std::size_t measdim>
-  ConstTrackStateProxy::MeasurementCovariance<measdim>
-  measurementCovariance_impl(IndexType index) const {
-    return ConstTrackStateProxy::MeasurementCovariance<measdim>{
+  ConstTrackStateProxy::CalibratedCovariance<measdim> calibratedCovariance_impl(
+      IndexType index) const {
+    return ConstTrackStateProxy::CalibratedCovariance<measdim>{
         m_collection->at(index).getData().measurementCovariance.data()};
   }
 
   template <std::size_t measdim>
-  TrackStateProxy::MeasurementCovariance<measdim> measurementCovariance_impl(
+  TrackStateProxy::CalibratedCovariance<measdim> calibratedCovariance_impl(
       IndexType index) {
-    return TrackStateProxy::MeasurementCovariance<measdim>{
+    return TrackStateProxy::CalibratedCovariance<measdim>{
         m_collection->at(index).data().measurementCovariance.data()};
   }