ATLAS Offline Software
Loading...
Searching...
No Matches
ActsTrk::MutableMultiTrajectory Class Referencefinal

Athena implementation of ACTS::MultiTrajectory (ReadWrite version) The data is stored in 4 external backends. More...

#include <MultiTrajectory.h>

Inheritance diagram for ActsTrk::MutableMultiTrajectory:

Public Types

using TrackStateProxy
using ConstTrackStateProxy

Public Member Functions

 MutableMultiTrajectory ()
 Construct a new Multi Trajectory object owning backends.
 MutableMultiTrajectory (const ActsTrk::MutableMultiTrajectory &other)
 MutableMultiTrajectory (ActsTrk::MutableMultiTrajectory &&other)=default
MutableMultiTrajectory & operator= (const ActsTrk::MutableMultiTrajectory &other)=delete
ActsTrk::IndexType addTrackState_impl (Acts::TrackStatePropMask mask, ActsTrk::IndexType iprevious)
 Add state with stograge for data that depends on the mask.
void addTrackStateComponents_impl (ActsTrk::IndexType istate, Acts::TrackStatePropMask mask)
 Add state components for the given mask.
std::any component_impl (Acts::HashedString key, ActsTrk::IndexType istate) const
 Access component by key.
std::any component_impl (Acts::HashedString key, ActsTrk::IndexType istate)
bool has_impl (Acts::HashedString key, ActsTrk::IndexType istate) const
 checks if given state has requested component
constexpr bool hasColumn_impl (Acts::HashedString key) const
 checks if MTJ has requested column (irrespectively of the state)
template<typename T>
void addColumn_impl (std::string_view key)
 enables particular decoration, type & name need to be specified
void unset_impl (Acts::TrackStatePropMask target, ActsTrk::IndexType istate)
 unsets a given state
void shareFrom_impl (ActsTrk::IndexType iself, ActsTrk::IndexType iother, Acts::TrackStatePropMask shareSource, Acts::TrackStatePropMask shareTarget)
 shares from a given state
ConstTrackStateProxy::ConstParameters parameters_impl (ActsTrk::IndexType index) const
 obtains proxy to the track state under given index
TrackStateProxy::Parameters parameters_impl (ActsTrk::IndexType index)
ConstTrackStateProxy::ConstCovariance covariance_impl (ActsTrk::IndexType index) const
 obtain covariances for a state at given index
TrackStateProxy::Covariance covariance_impl (ActsTrk::IndexType index)
ConstTrackStateProxy::Covariance trackMeasurementsCov (ActsTrk::IndexType index) const
 obtain measurement covariances for a state at given index
TrackStateProxy::Covariance trackMeasurementsCov (ActsTrk::IndexType index)
ConstTrackStateProxy::ConstCovariance jacobian_impl (ActsTrk::IndexType istate) const
 obtain jacobian for a state at given index
TrackStateProxy::Covariance jacobian_impl (ActsTrk::IndexType istate)
void ensureDynamicColumns_impl (const Acts::ConstVectorMultiTrajectory &other)
template<std::size_t measdim>
ConstTrackStateProxy::template ConstCalibrated< measdim > calibrated_impl (ActsTrk::IndexType index) const
 obtain calibrated measurements for a state at given index
template<std::size_t measdim, bool Enable = true>
std::enable_if_t< Enable, typename TrackStateProxy::template Calibrated< measdim > > calibrated_impl (ActsTrk::IndexType index)
template<std::size_t measdim>
ConstTrackStateProxy::template ConstCalibratedCovariance< measdim > calibratedCovariance_impl (ActsTrk::IndexType index) const
 obtain measurements covariance for a state at given index
template<std::size_t measdim, bool Enable = true>
std::enable_if_t< Enable, typename TrackStateProxy::template CalibratedCovariance< measdim > > calibratedCovariance_impl (ActsTrk::IndexType index)
Acts::TrackIndexType size_impl () const
 size of the MTJ
void clear_impl ()
 clears backends decoration columns are still declared
bool has_backends () const
 checks if the backends are connected (i.e.
template<typename val_t, typename cov_t>
requires (Eigen::PlainObjectBase<val_t>::RowsAtCompileTime > 0 && static_cast<unsigned>(Eigen::PlainObjectBase<val_t>
::RowsAtCompileTime) <= Acts::eBoundSize && static_cast<unsigned>(Eigen::PlainObjectBase<val_t>::RowsAtCompileTime)
== static_cast<unsigned>(Eigen::PlainObjectBase<cov_t>::RowsAtCompileTime) && Eigen::PlainObjectBase<cov_t>
::RowsAtCompileTime == Eigen::PlainObjectBase<cov_t>::ColsAtCompileTime)
void allocateCalibrated_impl (IndexType istate, const Eigen::DenseBase< val_t > &val, const Eigen::DenseBase< cov_t > &cov)
 Implementation of allocation of calibrated measurements.
ActsTrk::IndexType calibratedSize_impl (ActsTrk::IndexType istate) const
 Implementation of calibrated size.
void setUncalibratedSourceLink_impl (ActsTrk::IndexType istate, const Acts::SourceLink &sourceLink)
 Implementation of uncalibrated link insertion.
Acts::SourceLink getUncalibratedSourceLink_impl (ActsTrk::IndexType istate) const
 Implementation of uncalibrated link fetch.
void setReferenceSurface_impl (IndexType, std::shared_ptr< const Acts::Surface >)
const Acts::Surface * referenceSurface_impl (IndexType) const
void copyDynamicFrom_impl (ActsTrk::IndexType istate, Acts::HashedString key, const std::any &src_ptr)
 copy dynamic data from another MTJ
std::vector< Acts::HashedString > dynamicKeys_impl () const
 returns the keys of all the dynamic columns
const std::type_info & columnDataType_impl (Acts::HashedString key) const
std::string_view columnName_impl (Acts::HashedString key) const
xAOD::TrackStateAuxContainer * trackStatesAux ()
const xAOD::TrackParametersAuxContainer * trackParametersAux () const
xAOD::TrackParametersAuxContainer * trackParametersAux ()
xAOD::TrackJacobianAuxContainer * trackJacobiansAux ()
xAOD::TrackMeasurementAuxContainer * trackMeasurementsAux ()
xAOD::TrackSurfaceAuxContainer * trackSurfacesAux ()
xAOD::TrackSurfaceContainer * trackSurfaces ()
const xAOD::TrackSurfaceContainer * trackSurfaces () const
void excludeDecoration (std::string_view decorName)

Static Public Attributes

static const std::set< std::string > s_staticVariables

Private Member Functions

void trim ()

Private Attributes

std::unique_ptr< xAOD::TrackStateAuxContainer > m_trackStatesAux
size_t m_trackStatesSize = 0
std::unique_ptr< xAOD::TrackParametersAuxContainer > m_trackParametersAux
size_t m_trackParametersSize = 0
std::unique_ptr< xAOD::TrackJacobianAuxContainer > m_trackJacobiansAux
size_t m_trackJacobiansSize = 0
std::unique_ptr< xAOD::TrackMeasurementAuxContainer > m_trackMeasurementsAux
size_t m_trackMeasurementsSize = 0
std::unique_ptr< xAOD::TrackSurfaceContainer > m_surfacesBackend
std::unique_ptr< xAOD::TrackSurfaceAuxContainer > m_surfacesBackendAux
std::vector< ActsTrk::detail::Decoration > m_decorations
std::vector< std::optional< Acts::SourceLink > > m_calibratedSourceLinks
std::vector< std::optional< Acts::SourceLink > > m_uncalibratedSourceLinks
std::vector< StoredSurface > m_surfaces
GeometryContext m_geoContext
xAOD::TrackStateContainer m_trackStatesIface
std::unordered_set< Acts::HashedString > m_excluded {}

Detailed Description

Athena implementation of ACTS::MultiTrajectory (ReadWrite version) The data is stored in 4 external backends.

Backends lifetime are not maintained by this class. except when objects are default constructed (this functionality will be removed). This class is meant to be used in track finding algorithms (e.g. CKF) and then converted MultiTrajectory variant. These conversion is meant to be costless.

Definition at line 76 of file MultiTrajectory.h.

Member Typedef Documentation

◆ ConstTrackStateProxy

Initial value:
typename Acts::MultiTrajectory<
Athena implementation of ACTS::MultiTrajectory (ReadWrite version) The data is stored in 4 external b...
typename Acts::MultiTrajectory< ActsTrk::MutableMultiTrajectory >::ConstTrackStateProxy ConstTrackStateProxy

Definition at line 82 of file MultiTrajectory.h.

◆ TrackStateProxy

Initial value:
typename Acts::MultiTrajectory<
typename Acts::MultiTrajectory< ActsTrk::MutableMultiTrajectory >::TrackStateProxy TrackStateProxy

Definition at line 80 of file MultiTrajectory.h.

Constructor & Destructor Documentation

◆ MutableMultiTrajectory() [1/3]

ActsTrk::MutableMultiTrajectory::MutableMultiTrajectory ( )

Construct a new Multi Trajectory object owning backends.

Definition at line 101 of file MultiTrajectory.cxx.

102 : m_trackStatesAux (std::make_unique<xAOD::TrackStateAuxContainer>()),
103 m_trackParametersAux (std::make_unique<xAOD::TrackParametersAuxContainer>()),
104 m_trackJacobiansAux (std::make_unique<xAOD::TrackJacobianAuxContainer>()),
105 m_trackMeasurementsAux (std::make_unique<xAOD::TrackMeasurementAuxContainer>()),
106 m_surfacesBackend (std::make_unique<xAOD::TrackSurfaceContainer>()),
107 m_surfacesBackendAux (std::make_unique<xAOD::TrackSurfaceAuxContainer>())
108{
109 INSPECTCALL("c-tor " << this)
110
113
114}
#define INSPECTCALL(_INFO)
std::unique_ptr< xAOD::TrackParametersAuxContainer > m_trackParametersAux
xAOD::TrackStateContainer m_trackStatesIface
std::unique_ptr< xAOD::TrackStateAuxContainer > m_trackStatesAux
std::unique_ptr< xAOD::TrackSurfaceAuxContainer > m_surfacesBackendAux
std::unique_ptr< xAOD::TrackMeasurementAuxContainer > m_trackMeasurementsAux
std::unique_ptr< xAOD::TrackSurfaceContainer > m_surfacesBackend
std::unique_ptr< xAOD::TrackJacobianAuxContainer > m_trackJacobiansAux
T * get(TKey *tobj)
get a TObject* from a TKey* (why can't a TObject be a TKey?)
Definition hcg.cxx:132

◆ MutableMultiTrajectory() [2/3]

ActsTrk::MutableMultiTrajectory::MutableMultiTrajectory ( const ActsTrk::MutableMultiTrajectory & other)

Definition at line 116 of file MultiTrajectory.cxx.

118 {
119 INSPECTCALL("copy c-tor " << this << " src " << &other << " " << other.size())
120
121 *m_trackStatesAux = *other.m_trackStatesAux;
122 *m_trackParametersAux = *other.m_trackParametersAux;
123 *m_trackJacobiansAux = *other.m_trackJacobiansAux;
124 *m_trackMeasurementsAux = *other.m_trackMeasurementsAux;
125 m_decorations = other.m_decorations;
126 m_calibratedSourceLinks = other.m_calibratedSourceLinks;
127 m_uncalibratedSourceLinks = other.m_uncalibratedSourceLinks;
128
129 m_surfaces = other.m_surfaces;
130 m_geoContext = other.m_geoContext;
131 m_trackStatesIface.resize(m_trackStatesAux->size());
132 INSPECTCALL("copy c-tor done")
133}
std::vector< StoredSurface > m_surfaces
std::vector< std::optional< Acts::SourceLink > > m_calibratedSourceLinks
std::vector< ActsTrk::detail::Decoration > m_decorations
MutableMultiTrajectory()
Construct a new Multi Trajectory object owning backends.
std::vector< std::optional< Acts::SourceLink > > m_uncalibratedSourceLinks

◆ MutableMultiTrajectory() [3/3]

ActsTrk::MutableMultiTrajectory::MutableMultiTrajectory ( ActsTrk::MutableMultiTrajectory && other)
default

Member Function Documentation

◆ addColumn_impl()

template<typename T>
void ActsTrk::MutableMultiTrajectory::addColumn_impl ( std::string_view key)

enables particular decoration, type & name need to be specified

Template Parameters
Ttype of decoration (usually POD)
Parameters
keyname of the decoration

◆ addTrackState_impl()

IndexType ActsTrk::MutableMultiTrajectory::addTrackState_impl ( Acts::TrackStatePropMask mask,
ActsTrk::IndexType iprevious )

Add state with stograge for data that depends on the mask.

Parameters
mask- bitmask deciding which backends are extended
istate- previous state
Returns
index of just added state

Definition at line 175 of file MultiTrajectory.cxx.

177 {
178 using namespace Acts::HashedStringLiteral;
179 INSPECTCALL( this << " " << mask << " " << m_trackStatesIface.size() << " " << previous);
180 assert(m_trackStatesAux && "Missing Track States backend");
182 m_surfaces.push_back(nullptr);
183
184 // set kInvalid
185 constexpr auto kInvalid = Acts::kTrackIndexInvalid;
186
187 if (previous >= kInvalid - 1)
188 previous = kInvalid; // fix needed in Acts::MTJ
190 using namespace Acts;
191
192 auto addParam = [this]() -> IndexType {
193 stepResize(m_trackParametersAux.get(), m_trackParametersSize, 60);
194 // TODO ask AK if this resize could be method of aux container
195 m_trackParametersAux->params[m_trackParametersSize].resize(Acts::eBoundSize);
196 m_trackParametersAux->covMatrix[m_trackParametersSize].resize(Acts::eBoundSize*Acts::eBoundSize);
198 return m_trackParametersSize-1;
199 };
200
201 auto addJacobian = [this]() -> IndexType {
202 stepResize(m_trackJacobiansAux.get(), m_trackJacobiansSize);
203 m_trackJacobiansAux->jac[m_trackJacobiansSize].resize(Acts::eBoundSize*Acts::eBoundSize);
205 return m_trackJacobiansSize-1;
206 };
207
208 auto addMeasurement = [this]() -> IndexType {
210 m_trackMeasurementsAux->meas[m_trackMeasurementsSize].resize(Acts::eBoundSize);
211 m_trackMeasurementsAux->covMatrix[m_trackMeasurementsSize].resize(Acts::eBoundSize*Acts::eBoundSize);
214 };
215
216 m_trackStatesAux->predicted[m_trackStatesSize] = kInvalid;
217 if (ACTS_CHECK_BIT(mask, TrackStatePropMask::Predicted)) {
218 m_trackStatesAux->predicted[m_trackStatesSize] = addParam();
219 }
220
221 m_trackStatesAux->filtered[m_trackStatesSize] = kInvalid;
222 if (ACTS_CHECK_BIT(mask, TrackStatePropMask::Filtered)) {
223 m_trackStatesAux->filtered[m_trackStatesSize] = addParam();
224 }
225
226 m_trackStatesAux->smoothed[m_trackStatesSize] = kInvalid;
227 if (ACTS_CHECK_BIT(mask, TrackStatePropMask::Smoothed)) {
228 m_trackStatesAux->smoothed[m_trackStatesSize] = addParam();
229 }
230
231 m_trackStatesAux->jacobian[m_trackStatesSize] = kInvalid;
232 if (ACTS_CHECK_BIT(mask, TrackStatePropMask::Jacobian)) {
233 m_trackStatesAux->jacobian[m_trackStatesSize] = addJacobian();
234 }
235
236 m_uncalibratedSourceLinks.emplace_back(std::nullopt);
237 m_trackStatesAux->calibrated[m_trackStatesSize] = kInvalid;
238 m_trackStatesAux->measDim[m_trackStatesSize] = kInvalid;
239 // @TODO uncalibrated ?
240 if (ACTS_CHECK_BIT(mask, TrackStatePropMask::Calibrated)) {
241 m_trackStatesAux->calibrated.at(m_trackStatesSize) = addMeasurement();
242 m_calibratedSourceLinks.emplace_back(std::nullopt);
243 }
244
245 m_trackStatesAux->geometryId[m_trackStatesSize] = InvalidGeoID; // surface is invalid until set
247 return m_trackStatesSize-1;
248}
constexpr uint64_t InvalidGeoID
std::uint32_t IndexType
Definition Decoration.h:28
@ previous
Definition BinningData.h:34

◆ addTrackStateComponents_impl()

void ActsTrk::MutableMultiTrajectory::addTrackStateComponents_impl ( ActsTrk::IndexType istate,
Acts::TrackStatePropMask mask )

Add state components for the given mask.

Parameters
istate- state index
mask- bitmask deciding which backends are extended

Definition at line 251 of file MultiTrajectory.cxx.

253 {
254 using namespace Acts::HashedStringLiteral;
255 INSPECTCALL( this << " " << mask << " " << m_trackStatesIface.size() << " " << istate);
256
257 assert(m_trackStatesAux && "Missing Track States backend");
258
259 // set kInvalid
260 constexpr auto kInvalid = Acts::kTrackIndexInvalid;
261
262 using namespace Acts;
263
264 auto addParam = [this]() -> IndexType {
265 stepResize(m_trackParametersAux.get(), m_trackParametersSize, 60);
266 // TODO ask AK if this resize could be method of aux container
267 m_trackParametersAux->params[m_trackParametersSize].resize(Acts::eBoundSize);
268 m_trackParametersAux->covMatrix[m_trackParametersSize].resize(Acts::eBoundSize*Acts::eBoundSize);
270 return m_trackParametersSize-1;
271 };
272
273 auto addJacobian = [this]() -> IndexType {
274 stepResize(m_trackJacobiansAux.get(), m_trackJacobiansSize);
275 m_trackJacobiansAux->jac[m_trackJacobiansSize].resize(Acts::eBoundSize*Acts::eBoundSize);
277 return m_trackJacobiansSize-1;
278 };
279
280 auto addMeasurement = [this]() -> IndexType {
282 m_trackMeasurementsAux->meas[m_trackMeasurementsSize].resize(Acts::eBoundSize);
283 m_trackMeasurementsAux->covMatrix[m_trackMeasurementsSize].resize(Acts::eBoundSize*Acts::eBoundSize);
286 };
287
288 if ((m_trackStatesAux->predicted[istate] == kInvalid) &&
289 ACTS_CHECK_BIT(mask, TrackStatePropMask::Predicted)) {
290 m_trackStatesAux->predicted[istate] = addParam();
291 }
292
293 if ((m_trackStatesAux->filtered[istate] == kInvalid) &&
294 ACTS_CHECK_BIT(mask, TrackStatePropMask::Filtered)) {
295 m_trackStatesAux->filtered[istate] = addParam();
296 }
297
298 if ((m_trackStatesAux->smoothed[istate] == kInvalid) &&
299 ACTS_CHECK_BIT(mask, TrackStatePropMask::Smoothed)) {
300 m_trackStatesAux->smoothed[istate] = addParam();
301 }
302
303 if ((m_trackStatesAux->jacobian[istate] == kInvalid) &&
304 ACTS_CHECK_BIT(mask, TrackStatePropMask::Jacobian)) {
305 m_trackStatesAux->jacobian[istate] = addJacobian();
306 }
307
308 if ((m_trackStatesAux->calibrated[istate] == kInvalid) &&
309 ACTS_CHECK_BIT(mask, TrackStatePropMask::Calibrated)) {
310 m_trackStatesAux->calibrated[istate] = addMeasurement();
311 m_calibratedSourceLinks.emplace_back(std::nullopt);
312 }
313}

◆ allocateCalibrated_impl()

template<typename val_t, typename cov_t>
requires (Eigen::PlainObjectBase<val_t>::RowsAtCompileTime > 0 && static_cast<unsigned>(Eigen::PlainObjectBase<val_t>
::RowsAtCompileTime) <= Acts::eBoundSize && static_cast<unsigned>(Eigen::PlainObjectBase<val_t>::RowsAtCompileTime)
== static_cast<unsigned>(Eigen::PlainObjectBase<cov_t>::RowsAtCompileTime) && Eigen::PlainObjectBase<cov_t>
::RowsAtCompileTime == Eigen::PlainObjectBase<cov_t>::ColsAtCompileTime)
void ActsTrk::MutableMultiTrajectory::allocateCalibrated_impl ( IndexType istate,
const Eigen::DenseBase< val_t > & val,
const Eigen::DenseBase< cov_t > & cov )

Implementation of allocation of calibrated measurements.

◆ calibrated_impl() [1/2]

template<std::size_t measdim, bool Enable = true>
std::enable_if_t< Enable, typename TrackStateProxy::template Calibrated< measdim > > ActsTrk::MutableMultiTrajectory::calibrated_impl ( ActsTrk::IndexType index)
inline

Definition at line 256 of file MultiTrajectory.h.

256 {
257 xAOD::TrackStateIndexType measIdx = m_trackStatesAux->calibrated[index];
258 return typename TrackStateProxy::template Calibrated<measdim>{m_trackMeasurementsAux->meas[measIdx].data()};
259 }
str index
Definition DeMoScan.py:362
uint32_t TrackStateIndexType

◆ calibrated_impl() [2/2]

template<std::size_t measdim>
ConstTrackStateProxy::template ConstCalibrated< measdim > ActsTrk::MutableMultiTrajectory::calibrated_impl ( ActsTrk::IndexType index) const
inline

obtain calibrated measurements for a state at given index

Parameters
index
Returns
TrackStateProxy::Calibrated

Definition at line 248 of file MultiTrajectory.h.

248 {
249 xAOD::TrackStateIndexType measIdx = m_trackStatesAux->calibrated[index];
250 return typename ConstTrackStateProxy::template ConstCalibrated<measdim>{m_trackMeasurementsAux->meas[measIdx].data()};
251 }

◆ calibratedCovariance_impl() [1/2]

template<std::size_t measdim, bool Enable = true>
std::enable_if_t< Enable, typename TrackStateProxy::template CalibratedCovariance< measdim > > ActsTrk::MutableMultiTrajectory::calibratedCovariance_impl ( ActsTrk::IndexType index)
inline

Definition at line 277 of file MultiTrajectory.h.

277 {
278 xAOD::TrackStateIndexType measIdx = m_trackStatesAux->calibrated[index];
279 return TrackStateProxy::template CalibratedCovariance<measdim>{m_trackMeasurementsAux->covMatrix[measIdx].data()};
280 }

◆ calibratedCovariance_impl() [2/2]

template<std::size_t measdim>
ConstTrackStateProxy::template ConstCalibratedCovariance< measdim > ActsTrk::MutableMultiTrajectory::calibratedCovariance_impl ( ActsTrk::IndexType index) const
inline

obtain measurements covariance for a state at given index

Parameters
index
Returns
TrackStateProxy::Covariance

Definition at line 270 of file MultiTrajectory.h.

270 {
271 xAOD::TrackStateIndexType measIdx = m_trackStatesAux->calibrated[index];
272 return ConstTrackStateProxy::template ConstCalibratedCovariance<measdim>{m_trackMeasurementsAux->covMatrix[measIdx].data()};
273 }

◆ calibratedSize_impl()

IndexType ActsTrk::MutableMultiTrajectory::calibratedSize_impl ( ActsTrk::IndexType istate) const

Implementation of calibrated size.

Definition at line 548 of file MultiTrajectory.cxx.

548 {
549 // Retrieve the calibrated measurement size
550 // INSPECTCALL(istate << " " << trackMeasurements().size());
551 return m_trackStatesAux->measDim[istate];
552}

◆ clear_impl()

void ActsTrk::MutableMultiTrajectory::clear_impl ( )

clears backends decoration columns are still declared

Definition at line 527 of file MultiTrajectory.cxx.

527 {
528 INSPECTCALL(this);
529 m_trackStatesIface.resize(0);
531
532 m_trackParametersAux->resize(0);
534
535 m_trackJacobiansAux->resize(0);
537
538 m_trackMeasurementsAux->resize(0);
540
541 m_surfacesBackend->clear();
542 m_surfaces.clear();
545}

◆ columnDataType_impl()

const std::type_info & ActsTrk::MutableMultiTrajectory::columnDataType_impl ( Acts::HashedString key) const

Definition at line 144 of file MultiTrajectory.cxx.

144 {
145 for (auto& d : m_decorations) {
146 if (d.hash == key) {
147 return *SG::AuxTypeRegistry::instance().getType(d.auxid);
148 }
149 }
150 throw std::runtime_error(std::format("{:}() - Key is unknown {:}",__func__, key));
151 return typeid(const void*);
152}
const std::type_info * getType(SG::auxid_t auxid) const
Return the type of an aux data item.
static AuxTypeRegistry & instance()
Return the singleton registry instance.

◆ columnName_impl()

std::string_view ActsTrk::MutableMultiTrajectory::columnName_impl ( Acts::HashedString key) const

Definition at line 135 of file MultiTrajectory.cxx.

135 {
136 for (auto& d : m_decorations) {
137 if (d.hash == key) {
138 return d.name;
139 }
140 }
141 throw std::runtime_error(std::format("{:}() - Key is unknown {:}",__func__, key));
142 return "";
143}

◆ component_impl() [1/2]

std::any ActsTrk::MutableMultiTrajectory::component_impl ( Acts::HashedString key,
ActsTrk::IndexType istate )

Definition at line 406 of file MultiTrajectory.cxx.

407 {
408 using namespace Acts::HashedStringLiteral;
409 assert(istate < m_trackStatesIface.size() &&
410 "Attempt to reach beyond the Track States container size");
411 INSPECTCALL(key << " " << istate << " non-const component_impl")
412
413 switch (key) {
414 case "previous"_hash:
415 return &(m_trackStatesAux->previous[istate]);
416 case "next"_hash:
417 return &(m_trackStatesAux->next[istate]);
418 case "chi2"_hash:
419 return &(m_trackStatesAux->chi2[istate]);
420 case "pathLength"_hash:
421 return &(m_trackStatesAux->pathLength[istate]);
422 case "predicted"_hash:
423 return &(m_trackStatesAux->predicted[istate]);
424 case "filtered"_hash:
425 return &(m_trackStatesAux->filtered[istate]);
426 case "smoothed"_hash:
427 return &(m_trackStatesAux->smoothed[istate]);
428 case "projector"_hash: {
429 auto idx = m_trackStatesAux->calibrated[istate];
430 return &(m_trackMeasurementsAux->projector[idx]);
431 }
432 case "measdim"_hash:
433 return &(m_trackStatesAux->measDim[istate]);
434 case "typeFlags"_hash:
435 return &(m_trackStatesAux->typeFlags[istate]);
436
437 default: {
438 for (auto& d : m_decorations) {
439 if (d.hash == key) {
440 return d.setter(m_trackStatesAux.get(), istate, d.auxid);
441 }
442 }
443 throw std::runtime_error("MutableMultiTrajectory::component_impl no such component " + std::to_string(key));
444 }
445 }
446}

◆ component_impl() [2/2]

std::any ActsTrk::MutableMultiTrajectory::component_impl ( Acts::HashedString key,
ActsTrk::IndexType istate ) const

Access component by key.

Parameters
key
istate
Returns
std::any - that needs to be cast to a const ptr (non const for the nonconst variant)

Definition at line 449 of file MultiTrajectory.cxx.

451 {
452 using namespace Acts::HashedStringLiteral;
453 assert(istate < m_trackStatesIface.size() &&
454 "Attempt to reach beyond the Track States container size");
455 INSPECTCALL(key << " " << istate << " const component_impl")
456 switch (key) {
457 case "previous"_hash:
458 return &(to_const_ptr(m_trackStatesAux)->previous[istate]);
459 case "next"_hash:
460 return &(to_const_ptr(m_trackStatesAux)->next[istate]);
461 case "chi2"_hash:
462 return &(to_const_ptr(m_trackStatesAux)->chi2[istate]);
463 case "pathLength"_hash:
464 return &(to_const_ptr(m_trackStatesAux)->pathLength[istate]);
465 case "predicted"_hash:
466 return &(to_const_ptr(m_trackStatesAux)->predicted[istate]);
467 case "filtered"_hash:
468 return &(to_const_ptr(m_trackStatesAux)->filtered[istate]);
469 case "smoothed"_hash:
470 return &(to_const_ptr(m_trackStatesAux)->smoothed[istate]);
471 case "jacobian"_hash:
472 return &(to_const_ptr(m_trackStatesAux)->jacobian[istate]);
473 case "projector"_hash:{
474 auto idx = to_const_ptr(m_trackStatesAux)->calibrated[istate];
475 return &(to_const_ptr(m_trackMeasurementsAux)->projector[idx]);
476 }
477 case "calibrated"_hash: {
478 return &(to_const_ptr(m_trackStatesAux)->calibrated[istate]);
479 }
480 case "calibratedCov"_hash: {
481 return &(to_const_ptr(m_trackStatesAux)->calibrated[istate]);
482 }
483 case "measdim"_hash:
484 return &(to_const_ptr(m_trackStatesAux)->measDim[istate]);
485 case "typeFlags"_hash:
486 return &(to_const_ptr(m_trackStatesAux)->typeFlags[istate]);
487 default: {
488 for (auto& d : m_decorations) {
489 if (d.hash == key) {
490 INSPECTCALL("getting dynamic variable " << d.name << " " << istate);
491 return d.getter(m_trackStatesAux.get(), istate, d.auxid);
492 }
493 }
494 throw std::runtime_error("MutableMultiTrajectory::component_impl const no such component " + std::to_string(key));
495 }
496 }
497}
const T * to_const_ptr(const std::unique_ptr< T > &ptr)

◆ copyDynamicFrom_impl()

void ActsTrk::MutableMultiTrajectory::copyDynamicFrom_impl ( ActsTrk::IndexType istate,
Acts::HashedString key,
const std::any & src_ptr )

copy dynamic data from another MTJ

Parameters
istate- index of the track to be filled
key- key of the dynamic data
src_ptr- pointer to the source data
Warning
the type fetched from src and type of the destiantion decoration need to agree

Definition at line 622 of file MultiTrajectory.cxx.

624 {
625 if (m_excluded.count(key)) { return; }
626 INSPECTCALL("copy dynamic decoration of key " << key << " destination MTJ has " << m_decorations.size() << " decorations");
627 for (const detail::Decoration& d : m_decorations) {
628 INSPECTCALL("checking for destination of dynamic decoration " << d.name << " hash " << d.hash << " while looking for the key " << key);
629 if (d.hash == key) {
630 d.copier(m_trackStatesAux.get(), istate, d.auxid, src_ptr);
631 return;
632 }
633 }
634 throw std::invalid_argument("MultiTrajectory::copyDynamicFrom_impl no such decoration in destination MTJ " + std::to_string(key));
635}
std::unordered_set< Acts::HashedString > m_excluded

◆ covariance_impl() [1/2]

TrackStateProxy::Covariance ActsTrk::MutableMultiTrajectory::covariance_impl ( ActsTrk::IndexType index)
inline

Definition at line 198 of file MultiTrajectory.h.

198 {
199 return typename TrackStateProxy::Covariance{m_trackParametersAux->covMatrix[index].data()};
200 }

◆ covariance_impl() [2/2]

ConstTrackStateProxy::ConstCovariance ActsTrk::MutableMultiTrajectory::covariance_impl ( ActsTrk::IndexType index) const
inline

obtain covariances for a state at given index

Parameters
index
Returns
TrackStateProxy::Covariance

Definition at line 194 of file MultiTrajectory.h.

195 {
196 return typename ConstTrackStateProxy::ConstCovariance{m_trackParametersAux->covMatrix[index].data()};
197 }

◆ dynamicKeys_impl()

std::vector< Acts::HashedString > ActsTrk::MutableMultiTrajectory::dynamicKeys_impl ( ) const

returns the keys of all the dynamic columns

Definition at line 637 of file MultiTrajectory.cxx.

637 {
638 std::vector<Acts::HashedString> keys;
639 for ( const detail::Decoration& d: m_decorations) {
640 keys.push_back(d.hash);
641 INSPECTCALL("collecting dynamic decoration " << d.name << " hash " << d.hash);
642 }
643 return keys;
644}

◆ ensureDynamicColumns_impl()

void ActsTrk::MutableMultiTrajectory::ensureDynamicColumns_impl ( const Acts::ConstVectorMultiTrajectory & other)

Definition at line 159 of file MultiTrajectory.cxx.

159 {
160#ifdef ACTIVATE_LATER
161 ensureDynamicColumns(m_excluded, other, *this);
162#endif
163}
void ensureDynamicColumns(const std::unordered_set< Acts::HashedString > &exclude, const cont_in &in_container, cont_out &out_container)
Definition Decoration.h:195

◆ excludeDecoration()

void ActsTrk::MutableMultiTrajectory::excludeDecoration ( std::string_view decorName)

Definition at line 164 of file MultiTrajectory.cxx.

164 {
165 m_excluded.insert(Acts::hashStringDynamic(decorName));
166}

◆ getUncalibratedSourceLink_impl()

Acts::SourceLink ActsTrk::MutableMultiTrajectory::getUncalibratedSourceLink_impl ( ActsTrk::IndexType istate) const

Implementation of uncalibrated link fetch.

Definition at line 839 of file MultiTrajectory.cxx.

840 {
841 assert(istate < m_trackStatesIface.size());
842 // at the moment when converting Trk::Track to Acts tracks the measurements on track
843 // are not converted to xAOD::UncalibratedMeasurements, and the Acts::SourceLinks
844 // just contain a pointer to the Trk::Measurement. To keep this functionality
845 // SourceLinks are either stored in the m_uncalibratedSourceLinks cache
846 // or taken from the xAOD backend.
847 static const SG::ConstAccessor<const xAOD::UncalibratedMeasurement*> acc{"uncalibratedMeasurement"};
848 if (const xAOD::UncalibratedMeasurement* ptr = acc.withDefault(m_trackStatesIface, istate, nullptr))
849 {
851 }
852 return m_uncalibratedSourceLinks[istate].value();
853}
static Acts::SourceLink pack(const Ptr_t &measurement)
Pack the measurement type pointer to an Acts::SourceLink including the intermediate conversion into a...
SG::ConstAccessor< T, ALLOC > ConstAccessor
Definition AuxElement.h:570
UncalibratedMeasurement_v1 UncalibratedMeasurement
Define the version of the uncalibrated measurement class.

◆ has_backends()

bool ActsTrk::MutableMultiTrajectory::has_backends ( ) const

checks if the backends are connected (i.e.

is safe to use, else any other call will cause segfaults)

Definition at line 154 of file MultiTrajectory.cxx.

154 {
155 return m_trackStatesAux != nullptr and m_trackParametersAux != nullptr and
156 m_trackJacobiansAux != nullptr and m_trackMeasurementsAux != nullptr
157 and m_surfacesBackend != nullptr;
158}

◆ has_impl()

bool ActsTrk::MutableMultiTrajectory::has_impl ( Acts::HashedString key,
ActsTrk::IndexType istate ) const

checks if given state has requested component

Parameters
key- name (const char*)
istate- index in the
Returns
true
false

Definition at line 499 of file MultiTrajectory.cxx.

500 {
501 std::optional<bool> inTrackState = ::has_impl(m_trackStatesAux.get(), key, istate);
502 if (inTrackState.has_value())
503 return inTrackState.value();
504
505 // TODO remove once EL based source links are in use only
506 using namespace Acts::HashedStringLiteral;
507 if (key == "uncalibratedSourceLink"_hash){
508 INSPECTCALL(key << " " << istate << " uncalibratedSourceLink")
509 static const SG::ConstAccessor<const xAOD::UncalibratedMeasurement*> acc{"uncalibratedMeasurement"};
510 if (acc.isAvailable (m_trackStatesIface)) {
511 if (acc(m_trackStatesIface, istate) != nullptr) return true;
512 }
513
514 return (istate < m_uncalibratedSourceLinks.size() && m_uncalibratedSourceLinks[istate].has_value());
515 }
516
517 for (auto& d : m_decorations) {
518 if (d.hash == key) {
519 INSPECTCALL(key << " " << istate << " d.name")
520 return true;
521 }
522 }
523
524 return false;
525}
bool has_impl(Acts::HashedString key, ActsTrk::IndexType istate) const
checks if given state has requested component

◆ hasColumn_impl()

bool ActsTrk::MutableMultiTrajectory::hasColumn_impl ( Acts::HashedString key) const
constexpr

checks if MTJ has requested column (irrespectively of the state)

Parameters
key- name (const char*)
Returns
true - if the column is present
false - if not

◆ jacobian_impl() [1/2]

TrackStateProxy::Covariance ActsTrk::MutableMultiTrajectory::jacobian_impl ( ActsTrk::IndexType istate)
inline

Definition at line 232 of file MultiTrajectory.h.

232 {
233 xAOD::TrackStateIndexType jacIdx = m_trackStatesAux->jacobian[istate];
234 return typename TrackStateProxy::Covariance{m_trackJacobiansAux->jac[jacIdx].data()};
235 }

◆ jacobian_impl() [2/2]

ConstTrackStateProxy::ConstCovariance ActsTrk::MutableMultiTrajectory::jacobian_impl ( ActsTrk::IndexType istate) const
inline

obtain jacobian for a state at given index

Parameters
index
Returns
TrackStateProxy::Covariance

Definition at line 226 of file MultiTrajectory.h.

227 {
228 xAOD::TrackStateIndexType jacIdx = m_trackStatesAux->jacobian[istate];
229 return typename ConstTrackStateProxy::ConstCovariance{m_trackJacobiansAux->jac[jacIdx].data()};
230 }

◆ operator=()

MutableMultiTrajectory & ActsTrk::MutableMultiTrajectory::operator= ( const ActsTrk::MutableMultiTrajectory & other)
delete

◆ parameters_impl() [1/2]

TrackStateProxy::Parameters ActsTrk::MutableMultiTrajectory::parameters_impl ( ActsTrk::IndexType index)
inline

Definition at line 184 of file MultiTrajectory.h.

184 {
185 return typename TrackStateProxy::Parameters{m_trackParametersAux->params[index].data()};
186 }

◆ parameters_impl() [2/2]

ConstTrackStateProxy::ConstParameters ActsTrk::MutableMultiTrajectory::parameters_impl ( ActsTrk::IndexType index) const
inline

obtains proxy to the track state under given index

Parameters
index
Returns
TrackStateProxy::Parameters

Definition at line 179 of file MultiTrajectory.h.

180 {
181 return typename ConstTrackStateProxy::ConstParameters{m_trackParametersAux->params[index].data()};
182 }

◆ referenceSurface_impl()

const Acts::Surface * ActsTrk::MutableMultiTrajectory::referenceSurface_impl ( IndexType istate) const

Definition at line 617 of file MultiTrajectory.cxx.

617 {
618 if ( istate >= m_surfaces.size() ) throw std::out_of_range("MutableMultiTrajectory index " + std::to_string(istate) + " out of range " + std::to_string(m_surfaces.size()) + " when accessing reference surface");
619 return toSurfacePtr(m_surfaces[istate]);
620}

◆ setReferenceSurface_impl()

void ActsTrk::MutableMultiTrajectory::setReferenceSurface_impl ( IndexType istate,
std::shared_ptr< const Acts::Surface > surface )

Definition at line 591 of file MultiTrajectory.cxx.

592 {
593 if ( istate >= m_surfaces.size() )
594 m_surfaces.resize(istate+1, nullptr);
595
596 m_trackStatesAux->geometryId[istate] = surface->geometryId().value();
597 if (surface->geometryId().value() == 0) { // free surface, needs recording of properties
598 m_surfacesBackend->push_back(new xAOD::TrackSurface());
599 encodeSurface(m_surfacesBackendAux.get(), m_surfacesBackendAux->size()-1, surface.get(), m_geoContext.context());
600 m_trackStatesAux->surfaceIndex[istate] = m_surfacesBackend->size()-1;
601 m_surfaces[istate] = std::move(surface); // and memory management
602
603 } else {
604 m_surfaces[istate] = surface.get(); // no memory management, bare pointer
605 }
606 // store surface representation in
607}
void encodeSurface(xAOD::TrackSurfaceAuxContainer *backend, size_t index, const Acts::Surface *surface, const Acts::GeometryContext &geoContext)
Prepares persistifiable representation of surface into xAOD::TrackSurface object.
TrackSurface_v1 TrackSurface

◆ setUncalibratedSourceLink_impl()

void ActsTrk::MutableMultiTrajectory::setUncalibratedSourceLink_impl ( ActsTrk::IndexType istate,
const Acts::SourceLink & sourceLink )

Implementation of uncalibrated link insertion.

Definition at line 555 of file MultiTrajectory.cxx.

556 {
557 INSPECTCALL( istate );
558
560 static const Decor_t decor{"uncalibratedMeasurement"};
561 if (istate>= m_trackStatesIface.size()) {
562 throw std::range_error("istate out of range on TrackStates when attempting to access uncalibrated measurements");
563 }
564 Decor_t::span uncalibratedMeasurements = decor.getDecorationSpan(m_trackStatesIface);
565
566 // @TODO normally the source links should contain an xAOD::UncalibratedMeasurement pointer
567 // but in some cases some other payload is used e.g. when converting Trk::Tracks.
568 // Only UncalibratedMeasurement pointer can be stored in the xAOD backend. Everything
569 // else has to go into the cache.
570 // Currently there is no possibility to check whether the source link contains a certain payload
571 // so can only catch the bad any cast
572 try {
574 auto unpacked = detail::MeasurementCalibratorBase::unpackBase(sourceLink);
575 uncalibratedMeasurements.at(istate) = std::get<const xAOD::UncalibratedMeasurement*>(unpacked);
576 } else {
577 assert( istate < m_uncalibratedSourceLinks.size());
578 m_uncalibratedSourceLinks[istate] = sourceLink;
579 }
580 } catch (const std::bad_any_cast &err) {
581 try {
582 auto unpacked = sourceLink.get<const xAOD::UncalibratedMeasurement*>();
583 uncalibratedMeasurements.at(istate) = unpacked;
584 } catch (const std::bad_any_cast &err1) {
585 assert( istate < m_uncalibratedSourceLinks.size());
586 m_uncalibratedSourceLinks[istate] = sourceLink;
587 }
588 }
589}
static SourceLinkType getType(const Acts::SourceLink &sl)
Returns the enumeration corresponding to the object type cached within the Acts::SourceLink.
static SourceLink_t unpackBase(const Acts::SourceLink &sl)
Unpack the SourceLink_t from the passed Acts source link.
@ xAODUnCalibMeas
UnCalibrated Trk::PrepRawData objects.
SG::Decorator< T, ALLOC > Decorator
Helper class to provide type-safe access to aux data, specialized for JaggedVecElt.
Definition AuxElement.h:576

◆ shareFrom_impl()

void ActsTrk::MutableMultiTrajectory::shareFrom_impl ( ActsTrk::IndexType iself,
ActsTrk::IndexType iother,
Acts::TrackStatePropMask shareSource,
Acts::TrackStatePropMask shareTarget )

shares from a given state

Parameters
shareSource,shareTarget- property
iself,iother- indexes

Definition at line 316 of file MultiTrajectory.cxx.

320 {
321
322 assert(ACTS_CHECK_BIT(this->getTrackState(iother).getMask(), shareSource) &&
323 "Source has incompatible allocation");
324
325 using PM = Acts::TrackStatePropMask;
326 // set kInvalid
327 constexpr auto kInvalid = Acts::kTrackIndexInvalid;
328
329 IndexType sourceIndex{kInvalid};
330 switch (shareSource) {
331 case PM::Predicted:
332 sourceIndex = m_trackStatesAux->predicted[iother];
333 break;
334 case PM::Filtered:
335 sourceIndex = m_trackStatesAux->filtered[iother];
336 break;
337 case PM::Smoothed:
338 sourceIndex = m_trackStatesAux->smoothed[iother];
339 break;
340 case PM::Jacobian:
341 sourceIndex = m_trackStatesAux->jacobian[iother];
342 break;
343 default:
344 throw std::domain_error{"MutableMultiTrajectory Unable to share this component"};
345 }
346
347 assert(sourceIndex != kInvalid);
348
349 switch (shareTarget) {
350 case PM::Predicted:
351 assert(shareSource != PM::Jacobian);
352 m_trackStatesAux->predicted[iself] = sourceIndex;
353 break;
354 case PM::Filtered:
355 assert(shareSource != PM::Jacobian);
356 m_trackStatesAux->filtered[iself] = sourceIndex;
357 break;
358 case PM::Smoothed:
359 assert(shareSource != PM::Jacobian);
360 m_trackStatesAux->smoothed[iself] = sourceIndex;
361 break;
362 case PM::Jacobian:
363 assert(shareSource == PM::Jacobian);
364 m_trackStatesAux->jacobian[iself] = sourceIndex;
365 break;
366 default:
367 throw std::domain_error{"MutableMultiTrajectory Unable to share this component"};
368 }
369}

◆ size_impl()

Acts::TrackIndexType ActsTrk::MutableMultiTrajectory::size_impl ( ) const
inline

size of the MTJ

Returns
size_t

Definition at line 288 of file MultiTrajectory.h.

288 {
289 return m_trackStatesSize;
290 }

◆ trackJacobiansAux()

xAOD::TrackJacobianAuxContainer * ActsTrk::MutableMultiTrajectory::trackJacobiansAux ( )
inline

Definition at line 369 of file MultiTrajectory.h.

369 {
370 return m_trackJacobiansAux.get();
371 }

◆ trackMeasurementsAux()

xAOD::TrackMeasurementAuxContainer * ActsTrk::MutableMultiTrajectory::trackMeasurementsAux ( )
inline

Definition at line 373 of file MultiTrajectory.h.

373 {
374 return m_trackMeasurementsAux.get();
375 }

◆ trackMeasurementsCov() [1/2]

TrackStateProxy::Covariance ActsTrk::MutableMultiTrajectory::trackMeasurementsCov ( ActsTrk::IndexType index)
inline

Definition at line 214 of file MultiTrajectory.h.

214 {
215 return typename TrackStateProxy::Covariance{m_trackMeasurementsAux->covMatrix[index].data()};
216
217 }

◆ trackMeasurementsCov() [2/2]

ConstTrackStateProxy::Covariance ActsTrk::MutableMultiTrajectory::trackMeasurementsCov ( ActsTrk::IndexType index) const
inline

obtain measurement covariances for a state at given index

Parameters
index
Returns
TrackStateProxy::Covariance

Definition at line 208 of file MultiTrajectory.h.

209 {
210 return typename ConstTrackStateProxy::Covariance{m_trackMeasurementsAux->covMatrix[index].data()};
211
212 }

◆ trackParametersAux() [1/2]

xAOD::TrackParametersAuxContainer * ActsTrk::MutableMultiTrajectory::trackParametersAux ( )
inline

Definition at line 365 of file MultiTrajectory.h.

365 {
366 return m_trackParametersAux.get();
367 }

◆ trackParametersAux() [2/2]

const xAOD::TrackParametersAuxContainer * ActsTrk::MutableMultiTrajectory::trackParametersAux ( ) const
inline

Definition at line 362 of file MultiTrajectory.h.

362 {
363 return m_trackParametersAux.get();
364 }

◆ trackStatesAux()

xAOD::TrackStateAuxContainer * ActsTrk::MutableMultiTrajectory::trackStatesAux ( )
inline

Definition at line 360 of file MultiTrajectory.h.

360{ return m_trackStatesAux.get(); }

◆ trackSurfaces() [1/2]

xAOD::TrackSurfaceContainer * ActsTrk::MutableMultiTrajectory::trackSurfaces ( )
inline

Definition at line 380 of file MultiTrajectory.h.

380 {
381 return m_surfacesBackend.get();
382 }

◆ trackSurfaces() [2/2]

const xAOD::TrackSurfaceContainer * ActsTrk::MutableMultiTrajectory::trackSurfaces ( ) const
inline

Definition at line 383 of file MultiTrajectory.h.

383 {
384 return m_surfacesBackend.get();
385 }

◆ trackSurfacesAux()

xAOD::TrackSurfaceAuxContainer * ActsTrk::MutableMultiTrajectory::trackSurfacesAux ( )
inline

Definition at line 377 of file MultiTrajectory.h.

377 {
378 return m_surfacesBackendAux.get();
379 }

◆ trim()

void ActsTrk::MutableMultiTrajectory::trim ( )
private

Definition at line 647 of file MultiTrajectory.cxx.

647 {
649 static const SG::Decorator<const xAOD::UncalibratedMeasurement*> decor{"uncalibratedMeasurement"};
650 if (m_trackStatesSize > 0) {
651 (void)decor.getDecorationSpan(m_trackStatesIface);
652 }
656}

◆ unset_impl()

void ActsTrk::MutableMultiTrajectory::unset_impl ( Acts::TrackStatePropMask target,
ActsTrk::IndexType istate )

unsets a given state

Parameters
target- property
istate- index in the

Definition at line 372 of file MultiTrajectory.cxx.

374 {
375
376 using PM = Acts::TrackStatePropMask;
377 // set kInvalid
378 constexpr auto kInvalid = Acts::kTrackIndexInvalid;
379
380 switch (target) {
381 case PM::Predicted:
382 m_trackStatesAux->predicted[istate] = kInvalid;
383 break;
384 case PM::Filtered:
385 m_trackStatesAux->filtered[istate] = kInvalid;
386
387 break;
388 case PM::Smoothed:
389 m_trackStatesAux->smoothed[istate] = kInvalid;
390 break;
391 case PM::Jacobian:
392 m_trackStatesAux->jacobian[istate] = kInvalid;
393
394 break;
395 case PM::Calibrated:
396 m_trackStatesAux->measDim[istate] = kInvalid;
397 // TODO here m_measOffset[istate] and m_measCovOffset[istate] should be
398 // set to kInvalid
399
400 break;
401 default:
402 throw std::domain_error{"MutableMultiTrajectory Unable to unset this component"};
403 }
404}

Member Data Documentation

◆ m_calibratedSourceLinks

std::vector<std::optional<Acts::SourceLink> > ActsTrk::MutableMultiTrajectory::m_calibratedSourceLinks
private

Definition at line 411 of file MultiTrajectory.h.

◆ m_decorations

std::vector<ActsTrk::detail::Decoration> ActsTrk::MutableMultiTrajectory::m_decorations
private

Definition at line 409 of file MultiTrajectory.h.

◆ m_excluded

std::unordered_set<Acts::HashedString> ActsTrk::MutableMultiTrajectory::m_excluded {}
private

Definition at line 419 of file MultiTrajectory.h.

419{};

◆ m_geoContext

GeometryContext ActsTrk::MutableMultiTrajectory::m_geoContext
private

Definition at line 415 of file MultiTrajectory.h.

◆ m_surfaces

std::vector<StoredSurface> ActsTrk::MutableMultiTrajectory::m_surfaces
private

Definition at line 414 of file MultiTrajectory.h.

◆ m_surfacesBackend

std::unique_ptr<xAOD::TrackSurfaceContainer> ActsTrk::MutableMultiTrajectory::m_surfacesBackend
private

Definition at line 407 of file MultiTrajectory.h.

◆ m_surfacesBackendAux

std::unique_ptr<xAOD::TrackSurfaceAuxContainer> ActsTrk::MutableMultiTrajectory::m_surfacesBackendAux
private

Definition at line 408 of file MultiTrajectory.h.

◆ m_trackJacobiansAux

std::unique_ptr<xAOD::TrackJacobianAuxContainer> ActsTrk::MutableMultiTrajectory::m_trackJacobiansAux
private

Definition at line 401 of file MultiTrajectory.h.

◆ m_trackJacobiansSize

size_t ActsTrk::MutableMultiTrajectory::m_trackJacobiansSize = 0
private

Definition at line 402 of file MultiTrajectory.h.

◆ m_trackMeasurementsAux

std::unique_ptr<xAOD::TrackMeasurementAuxContainer> ActsTrk::MutableMultiTrajectory::m_trackMeasurementsAux
private

Definition at line 404 of file MultiTrajectory.h.

◆ m_trackMeasurementsSize

size_t ActsTrk::MutableMultiTrajectory::m_trackMeasurementsSize = 0
private

Definition at line 405 of file MultiTrajectory.h.

◆ m_trackParametersAux

std::unique_ptr<xAOD::TrackParametersAuxContainer> ActsTrk::MutableMultiTrajectory::m_trackParametersAux
private

Definition at line 398 of file MultiTrajectory.h.

◆ m_trackParametersSize

size_t ActsTrk::MutableMultiTrajectory::m_trackParametersSize = 0
private

Definition at line 399 of file MultiTrajectory.h.

◆ m_trackStatesAux

std::unique_ptr<xAOD::TrackStateAuxContainer> ActsTrk::MutableMultiTrajectory::m_trackStatesAux
private

Definition at line 395 of file MultiTrajectory.h.

◆ m_trackStatesIface

xAOD::TrackStateContainer ActsTrk::MutableMultiTrajectory::m_trackStatesIface
private

Definition at line 417 of file MultiTrajectory.h.

◆ m_trackStatesSize

size_t ActsTrk::MutableMultiTrajectory::m_trackStatesSize = 0
private

Definition at line 396 of file MultiTrajectory.h.

◆ m_uncalibratedSourceLinks

std::vector<std::optional<Acts::SourceLink> > ActsTrk::MutableMultiTrajectory::m_uncalibratedSourceLinks
private

Definition at line 412 of file MultiTrajectory.h.

◆ s_staticVariables

const std::set< std::string > ActsTrk::MutableMultiTrajectory::s_staticVariables
static
Initial value:
= {
"chi2", "pathLength", "typeFlags", "previous", "next", "predicted", "filtered", "smoothed", "jacobian", "calibrated", "measDim",
"uncalibratedMeasurement", "uncalibratedMeasurementLink" , "geometryId", "surfaceIndex"
}

Definition at line 387 of file MultiTrajectory.h.


The documentation for this class was generated from the following files: