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