stepper_extension_list_implementation.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2018 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/Utilities/Definitions.hpp"


namespace Acts {
namespace detail {
template <unsigned int N>
struct stepper_extension_list_impl;

template <unsigned int N>
struct stepper_extension_list_impl {
  template <typename propagator_state_t, typename stepper_t, typename... T>
  static void bid(const std::tuple<T...>& obs_tuple,
                  const propagator_state_t& state, const stepper_t& stepper,
                  std::array<int, sizeof...(T)>& bids) {
    std::get<N - 1>(bids) = std::get<N - 1>(obs_tuple).bid(state, stepper);
    stepper_extension_list_impl<N - 1>::bid(obs_tuple, state, stepper, bids);
  }

  template <typename propagator_state_t, typename stepper_t, typename... T>
  static bool k(std::tuple<T...>& obs_tuple, const propagator_state_t& state,
                const stepper_t& stepper, Vector3D& knew,
                const Vector3D& bField, std::array<double, 4>& kQoP,
                const std::array<bool, sizeof...(T)>& validExtensions,
                const int i = 0, const double h = 0,
                const Vector3D& kprev = Vector3D()) {
    // If element is invalid: continue
    if (!std::get<N - 1>(validExtensions)) {
      return stepper_extension_list_impl<N - 1>::k(
          obs_tuple, state, stepper, knew, bField, kQoP, validExtensions, i, h,
          kprev);
    }

    // Continue as long as evaluations are 'true'
    if (std::get<N - 1>(obs_tuple).k(state, stepper, knew, bField, kQoP, i, h,
                                     kprev)) {
      return stepper_extension_list_impl<N - 1>::k(
          obs_tuple, state, stepper, knew, bField, kQoP, validExtensions, i, h,
          kprev);
    } else {
      // Break at false
      return false;
    }
  }

  template <typename propagator_state_t, typename stepper_t, typename... T>
  static bool finalize(const std::tuple<T...>& obs_tuple,
                       propagator_state_t& state, const stepper_t& stepper,
                       const double h, FreeMatrix& D,
                       const std::array<bool, sizeof...(T)>& validExtensions) {
    // If element is invalid: continue
    if (!std::get<N - 1>(validExtensions)) {
      return stepper_extension_list_impl<N - 1>::finalize(
          obs_tuple, state, stepper, h, D, validExtensions);
    }

    // Continue as long as evaluations are 'true'
    if (std::get<N - 1>(obs_tuple).finalize(state, stepper, h, D)) {
      return stepper_extension_list_impl<N - 1>::finalize(
          obs_tuple, state, stepper, h, D, validExtensions);
    } else {
      // Break at false
      return false;
    }
  }

  template <typename propagator_state_t, typename stepper_t, typename... T>
  static bool finalize(const std::tuple<T...>& obs_tuple,
                       propagator_state_t& state, const stepper_t& stepper,
                       const double h,
                       const std::array<bool, sizeof...(T)>& validExtensions) {
    // If element is invalid: continue
    if (!std::get<N - 1>(validExtensions)) {
      return stepper_extension_list_impl<N - 1>::finalize(
          obs_tuple, state, stepper, h, validExtensions);
    }

    // Continue as long as evaluations are 'true'
    if (std::get<N - 1>(obs_tuple).finalize(state, stepper, h)) {
      return stepper_extension_list_impl<N - 1>::finalize(
          obs_tuple, state, stepper, h, validExtensions);
    } else {
      // Break at false
      return false;
    }
  }
};

template <>
struct stepper_extension_list_impl<0u> {
  template <typename propagator_state_t, typename stepper_t, typename... T>
  static void bid(const std::tuple<T...>& /*unused*/,
                  const propagator_state_t& /*unused*/,
                  const stepper_t& /*unused*/,
                  std::array<int, sizeof...(T)>& /*unused*/) {}

  template <typename propagator_state_t, typename stepper_t, typename... T>
  static bool k(std::tuple<T...>& /*unused*/,
                const propagator_state_t& /*unused*/,
                const stepper_t& /*unused*/, Vector3D& /*unused*/,
                const Vector3D& /*unused*/, std::array<double, 4>& /*unused*/,
                const std::array<bool, sizeof...(T)>& /*unused*/,
                const int /*unused*/, const double /*unused*/,
                const Vector3D& /*unused*/) {
    return true;
  }

  template <typename propagator_state_t, typename stepper_t, typename... T>
  static bool finalize(const std::tuple<T...>& /*unused*/,
                       propagator_state_t& /*unused*/,
                       const stepper_t& /*unused*/, const double /*unused*/,
                       FreeMatrix& /*unused*/,
                       const std::array<bool, sizeof...(T)>& /*unused*/) {
    return true;
  }

  template <typename propagator_state_t, typename stepper_t, typename... T>
  static bool finalize(const std::tuple<T...>& /*unused*/,
                       propagator_state_t& /*unused*/,
                       const stepper_t& /*unused*/, const double /*unused*/,
                       const std::array<bool, sizeof...(T)>& /*unused*/) {
    return true;
  }
};

}  // namespace detail
}  // namespace Acts