Analysis Software
Documentation for sPHENIX simulation software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
TrackStateProxyConcept.hpp
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file TrackStateProxyConcept.hpp
1 // This file is part of the Acts project.
2 //
3 // Copyright (C) 2023 CERN for the benefit of the Acts project
4 //
5 // This Source Code Form is subject to the terms of the Mozilla Public
6 // License, v. 2.0. If a copy of the MPL was not distributed with this
7 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 
9 #pragma once
10 
11 #include "Acts/Definitions/Algebra.hpp"
12 #include "Acts/Definitions/TrackParametrization.hpp"
13 #include "Acts/EventData/Measurement.hpp"
14 #include "Acts/EventData/SourceLink.hpp"
15 #include "Acts/EventData/TrackStatePropMask.hpp"
16 #include "Acts/EventData/TrackStateType.hpp"
17 #include "Acts/EventData/Types.hpp"
18 #include "Acts/Surfaces/Surface.hpp"
19 #include "Acts/Utilities/HashedString.hpp"
20 
21 #include <utility>
22 
23 #if defined(ACTS_CONCEPTS_SUPPORTED)
24 #include <concepts>
25 
26 namespace Acts {
27 
28 namespace detail {
29 using Parameters = Eigen::Map<BoundVector>;
30 using Covariance = Eigen::Map<BoundMatrix>;
31 
32 using ConstParameters = Eigen::Map<const BoundVector>;
33 using ConstCovariance = Eigen::Map<const BoundMatrix>;
34 
35 using Measurement = Eigen::Map<ActsVector<2>>;
36 using MeasurementCovariance = Eigen::Map<ActsSquareMatrix<2>>;
37 
38 using ConstMeasurement = Eigen::Map<const ActsVector<2>>;
39 using ConstMeasurementCovariance = Eigen::Map<const ActsSquareMatrix<2>>;
40 
41 using DynamicMeasurement =
42  Eigen::Map<Eigen::Matrix<Covariance::Scalar, Eigen::Dynamic, 1,
43  Eigen::ColMajor | Eigen::AutoAlign>>;
44 using DynamicMeasurementCovariance =
45  Eigen::Map<Eigen::Matrix<Covariance::Scalar, Eigen::Dynamic, Eigen::Dynamic,
46  Eigen::ColMajor | Eigen::AutoAlign>>;
47 
48 using ConstDynamicMeasurement =
49  Eigen::Map<const Eigen::Matrix<Covariance::Scalar, Eigen::Dynamic, 1,
50  Eigen::ColMajor | Eigen::AutoAlign>>;
51 using ConstDynamicMeasurementCovariance = Eigen::Map<
52  const Eigen::Matrix<Covariance::Scalar, Eigen::Dynamic, Eigen::Dynamic,
53  Eigen::ColMajor | Eigen::AutoAlign>>;
54 
55 constexpr static auto ProjectorFlags = Eigen::RowMajor | Eigen::AutoAlign;
56 using Projector = Eigen::Matrix<typename Covariance::Scalar, eBoundSize,
57  eBoundSize, ProjectorFlags>;
58 
59 using EffectiveProjector =
60  Eigen::Matrix<typename Projector::Scalar, Eigen::Dynamic, Eigen::Dynamic,
61  ProjectorFlags, eBoundSize, eBoundSize>;
62 
63 } // namespace detail
64 
65 template <typename T>
66 concept TrackStateProxyConcept =
67  requires(const T& cv, T v, HashedString key,
68  std::shared_ptr<const Surface> surface) {
69  { cv.index() } -> std::same_as<TrackIndexType>;
70 
71  { cv.previous() } -> std::same_as<TrackIndexType>;
72 
73  { cv.hasPrevious() } -> std::same_as<bool>;
74 
75  { cv.getMask() } -> std::same_as<TrackStatePropMask>;
76 
77  { cv.referenceSurface() } -> std::same_as<const Surface&>;
78 
79  { cv.hasReferenceSurface() } -> std::same_as<bool>;
80 
81  { cv.template has<hashString("blubb")>() } -> std::same_as<bool>;
82 
83  { cv.has(key) } -> std::same_as<bool>;
84 
85  { cv.has("blubb") } -> std::same_as<bool>;
86 
87  // Cannot verify for all types, so just check int
88  {
89  cv.template component<int, hashString("blubb")>()
90  } -> std::same_as<const int&>;
91 
92  { cv.template component<int>(key) } -> std::same_as<const int&>;
93 
94  { cv.parameters() } -> std::same_as<detail::ConstParameters>;
95  { cv.covariance() } -> std::same_as<detail::ConstCovariance>;
96 
97  { cv.predicted() } -> std::same_as<detail::ConstParameters>;
98  { cv.predictedCovariance() } -> std::same_as<detail::ConstCovariance>;
99  { cv.hasPredicted() } -> std::same_as<bool>;
100  { v.hasPredicted() } -> std::same_as<bool>;
101 
102  { cv.filtered() } -> std::same_as<detail::ConstParameters>;
103  { cv.filteredCovariance() } -> std::same_as<detail::ConstCovariance>;
104  { cv.hasFiltered() } -> std::same_as<bool>;
105  { v.hasFiltered() } -> std::same_as<bool>;
106 
107  { cv.smoothed() } -> std::same_as<detail::ConstParameters>;
108  { cv.smoothedCovariance() } -> std::same_as<detail::ConstCovariance>;
109  { cv.hasSmoothed() } -> std::same_as<bool>;
110  { v.hasSmoothed() } -> std::same_as<bool>;
111 
112  { cv.jacobian() } -> std::same_as<detail::ConstCovariance>;
113  { cv.hasJacobian() } -> std::same_as<bool>;
114  { v.hasJacobian() } -> std::same_as<bool>;
115 
116  { cv.hasProjector() } -> std::same_as<bool>;
117  { v.hasProjector() } -> std::same_as<bool>;
118 
119  { cv.effectiveProjector() } -> std::same_as<detail::EffectiveProjector>;
120  { v.effectiveProjector() } -> std::same_as<detail::EffectiveProjector>;
121 
122  { cv.projectorBitset() } -> std::same_as<ProjectorBitset>;
123  { v.projectorBitset() } -> std::same_as<ProjectorBitset>;
124 
125  { cv.getUncalibratedSourceLink() } -> std::same_as<SourceLink>;
126  { v.getUncalibratedSourceLink() } -> std::same_as<SourceLink>;
127 
128  { cv.hasCalibrated() } -> std::same_as<bool>;
129  { v.hasCalibrated() } -> std::same_as<bool>;
130 
131  { cv.template calibrated<2>() } -> std::same_as<detail::ConstMeasurement>;
132  {
133  cv.template calibratedCovariance<2>()
134  } -> std::same_as<detail::ConstMeasurementCovariance>;
135 
136  { cv.effectiveCalibrated() } -> std::same_as<detail::ConstDynamicMeasurement>;
137  {
138  cv.effectiveCalibratedCovariance()
139  } -> std::same_as<detail::ConstDynamicMeasurementCovariance>;
140 
141  { cv.calibratedSize() } -> std::same_as<TrackIndexType>;
142  { v.calibratedSize() } -> std::same_as<TrackIndexType>;
143 
144  { cv.chi2() } -> std::same_as<double>;
145 
146  { cv.pathLength() } -> std::same_as<double>;
147 
148  { cv.typeFlags() } -> std::same_as<ConstTrackStateType>;
149 };
150 
151 template <typename T>
152 concept ConstTrackStateProxyConcept = TrackStateProxyConcept<T> &&
153  requires(T v, HashedString key) {
154  // Cannot verify for all types, so just check int
155  {
156  v.template component<int, hashString("blubb")>()
157  } -> std::same_as<const int&>;
158 
159  { v.template component<int>(key) } -> std::same_as<const int&>;
160 
161  { v.predicted() } -> std::same_as<detail::ConstParameters>;
162  { v.predictedCovariance() } -> std::same_as<detail::ConstCovariance>;
163 
164  { v.filtered() } -> std::same_as<detail::ConstParameters>;
165  { v.filteredCovariance() } -> std::same_as<detail::ConstCovariance>;
166 
167  { v.smoothed() } -> std::same_as<detail::ConstParameters>;
168  { v.smoothedCovariance() } -> std::same_as<detail::ConstCovariance>;
169 
170  { v.jacobian() } -> std::same_as<detail::ConstCovariance>;
171 
172  { v.template calibrated<2>() } -> std::same_as<detail::ConstMeasurement>;
173  {
174  v.template calibratedCovariance<2>()
175  } -> std::same_as<detail::ConstMeasurementCovariance>;
176 
177  { v.effectiveCalibrated() } -> std::same_as<detail::ConstDynamicMeasurement>;
178  {
179  v.effectiveCalibratedCovariance()
180  } -> std::same_as<detail::ConstDynamicMeasurementCovariance>;
181 
182  { v.chi2() } -> std::same_as<double>;
183 
184  { v.pathLength() } -> std::same_as<double>;
185 
186  { v.typeFlags() } -> std::same_as<ConstTrackStateType>;
187 };
188 
189 template <typename T>
190 concept MutableTrackStateProxyConcept = TrackStateProxyConcept<T> &&
191  requires(T v, HashedString key, TrackStatePropMask mask,
192  TrackIndexType index, std::shared_ptr<const Surface> surface,
193  Eigen::Matrix<double, 3, 6> projector,
194  ProjectorBitset projectorBitset, SourceLink sl,
195  Acts::Measurement<BoundIndices, 2> meas, std::size_t measdim) {
196  {v.shareFrom(mask, mask)};
197 
198  {v.shareFrom(std::declval<typename T::Trajectory::ConstTrackStateProxy>(),
199  mask)};
200 
201  {v.shareFrom(std::declval<T>(), mask)};
202 
203  // Cannot verify copyFrom compatibility with other backend proxies
204  {v.copyFrom(std::declval<typename T::Trajectory::ConstTrackStateProxy>(),
205  mask)};
206 
207  {v.copyFrom(std::declval<T>(), mask)};
208 
209  {v.unset(mask)};
210 
211  // Cannot verify for all types, so just check int
212  { v.template component<int, hashString("blubb")>() } -> std::same_as<int&>;
213 
214  { v.template component<int>(key) } -> std::same_as<int&>;
215 
216  { v.predicted() } -> std::same_as<detail::Parameters>;
217  { v.predictedCovariance() } -> std::same_as<detail::Covariance>;
218 
219  { v.filtered() } -> std::same_as<detail::Parameters>;
220  { v.filteredCovariance() } -> std::same_as<detail::Covariance>;
221 
222  { v.smoothed() } -> std::same_as<detail::Parameters>;
223  { v.smoothedCovariance() } -> std::same_as<detail::Covariance>;
224 
225  { v.jacobian() } -> std::same_as<detail::Covariance>;
226 
227  {v.setProjector(projector)};
228 
229  {v.setProjectorBitset(projectorBitset)};
230 
231  {v.setUncalibratedSourceLink(sl)};
232 
233  { v.template calibrated<2>() } -> std::same_as<detail::Measurement>;
234  {
235  v.template calibratedCovariance<2>()
236  } -> std::same_as<detail::MeasurementCovariance>;
237 
238  { v.effectiveCalibrated() } -> std::same_as<detail::DynamicMeasurement>;
239  {
240  v.effectiveCalibratedCovariance()
241  } -> std::same_as<detail::DynamicMeasurementCovariance>;
242 
243  {v.setCalibrated(meas)};
244 
245  {v.allocateCalibrated(measdim)};
246 
247  { v.chi2() } -> std::same_as<double&>;
248 
249  { v.pathLength() } -> std::same_as<double&>;
250 
251  { v.typeFlags() } -> std::same_as<TrackStateType>;
252 };
253 } // namespace Acts
254 #endif