File indexing completed on 2025-07-12 07:51:36
0001
0002
0003
0004
0005
0006
0007
0008
0009 #pragma once
0010
0011 #include "Acts/Definitions/Algebra.hpp"
0012 #include "Acts/Definitions/TrackParametrization.hpp"
0013 #include "Acts/EventData/detail/CorrectedTransformationFreeToBound.hpp"
0014 #include "Acts/Propagator/ConstrainedStep.hpp"
0015 #include "Acts/Surfaces/BoundaryTolerance.hpp"
0016 #include "Acts/Surfaces/Surface.hpp"
0017 #include "Acts/Utilities/Concepts.hpp"
0018 #include "Acts/Utilities/Logger.hpp"
0019
0020 namespace Acts {
0021 namespace Concepts {
0022
0023
0024 template <typename Stepper, typename State = typename Stepper::State>
0025 concept CommonStepper = requires {
0026 typename Stepper::State;
0027 typename Stepper::Jacobian;
0028 typename Stepper::Covariance;
0029 typename Stepper::BoundState;
0030
0031 requires requires(const Stepper& s, State& t) {
0032 { s.transportCovarianceToCurvilinear(t) } -> std::same_as<void>;
0033
0034 requires requires(const Surface& sf, bool b,
0035 const FreeToBoundCorrection& corr) {
0036 {
0037 s.boundState(t, sf, b, corr)
0038 } -> std::same_as<Result<typename Stepper::BoundState>>;
0039 { s.transportCovarianceToBound(t, sf, corr) } -> std::same_as<void>;
0040 };
0041
0042 requires requires(bool b) {
0043 {
0044 s.curvilinearState(t, b)
0045 } -> std::same_as<typename Stepper::BoundState>;
0046 };
0047
0048 requires requires(const Surface& sf, std::uint8_t ui, Direction d,
0049 const BoundaryTolerance& bt, double sc,
0050 ConstrainedStep::Type st, const Logger& l) {
0051 { s.updateSurfaceStatus(t, sf, ui, d, bt, sc, st, l) };
0052 };
0053
0054 requires requires(const ConstrainedStep::Type st) {
0055 { s.releaseStepSize(t, st) } -> std::same_as<void>;
0056
0057 requires requires(double d) {
0058 { s.updateStepSize(t, d, st) } -> std::same_as<void>;
0059 };
0060 };
0061 };
0062
0063 requires requires(const Stepper& s, const State& t) {
0064 { s.position(t) } -> std::same_as<Vector3>;
0065 { s.direction(t) } -> std::same_as<Vector3>;
0066 { s.qOverP(t) } -> std::same_as<double>;
0067 { s.absoluteMomentum(t) } -> std::same_as<double>;
0068 { s.momentum(t) } -> std::same_as<Vector3>;
0069 { s.charge(t) } -> std::same_as<double>;
0070 { s.time(t) } -> std::same_as<double>;
0071 { s.outputStepSize(t) } -> std::same_as<std::string>;
0072
0073 requires requires(const ConstrainedStep::Type st) {
0074 { s.getStepSize(t, st) } -> std::same_as<double>;
0075 };
0076 };
0077 };
0078
0079
0080 template <typename Stepper, typename State = typename Stepper::State>
0081 concept SingleStepper =
0082 CommonStepper<Stepper, State> && requires(const Stepper& s, State& t) {
0083 requires requires(const FreeVector& fv, const BoundVector& bv,
0084 const BoundSquareMatrix& bm, const Surface& sf) {
0085 { s.update(t, fv, bv, bm, sf) } -> std::same_as<void>;
0086 };
0087
0088 requires requires(const Vector3& v1, const Vector3& v2, double d1,
0089 double d2) {
0090 { s.update(t, v1, v2, d1, d2) } -> std::same_as<void>;
0091 { s.getField(t, v1) } -> std::same_as<Result<Vector3>>;
0092 };
0093 };
0094
0095
0096 template <typename Stepper, typename State = typename Stepper::State>
0097 concept MultiStepper = CommonStepper<Stepper, State> && requires {
0098
0099 typename Stepper::ComponentProxy;
0100
0101
0102
0103 typename Stepper::ConstComponentProxy;
0104
0105 requires requires(const Stepper& s, State& t) {
0106 { s.numberComponents(t) } -> std::same_as<std::size_t>;
0107 { s.clearComponents(t) } -> std::same_as<void>;
0108 { s.removeMissedComponents(t) } -> std::same_as<void>;
0109 };
0110 };
0111 }
0112
0113
0114 template <typename _Stepper, typename State = typename _Stepper::State>
0115 concept StepperConcept = Concepts::SingleStepper<_Stepper, State> ||
0116 Concepts::MultiStepper<_Stepper, State>;
0117
0118
0119 template <typename State>
0120 concept StepperStateConcept = requires(const State& t) {
0121 { t.covTransport } -> Concepts::decayed_same_as<const bool&>;
0122 { t.pathAccumulated } -> Concepts::decayed_same_as<const double&>;
0123 };
0124
0125 }