StepperExtensionList.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2021 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/Propagator/detail/Auctioneer.hpp"
#include "Acts/Utilities/detail/Extendable.hpp"
#include "Acts/Utilities/detail/MPL/all_of.hpp"
#include "Acts/Utilities/detail/MPL/has_duplicates.hpp"

#include <array>

namespace Acts {

template <typename... extensions>
struct StepperExtensionList : private detail::Extendable<extensions...> {
 private:
  // Checkout for duplicates in the extensions
  static_assert(not detail::has_duplicates_v<extensions...>,
                "same extension type specified several times");

  static constexpr unsigned int nExtensions = sizeof...(extensions);

  static_assert(nExtensions != 0, "no extension type specified");

  // Access to all extensions
  using detail::Extendable<extensions...>::tuple;

  // Vector of valid extensions for a step
  std::array<bool, nExtensions> validExtensions{};

 public:
  // Access to an extension
  using detail::Extendable<extensions...>::get;

  template <typename propagator_state_t, typename stepper_t,
            typename navigtor_t>
  bool validExtensionForStep(const propagator_state_t& state,
                             const stepper_t& stepper,
                             const navigtor_t& navigator) {
    const auto bids = std::apply(
        [&](const auto&... ext) {
          return std::array<int, nExtensions>{
              ext.bid(state, stepper, navigator)...};
        },
        tuple());

    validExtensions = state.stepping.auctioneer(std::move(bids));

    return (std::find(validExtensions.begin(), validExtensions.end(), true) !=
            validExtensions.end());
  }

  template <typename propagator_state_t, typename stepper_t,
            typename navigator_t>
  bool k(const propagator_state_t& state, const stepper_t& stepper,
         const navigator_t& navigator, Vector3& knew, const Vector3& bField,
         std::array<double, 4>& kQoP, const int i, const double h = 0.,
         const Vector3& kprev = Vector3::Zero()) {
    // TODO replace with integer-templated lambda with C++20
    auto impl = [&, i, h](auto intType, auto& implRef) {
      constexpr int N = decltype(intType)::value;

      if constexpr (N == 0) {
        return true;
      } else {
        // If element is invalid: continue
        if (!std::get<N - 1>(validExtensions)) {
          return implRef(std::integral_constant<int, N - 1>{}, implRef);
        }
        // Continue as long as evaluations are 'true'
        if (std::get<N - 1>(this->tuple())
                .template k(state, stepper, navigator, knew, bField, kQoP, i, h,
                            kprev)) {
          return implRef(std::integral_constant<int, N - 1>{}, implRef);
        } else {
          // Break at false
          return false;
        }
      }
    };

    return impl(std::integral_constant<int, nExtensions>{}, impl);
  }

  template <typename propagator_state_t, typename stepper_t,
            typename navigator_t>
  bool k1(const propagator_state_t& state, const stepper_t& stepper,
          const navigator_t& navigator, Vector3& knew, const Vector3& bField,
          std::array<double, 4>& kQoP) {
    return k(state, stepper, navigator, knew, bField, kQoP, 0);
  }

  template <typename propagator_state_t, typename stepper_t,
            typename navigator_t>
  bool k2(const propagator_state_t& state, const stepper_t& stepper,
          const navigator_t& navigator, Vector3& knew, const Vector3& bField,
          std::array<double, 4>& kQoP, const double h, const Vector3& kprev) {
    return k(state, stepper, navigator, knew, bField, kQoP, 1, h, kprev);
  }

  template <typename propagator_state_t, typename stepper_t,
            typename navigator_t>
  bool k3(const propagator_state_t& state, const stepper_t& stepper,
          const navigator_t& navigator, Vector3& knew, const Vector3& bField,
          std::array<double, 4>& kQoP, const double h, const Vector3& kprev) {
    return k(state, stepper, navigator, knew, bField, kQoP, 2, h, kprev);
  }

  template <typename propagator_state_t, typename stepper_t,
            typename navigator_t>
  bool k4(const propagator_state_t& state, const stepper_t& stepper,
          const navigator_t& navigator, Vector3& knew, const Vector3& bField,
          std::array<double, 4>& kQoP, const double h, const Vector3& kprev) {
    return k(state, stepper, navigator, knew, bField, kQoP, 3, h, kprev);
  }

  template <typename propagator_state_t, typename stepper_t,
            typename navigator_t>
  bool finalize(propagator_state_t& state, const stepper_t& stepper,
                const navigator_t& navigator, const double h, FreeMatrix& D) {
    // TODO replace with integer-templated lambda with C++20
    auto impl = [&, h](auto intType, auto& implRef) {
      constexpr int N = decltype(intType)::value;

      if constexpr (N == 0) {
        return true;
      } else {
        // If element is invalid: continue
        if (!std::get<N - 1>(validExtensions)) {
          return implRef(std::integral_constant<int, N - 1>{}, implRef);
        }
        // Continue as long as evaluations are 'true'
        if (std::get<N - 1>(this->tuple())
                .finalize(state, stepper, navigator, h, D)) {
          return implRef(std::integral_constant<int, N - 1>{}, implRef);
        } else {
          // Break at false
          return false;
        }
      }
    };

    return impl(std::integral_constant<int, nExtensions>{}, impl);
  }

  template <typename propagator_state_t, typename stepper_t,
            typename navigator_t>
  bool finalize(propagator_state_t& state, const stepper_t& stepper,
                const navigator_t& navigator, const double h) {
    // TODO replace with integer-templated lambda with C++20
    auto impl = [&, h](auto intType, auto& implRef) {
      constexpr int N = decltype(intType)::value;

      if constexpr (N == 0) {
        return true;
      } else {
        // If element is invalid: continue
        if (!std::get<N - 1>(validExtensions)) {
          return implRef(std::integral_constant<int, N - 1>{}, implRef);
        }

        // Continue as long as evaluations are 'true'
        if (std::get<N - 1>(this->tuple())
                .finalize(state, stepper, navigator, h)) {
          return implRef(std::integral_constant<int, N - 1>{}, implRef);
        } else {
          // Break at false
          return false;
        }
      }
    };

    return impl(std::integral_constant<int, nExtensions>{}, impl);
  }
};

}  // namespace Acts