MultiTrajectory.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file MultiTrajectory.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2019-2020 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#pragma once

#include "Acts/Definitions/TrackParametrization.hpp"
#include "Acts/EventData/Measurement.hpp"
#include "Acts/EventData/MeasurementHelpers.hpp"
#include "Acts/EventData/SourceLink.hpp"
#include "Acts/EventData/TrackStatePropMask.hpp"
#include "Acts/EventData/TrackStateProxyConcept.hpp"
#include "Acts/EventData/TrackStateType.hpp"
#include "Acts/EventData/Types.hpp"
#include "Acts/Geometry/GeometryContext.hpp"
#include "Acts/Utilities/AlgebraHelpers.hpp"
#include "Acts/Utilities/Concepts.hpp"
#include "Acts/Utilities/HashedString.hpp"
#include "Acts/Utilities/Helpers.hpp"
#include "Acts/Utilities/ThrowAssert.hpp"
#include "Acts/Utilities/TypeTraits.hpp"

#include <bitset>
#include <cstddef>
#include <cstdint>
#include <iterator>
#include <memory>
#include <optional>
#include <type_traits>
#include <vector>

#include <Eigen/Core>

namespace Acts {

// forward declarations
template <typename derived_t>
class MultiTrajectory;
class Surface;

namespace detail_lt {
template <typename T, bool select>
using ConstIf = std::conditional_t<select, const T, T>;

template <typename T>
class TransitiveConstPointer {
 public:
  TransitiveConstPointer() = default;
  TransitiveConstPointer(T* ptr) : m_ptr{ptr} {}

  template <typename U>
  TransitiveConstPointer(const TransitiveConstPointer<U>& other)
      : m_ptr{other.ptr()} {}

  template <typename U>
  TransitiveConstPointer& operator=(const TransitiveConstPointer<U>& other) {
    m_ptr = other.m_ptr;
    return *this;
  }

  template <typename U>
  bool operator==(const TransitiveConstPointer<U>& other) const {
    return m_ptr == other.m_ptr;
  }

  const T* operator->() const { return m_ptr; }

  T* operator->() { return m_ptr; }

  template <typename U>
  friend class TransitiveConstPointer;

  const T& operator*() const { return *m_ptr; }

  T& operator*() { return *m_ptr; }

 private:
  T* ptr() const { return m_ptr; }

  T* m_ptr;
};

template <size_t Size, bool ReadOnlyMaps = true>
struct Types {
  enum {
    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>;
  using CoefficientsMap = Eigen::Map<ConstIf<Coefficients, ReadOnlyMaps>>;
  using CovarianceMap = Eigen::Map<ConstIf<Covariance, ReadOnlyMaps>>;

  using DynamicCoefficients = Eigen::Matrix<Scalar, Eigen::Dynamic, 1, Flags>;
  using DynamicCovariance =
      Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Flags>;
  using DynamicCoefficientsMap =
      Eigen::Map<ConstIf<DynamicCoefficients, ReadOnlyMaps>>;
  using DynamicCovarianceMap =
      Eigen::Map<ConstIf<DynamicCovariance, ReadOnlyMaps>>;
};
}  // namespace detail_lt

// This is public
template <size_t M, bool ReadOnly = true>
struct TrackStateTraits {
  using Parameters =
      typename detail_lt::Types<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;

  constexpr static auto ProjectorFlags = Eigen::RowMajor | Eigen::AutoAlign;
  using Projector =
      Eigen::Matrix<typename Covariance::Scalar, M, eBoundSize, ProjectorFlags>;
};

namespace detail_lt {

template <typename trajectory_t, size_t M, bool ReadOnly = true>
class TrackStateProxy {
 public:
  using Parameters = typename TrackStateTraits<M, ReadOnly>::Parameters;
  using Covariance = typename TrackStateTraits<M, ReadOnly>::Covariance;
  using ConstParameters = typename TrackStateTraits<M, true>::Parameters;
  using ConstCovariance = typename TrackStateTraits<M, true>::Covariance;

  template <size_t N>
  using Measurement = typename TrackStateTraits<N, ReadOnly>::Measurement;
  template <size_t N>
  using MeasurementCovariance =
      typename TrackStateTraits<N, ReadOnly>::MeasurementCovariance;
  template <size_t N>
  using ConstMeasurement = typename TrackStateTraits<N, true>::Measurement;
  template <size_t N>
  using ConstMeasurementCovariance =
      typename TrackStateTraits<N, true>::MeasurementCovariance;

  using IndexType = TrackIndexType;
  static constexpr IndexType kInvalid = kTrackIndexInvalid;

  // as opposed to the types above, this is an actual Matrix (rather than a
  // map)
  // @TODO: Does not copy flags, because this fails: can't have col major row
  // vector, but that's required for 1xN projection matrices below.
  using Projector = typename TrackStateTraits<M, ReadOnly>::Projector;
  using EffectiveProjector =
      Eigen::Matrix<typename Projector::Scalar, Eigen::Dynamic, Eigen::Dynamic,
                    TrackStateTraits<M, ReadOnly>::ProjectorFlags, M,
                    eBoundSize>;

  using Trajectory = trajectory_t;

  // Constructor and assignment operator to construct ReadOnly TrackStateProxy
  // from ReadWrite (mutable -> const)
  TrackStateProxy(const TrackStateProxy<Trajectory, M, false>& other)
      : m_traj{other.m_traj}, m_istate{other.m_istate} {}

  TrackStateProxy& operator=(
      const TrackStateProxy<Trajectory, M, false>& other) {
    m_traj = other.m_traj;
    m_istate = other.m_istate;

    return *this;
  }

  IndexType index() const { return m_istate; }

  IndexType previous() const {
    return component<IndexType, hashString("previous")>();
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  IndexType& previous() {
    return component<IndexType, hashString("previous")>();
  }

  bool hasPrevious() const {
    return component<IndexType, hashString("previous")>() != kInvalid;
  }

  TrackStatePropMask getMask() const;

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  void shareFrom(TrackStatePropMask shareSource,
                 TrackStatePropMask shareTarget) {
    shareFrom(*this, shareSource, shareTarget);
  }

  template <bool RO = ReadOnly, bool ReadOnlyOther,
            typename = std::enable_if_t<!RO>>
  void shareFrom(const TrackStateProxy<Trajectory, M, ReadOnlyOther>& other,
                 TrackStatePropMask component) {
    shareFrom(other, component, component);
  }

  template <bool RO = ReadOnly, bool ReadOnlyOther,
            typename = std::enable_if_t<!RO>>
  void shareFrom(const TrackStateProxy<Trajectory, M, ReadOnlyOther>& other,
                 TrackStatePropMask shareSource,
                 TrackStatePropMask shareTarget) {
    assert(m_traj == other.m_traj &&
           "Cannot share components across MultiTrajectories");

    assert(ACTS_CHECK_BIT(other.getMask(), shareSource) &&
           "Source has incompatible allocation");

    m_traj->self().shareFrom(m_istate, other.m_istate, shareSource,
                             shareTarget);
  }

  template <ACTS_CONCEPT(TrackStateProxyConcept) track_state_proxy_t,
            bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  void copyFrom(const track_state_proxy_t& other,
                TrackStatePropMask mask = TrackStatePropMask::All,
                bool onlyAllocated = true) {
    using PM = TrackStatePropMask;

    // @TODO: How to support arbitrary columns here?

    if (onlyAllocated) {
      auto dest = getMask();
      auto src = other.getMask() &
                 mask;  // combine what we have with what we want to copy

      if (ACTS_CHECK_BIT(src, PM::Calibrated)) {
        // on-demand allocate calibrated
        dest |= PM::Calibrated;
      }

      if ((static_cast<std::underlying_type_t<TrackStatePropMask>>(
               (src ^ dest) & src) != 0 ||
           dest == TrackStatePropMask::None ||
           src == TrackStatePropMask::None) &&
          mask != TrackStatePropMask::None) {
        throw std::runtime_error(
            "Attempt track state copy with incompatible allocations");
      }

      // we're sure now this has correct allocations, so just copy
      if (ACTS_CHECK_BIT(src, PM::Predicted)) {
        predicted() = other.predicted();
        predictedCovariance() = other.predictedCovariance();
      }

      if (ACTS_CHECK_BIT(src, PM::Filtered)) {
        filtered() = other.filtered();
        filteredCovariance() = other.filteredCovariance();
      }

      if (ACTS_CHECK_BIT(src, PM::Smoothed)) {
        smoothed() = other.smoothed();
        smoothedCovariance() = other.smoothedCovariance();
      }

      if (other.hasUncalibratedSourceLink()) {
        setUncalibratedSourceLink(other.getUncalibratedSourceLink());
      }

      if (ACTS_CHECK_BIT(src, PM::Jacobian)) {
        jacobian() = other.jacobian();
      }

      if (ACTS_CHECK_BIT(src, PM::Calibrated)) {
        allocateCalibrated(other.calibratedSize());

        // workaround for gcc8 bug:
        // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=86594
        auto* self = this;
        visit_measurement(other.calibratedSize(), [&](auto N) {
          constexpr int measdim = decltype(N)::value;
          self->template calibrated<measdim>() =
              other.template calibrated<measdim>();
          self->template calibratedCovariance<measdim>() =
              other.template calibratedCovariance<measdim>();
        });

        setProjectorBitset(other.projectorBitset());
      }
    } else {
      if (ACTS_CHECK_BIT(mask, PM::Predicted) &&
          has<hashString("predicted")>() &&
          other.template has<hashString("predicted")>()) {
        predicted() = other.predicted();
        predictedCovariance() = other.predictedCovariance();
      }

      if (ACTS_CHECK_BIT(mask, PM::Filtered) && has<hashString("filtered")>() &&
          other.template has<hashString("filtered")>()) {
        filtered() = other.filtered();
        filteredCovariance() = other.filteredCovariance();
      }

      if (ACTS_CHECK_BIT(mask, PM::Smoothed) && has<hashString("smoothed")>() &&
          other.template has<hashString("smoothed")>()) {
        smoothed() = other.smoothed();
        smoothedCovariance() = other.smoothedCovariance();
      }

      if (other.hasUncalibratedSourceLink()) {
        setUncalibratedSourceLink(other.getUncalibratedSourceLink());
      }

      if (ACTS_CHECK_BIT(mask, PM::Jacobian) && has<hashString("jacobian")>() &&
          other.template has<hashString("jacobian")>()) {
        jacobian() = other.jacobian();
      }

      if (ACTS_CHECK_BIT(mask, PM::Calibrated) &&
          has<hashString("calibrated")>() &&
          other.template has<hashString("calibrated")>()) {
        allocateCalibrated(other.calibratedSize());

        // workaround for gcc8 bug:
        // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=86594
        auto* self = this;
        visit_measurement(other.calibratedSize(), [&](auto N) {
          constexpr int measdim = decltype(N)::value;
          self->template calibrated<measdim>() =
              other.template calibrated<measdim>();
          self->template calibratedCovariance<measdim>() =
              other.template calibratedCovariance<measdim>();
        });

        setProjectorBitset(other.projectorBitset());
      }
    }

    chi2() = other.chi2();
    pathLength() = other.pathLength();
    typeFlags() = other.typeFlags();

    if (other.hasReferenceSurface()) {
      setReferenceSurface(other.referenceSurface().getSharedPtr());
    }
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  void unset(TrackStatePropMask target) {
    m_traj->self().unset(target, m_istate);
  }

  const Surface& referenceSurface() const {
    assert(hasReferenceSurface() &&
           "TrackState does not have reference surface");
    return *m_traj->referenceSurface(m_istate);
  }

  bool hasReferenceSurface() const {
    return m_traj->referenceSurface(m_istate) != nullptr;
  }

  // NOLINTBEGIN(performance-unnecessary-value-param)
  // looks like a false-positive. clang-tidy believes `srf` is not movable.

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  void setReferenceSurface(std::shared_ptr<const Surface> srf) {
    m_traj->setReferenceSurface(m_istate, std::move(srf));
  }
  // NOLINTEND(performance-unnecessary-value-param)

  template <HashedString key>
  constexpr bool has() const {
    return m_traj->template has<key>(m_istate);
  }

  constexpr bool has(HashedString key) const {
    return m_traj->has(key, m_istate);
  }

  constexpr bool has(std::string_view key) const {
    return has(hashString(key));
  }

  template <typename T, HashedString key, bool RO = ReadOnly,
            typename = std::enable_if_t<!RO>>
  constexpr T& component() {
    return m_traj->template component<T, key>(m_istate);
  }

  template <typename T, bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  constexpr T& component(HashedString key) {
    return m_traj->template component<T>(key, m_istate);
  }

  template <typename T, bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  constexpr T& component(std::string_view key) {
    return m_traj->template component<T>(hashString(key), m_istate);
  }

  template <typename T, HashedString key>
  constexpr const T& component() const {
    return m_traj->template component<T, key>(m_istate);
  }

  template <typename T>
  constexpr const T& component(HashedString key) const {
    return m_traj->template component<T>(key, m_istate);
  }

  template <typename T>
  constexpr const T& component(std::string_view key) const {
    return m_traj->template component<T>(hashString(key), m_istate);
  }

  ConstParameters parameters() const;

  ConstCovariance covariance() const;

  ConstParameters predicted() const {
    assert(has<hashString("predicted")>());
    return m_traj->self().parameters(
        component<IndexType, hashString("predicted")>());
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  Parameters predicted() {
    assert(has<hashString("predicted")>());
    return m_traj->self().parameters(
        component<IndexType, hashString("predicted")>());
  }

  ConstCovariance predictedCovariance() const {
    assert(has<hashString("predicted")>());
    return m_traj->self().covariance(
        component<IndexType, hashString("predicted")>());
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  Covariance predictedCovariance() {
    assert(has<hashString("predicted")>());
    return m_traj->self().covariance(
        component<IndexType, hashString("predicted")>());
  }

  bool hasPredicted() const { return has<hashString("predicted")>(); }

  ConstParameters filtered() const {
    assert(has<hashString("filtered")>());
    return m_traj->self().parameters(
        component<IndexType, hashString("filtered")>());
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  Parameters filtered() {
    assert(has<hashString("filtered")>());
    return m_traj->self().parameters(
        component<IndexType, hashString("filtered")>());
  }

  ConstCovariance filteredCovariance() const {
    assert(has<hashString("filtered")>());
    return m_traj->self().covariance(
        component<IndexType, hashString("filtered")>());
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  Covariance filteredCovariance() {
    assert(has<hashString("filtered")>());
    return m_traj->self().covariance(
        component<IndexType, hashString("filtered")>());
  }

  bool hasFiltered() const { return has<hashString("filtered")>(); }

  ConstParameters smoothed() const {
    assert(has<hashString("smoothed")>());
    return m_traj->self().parameters(
        component<IndexType, hashString("smoothed")>());
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  Parameters smoothed() {
    assert(has<hashString("smoothed")>());
    return m_traj->self().parameters(
        component<IndexType, hashString("smoothed")>());
  }

  ConstCovariance smoothedCovariance() const {
    assert(has<hashString("smoothed")>());
    return m_traj->self().covariance(
        component<IndexType, hashString("smoothed")>());
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  Covariance smoothedCovariance() {
    assert(has<hashString("smoothed")>());
    return m_traj->self().covariance(
        component<IndexType, hashString("smoothed")>());
  }

  bool hasSmoothed() const { return has<hashString("smoothed")>(); }

  ConstCovariance jacobian() const {
    assert(has<hashString("jacobian")>());
    return m_traj->self().jacobian(m_istate);
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  Covariance jacobian() {
    assert(has<hashString("jacobian")>());
    return m_traj->self().jacobian(m_istate);
  }

  bool hasJacobian() const { return has<hashString("jacobian")>(); }

  Projector projector() const;

  bool hasProjector() const { return has<hashString("projector")>(); }

  EffectiveProjector effectiveProjector() const {
    return projector().topLeftCorner(calibratedSize(), M);
  }

  template <typename Derived, bool RO = ReadOnly,
            typename = std::enable_if_t<!RO>>
  void setProjector(const Eigen::MatrixBase<Derived>& projector) {
    constexpr int rows = Eigen::MatrixBase<Derived>::RowsAtCompileTime;
    constexpr int cols = Eigen::MatrixBase<Derived>::ColsAtCompileTime;

    static_assert(rows != -1 && cols != -1,
                  "Assignment of dynamic matrices is currently not supported.");

    assert(has<hashString("projector")>());

    static_assert(rows <= M, "Given projector has too many rows");
    static_assert(cols <= eBoundSize, "Given projector has too many columns");

    // set up full size projector with only zeros
    typename TrackStateProxy::Projector fullProjector =
        decltype(fullProjector)::Zero();

    // assign (potentially) smaller actual projector to matrix, preserving
    // zeroes outside of smaller matrix block.
    fullProjector.template topLeftCorner<rows, cols>() = projector;

    // convert to bitset before storing
    auto projectorBitset = matrixToBitset(fullProjector);
    component<ProjectorBitset, hashString("projector")>() =
        projectorBitset.to_ullong();
  }

  ProjectorBitset projectorBitset() const {
    assert(has<hashString("projector")>());
    return component<ProjectorBitset, hashString("projector")>();
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  void setProjectorBitset(ProjectorBitset proj) {
    assert(has<hashString("projector")>());
    component<ProjectorBitset, hashString("projector")>() = proj;
  }

  SourceLink getUncalibratedSourceLink() const;

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  void setUncalibratedSourceLink(SourceLink sourceLink) {
    m_traj->setUncalibratedSourceLink(m_istate, std::move(sourceLink));
  }

  bool hasUncalibratedSourceLink() const {
    return has<hashString("uncalibratedSourceLink")>();
  }

  bool hasCalibrated() const { return has<hashString("calibrated")>(); }

  template <size_t measdim>
  ConstMeasurement<measdim> calibrated() const {
    assert(has<hashString("calibrated")>());
    return m_traj->self().template measurement<measdim>(m_istate);
  }

  template <size_t measdim, bool RO = ReadOnly,
            typename = std::enable_if_t<!RO>>
  Measurement<measdim> calibrated() {
    assert(has<hashString("calibrated")>());
    return m_traj->self().template measurement<measdim>(m_istate);
  }

  template <size_t measdim>
  ConstMeasurementCovariance<measdim> calibratedCovariance() const {
    assert(has<hashString("calibratedCov")>());
    return m_traj->self().template measurementCovariance<measdim>(m_istate);
  }

  template <size_t measdim, bool RO = ReadOnly,
            typename = std::enable_if_t<!RO>>
  MeasurementCovariance<measdim> calibratedCovariance() {
    assert(has<hashString("calibratedCov")>());
    return m_traj->self().template measurementCovariance<measdim>(m_istate);
  }

  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 Types<M, ReadOnly>::DynamicCoefficientsMap{
          self->template calibrated<kMeasurementSize>().data(),
          kMeasurementSize};
    });
  }

  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 Types<M, true>::DynamicCoefficientsMap{
          self->template calibrated<kMeasurementSize>().data(),
          kMeasurementSize};
    });
  }

  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 Types<M, ReadOnly>::DynamicCovarianceMap{
          self->template calibratedCovariance<kMeasurementSize>().data(),
          kMeasurementSize, kMeasurementSize};
    });
  }

  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 Types<M, true>::DynamicCovarianceMap{
          self->template calibratedCovariance<kMeasurementSize>().data(),
          kMeasurementSize, kMeasurementSize};
    });
  }

  IndexType calibratedSize() const { return m_traj->calibratedSize(m_istate); }

  template <size_t kMeasurementSize, bool RO = ReadOnly,
            typename = std::enable_if_t<!RO>>
  void setCalibrated(
      const Acts::Measurement<BoundIndices, kMeasurementSize>& meas) {
    static_assert(kMeasurementSize <= M,
                  "Input measurement must be within the allowed size");

    allocateCalibrated(kMeasurementSize);
    assert(hasCalibrated());

    calibrated<kMeasurementSize>().setZero();
    calibrated<kMeasurementSize>().template head<kMeasurementSize>() =
        meas.parameters();
    calibratedCovariance<kMeasurementSize>().setZero();
    calibratedCovariance<kMeasurementSize>()
        .template topLeftCorner<kMeasurementSize, kMeasurementSize>() =
        meas.covariance();
    setProjector(meas.projector());
  }

  void allocateCalibrated(size_t measdim) {
    m_traj->allocateCalibrated(m_istate, measdim);
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  double& chi2() {
    return component<double, hashString("chi2")>();
  }

  double chi2() const { return component<double, hashString("chi2")>(); }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  double& pathLength() {
    return component<double, hashString("pathLength")>();
  }

  double pathLength() const {
    return component<double, hashString("pathLength")>();
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  TrackStateType typeFlags() {
    return TrackStateType{
        component<TrackStateType::raw_type, hashString("typeFlags")>()};
  }

  ConstTrackStateType typeFlags() const {
    return ConstTrackStateType{
        component<TrackStateType::raw_type, hashString("typeFlags")>()};
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  MultiTrajectory<Trajectory>& trajectory() {
    return *m_traj;
  }

  const MultiTrajectory<Trajectory>& trajectory() const { return *m_traj; }

 private:
  // Private since it can only be created by the trajectory.
  TrackStateProxy(ConstIf<MultiTrajectory<Trajectory>, ReadOnly>& trajectory,
                  IndexType istate);

  TransitiveConstPointer<ConstIf<MultiTrajectory<Trajectory>, ReadOnly>> m_traj;
  IndexType m_istate;

  friend class Acts::MultiTrajectory<Trajectory>;
  friend class TrackStateProxy<Trajectory, M, true>;
  friend class TrackStateProxy<Trajectory, M, false>;
};

template <bool reverse, typename trajectory_t, size_t M, bool ReadOnly>
class TrackStateRange {
  using ProxyType = TrackStateProxy<trajectory_t, M, ReadOnly>;
  using IndexType = typename ProxyType::IndexType;
  static constexpr IndexType kInvalid = ProxyType::kInvalid;

 public:
  struct Iterator {
    std::optional<ProxyType> proxy;

    using iterator_category = std::forward_iterator_tag;
    using value_type = ProxyType;
    using difference_type = std::ptrdiff_t;
    using pointer = void;
    using reference = void;

    Iterator& operator++() {
      if (!proxy) {
        return *this;
      }
      if constexpr (reverse) {
        if (proxy->hasPrevious()) {
          proxy = proxy->trajectory().getTrackState(proxy->previous());
          return *this;
        } else {
          proxy = std::nullopt;
          return *this;
        }
      } else {
        IndexType next =
            proxy->template component<IndexType, hashString("next")>();
        if (next != kInvalid) {
          proxy = proxy->trajectory().getTrackState(next);
          return *this;
        } else {
          proxy = std::nullopt;
          return *this;
        }
      }
    }

    bool operator==(const Iterator& other) const {
      if (!proxy && !other.proxy) {
        return true;
      }
      if (proxy && other.proxy) {
        return proxy->index() == other.proxy->index();
      }
      return false;
    }

    bool operator!=(const Iterator& other) const { return !(*this == other); }

    ProxyType operator*() const { return *proxy; }
    ProxyType operator*() { return *proxy; }
  };

  TrackStateRange(ProxyType _begin) : m_begin{_begin} {}
  TrackStateRange() : m_begin{std::nullopt} {}

  Iterator begin() { return m_begin; }
  Iterator end() { return Iterator{std::nullopt}; }

 private:
  Iterator m_begin;
};

// implement track state visitor concept
template <typename T, typename TS>
using call_operator_t = decltype(std::declval<T>()(std::declval<TS>()));

template <typename T, typename TS>
constexpr bool VisitorConcept = Concepts ::require<
    Concepts ::either<Concepts ::identical_to<bool, call_operator_t, T, TS>,
                      Concepts ::identical_to<void, call_operator_t, T, TS>>>;

}  // namespace detail_lt

namespace MultiTrajectoryTraits {
constexpr unsigned int MeasurementSizeMax = eBoundSize;
using IndexType = TrackIndexType;
constexpr IndexType kInvalid = kTrackIndexInvalid;
}  // namespace MultiTrajectoryTraits

template <typename T>
struct IsReadOnlyMultiTrajectory;

template <typename derived_t>
class MultiTrajectory {
 public:
  using Derived = derived_t;

  static constexpr bool ReadOnly = IsReadOnlyMultiTrajectory<Derived>::value;

  // Pull out type alias and re-expose them for ease of use.
  //
  static constexpr unsigned int MeasurementSizeMax =
      MultiTrajectoryTraits::MeasurementSizeMax;

  using ConstTrackStateProxy =
      detail_lt::TrackStateProxy<Derived, MeasurementSizeMax, true>;
  using TrackStateProxy =
      detail_lt::TrackStateProxy<Derived, MeasurementSizeMax, false>;

  using IndexType = typename TrackStateProxy::IndexType;
  static constexpr IndexType kInvalid = TrackStateProxy::kInvalid;

 protected:
  MultiTrajectory() = default;  // pseudo abstract base class

 private:
  constexpr Derived& self() { return static_cast<Derived&>(*this); }
  constexpr const Derived& self() const {
    return static_cast<const Derived&>(*this);
  }

  constexpr bool checkOptional(HashedString key, IndexType istate) const {
    using namespace Acts::HashedStringLiteral;
    switch (key) {
      case "predicted"_hash:
      case "filtered"_hash:
      case "smoothed"_hash:
      case "calibrated"_hash:
      case "jacobian"_hash:
      case "projector"_hash:
        return self().has_impl(key, istate);
      default:
        return true;
    }
  }

 public:
  ConstTrackStateProxy getTrackState(IndexType istate) const {
    return {*this, istate};
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  TrackStateProxy getTrackState(IndexType istate) {
    return {*this, istate};
  }

  template <typename F>
  void visitBackwards(IndexType iendpoint, F&& callable) const;

  auto reverseTrackStateRange(IndexType iendpoint) const {
    using range_t =
        detail_lt::TrackStateRange<true, Derived, MeasurementSizeMax, true>;
    if (iendpoint == kInvalid) {
      return range_t{};
    }

    return range_t{getTrackState(iendpoint)};
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  auto reverseTrackStateRange(IndexType iendpoint) {
    using range_t =
        detail_lt::TrackStateRange<true, Derived, MeasurementSizeMax, false>;
    if (iendpoint == kInvalid) {
      return range_t{};
    }

    return range_t{getTrackState(iendpoint)};
  }

  auto forwardTrackStateRange(IndexType istartpoint) const {
    using range_t =
        detail_lt::TrackStateRange<false, Derived, MeasurementSizeMax, true>;
    if (istartpoint == kInvalid) {
      return range_t{};
    }

    return range_t{getTrackState(istartpoint)};
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  auto forwardTrackStateRange(IndexType istartpoint) {
    using range_t =
        detail_lt::TrackStateRange<false, Derived, MeasurementSizeMax, false>;
    if (istartpoint == kInvalid) {
      return range_t{};
    }

    return range_t{getTrackState(istartpoint)};
  }

  template <typename F, bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  void applyBackwards(IndexType iendpoint, F&& callable) {
    static_assert(detail_lt::VisitorConcept<F, TrackStateProxy>,
                  "Callable needs to satisfy VisitorConcept");

    if (iendpoint == MultiTrajectoryTraits::kInvalid) {
      throw std::runtime_error(
          "Cannot apply backwards with kInvalid as endpoint");
    }

    while (true) {
      auto ts = getTrackState(iendpoint);
      if constexpr (std::is_same_v<std::invoke_result_t<F, TrackStateProxy>,
                                   bool>) {
        bool proceed = callable(ts);
        // this point has no parent and ends the trajectory, or a break was
        // requested
        if (!proceed || !ts.hasPrevious()) {
          break;
        }
      } else {
        callable(ts);
        // this point has no parent and ends the trajectory
        if (!ts.hasPrevious()) {
          break;
        }
      }
      iendpoint = ts.previous();
    }
  }

  auto&& convertToReadOnly() const {
    auto&& cv = self().convertToReadOnly_impl();
    static_assert(
        IsReadOnlyMultiTrajectory<decltype(cv)>::value,
        "convertToReadOnly_impl does not return something that reports "
        "being ReadOnly.");
    return cv;
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  constexpr void clear() {
    self().clear_impl();
  }

  constexpr IndexType size() const { return self().size_impl(); }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  constexpr IndexType addTrackState(
      TrackStatePropMask mask = TrackStatePropMask::All,
      IndexType iprevious = kInvalid) {
    return self().addTrackState_impl(mask, iprevious);
  }

  template <typename T, bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  constexpr void addColumn(const std::string& key) {
    self().template addColumn_impl<T>(key);
  }

  constexpr bool hasColumn(HashedString key) const {
    return self().hasColumn_impl(key);
  }

 protected:
  // These are internal helper functions which the @c TrackStateProxy class talks to

  constexpr bool has(HashedString key, IndexType istate) const {
    return self().has_impl(key, istate);
  }

  template <HashedString key>
  constexpr bool has(IndexType istate) const {
    return self().has_impl(key, istate);
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  constexpr typename TrackStateProxy::Parameters parameters(IndexType parIdx) {
    return self().parameters_impl(parIdx);
  }

  constexpr typename ConstTrackStateProxy::Parameters parameters(
      IndexType parIdx) const {
    return self().parameters_impl(parIdx);
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  constexpr typename TrackStateProxy::Covariance covariance(IndexType covIdx) {
    return self().covariance_impl(covIdx);
  }

  constexpr typename ConstTrackStateProxy::Covariance covariance(
      IndexType covIdx) const {
    return self().covariance_impl(covIdx);
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  constexpr typename TrackStateProxy::Covariance jacobian(IndexType jacIdx) {
    return self().jacobian_impl(jacIdx);
  }

  constexpr typename ConstTrackStateProxy::Covariance jacobian(
      IndexType jacIdx) const {
    return self().jacobian_impl(jacIdx);
  }

  template <size_t measdim, bool RO = ReadOnly,
            typename = std::enable_if_t<!RO>>
  constexpr typename TrackStateProxy::template Measurement<measdim> measurement(
      IndexType measIdx) {
    return self().template measurement_impl<measdim>(measIdx);
  }

  template <size_t measdim>
  constexpr typename ConstTrackStateProxy::template Measurement<measdim>
  measurement(IndexType measIdx) const {
    return self().template measurement_impl<measdim>(measIdx);
  }

  template <size_t measdim, bool RO = ReadOnly,
            typename = std::enable_if_t<!RO>>
  constexpr typename TrackStateProxy::template MeasurementCovariance<measdim>
  measurementCovariance(IndexType covIdx) {
    return self().template measurementCovariance_impl<measdim>(covIdx);
  }

  template <size_t measdim>
  constexpr
      typename ConstTrackStateProxy::template MeasurementCovariance<measdim>
      measurementCovariance(IndexType covIdx) const {
    return self().template measurementCovariance_impl<measdim>(covIdx);
  }

  IndexType calibratedSize(IndexType istate) const {
    return self().calibratedSize_impl(istate);
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  constexpr void shareFrom(IndexType iself, IndexType iother,
                           TrackStatePropMask shareSource,
                           TrackStatePropMask shareTarget) {
    self().shareFrom_impl(iself, iother, shareSource, shareTarget);
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  constexpr void unset(TrackStatePropMask target, IndexType istate) {
    self().unset_impl(target, istate);
  }

  template <typename T, HashedString key, bool RO = ReadOnly,
            typename = std::enable_if_t<!RO>>
  constexpr T& component(IndexType istate) {
    assert(checkOptional(key, istate));
    return *std::any_cast<T*>(self().component_impl(key, istate));
  }

  template <typename T, bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  constexpr T& component(HashedString key, IndexType istate) {
    assert(checkOptional(key, istate));
    return *std::any_cast<T*>(self().component_impl(key, istate));
  }

  template <typename T, HashedString key>
  constexpr const T& component(IndexType istate) const {
    assert(checkOptional(key, istate));
    return *std::any_cast<const T*>(self().component_impl(key, istate));
  }

  template <typename T>
  constexpr const T& component(HashedString key, IndexType istate) const {
    assert(checkOptional(key, istate));
    return *std::any_cast<const T*>(self().component_impl(key, istate));
  }

  void allocateCalibrated(IndexType istate, size_t measdim) {
    throw_assert(measdim > 0 && measdim <= eBoundSize,
                 "Invalid measurement dimension detected");

    self().allocateCalibrated_impl(istate, measdim);
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  void setUncalibratedSourceLink(IndexType istate, SourceLink sourceLink) {
    self().setUncalibratedSourceLink_impl(istate, std::move(sourceLink));
  }

  SourceLink getUncalibratedSourceLink(IndexType istate) const {
    return self().getUncalibratedSourceLink_impl(istate);
  }

  const Surface* referenceSurface(IndexType istate) const {
    return self().referenceSurface_impl(istate);
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  void setReferenceSurface(IndexType istate,
                           std::shared_ptr<const Surface> surface) {
    self().setReferenceSurface_impl(istate, std::move(surface));
  }

 private:
  friend class detail_lt::TrackStateProxy<Derived, MeasurementSizeMax, true>;
  friend class detail_lt::TrackStateProxy<Derived, MeasurementSizeMax, false>;
};

}  // namespace Acts

#include "Acts/EventData/MultiTrajectory.ipp"