Acts::Concepts::CommonStepper Concept Reference

Concept that is satisfied by both single- and multi-steppers. More...

#include <Acts/Propagator/StepperConcept.hpp>

Concept definition

template<typename Stepper, typename State typename Stepper::State>
concept Acts::Concepts::CommonStepper =  requires {
  typename Stepper::State;
  typename Stepper::Jacobian;
  typename Stepper::Covariance;
  typename Stepper::BoundState;
 
  requires requires(const Stepper& s, State& t) {
    { s.transportCovarianceToCurvilinear(t) } -> std::same_as<void>;
 
    requires requires(
        const std::tuple_element_t<0, typename Stepper::BoundState>& par) {
      { s.initialize(t, par) } -> std::same_as<void>;
    };
 
    requires requires(const Surface& sf, bool b,
                      const FreeToBoundCorrection& corr) {
      {
        s.boundState(t, sf, b, corr)
      } -> std::same_as<Result<typename Stepper::BoundState>>;
      { s.transportCovarianceToBound(t, sf, corr) } -> std::same_as<void>;
    };
 
    requires requires(bool b) {
      {
        s.curvilinearState(t, b)
      } -> std::same_as<typename Stepper::BoundState>;
    };
 
    requires requires(const Surface& sf, std::uint8_t ui, Direction d,
                      const BoundaryTolerance& bt, double sc,
                      ConstrainedStep::Type st, const Logger& l) {
      { s.updateSurfaceStatus(t, sf, ui, d, bt, sc, st, l) };
    };
 
    requires requires(const ConstrainedStep::Type st) {
      { s.releaseStepSize(t, st) } -> std::same_as<void>;
 
      requires requires(double d) {
        { s.updateStepSize(t, d, st) } -> std::same_as<void>;
      };
    };
  };
 
  requires requires(const Stepper& s, const State& t) {
    { s.position(t) } -> std::same_as<Vector3>;
    { s.direction(t) } -> std::same_as<Vector3>;
    { s.qOverP(t) } -> std::same_as<double>;
    { s.absoluteMomentum(t) } -> std::same_as<double>;
    { s.momentum(t) } -> std::same_as<Vector3>;
    { s.charge(t) } -> std::same_as<double>;
    { s.time(t) } -> std::same_as<double>;
    { s.outputStepSize(t) } -> std::same_as<std::string>;
 
    requires requires(const ConstrainedStep::Type st) {
      { s.getStepSize(t, st) } -> std::same_as<double>;
    };
  };
}

Detailed Description

Concept that is satisfied by both single- and multi-steppers.