Back to home page

EIC code displayed by LXR

 
 

    


File indexing completed on 2025-07-12 07:51:36

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 
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 /// @brief Concept that is satisfied by single-steppers.
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 /// @brief Concept that is satisfied by multi-steppers.
0096 template <typename Stepper, typename State = typename Stepper::State>
0097 concept MultiStepper = CommonStepper<Stepper, State> && requires {
0098   // TODO for now we do not check if the ComponentProxy does fulfill a concept
0099   typename Stepper::ComponentProxy;
0100 
0101   // TODO for now we do not check if the ConstComponentProxy does fulfill a
0102   // concept
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 }  // namespace Concepts
0112 
0113 /// @brief Concept that is satisfied by steppers.
0114 template <typename _Stepper, typename State = typename _Stepper::State>
0115 concept StepperConcept = Concepts::SingleStepper<_Stepper, State> ||
0116                          Concepts::MultiStepper<_Stepper, State>;
0117 
0118 /// @brief Concept that is satisfied by stepper states.
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 }  // namespace Acts