Acts/EventData/TrackStateProxyConcept.hpp

0001 // This file is part of the Acts project.
0002 //
0003 // Copyright (C) 2023 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/Measurement.hpp"
0014 #include "Acts/EventData/SourceLink.hpp"
0015 #include "Acts/EventData/TrackStatePropMask.hpp"
0016 #include "Acts/EventData/TrackStateType.hpp"
0017 #include "Acts/EventData/Types.hpp"
0018 #include "Acts/Surfaces/Surface.hpp"
0019 #include "Acts/Utilities/HashedString.hpp"
0020
0021 #include <utility>
0022
0023 #if defined(__cpp_concepts)
0024 #include <concepts>
0025
0026 namespace Acts {
0027
0028 namespace detail {
0029 using Parameters = Eigen::Map<BoundVector>;
0030 using Covariance = Eigen::Map<BoundMatrix>;
0031
0032 using ConstParameters = Eigen::Map<const BoundVector>;
0033 using ConstCovariance = Eigen::Map<const BoundMatrix>;
0034
0035 using Measurement = Eigen::Map<ActsVector<2>>;
0036 using MeasurementCovariance = Eigen::Map<ActsSquareMatrix<2>>;
0037
0038 using ConstMeasurement = Eigen::Map<const ActsVector<2>>;
0039 using ConstMeasurementCovariance = Eigen::Map<const ActsSquareMatrix<2>>;
0040
0041 using DynamicMeasurement =
0042     Eigen::Map<Eigen::Matrix<Covariance::Scalar, Eigen::Dynamic, 1,
0043                              Eigen::ColMajor | Eigen::AutoAlign>>;
0044 using DynamicMeasurementCovariance =
0045     Eigen::Map<Eigen::Matrix<Covariance::Scalar, Eigen::Dynamic, Eigen::Dynamic,
0046                              Eigen::ColMajor | Eigen::AutoAlign>>;
0047
0048 using ConstDynamicMeasurement =
0049     Eigen::Map<const Eigen::Matrix<Covariance::Scalar, Eigen::Dynamic, 1,
0050                                    Eigen::ColMajor | Eigen::AutoAlign>>;
0051 using ConstDynamicMeasurementCovariance = Eigen::Map<
0052     const Eigen::Matrix<Covariance::Scalar, Eigen::Dynamic, Eigen::Dynamic,
0053                         Eigen::ColMajor | Eigen::AutoAlign>>;
0054
0055 constexpr static auto ProjectorFlags = Eigen::RowMajor | Eigen::AutoAlign;
0056 using Projector = Eigen::Matrix<typename Covariance::Scalar, eBoundSize,
0057                                 eBoundSize, ProjectorFlags>;
0058
0059 using EffectiveProjector =
0060     Eigen::Matrix<typename Projector::Scalar, Eigen::Dynamic, Eigen::Dynamic,
0061                   ProjectorFlags, eBoundSize, eBoundSize>;
0062
0063 }  // namespace detail
0064
0065 template <typename T>
0066 concept TrackStateProxyConcept =
0067     requires(const T& cv, T v, HashedString key,
0068              std::shared_ptr<const Surface> surface) {
0069   { cv.index() } -> std::same_as<TrackIndexType>;
0070
0071   { cv.previous() } -> std::same_as<TrackIndexType>;
0072
0073   { cv.hasPrevious() } -> std::same_as<bool>;
0074
0075   { cv.getMask() } -> std::same_as<TrackStatePropMask>;
0076
0077   { cv.referenceSurface() } -> std::same_as<const Surface&>;
0078
0079   { cv.hasReferenceSurface() } -> std::same_as<bool>;
0080
0081   { cv.template has<hashString("blubb")>() } -> std::same_as<bool>;
0082
0083   { cv.has(key) } -> std::same_as<bool>;
0084
0085   { cv.has("blubb") } -> std::same_as<bool>;
0086
0087   // Cannot verify for all types, so just check int
0088   {
0089     cv.template component<int, hashString("blubb")>()
0090     } -> std::same_as<const int&>;
0091
0092   { cv.template component<int>(key) } -> std::same_as<const int&>;
0093
0094   { cv.parameters() } -> std::same_as<detail::ConstParameters>;
0095   { cv.covariance() } -> std::same_as<detail::ConstCovariance>;
0096
0097   { cv.predicted() } -> std::same_as<detail::ConstParameters>;
0098   { cv.predictedCovariance() } -> std::same_as<detail::ConstCovariance>;
0099   { cv.hasPredicted() } -> std::same_as<bool>;
0100   { v.hasPredicted() } -> std::same_as<bool>;
0101
0102   { cv.filtered() } -> std::same_as<detail::ConstParameters>;
0103   { cv.filteredCovariance() } -> std::same_as<detail::ConstCovariance>;
0104   { cv.hasFiltered() } -> std::same_as<bool>;
0105   { v.hasFiltered() } -> std::same_as<bool>;
0106
0107   { cv.smoothed() } -> std::same_as<detail::ConstParameters>;
0108   { cv.smoothedCovariance() } -> std::same_as<detail::ConstCovariance>;
0109   { cv.hasSmoothed() } -> std::same_as<bool>;
0110   { v.hasSmoothed() } -> std::same_as<bool>;
0111
0112   { cv.jacobian() } -> std::same_as<detail::ConstCovariance>;
0113   { cv.hasJacobian() } -> std::same_as<bool>;
0114   { v.hasJacobian() } -> std::same_as<bool>;
0115
0116   { cv.hasProjector() } -> std::same_as<bool>;
0117   { v.hasProjector() } -> std::same_as<bool>;
0118
0119   { cv.effectiveProjector() } -> std::same_as<detail::EffectiveProjector>;
0120   { v.effectiveProjector() } -> std::same_as<detail::EffectiveProjector>;
0121
0122   { cv.projectorBitset() } -> std::same_as<ProjectorBitset>;
0123   { v.projectorBitset() } -> std::same_as<ProjectorBitset>;
0124
0125   { cv.getUncalibratedSourceLink() } -> std::same_as<SourceLink>;
0126   { v.getUncalibratedSourceLink() } -> std::same_as<SourceLink>;
0127
0128   { cv.hasCalibrated() } -> std::same_as<bool>;
0129   { v.hasCalibrated() } -> std::same_as<bool>;
0130
0131   { cv.template calibrated<2>() } -> std::same_as<detail::ConstMeasurement>;
0132   {
0133     cv.template calibratedCovariance<2>()
0134     } -> std::same_as<detail::ConstMeasurementCovariance>;
0135
0136   { cv.effectiveCalibrated() } -> std::same_as<detail::ConstDynamicMeasurement>;
0137   {
0138     cv.effectiveCalibratedCovariance()
0139     } -> std::same_as<detail::ConstDynamicMeasurementCovariance>;
0140
0141   { cv.calibratedSize() } -> std::same_as<TrackIndexType>;
0142   { v.calibratedSize() } -> std::same_as<TrackIndexType>;
0143
0144   { cv.chi2() } -> std::same_as<float>;
0145
0146   { cv.pathLength() } -> std::same_as<double>;
0147
0148   { cv.typeFlags() } -> std::same_as<ConstTrackStateType>;
0149 };
0150
0151 template <typename T>
0152 concept ConstTrackStateProxyConcept = TrackStateProxyConcept<T> &&
0153     requires(T v, HashedString key) {
0154   // Cannot verify for all types, so just check int
0155   {
0156     v.template component<int, hashString("blubb")>()
0157     } -> std::same_as<const int&>;
0158
0159   { v.template component<int>(key) } -> std::same_as<const int&>;
0160
0161   { v.predicted() } -> std::same_as<detail::ConstParameters>;
0162   { v.predictedCovariance() } -> std::same_as<detail::ConstCovariance>;
0163
0164   { v.filtered() } -> std::same_as<detail::ConstParameters>;
0165   { v.filteredCovariance() } -> std::same_as<detail::ConstCovariance>;
0166
0167   { v.smoothed() } -> std::same_as<detail::ConstParameters>;
0168   { v.smoothedCovariance() } -> std::same_as<detail::ConstCovariance>;
0169
0170   { v.jacobian() } -> std::same_as<detail::ConstCovariance>;
0171
0172   { v.template calibrated<2>() } -> std::same_as<detail::ConstMeasurement>;
0173   {
0174     v.template calibratedCovariance<2>()
0175     } -> std::same_as<detail::ConstMeasurementCovariance>;
0176
0177   { v.effectiveCalibrated() } -> std::same_as<detail::ConstDynamicMeasurement>;
0178   {
0179     v.effectiveCalibratedCovariance()
0180     } -> std::same_as<detail::ConstDynamicMeasurementCovariance>;
0181
0182   { v.chi2() } -> std::same_as<double>;
0183
0184   { v.pathLength() } -> std::same_as<double>;
0185
0186   { v.typeFlags() } -> std::same_as<ConstTrackStateType>;
0187 };
0188
0189 template <typename T>
0190 concept MutableTrackStateProxyConcept = TrackStateProxyConcept<T> &&
0191     requires(T v, HashedString key, TrackStatePropMask mask,
0192              TrackIndexType index, std::shared_ptr<const Surface> surface,
0193              Eigen::Matrix<double, 3, 6> projector,
0194              ProjectorBitset projectorBitset, SourceLink sl,
0195              Acts::Measurement<BoundIndices, 2> meas, std::size_t measdim) {
0196   {v.shareFrom(mask, mask)};
0197
0198   {v.shareFrom(std::declval<typename T::Trajectory::ConstTrackStateProxy>(),
0199                mask)};
0200
0201   {v.shareFrom(std::declval<T>(), mask)};
0202
0203   // Cannot verify copyFrom compatibility with other backend proxies
0204   {v.copyFrom(std::declval<typename T::Trajectory::ConstTrackStateProxy>(),
0205               mask)};
0206
0207   {v.copyFrom(std::declval<T>(), mask)};
0208
0209   {v.unset(mask)};
0210
0211   // Cannot verify for all types, so just check int
0212   { v.template component<int, hashString("blubb")>() } -> std::same_as<int&>;
0213
0214   { v.template component<int>(key) } -> std::same_as<int&>;
0215
0216   { v.predicted() } -> std::same_as<detail::Parameters>;
0217   { v.predictedCovariance() } -> std::same_as<detail::Covariance>;
0218
0219   { v.filtered() } -> std::same_as<detail::Parameters>;
0220   { v.filteredCovariance() } -> std::same_as<detail::Covariance>;
0221
0222   { v.smoothed() } -> std::same_as<detail::Parameters>;
0223   { v.smoothedCovariance() } -> std::same_as<detail::Covariance>;
0224
0225   { v.jacobian() } -> std::same_as<detail::Covariance>;
0226
0227   {v.setProjector(projector)};
0228
0229   {v.setProjectorBitset(projectorBitset)};
0230
0231   {v.setUncalibratedSourceLink(sl)};
0232
0233   { v.template calibrated<2>() } -> std::same_as<detail::Measurement>;
0234   {
0235     v.template calibratedCovariance<2>()
0236     } -> std::same_as<detail::MeasurementCovariance>;
0237
0238   { v.effectiveCalibrated() } -> std::same_as<detail::DynamicMeasurement>;
0239   {
0240     v.effectiveCalibratedCovariance()
0241     } -> std::same_as<detail::DynamicMeasurementCovariance>;
0242
0243   {v.setCalibrated(meas)};
0244
0245   {v.allocateCalibrated(measdim)};
0246
0247   { v.chi2() } -> std::same_as<double&>;
0248
0249   { v.pathLength() } -> std::same_as<double&>;
0250
0251   { v.typeFlags() } -> std::same_as<TrackStateType>;
0252 };
0253 }  // namespace Acts
0254 #endif