Acts/Propagator/StepperConcept.hpp

0001 // This file is part of the Acts project.
0002 //
0003 // Copyright (C) 2019-2020 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 http://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/TrackParameters.hpp"
0014 #include "Acts/EventData/detail/CorrectedTransformationFreeToBound.hpp"
0015 #include "Acts/Propagator/ConstrainedStep.hpp"
0016 #include "Acts/Surfaces/BoundaryTolerance.hpp"
0017 #include "Acts/Surfaces/Surface.hpp"
0018 #include "Acts/Utilities/Concepts.hpp"
0019 #include "Acts/Utilities/Intersection.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::State;
0029   typename Stepper::Jacobian;
0030   typename Stepper::Covariance;
0031   typename Stepper::BoundState;
0032   typename Stepper::CurvilinearState;
0033
0034   requires requires(const Stepper& s, State& t) {
0035     { s.transportCovarianceToCurvilinear(t) } -> std::same_as<void>;
0036
0037     requires requires(const BoundVector& bv, const BoundSquareMatrix& bm,
0038                       const Surface& sf, const double d) {
0039       { s.resetState(t, bv, bm, sf, d) } -> std::same_as<void>;
0040     };
0041
0042     requires requires(const Surface& sf, bool b,
0043                       const FreeToBoundCorrection& corr) {
0044       {
0045         s.boundState(t, sf, b, corr)
0046       } -> std::same_as<Result<typename Stepper::BoundState>>;
0047       { s.transportCovarianceToBound(t, sf, corr) } -> std::same_as<void>;
0048     };
0049
0050     requires requires(bool b) {
0051       {
0052         s.curvilinearState(t, b)
0053       } -> std::same_as<typename Stepper::CurvilinearState>;
0054     };
0055
0056     requires requires(const Surface& sf, std::uint8_t ui, Direction d,
0057                       const BoundaryTolerance& bt, ActsScalar sc,
0058                       const Logger& l) {
0059       { s.updateSurfaceStatus(t, sf, ui, d, bt, sc, l) };
0060     };
0061
0062     requires requires(const ConstrainedStep::Type st) {
0063       { s.releaseStepSize(t, st) } -> std::same_as<void>;
0064
0065       requires requires(double d, bool b) {
0066         { s.updateStepSize(t, d, st, b) } -> std::same_as<void>;
0067       };
0068     };
0069   };
0070
0071   requires requires(const Stepper& s, const State& t) {
0072     { s.position(t) } -> std::same_as<Vector3>;
0073     { s.direction(t) } -> std::same_as<Vector3>;
0074     { s.qOverP(t) } -> std::same_as<double>;
0075     { s.absoluteMomentum(t) } -> std::same_as<double>;
0076     { s.momentum(t) } -> std::same_as<Vector3>;
0077     { s.charge(t) } -> std::same_as<double>;
0078     { s.time(t) } -> std::same_as<double>;
0079     { s.outputStepSize(t) } -> std::same_as<std::string>;
0080
0081     requires requires(const ConstrainedStep::Type st) {
0082       { s.getStepSize(t, st) } -> std::same_as<double>;
0083     };
0084   };
0085 };
0086
0087 /// @brief Concept that is satisfied by single-steppers.
0088 template <typename Stepper, typename State = typename Stepper::State>
0089 concept SingleStepper =
0090     CommonStepper<Stepper, State> && requires(const Stepper& s, State& t) {
0091       requires requires(const FreeVector& fv, const BoundVector& bv,
0092                         const BoundSquareMatrix& bm, const Surface& sf) {
0093         { s.update(t, fv, bv, bm, sf) } -> std::same_as<void>;
0094       };
0095
0096       requires requires(const Vector3& v1, const Vector3& v2, double d1,
0097                         double d2) {
0098         { s.update(t, v1, v2, d1, d2) } -> std::same_as<void>;
0099         { s.getField(t, v1) } -> std::same_as<Result<Vector3>>;
0100       };
0101     };
0102
0103 /// @brief Concept that is satisfied by multi-steppers.
0104 template <typename Stepper, typename State = typename Stepper::State>
0105 concept MultiStepper = CommonStepper<Stepper, State> && requires {
0106   // TODO for now we do not check if the ComponentProxy does fulfill a concept
0107   typename Stepper::ComponentProxy;
0108
0109   // TODO for now we do not check if the ConstComponentProxy does fulfill a
0110   // concept
0111   typename Stepper::ConstComponentProxy;
0112
0113   requires requires(const Stepper& s, State& t) {
0114     { s.numberComponents(t) } -> std::same_as<std::size_t>;
0115     { s.clearComponents(t) } -> std::same_as<void>;
0116     { s.removeMissedComponents(t) } -> std::same_as<void>;
0117   };
0118 };
0119 }  // namespace Concepts
0120
0121 /// @brief Concept that is satisfied by steppers.
0122 template <typename _Stepper, typename State = typename _Stepper::State>
0123 concept StepperConcept = Concepts::SingleStepper<_Stepper, State> ||
0124                          Concepts::MultiStepper<_Stepper, State>;
0125
0126 /// @brief Concept that is satisfied by stepper states.
0127 template <typename State>
0128 concept StepperStateConcept = requires(const State& t) {
0129   { t.covTransport } -> Concepts::decayed_same_as<const bool&>;
0130   { t.pathAccumulated } -> Concepts::decayed_same_as<const double&>;
0131 };
0132
0133 }  // namespace Acts