Tracking/Acts/ActsEvent/ActsEvent/TrackSummaryContainer.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
#ifndef ACTSEVENT_TRACKSUMMARYCONTAINER_H
#define ACTSEVENT_TRACKSUMMARYCONTAINER_H
#include <type_traits>
#include <string_view>
 
#include "Acts/EventData/TrackContainer.hpp"
#include "Acts/Surfaces/Surface.hpp"
#include "Acts/Utilities/HashedString.hpp"
#include "ActsEvent/Decoration.h"
#include "xAODTracking/TrackSummaryContainer.h"
#include "xAODTracking/TrackSummaryAuxContainer.h"
#include "xAODTracking/TrackSurfaceContainer.h"
#include "xAODTracking/TrackSurfaceAuxContainer.h"
 
namespace ActsTrk {
class MutableTrackSummaryContainer;
class TrackSummaryContainer;
class MutableTrackContainerHandlesHelper;
 
}  // namespace ActsTrk
 
namespace Acts {
class Surface;
template <typename T>
struct IsReadOnlyTrackContainer {};
 
template <typename T>
struct IsReadOnlyTrackContainer<T&> : IsReadOnlyTrackContainer<T> {};
 
template <typename T>
struct IsReadOnlyTrackContainer<T&&> : IsReadOnlyTrackContainer<T> {};
 
template <>
struct IsReadOnlyTrackContainer<ActsTrk::TrackSummaryContainer>
    : std::true_type {};
 
template <>
struct IsReadOnlyTrackContainer<ActsTrk::MutableTrackSummaryContainer>
    : std::false_type {};
 
    
}  // namespace Acts
 
namespace ActsTrk {
 
using ConstParameters = Acts::TrackStateTraits<3>::Parameters;
using ConstCovariance = Acts::TrackStateTraits<3>::Covariance;
using Parameters = Acts::TrackStateTraits<3, false>::Parameters;
using Covariance = Acts::TrackStateTraits<3, false>::Covariance;
 
class MutableTrackSummaryContainer;
 
class TrackSummaryContainer {
 public:
  using IndexType = uint32_t; // TODO find common place for it
  static constexpr auto kInvalid = Acts::MultiTrajectoryTraits::kInvalid;
  TrackSummaryContainer(const DataLink<xAOD::TrackSummaryContainer>& lin = nullptr);
  static const std::set<std::string> staticVariables;
  static const std::set<Acts::HashedString> staticVariableHashes;
  constexpr bool hasColumn_impl(Acts::HashedString key) const;

  const Acts::Surface* referenceSurface_impl(ActsTrk::IndexType itrack) const;

  Acts::ParticleHypothesis particleHypothesis_impl(IndexType itrack) const;

  std::size_t size_impl() const;

  std::any component_impl(Acts::HashedString key,
                          ActsTrk::IndexType itrack) const;

  ActsTrk::ConstParameters parameters(ActsTrk::IndexType itrack) const;

  ActsTrk::ConstCovariance covariance(ActsTrk::IndexType itrack) const;
  
  void fillFrom(ActsTrk::MutableTrackSummaryContainer& mtb);
 
  template<typename T>
  friend class MutableTrackContainerHandle;
  friend class MutableTrackSummaryContainer;
 
  void restoreDecorations();
 
  void decodeSurfaces(const xAOD::TrackSurfaceContainer* src);
 
  std::vector<Acts::HashedString> dynamicKeys_impl() const;
 
 protected:
 
  DataLink<xAOD::TrackSummaryContainer> m_trackBackend = nullptr;
  std::vector<ActsTrk::detail::Decoration> m_decorations;
  std::vector<std::shared_ptr<const Acts::Surface>> m_surfaces; // decoded transient form of surfaces
};
 
class MutableTrackSummaryContainer : public TrackSummaryContainer {
 public:
  MutableTrackSummaryContainer();
  MutableTrackSummaryContainer(const MutableTrackSummaryContainer&) = delete;
  MutableTrackSummaryContainer operator=(const MutableTrackSummaryContainer&) = delete;
  MutableTrackSummaryContainer(MutableTrackSummaryContainer&&);
  MutableTrackSummaryContainer& operator=(MutableTrackSummaryContainer&& other) noexcept;
  
  ActsTrk::IndexType addTrack_impl();

  void removeTrack_impl(ActsTrk::IndexType itrack);

  template <typename T>
  constexpr void addColumn_impl(std::string_view key);

  void copyDynamicFrom_impl (ActsTrk::IndexType itrack,
                             Acts::HashedString key,
                             const std::any& src_ptr);
 

  std::any component_impl(Acts::HashedString key,
                          ActsTrk::IndexType itrack);
  using TrackSummaryContainer::component_impl;

  ActsTrk::Parameters parameters(ActsTrk::IndexType itrack);
  using TrackSummaryContainer::parameters;

  ActsTrk::Covariance covariance(ActsTrk::IndexType itrack);
  using TrackSummaryContainer::covariance;

  void ensureDynamicColumns_impl(const MutableTrackSummaryContainer& other);
  void ensureDynamicColumns_impl(const TrackSummaryContainer& other);

  void reserve(ActsTrk::IndexType size);

  void clear();

  void setReferenceSurface_impl(ActsTrk::IndexType itrack,
                                std::shared_ptr<const Acts::Surface> surface);
  void setParticleHypothesis_impl(ActsTrk::IndexType itrack, 
                                  const Acts::ParticleHypothesis& particleHypothesis);
 
  friend class ActsTrk::MutableTrackContainerHandlesHelper;
 
 
  xAOD::TrackSummaryContainer* trackBackend(){
    return m_mutableTrackBackend.get();
  }
 
  void encodeSurfaces(xAOD::TrackSurfaceAuxContainer* dest, const Acts::GeometryContext&);
 
 private:
  std::unique_ptr<xAOD::TrackSummaryContainer> m_mutableTrackBackend;
  std::unique_ptr<xAOD::TrackSummaryAuxContainer> m_mutableTrackBackendAux;
};
 
 
constexpr bool ActsTrk::TrackSummaryContainer::hasColumn_impl(
    Acts::HashedString key) const {
  using namespace Acts::HashedStringLiteral;
  switch (key) {
    case "params"_hash:
    case "cov"_hash:
    case "nMeasurements"_hash:
    case "nHoles"_hash:
    case "d0"_hash:
    case "chi2"_hash:
    case "ndf"_hash:
    case "nOutliers"_hash:
    case "hSharedHits"_hash:
    case "tipIndex"_hash:
    case "stemIndex"_hash:
 
      return true;
  }
  for (auto& d : m_decorations) {
    if (d.hash == key) {
      return true;
    }
  }
  return false;
}
 
namespace details{
} // EOF detail
 
template <typename T>
constexpr void MutableTrackSummaryContainer::addColumn_impl(
    std::string_view name) {
  if (not ActsTrk::detail::accepted_decoration_types<T>::value) {
    throw std::runtime_error(
        "TrackSummaryContainer::addColumn_impl: "
        "unsupported decoration type");
  }
  m_decorations.emplace_back(ActsTrk::detail::decoration<T>(
      name,
      ActsTrk::detail::constDecorationGetter<T>, 
      ActsTrk::detail::decorationCopier<T>,
      ActsTrk::detail::decorationSetter<T>
      ));
}
 
}  // namespace ActsTrk
 
#include "AthenaKernel/CLASS_DEF.h"
CLASS_DEF( ActsTrk::TrackSummaryContainer, 1185802350, 1 )
#endif