ATLAS Offline Software
Loading...
Searching...
No Matches
TrackContainerHandlesHelper.cxx
Go to the documentation of this file.
1/*
2 Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
3*/
8
9#include "GeoModelKernel/throwExcept.h"
10
11#include <string>
12#include <sstream>
13#include <span>
14#include <regex>
15
18
19namespace ActsTrk {
20
21std::string prefixFromTrackContainerName(const std::string& tracks) {
22 std::regex word_regex("(.*)Tracks$");
23 std::smatch match_regex;
24
25 if ( not std::regex_search(tracks, match_regex, word_regex) or match_regex.size() < 2) {
26 return tracks;
27 }
28
29 return match_regex[1].str();
30}
31
32#define RECORD_xAOD(key, container, auxContainer, ctx) \
33 { \
34 SG::WriteHandle handle{key, ctx}; \
35 if (!handle.record(std::move(container), \
36 std::move(auxContainer)).isSuccess()){ \
37 THROW_EXCEPTION("Cannot record "<<key.fullKey()<<" backend"); \
38 } \
39 }
40
41#define INIT_CHECK(key) \
42 if (!key.initialize().isSuccess()) { \
43 THROW_EXCEPTION("Failed to initialize key "<<key.fullKey()); \
44 }
45
46StatusCode MutableTrackContainerHandlesHelper::initialize(std::string_view prefix) {
47 m_statesKey = std::format("{:}TrackStates", prefix);
48 m_parametersKey = std::format("{:}TrackParameters", prefix);
49 m_jacobiansKey = std::format("{:}TrackJacobians", prefix);
50 m_measurementsKey = std::format("{:}TrackMeasurements", prefix);
51 m_surfacesKey = std::format("{:}TrackStateSurfaces", prefix);
52 m_mtjKey = std::format("{:}MultiTrajectory", prefix); // identical names, underlying types are distinct
59
60 // Track Container backends
61 m_xAODTrackSummaryKey = std::format("{:}TrackSummary", prefix);
62 m_trackSurfacesKey = std::format("{:}TrackSurfaces", prefix);
63 m_trackSummaryKey = std::format("{:}TrackSummary", prefix);
67 return StatusCode::SUCCESS;
68}
69
70
71
72
73 std::unique_ptr<ActsTrk::PersistentTrackContainer>
75 const Acts::GeometryContext& geoContext,
76 const EventContext& evtContext) const {
77
79 for (const auto& exclude : m_excludeDecors) {
80 mmjt.trackStateContainer().excludeDecoration(exclude);
81 mmjt.container().excludeDecoration(exclude);
82 }
83 mmjt.ensureDynamicColumns(tc);
84 for ( auto track : tc) {
85 auto destProxy = mmjt.makeTrack();
86 destProxy.copyFrom(track);
87 }
88 return moveToConst(std::move(mmjt), geoContext, evtContext);
89}
90std::unique_ptr<ActsTrk::MultiTrajectory>
92 ActsTrk::MutableMultiTrajectory&& mmtj, const EventContext& evtContext) const {
93
94 mmtj.trim();
95
96 auto statesBackendHandle = SG::makeHandle(m_statesKey, evtContext);
97 auto statesInterface =
99 mmtj.trackStatesAux());
100 RECORD_xAOD(m_statesKey, statesInterface, mmtj.m_trackStatesAux, evtContext);
101
102 auto parametersInterface =
104 mmtj.trackParametersAux());
105 RECORD_xAOD(m_parametersKey, parametersInterface, mmtj.m_trackParametersAux, evtContext);
106
107 auto jacobiansInterface =
109 mmtj.trackJacobiansAux());
110 RECORD_xAOD(m_jacobiansKey, jacobiansInterface, mmtj.m_trackJacobiansAux, evtContext);
111
112 auto measurementsInterface =
114 mmtj.trackMeasurementsAux());
115 RECORD_xAOD(m_measurementsKey, measurementsInterface, mmtj.m_trackMeasurementsAux, evtContext);
116
117 auto surfacesBackendHandle = SG::makeHandle(m_surfacesKey, evtContext);
118 RECORD_xAOD(m_surfacesKey, mmtj.m_surfacesBackend, mmtj.m_surfacesBackendAux, evtContext);
119
120 // construct const MTJ version
121 auto cmtj = std::make_unique<ActsTrk::MultiTrajectory>(
123 evtContext),
125 m_parametersKey.key() + "Aux.", evtContext),
127 m_jacobiansKey.key() + "Aux.", evtContext),
129 m_measurementsKey.key() + "Aux.", evtContext),
131 m_surfacesKey.key() + "Aux.", evtContext)
132 );
133 cmtj->moveSurfaces(&mmtj);
134 cmtj->moveLinks(&mmtj);
135
136 return cmtj;
137}
138
139std::unique_ptr<ActsTrk::PersistentTrackContainer>
141 ActsTrk::MutablePersistentTrackContainer&& tc, const Acts::GeometryContext& geoContext, const EventContext& evtContext) const {
142
143
144 std::unique_ptr<ActsTrk::MultiTrajectory> constMtj =
145 moveToConst(std::move(tc.trackStateContainer()), evtContext);
146
147 auto constMtjHandle = SG::makeHandle(m_mtjKey, evtContext);
148 if (constMtjHandle.record(std::move(constMtj)).isFailure()) {
149 throw std::runtime_error(
150 "MutableTrackContainerHandlesHelper::moveToConst, can't record "
151 "ConstMultiTrajectory");
152 }
153
154 auto trackSurfacesAux = std::make_unique<xAOD::TrackSurfaceAuxContainer>();
155 tc.container().encodeSurfaces(trackSurfacesAux.get(), geoContext);
156
157 auto interfaceTrackSummaryContainer =
159 tc.container().m_mutableTrackBackendAux.get());
160 RECORD_xAOD(m_xAODTrackSummaryKey, interfaceTrackSummaryContainer, tc.container().m_mutableTrackBackendAux, evtContext);
161
163 trackSurfacesAux.get());
164 RECORD_xAOD(m_trackSurfacesKey, trackSurfaces, trackSurfacesAux, evtContext);
165
166 auto constTrackSummary = std::make_unique<ActsTrk::TrackSummaryContainer>(
168 evtContext));
169 constTrackSummary->restoreDecorations();
170 constTrackSummary->fillFrom(tc.container());
171
172 auto constTrackSummaryHandle = SG::makeHandle(m_trackSummaryKey, evtContext);
173 if (constTrackSummaryHandle.record(std::move(constTrackSummary))
174 .isFailure()) {
175 throw std::runtime_error(
176 "MutableTrackContainerHandlesHelper::moveToConst, can't record "
177 "TrackSummary");
178 }
179 auto constTrack = std::make_unique<ActsTrk::PersistentTrackContainer>(
181 evtContext),
183 return constTrack;
184}
185
186// const version
188 const std::string& prefix) {
189 m_statesKey = prefix + "TrackStates";
190 m_parametersKey = prefix + "TrackParameters";
191 m_jacobiansKey = prefix + "TrackJacobians";
192 m_measurementsKey = prefix + "TrackMeasurements";
193 m_surfacesKey = prefix + "TrackSurfaces";
194 m_mtjKey = prefix + "MultiTrajectory";
195
202
203 m_xAODTrackSummaryKey = prefix + "TrackSummary";
204 m_trackSurfacesKey = prefix + "TrackSurfaces";
205 m_trackSummaryKey = prefix + "TrackSummary";
206
210
211 return StatusCode::SUCCESS;
212}
213
214std::unique_ptr<ActsTrk::MultiTrajectory>
215ConstTrackContainerHandlesHelper::buildMtj(const Acts::TrackingGeometry* geo,
216 const EventContext& evtContext) const {
217 // we need to build it from backends
218 DataLink<xAOD::TrackStateAuxContainer> statesLink(m_statesKey.key() + "Aux.",
219 evtContext);
220 if (not statesLink.isValid()) {
221 throw std::runtime_error(
222 "ConstMultiTrajectoryHandle::build, StatesLink is invalid");
223 }
224 // The restoration of the pointers to uncalibrated measurements should only
225 // be done once, if it is done in parallel by multiple callers all callers should
226 // write exactly the same value to exactly the same memory location
227 xAOD::TrackStateAuxContainer *nonConstStatesLink ATLAS_THREAD_SAFE = const_cast<xAOD::TrackStateAuxContainer *>(statesLink.getDataPtr());
228 restoreUncalibMeasurementPtr(*nonConstStatesLink);
229
231 m_parametersKey.key() + "Aux.", evtContext);
232 if (not parametersLink.isValid()) {
233 throw std::runtime_error(
234 "ConstMultiTrajectoryHandle::build, ParametersLink is invalid");
235 }
236
238 m_jacobiansKey.key() + "Aux.", evtContext);
239 if (not jacobiansLink.isValid()) {
240 throw std::runtime_error(
241 "ConstMultiTrajectoryHandle::build, JacobiansLink is invalid");
242 }
243
245 m_measurementsKey.key() + "Aux.", evtContext);
246 if (not measurementsLink.isValid()) {
247 throw std::runtime_error(
248 "ConstMultiTrajectoryHandle::build, MeasurementsLink is invalid");
249 }
250
252 m_surfacesKey.key() + "Aux.", evtContext);
253 if (not surfacesLink.isValid()) {
254 throw std::runtime_error(
255 "ConstMultiTrajectoryHandle::build, SurfacesLink is invalid");
256 }
257
258
259 auto cmtj = std::make_unique<ActsTrk::MultiTrajectory>(
260 statesLink, parametersLink, jacobiansLink, measurementsLink, surfacesLink);
261 cmtj->fillSurfaces(geo);
262 return cmtj;
263}
264
265std::unique_ptr<ActsTrk::PersistentTrackContainer>
266ConstTrackContainerHandlesHelper::build(const Acts::TrackingGeometry* geo,
267 const Acts::GeometryContext& /*geoContext*/,
268 const EventContext& evtContext) const {
269
270 std::unique_ptr<ActsTrk::MultiTrajectory> mtj = buildMtj(geo,evtContext);
271 auto mtjHandle = SG::makeHandle(m_mtjKey, evtContext);
272 if (mtjHandle.record(std::move(mtj)).isFailure()) {
273 throw std::runtime_error(
274 "ConstTrackContainerHandle<C>::build failed recording MTJ");
275 }
277 evtContext);
278 if (not summaryLink.isValid()) {
279 throw std::runtime_error(
280 "ConstTrackContainerHandle::build, SummaryLink is invalid");
281 }
282
283 auto surfacesHandle = SG::makeHandle(m_trackSurfacesKey, evtContext);
284 if (not surfacesHandle.isValid()) {
285 throw std::runtime_error(
286 "ConstTrackContainerHandle::build, SurfaceHandle is invalid");
287 }
288
289 auto constTrackSummary = std::make_unique<ActsTrk::TrackSummaryContainer>(summaryLink);
290 constTrackSummary->decodeSurfaces( surfacesHandle.cptr());
291
292 auto summaryHandle = SG::makeHandle(m_trackSummaryKey, evtContext);
293 if (summaryHandle.record(std::move(constTrackSummary)).isFailure()) {
294 throw std::runtime_error(
295 "MutableTrackContainerHandle::build, can't record "
296 "TrackSummary");
297 }
298
299 auto constTrack = std::make_unique<ActsTrk::PersistentTrackContainer>(
301 evtContext),
303
304 return constTrack;
305
306}
307
308namespace {
309 template <typename T>
310 using const_span = std::span<T const>;
311
312 // get an aux variable for elements (read only)
313 template <typename T>
314 const_span<T> getElementVector( const xAOD::AuxContainerBase &aux_container, const SG::ConstAccessor<T> &accessor) {
315 const T *data = static_cast<const T *>(aux_container.getData (accessor.auxid()));
316 const_span<T> ret( data, aux_container.size() );
317 return ret;
318 }
319
320 // create a new decoration for all elements using the default value
321 template <typename T>
322 std::span<T> createDecoration(xAOD::AuxContainerBase &aux_container, const SG::Decorator<T> &decor) {
323 std::size_t sz=aux_container.size();
324 T *data = static_cast<T *>(aux_container.getDecoration(decor.auxid(), sz, sz));
325 return std::span<T>( data, sz );
326 }
327
328 void throwConflictingUncalibratedMeasurementPointerValue(const xAOD::UncalibratedMeasurement *is,
329 const xAOD::UncalibratedMeasurement *should) {
330 std::stringstream msg;
331 msg << "Conflicting values for TrackState.uncalibratedMeasurement. Already set " << static_cast<const void *>(is)
332 << " would set " << static_cast<const void *>(should);
333 throw std::runtime_error(msg.str());
334 }
335}
336
339 static const SG::ConstAccessor< link_t > link_accessor("uncalibratedMeasurementLink");
340
341 if (statesLink.getAuxIDs().test(link_accessor.auxid())){
342 const_span<link_t> elementLinks = getElementVector(statesLink, link_accessor);
343
345 decor("uncalibratedMeasurement");
346
347 std::span<const xAOD::UncalibratedMeasurement *> uncalibratedMeasurements
348 = createDecoration( statesLink, decor);
349
350 for (unsigned int index = 0; index < elementLinks.size(); ++index) {
351 const link_t &el = elementLinks[index];
352 const xAOD::UncalibratedMeasurement *a_measurement = (el.isValid() ? *el : nullptr);
353 // @TODO is this check necessary ?
354 if (uncalibratedMeasurements[index] != nullptr && a_measurement != uncalibratedMeasurements[index]) {
355 throwConflictingUncalibratedMeasurementPointerValue(uncalibratedMeasurements[index], a_measurement);
356 }
357 uncalibratedMeasurements[index]=a_measurement;
358 }
359 }
360 else {
361 std::cerr << "WARNING no uncalibratedMeasurementLink aux data " << std::endl;
362 }
363}
364} // namespace ActsTrk
365
366#undef INIT_CHECK
367#undef RECORD_xAOD
static Double_t sz
static Double_t tc
Handle class for reading from StoreGate.
Handle class for recording to StoreGate.
#define INIT_CHECK(key)
#define RECORD_xAOD(key, container, auxContainer, ctx)
#define ATLAS_THREAD_SAFE
SG::ReadHandleKey< xAOD::TrackMeasurementContainer > m_measurementsKey
std::unique_ptr< ActsTrk::PersistentTrackContainer > build(const Acts::TrackingGeometry *geo, const Acts::GeometryContext &geoContext, const EventContext &context) const
SG::ReadHandleKey< xAOD::TrackSurfaceContainer > m_surfacesKey
SG::WriteHandleKey< ActsTrk::MultiTrajectory > m_mtjKey
SG::ReadHandleKey< xAOD::TrackStateContainer > m_statesKey
void restoreUncalibMeasurementPtr(xAOD::TrackStateAuxContainer &statesLink) const
SG::ReadHandleKey< xAOD::TrackJacobianContainer > m_jacobiansKey
SG::WriteHandleKey< ActsTrk::TrackSummaryContainer > m_trackSummaryKey
SG::ReadHandleKey< xAOD::TrackParametersContainer > m_parametersKey
StatusCode initialize(const std::string &prefix)
Sets up the handles.
SG::ReadHandleKey< xAOD::TrackSurfaceContainer > m_trackSurfacesKey
SG::ReadHandleKey< xAOD::TrackSummaryContainer > m_xAODTrackSummaryKey
std::unique_ptr< ActsTrk::MultiTrajectory > buildMtj(const Acts::TrackingGeometry *geo, const EventContext &context) const
Athena implementation of ACTS::MultiTrajectory (ReadWrite version) The data is stored in 4 external b...
std::unique_ptr< ActsTrk::PersistentTrackContainer > copyToPersistent(const ActsTrk::TrackContainer &tc, const Acts::GeometryContext &geoContext, const EventContext &evtContext) const
SG::WriteHandleKey< xAOD::TrackParametersContainer > m_parametersKey
std::unique_ptr< ActsTrk::PersistentTrackContainer > moveToConst(ActsTrk::MutablePersistentTrackContainer &&tc, const Acts::GeometryContext &geoContext, const EventContext &evtContext) const
produces ActsTrk::ConstTrackContainer with all backends stored in SG
SG::WriteHandleKey< xAOD::TrackMeasurementContainer > m_measurementsKey
Gaudi::Property< std::set< std::string > > m_excludeDecors
SG::WriteHandleKey< xAOD::TrackSurfaceContainer > m_trackSurfacesKey
SG::WriteHandleKey< xAOD::TrackJacobianContainer > m_jacobiansKey
SG::WriteHandleKey< ActsTrk::MultiTrajectory > m_mtjKey
SG::WriteHandleKey< xAOD::TrackSummaryContainer > m_xAODTrackSummaryKey
SG::WriteHandleKey< ActsTrk::TrackSummaryContainer > m_trackSummaryKey
SG::WriteHandleKey< xAOD::TrackStateContainer > m_statesKey
SG::WriteHandleKey< xAOD::TrackSurfaceContainer > m_surfacesKey
StatusCode initialize(std::string_view prefix)
Sets up the handles.
Helper class to provide constant type-safe access to aux data.
SG::auxid_t auxid() const
Return the aux id for this variable.
Common base class for the auxiliary containers.
virtual const void * getData(auxid_t auxid) const override
Get a pointer to a given array.
virtual const auxid_set_t & getAuxIDs() const override
Get the types(names) of variables handled by this container.
virtual size_t size() const override
Get the size of the container.
virtual void * getDecoration(auxid_t auxid, size_t size, size_t capacity) override
Get a pointer to a given array, as a decoration.
std::set< std::string > exclude
list of directories to be excluded
Definition hcg.cxx:100
The AlignStoreProviderAlg loads the rigid alignment corrections and pipes them through the readout ge...
std::string prefixFromTrackContainerName(const std::string &tracks)
Parse TrackContainer name to get the prefix for backends The name has to contain XYZTracks,...
std::unique_ptr< IFACE > makeInterfaceContainer(const AUX *aux)
helper to construct interface container for already filled Aux container TODO maybe should be moved t...
SG::Decorator< T, ALLOC > Decorator
Helper class to provide type-safe access to aux data, specialized for JaggedVecElt.
Definition AuxElement.h:576
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition index.py:1
TrackStateAuxContainer_v1 TrackStateAuxContainer
UncalibratedMeasurement_v1 UncalibratedMeasurement
Define the version of the uncalibrated measurement class.
MsgStream & msg
Definition testRead.cxx:32