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) 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/Propagator/detail/Auctioneer.hpp"
#include "Acts/Propagator/detail/stepper_extension_list_implementation.hpp"
#include "Acts/Utilities/detail/Extendable.hpp"
#include "Acts/Utilities/detail/MPL/all_of.hpp"
#include "Acts/Utilities/detail/MPL/has_duplicates.hpp"

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;

  using impl = detail::stepper_extension_list_impl<nExtensions>;

  // 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>
  bool validExtensionForStep(const propagator_state_t& state,
                             const stepper_t& stepper) {
    std::array<int, nExtensions> bids;
    // Ask all extensions for a boolean statement of their validity
    impl::bid(tuple(), state, stepper, bids);
    // Post-process the vector in an auctioneer
    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>
  bool k1(const propagator_state_t& state, const stepper_t& stepper,
          Vector3D& knew, const Vector3D& bField, std::array<double, 4>& kQoP) {
    return impl::k(tuple(), state, stepper, knew, bField, kQoP,
                   validExtensions);
  }

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

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

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

  template <typename propagator_state_t, typename stepper_t>
  bool finalize(propagator_state_t& state, const stepper_t& stepper,
                const double h, FreeMatrix& D) {
    return impl::finalize(tuple(), state, stepper, h, D, validExtensions);
  }

  template <typename propagator_state_t, typename stepper_t>
  bool finalize(propagator_state_t& state, const stepper_t& stepper,
                const double h) {
    return impl::finalize(tuple(), state, stepper, h, validExtensions);
  }
};

}  // namespace Acts