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/Surfaces/BoundaryTolerance.hpp"
0017 #include "Acts/Surfaces/Surface.hpp"
0018 #include "Acts/Utilities/Concepts.hpp"
0019 #include "Acts/Utilities/Logger.hpp"
0020
0021 namespace Acts {
0022 namespace Concepts {
0023
0024 /// @brief Concept that is satisfied by both single- and multi-steppers.
0025 template <typename Stepper, typename State = typename Stepper::State>
0026 concept CommonStepper = requires {
0027   typename Stepper::BoundParameters;
0028   typename Stepper::State;
0029   typename Stepper::Jacobian;
0030   typename Stepper::Covariance;
0031   typename Stepper::BoundState;
0032
0033   requires requires(const Stepper& s, State& t) {
0034     { s.transportCovarianceToCurvilinear(t) } -> std::same_as<void>;
0035
0036     requires requires(
0037         const std::tuple_element_t<0, typename Stepper::BoundState>& par) {
0038       { s.initialize(t, par) } -> std::same_as<void>;
0039     };
0040
0041     requires requires(const Surface& sf, bool b,
0042                       const FreeToBoundCorrection& corr) {
0043       {
0044         s.boundState(t, sf, b, corr)
0045       } -> std::same_as<Result<typename Stepper::BoundState>>;
0046       { s.transportCovarianceToBound(t, sf, corr) } -> std::same_as<void>;
0047     };
0048
0049     requires requires(bool b) {
0050       {
0051         s.curvilinearState(t, b)
0052       } -> std::same_as<typename Stepper::BoundState>;
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
0080     requires requires(const ConstrainedStep::Type st) {
0081       { s.getStepSize(t, st) } -> std::same_as<double>;
0082     };
0083   };
0084 };
0085
0086 /// @brief Concept that is satisfied by single-steppers.
0087 template <typename Stepper, typename State = typename Stepper::State>
0088 concept SingleStepper =
0089     CommonStepper<Stepper, State> && requires(const Stepper& s, State& t) {
0090       requires BoundTrackParametersConcept<typename Stepper::BoundParameters>;
0091
0092       requires requires(const FreeVector& fv, const BoundVector& bv,
0093                         const BoundMatrix& bm, const Surface& sf) {
0094         { s.update(t, fv, bv, bm, sf) } -> std::same_as<void>;
0095       };
0096
0097       requires requires(const Vector3& v1, const Vector3& v2, double d1,
0098                         double d2) {
0099         { s.update(t, v1, v2, d1, d2) } -> std::same_as<void>;
0100         { s.getField(t, v1) } -> std::same_as<Result<Vector3>>;
0101       };
0102     };
0103
0104 /// @brief Concept that is satisfied by multi-steppers.
0105 template <typename Stepper, typename State = typename Stepper::State>
0106 concept MultiStepper = CommonStepper<Stepper, State> && requires {
0107   // TODO for now we do not check if the ComponentProxy does fulfill a concept
0108   typename Stepper::ComponentProxy;
0109
0110   // TODO for now we do not check if the ConstComponentProxy does fulfill a
0111   // concept
0112   typename Stepper::ConstComponentProxy;
0113
0114   requires requires(const Stepper& s, State& t) {
0115     { s.numberComponents(t) } -> std::same_as<std::size_t>;
0116     { s.clearComponents(t) } -> std::same_as<void>;
0117     { s.removeMissedComponents(t) } -> std::same_as<void>;
0118   };
0119 };
0120 }  // namespace Concepts
0121
0122 /// @brief Concept that is satisfied by steppers.
0123 template <typename _Stepper, typename State = typename _Stepper::State>
0124 concept StepperConcept = Concepts::SingleStepper<_Stepper, State> ||
0125                          Concepts::MultiStepper<_Stepper, State>;
0126
0127 /// @brief Concept that is satisfied by stepper states.
0128 template <typename State>
0129 concept StepperStateConcept = requires(const State& t) {
0130   { t.covTransport } -> Concepts::decayed_same_as<const bool&>;
0131   { t.pathAccumulated } -> Concepts::decayed_same_as<const double&>;
0132 };
0133
0134 }  // namespace Acts