Acts/Propagator/StepperConcept.hpp

0001 // This file is part of the ACTS project.
0002 //
0003 // Copyright (C) 2016 CERN for the benefit of the ACTS project
0004 //
0005 // This Source Code Form is subject to the terms of the Mozilla Public
0006 // License, v. 2.0. If a copy of the MPL was not distributed with this
0007 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
0008
0009 #pragma once
0010
0011 #include "Acts/Definitions/Algebra.hpp"
0012 #include "Acts/Definitions/TrackParametrization.hpp"
0013 #include "Acts/EventData/TrackParametersConcept.hpp"
0014 #include "Acts/EventData/detail/CorrectedTransformationFreeToBound.hpp"
0015 #include "Acts/Propagator/ConstrainedStep.hpp"
0016 #include "Acts/Propagator/StepperStatistics.hpp"
0017 #include "Acts/Surfaces/BoundaryTolerance.hpp"
0018 #include "Acts/Surfaces/Surface.hpp"
0019 #include "Acts/Utilities/Concepts.hpp"
0020 #include "Acts/Utilities/Logger.hpp"
0021
0022 namespace Acts {
0023 namespace Concepts {
0024
0025 /// @brief Concept that is satisfied by both single- and multi-steppers.
0026 template <typename Stepper, typename State = typename Stepper::State>
0027 concept CommonStepper = requires {
0028   typename Stepper::BoundParameters;
0029   typename Stepper::State;
0030   typename Stepper::Jacobian;
0031   typename Stepper::Covariance;
0032
0033   requires requires(const Stepper& s, State& t) {
0034     { s.transportToCurvilinear(t) } -> std::same_as<typename Stepper::Jacobian>;
0035     { s.prepareCurvilinearState(t) } -> std::same_as<bool>;
0036
0037     // Retain field-based compatibility for custom steppers until the next
0038     // breaking release; new steppers can provide curvature directly.
0039     requires requires {
0040       { s.curvature(t) } -> std::same_as<Result<Vector3>>;
0041     } || requires(const Vector3& position) {
0042       { s.getField(t, position) } -> std::same_as<Result<Vector3>>;
0043     };
0044
0045     requires requires(const typename Stepper::BoundParameters& par) {
0046       { s.initialize(t, par) } -> std::same_as<void>;
0047     };
0048
0049     requires requires(const Surface& sf, const FreeToBoundCorrection& corr) {
0050       {
0051         s.transportToBound(t, sf, corr)
0052       } -> std::same_as<Result<typename Stepper::Jacobian>>;
0053     };
0054
0055     requires requires(const Surface& sf, std::uint8_t ui, Direction d,
0056                       const BoundaryTolerance& bt, double sc,
0057                       ConstrainedStep::Type st, const Logger& l) {
0058       { s.updateSurfaceStatus(t, sf, ui, d, bt, sc, st, l) };
0059     };
0060
0061     requires requires(const ConstrainedStep::Type st) {
0062       { s.releaseStepSize(t, st) } -> std::same_as<void>;
0063
0064       requires requires(double d) {
0065         { s.updateStepSize(t, d, st) } -> std::same_as<void>;
0066       };
0067     };
0068   };
0069
0070   requires requires(const Stepper& s, const State& t) {
0071     { s.position(t) } -> std::same_as<Vector3>;
0072     { s.direction(t) } -> std::same_as<Vector3>;
0073     { s.qOverP(t) } -> std::same_as<double>;
0074     { s.absoluteMomentum(t) } -> std::same_as<double>;
0075     { s.momentum(t) } -> std::same_as<Vector3>;
0076     { s.charge(t) } -> std::same_as<double>;
0077     { s.time(t) } -> std::same_as<double>;
0078     { s.outputStepSize(t) } -> std::same_as<std::string>;
0079     { s.pathLength(t) } -> std::same_as<double>;
0080     { s.hasCovariance(t) } -> std::same_as<bool>;
0081     { s.statistics(t) } -> std::same_as<const StepperStatistics&>;
0082     {
0083       s.curvilinearParameters(t)
0084     } -> std::same_as<typename Stepper::BoundParameters>;
0085
0086     requires requires(const Surface& sf) {
0087       {
0088         s.boundParameters(t, sf)
0089       } -> std::same_as<Result<typename Stepper::BoundParameters>>;
0090     };
0091
0092     requires requires(const ConstrainedStep::Type st) {
0093       { s.getStepSize(t, st) } -> std::same_as<double>;
0094     };
0095   };
0096 };
0097
0098 /// @brief Concept that is satisfied by single-steppers.
0099 template <typename Stepper, typename State = typename Stepper::State>
0100 concept SingleStepper =
0101     CommonStepper<Stepper, State> && requires(const Stepper& s, State& t) {
0102       requires BoundTrackParametersConcept<typename Stepper::BoundParameters>;
0103
0104       requires requires(const Vector3& position) {
0105         { s.getField(t, position) } -> std::same_as<Result<Vector3>>;
0106       };
0107
0108       requires requires(const FreeVector& fv, const BoundVector& bv,
0109                         const BoundMatrix& bm, const Surface& sf) {
0110         { s.update(t, fv, bv, bm, sf) } -> std::same_as<void>;
0111       };
0112
0113       requires requires(const Vector3& v1, const Vector3& v2, double d1,
0114                         double d2) {
0115         { s.update(t, v1, v2, d1, d2) } -> std::same_as<void>;
0116       };
0117
0118       requires requires(const typename Stepper::Covariance& cov) {
0119         { s.setCovariance(t, cov) } -> std::same_as<void>;
0120       };
0121
0122       requires requires(const Stepper& cs, const State& ct) {
0123         {
0124           cs.covariance(ct)
0125         } -> std::same_as<const std::optional<typename Stepper::Covariance>&>;
0126         { cs.stepSize(ct) } -> std::same_as<const ConstrainedStep&>;
0127       };
0128     };
0129
0130 /// @brief Concept that is satisfied by multi-steppers.
0131 template <typename Stepper, typename State = typename Stepper::State>
0132 concept MultiStepper = CommonStepper<Stepper, State> && requires {
0133   // TODO for now we do not check if the ComponentProxy does fulfill a concept
0134   typename Stepper::ComponentProxy;
0135
0136   // TODO for now we do not check if the ConstComponentProxy does fulfill a
0137   // concept
0138   typename Stepper::ConstComponentProxy;
0139
0140   requires requires(const Stepper& s, State& t) {
0141     { s.numberComponents(t) } -> std::same_as<std::size_t>;
0142     { s.clearComponents(t) } -> std::same_as<void>;
0143     { s.removeMissedComponents(t) } -> std::same_as<void>;
0144   };
0145 };
0146 }  // namespace Concepts
0147
0148 /// @brief Concept that is satisfied by steppers.
0149 template <typename _Stepper, typename State = typename _Stepper::State>
0150 concept StepperConcept = Concepts::SingleStepper<_Stepper, State> ||
0151                          Concepts::MultiStepper<_Stepper, State>;
0152
0153 }  // namespace Acts