** Warning **

Issuing rollback() due to DESTROY without explicit disconnect() of DBD::mysql::db handle dbname=lxr_eic at /usr/local/share/lxr/lxr-2.3.7/lib/LXR/Common.pm line 1161, <GEN9> line 1.

Last-Modified: Mon, 19 Jan 2025 08:18:04 GMT Content-Type: text/html; charset=utf-8 /master/include/Acts/Propagator/StepperConcept.hpp
Back to home page

EIC code displayed by LXR
 
 

    

Warning, file /include/Acts/Propagator/StepperConcept.hpp was not indexed or was modified since last indexation (in which case cross-reference links may be missing, inaccurate or erroneous).

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/EventData/TrackParameters.hpp"
0013 #include "Acts/EventData/detail/CorrectedTransformationFreeToBound.hpp"
0014 #include "Acts/Propagator/ConstrainedStep.hpp"
0015 #include "Acts/Surfaces/BoundaryCheck.hpp"
0016 #include "Acts/Surfaces/Surface.hpp"
0017 #include "Acts/Utilities/Intersection.hpp"
0018 #include "Acts/Utilities/Logger.hpp"
0019 #include "Acts/Utilities/TypeTraits.hpp"
0020 
0021 namespace Acts {
0022 class Surface;
0023 
0024 namespace Concepts::Stepper {
0025 
0026 template <typename T>
0027 using state_t = typename T::State;
0028 
0029 template <typename T>
0030 using jacobian_t = typename T::Jacobian;
0031 template <typename T>
0032 using covariance_t = typename T::Covariance;
0033 template <typename T>
0034 using bound_state_t = typename T::BoundState;
0035 template <typename T>
0036 using curvilinear_state_t = typename T::CurvilinearState;
0037 
0038 METHOD_TRAIT(reset_state_t, resetState);
0039 METHOD_TRAIT(get_field_t, getField);
0040 METHOD_TRAIT(position_t, position);
0041 METHOD_TRAIT(direction_t, direction);
0042 METHOD_TRAIT(qop_t, qOverP);
0043 METHOD_TRAIT(absolute_momentum_t, absoluteMomentum);
0044 METHOD_TRAIT(momentum_t, momentum);
0045 METHOD_TRAIT(charge_t, charge);
0046 METHOD_TRAIT(time_t, time);
0047 METHOD_TRAIT(bound_state_method_t, boundState);
0048 METHOD_TRAIT(curvilinear_state_method_t, curvilinearState);
0049 METHOD_TRAIT(update_t, update);
0050 METHOD_TRAIT(covariance_transport_bound_t, transportCovarianceToBound);
0051 METHOD_TRAIT(covariance_transport_curvilinear_t,
0052              transportCovarianceToCurvilinear);
0053 METHOD_TRAIT(step_t, step);
0054 METHOD_TRAIT(update_surface_status_t, updateSurfaceStatus);
0055 METHOD_TRAIT(update_step_size_t, updateStepSize);
0056 METHOD_TRAIT(get_step_size_t, getStepSize);
0057 METHOD_TRAIT(release_step_size_t, releaseStepSize);
0058 METHOD_TRAIT(output_step_size_t, outputStepSize);
0059 
0060 template <typename T>
0061 using cov_transport_t = decltype(std::declval<T>().covTransport);
0062 template <typename T>
0063 using cov_t = decltype(std::declval<T>().cov);
0064 template <typename T>
0065 using path_accumulated_t = decltype(std::declval<T>().pathAccumulated);
0066 template <typename T>
0067 using step_size_t = decltype(std::declval<T>().stepSize);
0068 
0069 // clang-format off
0070     template <typename S>
0071     constexpr bool StepperStateConcept
0072       = require<has_member<S, cov_transport_t, bool>,
0073                 has_member<S, cov_t, BoundSquareMatrix>,
0074                 has_member<S, path_accumulated_t, double>//,
0075 //                 has_member<S, step_size_t, ConstrainedStep>
0076                >;
0077 // clang-format on
0078 
0079 // clang-format off
0080 template <typename S>
0081 constexpr bool MultiStepperStateConcept= require<
0082   has_member<S, cov_transport_t, bool>,
0083   has_member<S, path_accumulated_t, double>
0084 >;
0085 // clang-format on
0086 
0087 // clang-format off
0088     template <typename S, typename state = typename S::State>
0089       struct CommonStepperConcept {
0090         constexpr static bool state_exists = exists<state_t, S>;
0091         static_assert(state_exists, "State type not found");
0092         constexpr static bool jacobian_exists = exists<jacobian_t, S>;
0093         static_assert(jacobian_exists, "Jacobian type not found");
0094         constexpr static bool covariance_exists = exists<covariance_t, S>;
0095         static_assert(covariance_exists, "Covariance type not found");
0096         constexpr static bool bound_state_exists = exists<bound_state_t, S>;
0097         static_assert(bound_state_exists, "BoundState type not found");
0098         constexpr static bool curvilinear_state_exists = exists<curvilinear_state_t, S>;
0099         static_assert(curvilinear_state_exists, "CurvilinearState type not found");
0100         constexpr static bool reset_state_exists = has_method<const S, void, reset_state_t, state&, const BoundVector&, const BoundSquareMatrix&, const Surface&, const double>;
0101         static_assert(reset_state_exists, "resetState method not found");
0102         constexpr static bool position_exists = has_method<const S, Vector3, position_t, const state&>;
0103         static_assert(position_exists, "position method not found");
0104         constexpr static bool direction_exists = has_method<const S, Vector3, direction_t, const state&>;
0105         static_assert(direction_exists, "direction method not found");
0106         constexpr static bool qop_exists = has_method<const S, double, qop_t, const state&>;
0107         static_assert(qop_exists, "qOverP method not found");
0108         constexpr static bool absolute_momentum_exists = has_method<const S, double, absolute_momentum_t, const state&>;
0109         static_assert(absolute_momentum_exists, "absoluteMomentum method not found");
0110         constexpr static bool momentum_exists = has_method<const S, Vector3, momentum_t, const state&>;
0111         static_assert(momentum_exists, "momentum method not found");
0112         constexpr static bool charge_exists = has_method<const S, double, charge_t, const state&>;
0113         static_assert(charge_exists, "charge method not found");
0114         constexpr static bool time_exists = has_method<const S, double, time_t, const state&>;
0115         static_assert(time_exists, "time method not found");
0116         constexpr static bool bound_state_method_exists= has_method<const S, Result<typename S::BoundState>, bound_state_method_t, state&, const Surface&, bool, const FreeToBoundCorrection&>;
0117         static_assert(bound_state_method_exists, "boundState method not found");
0118         constexpr static bool curvilinear_state_method_exists = has_method<const S, typename S::CurvilinearState, curvilinear_state_method_t, state&, bool>;
0119         static_assert(curvilinear_state_method_exists, "curvilinearState method not found");
0120         constexpr static bool covariance_transport_exists = require<has_method<const S, void, covariance_transport_curvilinear_t, state&>,
0121                                                                     has_method<const S, void, covariance_transport_bound_t, state&, const Surface&, const FreeToBoundCorrection&>>;
0122         static_assert(covariance_transport_exists, "covarianceTransport method not found");
0123         constexpr static bool update_surface_exists = has_method<const S, Intersection3D::Status, update_surface_status_t, state&, const Surface&, std::uint8_t, Direction, const BoundaryCheck&, ActsScalar, const Logger&>;
0124         static_assert(update_surface_exists, "updateSurfaceStatus method not found");
0125         constexpr static bool update_step_size_exists = has_method<const S, void, update_step_size_t, state&, double, ConstrainedStep::Type, bool>;
0126         static_assert(update_step_size_exists, "updateStepSize method not found");
0127         constexpr static bool get_step_size_exists = has_method<const S, double, get_step_size_t, const state &, ConstrainedStep::Type>;
0128         static_assert(get_step_size_exists, "getStepSize method not found");
0129         constexpr static bool release_step_size_exists = has_method<const S, void, release_step_size_t, state&, ConstrainedStep::Type>;
0130         static_assert(release_step_size_exists, "releaseStepSize method not found");
0131         constexpr static bool output_step_size_exists = has_method<const S, std::string, output_step_size_t, const state&>;
0132         static_assert(output_step_size_exists, "outputStepSize method not found");
0133 
0134         constexpr static bool value = require<state_exists,
0135                                               jacobian_exists,
0136                                               covariance_exists,
0137                                               bound_state_exists,
0138                                               curvilinear_state_exists,
0139                                               position_exists,
0140                                               direction_exists,
0141                                               qop_exists,
0142                                               absolute_momentum_exists,
0143                                               momentum_exists,
0144                                               charge_exists,
0145                                               time_exists,
0146                                               bound_state_method_exists,
0147                                               curvilinear_state_method_exists,
0148                                               covariance_transport_exists,
0149                                               update_surface_exists,
0150                                               update_step_size_exists,
0151                                               release_step_size_exists,
0152                                               output_step_size_exists>;
0153 
0154       };
0155 // clang-format on
0156 
0157 // clang-format off
0158     // NOTE This static_asserts in here must be commented out, since it would break the compilation for the MultiStepper
0159     template <typename S, typename state = typename S::State>
0160       struct SingleStepperConcept {
0161         constexpr static bool common_stepper_concept_fullfilled = CommonStepperConcept<S, state>::value;
0162         static_assert(common_stepper_concept_fullfilled, "Stepper does not fulfill common stepper concept");
0163         constexpr static bool update_method_exists = require<has_method<const S, void, update_t, state&, const FreeVector&, const BoundVector&, const BoundSquareMatrix&, const Surface&>, has_method<const S, void, update_t, state&, const Vector3&, const Vector3&, double, double>>;
0164         // static_assert(update_method_exists, "update method not found");
0165         constexpr static bool get_field_exists = has_method<const S, Result<Vector3>, get_field_t, state&, const Vector3&>;
0166         // static_assert(get_field_exists, "getField method not found");
0167 
0168         constexpr static bool value = require<common_stepper_concept_fullfilled,
0169                                               update_method_exists,
0170                                               get_field_exists>;
0171       };
0172 // clang-format on
0173 
0174 // clang-format off
0175     template <typename S, typename state = typename S::State>
0176       struct MultiStepperConcept {
0177         constexpr static bool common_stepper_concept_fullfilled = CommonStepperConcept<S, state>::value;
0178         static_assert(common_stepper_concept_fullfilled, "Common stepper concept not fulfilled");
0179 
0180         // TODO for now we do not check if the ComponentProxy does fulfill a concept
0181         template <typename T> using component_proxy_t = typename T::ComponentProxy;
0182         constexpr static bool component_proxy_exists = exists<component_proxy_t, S>;
0183         // static_assert(component_proxy_exists, "!component_proxy_exists");
0184 
0185         // TODO for now we do not check if the ConstComponentProxy does fulfill a concept
0186         template <typename T> using const_component_proxy_t = typename T::ConstComponentProxy;
0187         constexpr static bool const_component_proxy_exists = exists<const_component_proxy_t, S>;
0188         // static_assert(const_component_proxy_exists, "!const_component_proxy_exists");
0189 
0190         METHOD_TRAIT(number_components_t, numberComponents);
0191         constexpr static bool number_components_exists = has_method<const S, std::size_t, number_components_t, const state&>;
0192         // static_assert(number_components_exists, "!num_components_exists");
0193 
0194         // TODO We cannot check addComponents since it is a template member function
0195 
0196         METHOD_TRAIT(clear_components_t, clearComponents);
0197         constexpr static bool clear_components_exists = has_method<const S, void, clear_components_t, state&>;
0198         // static_assert(clear_components_exists, "!clear_components_exists");
0199 
0200         METHOD_TRAIT(remove_missed_components_t, removeMissedComponents);
0201         constexpr static bool remove_missed_components_exists = has_method<const S, void, remove_missed_components_t, state&>;
0202         // static_assert(remove_missed_components_exists, "!remove_missed_components_exists");
0203 
0204         constexpr static bool value = require<common_stepper_concept_fullfilled,
0205                                               component_proxy_exists,
0206                                               const_component_proxy_exists,
0207                                               number_components_exists,
0208                                               clear_components_exists,
0209                                               remove_missed_components_exists>;
0210         };
0211 // clang-format on
0212 
0213 }  // namespace Concepts::Stepper
0214 
0215 template <typename stepper, typename state = typename stepper::State>
0216 constexpr bool StepperConcept =
0217     Acts::Concepts ::Stepper::SingleStepperConcept<stepper, state>::value ||
0218     Acts::Concepts ::Stepper::MultiStepperConcept<stepper, state>::value;
0219 template <typename stepper>
0220 constexpr bool StepperStateConcept =
0221     Acts::Concepts ::Stepper::StepperStateConcept<stepper> ||
0222     Acts::Concepts ::Stepper::MultiStepperStateConcept<stepper>;
0223 }  // namespace Acts
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!