TrackContainer.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2023 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/Algebra.hpp"
#include "Acts/Definitions/TrackParametrization.hpp"
#include "Acts/Definitions/Units.hpp"
#include "Acts/EventData/MultiTrajectory.hpp"
#include "Acts/EventData/TrackContainerBackendConcept.hpp"
#include "Acts/EventData/TrackProxy.hpp"
#include "Acts/EventData/Types.hpp"
#include "Acts/EventData/Utils.hpp"
#include "Acts/Utilities/HashedString.hpp"
#include "Acts/Utilities/Holders.hpp"
#include "Acts/Utilities/UnitVectors.hpp"

#include <any>
#include <cstddef>
#include <iterator>

namespace Acts {

template <typename T>
struct IsReadOnlyTrackContainer;

template <ACTS_CONCEPT(TrackContainerBackend) track_container_t,
          typename traj_t,
          template <typename> class holder_t = detail::RefHolder>
class TrackContainer {
 public:
  static constexpr bool ReadOnly =
      IsReadOnlyTrackContainer<track_container_t>::value;
  static constexpr bool TrackStateReadOnly =
      IsReadOnlyMultiTrajectory<traj_t>::value;

  static_assert(ReadOnly == TrackStateReadOnly,
                "Either both track container and track state container need to "
                "be readonly or both have to be readwrite");

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

  using TrackProxy =
      Acts::TrackProxy<track_container_t, traj_t, holder_t, false>;
  using ConstTrackProxy =
      Acts::TrackProxy<track_container_t, traj_t, holder_t, true>;

#ifndef DOXYGEN
  friend TrackProxy;
  friend ConstTrackProxy;
#endif

  TrackContainer(holder_t<track_container_t> container, holder_t<traj_t> traj)
      : m_container{std::move(container)}, m_traj{std::move(traj)} {}

  template <template <typename> class H = holder_t,
            typename = std::enable_if_t<
                detail::is_same_template<H, detail::RefHolder>::value>>
  TrackContainer(track_container_t& container, traj_t& traj)
      : m_container{&container}, m_traj{&traj} {}

  template <
      template <typename> class H = holder_t,
      bool RO = (IsReadOnlyTrackContainer<track_container_t>::value &&
                 IsReadOnlyMultiTrajectory<traj_t>::value),
      typename = std::enable_if_t<
          detail::is_same_template<H, detail::ConstRefHolder>::value && RO>>
  TrackContainer(const track_container_t& container, const traj_t& traj)
      : m_container{&container}, m_traj{&traj} {}

  ConstTrackProxy getTrack(IndexType itrack) const {
    return {*this, itrack};
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  TrackProxy getTrack(IndexType itrack) {
    return {*this, itrack};
  }

  constexpr IndexType size() const {
    return m_container->size_impl();
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  IndexType addTrack() {
    auto track = getTrack(m_container->addTrack_impl());
    track.tipIndex() = kInvalid;
    return track.index();
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  void removeTrack(IndexType itrack) {
    m_container->removeTrack_impl(itrack);
  }

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

  constexpr bool hasColumn(const std::string& key) const {
    return m_container->hasColumn_impl(hashString(key));
  }

  constexpr bool hasColumn(HashedString key) const {
    return m_container->hasColumn_impl(key);
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  auto& container() {
    return *m_container;
  }

  const auto& container() const {
    return *m_container;
  }

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

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  auto& trackStateContainerHolder() {
    return m_traj;
  }

  const auto& trackStateContainer() const {
    return *m_traj;
  }

  const auto& trackStateContainerHolder() const {
    return m_traj;
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  auto begin() {
    return detail_tc::TrackProxyIterator<std::decay_t<decltype(*this)>,
                                         TrackProxy, false>{*this, 0};
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  auto end() {
    return detail_tc::TrackProxyIterator<std::decay_t<decltype(*this)>,
                                         TrackProxy, false>{*this, size()};
  }

  auto begin() const {
    return detail_tc::TrackProxyIterator<std::decay_t<decltype(*this)>,
                                         ConstTrackProxy, true>{*this, 0};
  }

  auto end() const {
    return detail_tc::TrackProxyIterator<std::decay_t<decltype(*this)>,
                                         ConstTrackProxy, true>{*this, size()};
  }

  template <typename other_track_container_t, bool RO = ReadOnly,
            typename = std::enable_if_t<!RO>>
  void ensureDynamicColumns(const other_track_container_t& other) {
    container().ensureDynamicColumns_impl(other.container());
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  void clear() {
    m_container->clear();
    m_traj->clear();
  }

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

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

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

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

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  constexpr typename TrackProxy::Parameters parameters(IndexType itrack) {
    return container().parameters(itrack);
  }

  constexpr typename ConstTrackProxy::ConstParameters parameters(
      IndexType itrack) const {
    return container().parameters(itrack);
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  constexpr typename TrackProxy::Covariance covariance(IndexType itrack) {
    return container().covariance(itrack);
  }

  constexpr typename ConstTrackProxy::ConstCovariance covariance(
      IndexType itrack) const {
    return container().covariance(itrack);
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  auto reverseTrackStateRange(IndexType itrack) {
    auto tip = component<IndexType, hashString("tipIndex")>(itrack);
    return m_traj->reverseTrackStateRange(tip);
  }

  auto reverseTrackStateRange(IndexType itrack) const {
    auto tip = component<IndexType, hashString("tipIndex")>(itrack);
    return m_traj->reverseTrackStateRange(tip);
  }

  template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  auto forwardTrackStateRange(IndexType itrack) {
    auto stem = component<IndexType, hashString("stemIndex")>(itrack);
    if (stem == kInvalid) {
      throw std::invalid_argument{"Track has no stem index"};
    }
    return m_traj->forwardTrackStateRange(stem);
  }

  auto forwardTrackStateRange(IndexType itrack) const {
    auto stem = component<IndexType, hashString("stemIndex")>(itrack);
    if (stem == kInvalid) {
      throw std::invalid_argument{"Track has no stem index"};
    }
    return m_traj->forwardTrackStateRange(stem);
  }

 private:
  template <typename T, bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
  void copyDynamicFrom(IndexType dstIdx, const T& src, IndexType srcIdx) {
    container().copyDynamicFrom_impl(dstIdx, src, srcIdx);
  }

  detail_tc::ConstIf<holder_t<track_container_t>, ReadOnly> m_container;
  detail_tc::ConstIf<holder_t<traj_t>, ReadOnly> m_traj;
};

template <ACTS_CONCEPT(TrackContainerBackend) track_container_t,
          typename traj_t>
TrackContainer(track_container_t& container, traj_t& traj)
    -> TrackContainer<track_container_t, traj_t, detail::RefHolder>;

template <ACTS_CONCEPT(TrackContainerBackend) track_container_t,
          typename traj_t>
TrackContainer(const track_container_t& container, const traj_t& traj)
    -> TrackContainer<track_container_t, traj_t, detail::ConstRefHolder>;

template <ACTS_CONCEPT(TrackContainerBackend) track_container_t,
          typename traj_t>
TrackContainer(track_container_t&& container, traj_t&& traj)
    -> TrackContainer<track_container_t, traj_t, detail::ValueHolder>;

template <typename T, bool ReadOnly>
struct TrackAccessorBase {
  HashedString key;

  TrackAccessorBase(HashedString _key) : key{_key} {}
  TrackAccessorBase(const std::string& _key) : key{hashString(_key)} {}

  template <typename track_proxy_t, bool RO = ReadOnly,
            typename = std::enable_if_t<!RO>>
  T& operator()(track_proxy_t track) const {
    static_assert(!track_proxy_t::ReadOnly,
                  "Cannot get mutable ref for const track proxy");
    return track.template component<T>(key);
  }

  template <typename track_proxy_t, bool RO = ReadOnly,
            typename = std::enable_if_t<RO>>
  const T& operator()(track_proxy_t track) const {
    if constexpr (track_proxy_t::ReadOnly) {
      return track.template component<T>(key);
    } else {
      typename track_proxy_t::ConstTrackProxy ctrack{track};
      return ctrack.template component<T>(key);
    }
  }
};

template <typename T>
using TrackAccessor = TrackAccessorBase<T, false>;
template <typename T>
using ConstTrackAccessor = TrackAccessorBase<T, true>;

}  // namespace Acts