NavigationStateUpdators.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2022 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/Common.hpp"
#include "Acts/Detector/Portal.hpp"
#include "Acts/Navigation/NavigationDelegates.hpp"
#include "Acts/Surfaces/Surface.hpp"
#include "Acts/Utilities/BinningType.hpp"
#include "Acts/Utilities/Enumerate.hpp"
#include "Acts/Utilities/IAxis.hpp"
#include "Acts/Utilities/VectorHelpers.hpp"

#include <array>
#include <memory>

namespace Acts {

namespace Experimental {

inline void updateCandidates(const GeometryContext& gctx,
                             NavigationState& nState) {
  const auto& position = nState.position;
  const auto& direction = nState.direction;
  auto& nCandidates = nState.surfaceCandidates;

  for (auto& c : nCandidates) {
    // Get the surface representation: either native surfcae of portal
    const Surface& sRep =
        c.surface != nullptr ? *c.surface : c.portal->surface();

    // Get the intersection @todo make a templated intersector
    // TODO surface tolerance
    auto sIntersection = sRep.intersect(gctx, position, direction,
                                        c.boundaryCheck, s_onSurfaceTolerance);
    c.objectIntersection = sIntersection[c.objectIntersection.index()];
  }
}

template <typename object_type, typename filler_type>
class SingleObjectImpl : public INavigationDelegate {
 public:
  SingleObjectImpl(const object_type* so) : object(so) {}

  void update([[maybe_unused]] const GeometryContext& gctx,
              NavigationState& nState) const {
    filler_type::fill(nState, object);
  }

 private:
  // The object to be filled in
  const object_type* object = nullptr;
};

template <typename extractor_type, typename filler_type>
class StaticUpdatorImpl : public INavigationDelegate {
 public:
  void update([[maybe_unused]] const GeometryContext& gctx,
              NavigationState& nState) const {
    auto extracted = extractor_type::extract(gctx, nState);
    filler_type::fill(nState, extracted);
  }
};

template <typename grid_t, typename extractor_type, typename filler_type>
class IndexedUpdatorImpl : public INavigationDelegate {
 public:
  using grid_type = grid_t;

  extractor_type extractor;

  grid_type grid;

  std::array<BinningValue, grid_type::DIM> casts{};

  Transform3 transform = Transform3::Identity();

  IndexedUpdatorImpl(grid_type&& igrid,
                     const std::array<BinningValue, grid_type::DIM>& icasts,
                     const Transform3& itr = Transform3::Identity())
      : grid(std::move(igrid)), casts(icasts), transform(itr) {}

  IndexedUpdatorImpl() = delete;

  void update(const GeometryContext& gctx, NavigationState& nState) const {
    // Extract the index grid entry
    const auto& entry = grid.atPosition(castPosition(nState.position));
    auto extracted = extractor.extract(gctx, nState, entry);
    filler_type::fill(nState, extracted);

    updateCandidates(gctx, nState);
  }

  std::array<ActsScalar, grid_type::DIM> castPosition(
      const Vector3& position) const {
    // Transform into local 3D frame
    Vector3 tposition = transform * position;

    std::array<ActsScalar, grid_type::DIM> casted{};
    fillCasts(tposition, casted,
              std::make_integer_sequence<std::size_t, grid_type::DIM>{});
    return casted;
  }

 private:
  template <typename Array, std::size_t... idx>
  void fillCasts(const Vector3& position, Array& a,
                 std::index_sequence<idx...> /*indices*/) const {
    ((a[idx] = VectorHelpers::cast(position, casts[idx])), ...);
  }
};

template <typename... updators_t>
class ChainedUpdatorImpl : public INavigationDelegate {
 public:
  std::tuple<updators_t...> updators;

  ChainedUpdatorImpl(const std::tuple<updators_t...>&& upts)
      : updators(std::move(upts)) {}

  void update(const GeometryContext& gctx, NavigationState& nState) const {
    // Unfold the tuple and add the attachers
    std::apply(
        [&](auto&&... updator) { ((updator.update(gctx, nState)), ...); },
        updators);
  }
};

}  // namespace Experimental
}  // namespace Acts