ATLAS Offline Software
Public Types | Public Member Functions | Public Attributes | Static Public Attributes | Private Member Functions | Private Attributes | List of all members
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:
Collaboration diagram for ActsTrk::MutableMultiTrajectory:

Public Types

using TrackStateProxy = typename Acts::MultiTrajectory< ActsTrk::MutableMultiTrajectory >::TrackStateProxy
 
using ConstTrackStateProxy = typename Acts::MultiTrajectory< ActsTrk::MutableMultiTrajectory >::ConstTrackStateProxy
 

Public Member Functions

 MutableMultiTrajectory ()
 Construct a new Multi Trajectory object owning backends. More...
 
 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. More...
 
void addTrackStateComponents_impl (ActsTrk::IndexType istate, Acts::TrackStatePropMask mask)
 Add state components for the given mask. More...
 
std::any component_impl (Acts::HashedString key, ActsTrk::IndexType istate) const
 Access component by key. More...
 
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 More...
 
constexpr bool hasColumn_impl (Acts::HashedString key) const
 checks if MTJ has requested column (irrespectively of the state) More...
 
template<typename T >
void addColumn_impl (std::string_view key)
 enables particular decoration, type & name need to be specified More...
 
void unset_impl (Acts::TrackStatePropMask target, ActsTrk::IndexType istate)
 unsets a given state More...
 
void shareFrom_impl (ActsTrk::IndexType iself, ActsTrk::IndexType iother, Acts::TrackStatePropMask shareSource, Acts::TrackStatePropMask shareTarget)
 shares from a given state More...
 
ConstTrackStateProxy::Parameters parameters_impl (ActsTrk::IndexType index) const
 obtains proxy to the track state under given index More...
 
TrackStateProxy::Parameters parameters_impl (ActsTrk::IndexType index)
 
ConstTrackStateProxy::Covariance covariance_impl (ActsTrk::IndexType index) const
 obtain covariances for a state at given index More...
 
TrackStateProxy::Covariance covariance_impl (ActsTrk::IndexType index)
 
ConstTrackStateProxy::Covariance trackMeasurementsCov (ActsTrk::IndexType index) const
 obtain measurement covariances for a state at given index More...
 
TrackStateProxy::Covariance trackMeasurementsCov (ActsTrk::IndexType index)
 
ConstTrackStateProxy::Covariance jacobian_impl (ActsTrk::IndexType istate) const
 obtain jacobian for a state at given index More...
 
TrackStateProxy::Covariance jacobian_impl (ActsTrk::IndexType istate)
 
template<std::size_t measdim>
ConstTrackStateProxy::template Calibrated< measdim > calibrated_impl (ActsTrk::IndexType index) const
 obtain calibrated measurements for a state at given index More...
 
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 CalibratedCovariance< measdim > calibratedCovariance_impl (ActsTrk::IndexType index) const
 obtain measurements covariance for a state at given index More...
 
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 More...
 
void clear_impl ()
 clears backends decoration columns are still declared More...
 
bool has_backends () const
 checks if the backends are connected (i.e. More...
 
void setUncalibratedSourceLink_impl (ActsTrk::IndexType istate, const Acts::SourceLink &sourceLink)
 Implementation of uncalibrated link insertion. More...
 
Acts::SourceLink getUncalibratedSourceLink_impl (ActsTrk::IndexType istate) const
 Implementation of uncalibrated link fetch. More...
 
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 More...
 
std::vector< Acts::HashedString > dynamicKeys_impl () const
 returns the keys of all the dynamic columns More...
 
xAOD::TrackStateAuxContainer * trackStatesAux ()
 
const xAOD::TrackParametersAuxContainer * trackParametersAux () const
 
xAOD::TrackParametersAuxContainer * trackParametersAux ()
 
xAOD::TrackJacobianAuxContainer * trackJacobiansAux ()
 
xAOD::TrackMeasurementAuxContainer * trackMeasurementsAux ()
 
xAOD::TrackSurfaceAuxContainer * trackSurfacesAux ()
 

Public Attributes

template<typename val_t , typename cov_t >
void allocateCalibrated_impl(IndexType istate, const Eigen::DenseBase< val_t > &val, const Eigen::DenseBase< cov_t > &cov) requires(Eigen ActsTrk::IndexType calibratedSize_impl (ActsTrk::IndexType istate) const
 Implementation of allocation of calibrated measurements. More...
 

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
 
ActsGeometryContext m_geoContext
 
xAOD::TrackStateContainer m_trackStatesIface
 

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 80 of file MultiTrajectory.h.

Member Typedef Documentation

◆ ConstTrackStateProxy

using ActsTrk::MutableMultiTrajectory::ConstTrackStateProxy = typename Acts::MultiTrajectory< ActsTrk::MutableMultiTrajectory>::ConstTrackStateProxy

Definition at line 86 of file MultiTrajectory.h.

◆ TrackStateProxy

using ActsTrk::MutableMultiTrajectory::TrackStateProxy = typename Acts::MultiTrajectory< ActsTrk::MutableMultiTrajectory>::TrackStateProxy

Definition at line 84 of file MultiTrajectory.h.

Constructor & Destructor Documentation

◆ MutableMultiTrajectory() [1/3]

ActsTrk::MutableMultiTrajectory::MutableMultiTrajectory ( )

Construct a new Multi Trajectory object owning backends.

Definition at line 93 of file MultiTrajectory.cxx.

94  : m_trackStatesAux (std::make_unique<xAOD::TrackStateAuxContainer>()),
95  m_trackParametersAux (std::make_unique<xAOD::TrackParametersAuxContainer>()),
96  m_trackJacobiansAux (std::make_unique<xAOD::TrackJacobianAuxContainer>()),
97  m_trackMeasurementsAux (std::make_unique<xAOD::TrackMeasurementAuxContainer>()),
98  m_surfacesBackend (std::make_unique<xAOD::TrackSurfaceContainer>()),
99  m_surfacesBackendAux (std::make_unique<xAOD::TrackSurfaceAuxContainer>())
100 {
101  INSPECTCALL("c-tor " << this)
102 
103  m_surfacesBackend->setStore(m_surfacesBackendAux.get());
104  m_trackStatesIface.setStore(m_trackStatesAux.get());
105 
106 }

◆ MutableMultiTrajectory() [2/3]

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

Definition at line 108 of file MultiTrajectory.cxx.

109  : MutableMultiTrajectory()
110  {
111  INSPECTCALL("copy c-tor " << this << " src " << &other << " " << other.size())
112 
113  *m_trackStatesAux = *other.m_trackStatesAux;
114  *m_trackParametersAux = *other.m_trackParametersAux;
115  *m_trackJacobiansAux = *other.m_trackJacobiansAux;
116  *m_trackMeasurementsAux = *other.m_trackMeasurementsAux;
117  m_decorations = other.m_decorations;
118  m_calibratedSourceLinks = other.m_calibratedSourceLinks;
119  m_uncalibratedSourceLinks = other.m_uncalibratedSourceLinks;
120 
121  m_surfaces = other.m_surfaces;
122  m_geoContext = other.m_geoContext;
123  m_trackStatesIface.resize(m_trackStatesAux->size());
124  INSPECTCALL("copy c-tor done")
125 }

◆ 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()

ActsTrk::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 141 of file MultiTrajectory.cxx.

143  {
144  using namespace Acts::HashedStringLiteral;
145  INSPECTCALL( this << " " << mask << " " << m_trackStatesIface.size() << " " << previous);
146  assert(m_trackStatesAux && "Missing Track States backend");
147  stepResize(&m_trackStatesIface, m_trackStatesSize);
148  m_surfaces.push_back(nullptr);
149 
150  // set kInvalid
151  using Acts::MultiTrajectoryTraits::kInvalid;
152 
153  if (previous >= kInvalid - 1)
154  previous = kInvalid; // fix needed in Acts::MTJ
155  m_trackStatesAux->previous[m_trackStatesSize] = previous;
156  using namespace Acts;
157 
158  auto addParam = [this]() -> ActsTrk::IndexType {
159  stepResize(m_trackParametersAux.get(), m_trackParametersSize, 60);
160  // TODO ask AK if this resize could be method of aux container
161  m_trackParametersAux->params[m_trackParametersSize].resize(Acts::eBoundSize);
162  m_trackParametersAux->covMatrix[m_trackParametersSize].resize(Acts::eBoundSize*Acts::eBoundSize);
163  m_trackParametersSize++;
164  return m_trackParametersSize-1;
165  };
166 
167  auto addJacobian = [this]() -> ActsTrk::IndexType {
168  stepResize(m_trackJacobiansAux.get(), m_trackJacobiansSize);
169  m_trackJacobiansAux->jac[m_trackJacobiansSize].resize(Acts::eBoundSize*Acts::eBoundSize);
170  m_trackJacobiansSize++;
171  return m_trackJacobiansSize-1;
172  };
173 
174  auto addMeasurement = [this]() -> ActsTrk::IndexType {
175  stepResize(m_trackMeasurementsAux.get(), m_trackMeasurementsSize );
176  m_trackMeasurementsAux->meas[m_trackMeasurementsSize].resize(Acts::eBoundSize);
177  m_trackMeasurementsAux->covMatrix[m_trackMeasurementsSize].resize(Acts::eBoundSize*Acts::eBoundSize);
178  m_trackMeasurementsSize++;
179  return m_trackMeasurementsSize-1;
180  };
181 
182  m_trackStatesAux->predicted[m_trackStatesSize] = kInvalid;
183  if (ACTS_CHECK_BIT(mask, TrackStatePropMask::Predicted)) {
184  m_trackStatesAux->predicted[m_trackStatesSize] = addParam();
185  }
186 
187  m_trackStatesAux->filtered[m_trackStatesSize] = kInvalid;
188  if (ACTS_CHECK_BIT(mask, TrackStatePropMask::Filtered)) {
189  m_trackStatesAux->filtered[m_trackStatesSize] = addParam();
190  }
191 
192  m_trackStatesAux->smoothed[m_trackStatesSize] = kInvalid;
193  if (ACTS_CHECK_BIT(mask, TrackStatePropMask::Smoothed)) {
194  m_trackStatesAux->smoothed[m_trackStatesSize] = addParam();
195  }
196 
197  m_trackStatesAux->jacobian[m_trackStatesSize] = kInvalid;
198  if (ACTS_CHECK_BIT(mask, TrackStatePropMask::Jacobian)) {
199  m_trackStatesAux->jacobian[m_trackStatesSize] = addJacobian();
200  }
201 
202  m_uncalibratedSourceLinks.emplace_back(std::nullopt);
203  m_trackStatesAux->calibrated[m_trackStatesSize] = kInvalid;
204  m_trackStatesAux->measDim[m_trackStatesSize] = kInvalid;
205  // @TODO uncalibrated ?
206  if (ACTS_CHECK_BIT(mask, TrackStatePropMask::Calibrated)) {
207  m_trackStatesAux->calibrated.at(m_trackStatesSize) = addMeasurement();
208  m_calibratedSourceLinks.emplace_back(std::nullopt);
209  }
210 
211  m_trackStatesAux->geometryId[m_trackStatesSize] = InvalidGeoID; // surface is invalid until set
212  m_trackStatesSize++;
213  return m_trackStatesSize-1;
214 }

◆ 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 217 of file MultiTrajectory.cxx.

219  {
220  using namespace Acts::HashedStringLiteral;
221  INSPECTCALL( this << " " << mask << " " << m_trackStatesIface.size() << " " << previous);
222 
223  assert(m_trackStatesAux && "Missing Track States backend");
224 
225  // set kInvalid
226  using Acts::MultiTrajectoryTraits::kInvalid;
227 
228  using namespace Acts;
229 
230  auto addParam = [this]() -> ActsTrk::IndexType {
231  stepResize(m_trackParametersAux.get(), m_trackParametersSize, 60);
232  // TODO ask AK if this resize could be method of aux container
233  m_trackParametersAux->params[m_trackParametersSize].resize(Acts::eBoundSize);
234  m_trackParametersAux->covMatrix[m_trackParametersSize].resize(Acts::eBoundSize*Acts::eBoundSize);
235  m_trackParametersSize++;
236  return m_trackParametersSize-1;
237  };
238 
239  auto addJacobian = [this]() -> ActsTrk::IndexType {
240  stepResize(m_trackJacobiansAux.get(), m_trackJacobiansSize);
241  m_trackJacobiansAux->jac[m_trackJacobiansSize].resize(Acts::eBoundSize*Acts::eBoundSize);
242  m_trackJacobiansSize++;
243  return m_trackJacobiansSize-1;
244  };
245 
246  auto addMeasurement = [this]() -> ActsTrk::IndexType {
247  stepResize(m_trackMeasurementsAux.get(), m_trackMeasurementsSize );
248  m_trackMeasurementsAux->meas[m_trackMeasurementsSize].resize(Acts::eBoundSize);
249  m_trackMeasurementsAux->covMatrix[m_trackMeasurementsSize].resize(Acts::eBoundSize*Acts::eBoundSize);
250  m_trackMeasurementsSize++;
251  return m_trackMeasurementsSize-1;
252  };
253 
254  if ((m_trackStatesAux->predicted[istate] == kInvalid) &&
255  ACTS_CHECK_BIT(mask, TrackStatePropMask::Predicted)) {
256  m_trackStatesAux->predicted[istate] = addParam();
257  }
258 
259  if ((m_trackStatesAux->filtered[istate] == kInvalid) &&
260  ACTS_CHECK_BIT(mask, TrackStatePropMask::Filtered)) {
261  m_trackStatesAux->filtered[istate] = addParam();
262  }
263 
264  if ((m_trackStatesAux->smoothed[istate] == kInvalid) &&
265  ACTS_CHECK_BIT(mask, TrackStatePropMask::Smoothed)) {
266  m_trackStatesAux->smoothed[istate] = addParam();
267  }
268 
269  if ((m_trackStatesAux->jacobian[istate] == kInvalid) &&
270  ACTS_CHECK_BIT(mask, TrackStatePropMask::Jacobian)) {
271  m_trackStatesAux->jacobian[istate] = addJacobian();
272  }
273 
274  if ((m_trackStatesAux->calibrated[istate] == kInvalid) &&
275  ACTS_CHECK_BIT(mask, TrackStatePropMask::Calibrated)) {
276  m_trackStatesAux->calibrated[istate] = addMeasurement();
277  m_calibratedSourceLinks.emplace_back(std::nullopt);
278  }
279 }

◆ 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 258 of file MultiTrajectory.h.

258  {
259  xAOD::TrackStateIndexType measIdx = m_trackStatesAux->calibrated[index];
260  return typename TrackStateProxy::template Calibrated<measdim>{m_trackMeasurementsAux->meas[measIdx].data()};
261  }

◆ calibrated_impl() [2/2]

template<std::size_t measdim>
ConstTrackStateProxy::template Calibrated<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 250 of file MultiTrajectory.h.

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

◆ 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 279 of file MultiTrajectory.h.

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

◆ calibratedCovariance_impl() [2/2]

template<std::size_t measdim>
ConstTrackStateProxy::template CalibratedCovariance<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 272 of file MultiTrajectory.h.

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

◆ clear_impl()

void ActsTrk::MutableMultiTrajectory::clear_impl ( )

clears backends decoration columns are still declared

Definition at line 493 of file MultiTrajectory.cxx.

493  {
494  INSPECTCALL(this);
495  m_trackStatesIface.resize(0);
496  m_trackStatesSize = 0;
497 
498  m_trackParametersAux->resize(0);
499  m_trackParametersSize = 0;
500 
501  m_trackJacobiansAux->resize(0);
502  m_trackJacobiansSize = 0;
503 
504  m_trackMeasurementsAux->resize(0);
505  m_trackMeasurementsSize = 0;
506 
507  m_surfacesBackend->clear();
508  m_surfaces.clear();
509  m_calibratedSourceLinks.clear();
510  m_uncalibratedSourceLinks.clear();
511 }

◆ component_impl() [1/2]

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

Definition at line 372 of file MultiTrajectory.cxx.

373  {
374  using namespace Acts::HashedStringLiteral;
375  assert(istate < m_trackStatesIface.size() &&
376  "Attempt to reach beyond the Track States container size");
377  INSPECTCALL(key << " " << istate << " non-const component_impl")
378 
379  switch (key) {
380  case "previous"_hash:
381  return &(m_trackStatesAux->previous[istate]);
382  case "next"_hash:
383  return &(m_trackStatesAux->next[istate]);
384  case "chi2"_hash:
385  return &(m_trackStatesAux->chi2[istate]);
386  case "pathLength"_hash:
387  return &(m_trackStatesAux->pathLength[istate]);
388  case "predicted"_hash:
389  return &(m_trackStatesAux->predicted[istate]);
390  case "filtered"_hash:
391  return &(m_trackStatesAux->filtered[istate]);
392  case "smoothed"_hash:
393  return &(m_trackStatesAux->smoothed[istate]);
394  case "projector"_hash: {
395  auto idx = m_trackStatesAux->calibrated[istate];
396  return &(m_trackMeasurementsAux->projector[idx]);
397  }
398  case "measdim"_hash:
399  return &(m_trackStatesAux->measDim[istate]);
400  case "typeFlags"_hash:
401  return &(m_trackStatesAux->typeFlags[istate]);
402 
403  default: {
404  for (auto& d : m_decorations) {
405  if (d.hash == key) {
406  return d.setter(m_trackStatesAux.get(), istate, d.auxid);
407  }
408  }
409  throw std::runtime_error("MutableMultiTrajectory::component_impl no such component " + std::to_string(key));
410  }
411  }
412 }

◆ 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 415 of file MultiTrajectory.cxx.

417  {
418  using namespace Acts::HashedStringLiteral;
419  assert(istate < m_trackStatesIface.size() &&
420  "Attempt to reach beyond the Track States container size");
421  INSPECTCALL(key << " " << istate << " const component_impl")
422  switch (key) {
423  case "previous"_hash:
424  return &(to_const_ptr(m_trackStatesAux)->previous[istate]);
425  case "next"_hash:
426  return &(to_const_ptr(m_trackStatesAux)->next[istate]);
427  case "chi2"_hash:
428  return &(to_const_ptr(m_trackStatesAux)->chi2[istate]);
429  case "pathLength"_hash:
430  return &(to_const_ptr(m_trackStatesAux)->pathLength[istate]);
431  case "predicted"_hash:
432  return &(to_const_ptr(m_trackStatesAux)->predicted[istate]);
433  case "filtered"_hash:
434  return &(to_const_ptr(m_trackStatesAux)->filtered[istate]);
435  case "smoothed"_hash:
436  return &(to_const_ptr(m_trackStatesAux)->smoothed[istate]);
437  case "jacobian"_hash:
438  return &(to_const_ptr(m_trackStatesAux)->jacobian[istate]);
439  case "projector"_hash:{
440  auto idx = to_const_ptr(m_trackStatesAux)->calibrated[istate];
441  return &(to_const_ptr(m_trackMeasurementsAux)->projector[idx]);
442  }
443  case "calibrated"_hash: {
444  return &(to_const_ptr(m_trackStatesAux)->calibrated[istate]);
445  }
446  case "calibratedCov"_hash: {
447  return &(to_const_ptr(m_trackStatesAux)->calibrated[istate]);
448  }
449  case "measdim"_hash:
450  return &(to_const_ptr(m_trackStatesAux)->measDim[istate]);
451  case "typeFlags"_hash:
452  return &(to_const_ptr(m_trackStatesAux)->typeFlags[istate]);
453  default: {
454  for (auto& d : m_decorations) {
455  if (d.hash == key) {
456  INSPECTCALL("getting dynamic variable " << d.name << " " << istate);
457  return d.getter(m_trackStatesAux.get(), istate, d.auxid);
458  }
459  }
460  throw std::runtime_error("MutableMultiTrajectory::component_impl const no such component " + std::to_string(key));
461  }
462  }
463 }

◆ 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 578 of file MultiTrajectory.cxx.

580  {
581  for (const ActsTrk::detail::Decoration& d : m_decorations) {
582  if (d.hash == key) {
583  d.copier(m_trackStatesAux.get(), istate, d.auxid, src_ptr);
584  return;
585  }
586  }
587  throw std::runtime_error("MultiTrajectory::copyDynamicFrom_impl no such decoration in destination MTJ " + std::to_string(key));
588 }

◆ covariance_impl() [1/2]

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

Definition at line 202 of file MultiTrajectory.h.

202  {
203  return typename TrackStateProxy::Covariance{m_trackParametersAux->covMatrix[index].data()};
204  }

◆ covariance_impl() [2/2]

ConstTrackStateProxy::Covariance 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 198 of file MultiTrajectory.h.

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

◆ dynamicKeys_impl()

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

returns the keys of all the dynamic columns

Definition at line 590 of file MultiTrajectory.cxx.

590  {
591  std::vector<Acts::HashedString> keys;
592  for ( const ActsTrk::detail::Decoration& d: m_decorations) {
593  keys.push_back(d.hash);
594  }
595  return keys;
596 }

◆ getUncalibratedSourceLink_impl()

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

Implementation of uncalibrated link fetch.

Definition at line 788 of file MultiTrajectory.cxx.

789  {
790  assert(istate < m_trackStatesIface.size());
791  // at the moment when converting Trk::Track to Acts tracks the measurements on track
792  // are not converted to xAOD::UncalibratedMeasurements, and the Acts::SourceLinks
793  // just contain a pointer to the Trk::Measurement. To keep this functionality
794  // SourceLinks are either stored in the m_uncalibratedSourceLinks cache
795  // or taken from the xAOD backend.
796  static const SG::ConstAccessor<const xAOD::UncalibratedMeasurement*> acc{"uncalibratedMeasurement"};
797  if (const xAOD::UncalibratedMeasurement* ptr = acc.withDefault(m_trackStatesIface, istate, nullptr))
798  {
799  return Acts::SourceLink( ptr );
800  }
801  return m_uncalibratedSourceLinks[istate].value();
802 }

◆ 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 128 of file MultiTrajectory.cxx.

128  {
129  return m_trackStatesAux != nullptr and m_trackParametersAux != nullptr and
130  m_trackJacobiansAux != nullptr and m_trackMeasurementsAux != nullptr
131  and m_surfacesBackend != nullptr;
132 }

◆ 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 465 of file MultiTrajectory.cxx.

466  {
467  std::optional<bool> inTrackState = ::has_impl(m_trackStatesAux.get(), key, istate);
468  if (inTrackState.has_value())
469  return inTrackState.value();
470 
471  // TODO remove once EL based source links are in use only
472  using namespace Acts::HashedStringLiteral;
473  if (key == "uncalibratedSourceLink"_hash){
474  INSPECTCALL(key << " " << istate << " uncalibratedSourceLink")
475  static const SG::ConstAccessor<const xAOD::UncalibratedMeasurement*> acc{"uncalibratedMeasurement"};
476  if (acc.isAvailable (m_trackStatesIface)) {
477  if (acc(m_trackStatesIface, istate) != nullptr) return true;
478  }
479 
480  return (istate < m_uncalibratedSourceLinks.size() && m_uncalibratedSourceLinks[istate].has_value());
481  }
482 
483  for (auto& d : m_decorations) {
484  if (d.hash == key) {
485  INSPECTCALL(key << " " << istate << " d.name")
486  return true;
487  }
488  }
489 
490  return false;
491 }

◆ hasColumn_impl()

constexpr 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 236 of file MultiTrajectory.h.

236  {
237  xAOD::TrackStateIndexType jacIdx = m_trackStatesAux->jacobian[istate];
238  return typename TrackStateProxy::Covariance{m_trackJacobiansAux->jac[jacIdx].data()};
239  }

◆ jacobian_impl() [2/2]

ConstTrackStateProxy::Covariance 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 230 of file MultiTrajectory.h.

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

◆ 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 188 of file MultiTrajectory.h.

188  {
189  return typename TrackStateProxy::Parameters{m_trackParametersAux->params[index].data()};
190  }

◆ parameters_impl() [2/2]

ConstTrackStateProxy::Parameters 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 183 of file MultiTrajectory.h.

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

◆ referenceSurface_impl()

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

Definition at line 573 of file MultiTrajectory.cxx.

573  {
574  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");
575  return toSurfacePtr(m_surfaces[istate]);
576 }

◆ setReferenceSurface_impl()

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

Definition at line 547 of file MultiTrajectory.cxx.

548  {
549  if ( istate >= m_surfaces.size() )
550  m_surfaces.resize(istate+1, nullptr);
551 
552  m_trackStatesAux->geometryId[istate] = surface->geometryId().value();
553  if (surface->geometryId().value() == 0) { // free surface, needs recording of properties
554  m_surfacesBackend->push_back(new xAOD::TrackSurface());
555  encodeSurface(m_surfacesBackendAux.get(), m_surfacesBackendAux->size()-1, surface.get(), m_geoContext.context());
556  m_trackStatesAux->surfaceIndex[istate] = m_surfacesBackend->size()-1;
557  m_surfaces[istate] = std::move(surface); // and memory management
558 
559  } else {
560  m_surfaces[istate] = surface.get(); // no memory management, bare pointer
561  }
562  // store surface representation in
563 }

◆ setUncalibratedSourceLink_impl()

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

Implementation of uncalibrated link insertion.

Definition at line 521 of file MultiTrajectory.cxx.

522  {
523  INSPECTCALL( istate );
524 
525  using Decor_t = SG::Decorator<const xAOD::UncalibratedMeasurement*>;
526  static const Decor_t decor{"uncalibratedMeasurement"};
527  if (istate>= m_trackStatesIface.size()) {
528  throw std::range_error("istate out of range on TrackStates when attempting to access uncalibrated measurements");
529  }
530  Decor_t::span uncalibratedMeasurements = decor.getDecorationSpan(m_trackStatesIface);
531 
532  // @TODO normally the source links should contain an xAOD::UncalibratedMeasurement pointer
533  // but in some cases some other payload is used e.g. when converting Trk::Tracks.
534  // Only UncalibratedMeasurement pointer can be stored in the xAOD backend. Everything
535  // else has to go into the cache.
536  // Currently there is no possibility to check whether the source link contains a certain payload
537  // so can only catch the bad any cast
538  try {
539  uncalibratedMeasurements.at(istate) = sourceLink.get<ATLASUncalibSourceLink>();
540  }
541  catch (std::bad_any_cast &err) {
542  assert( istate < m_uncalibratedSourceLinks.size());
543  m_uncalibratedSourceLinks[istate] = sourceLink;
544  }
545 }

◆ 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 282 of file MultiTrajectory.cxx.

286  {
287 
288  assert(ACTS_CHECK_BIT(this->getTrackState(iother).getMask(), shareSource) &&
289  "Source has incompatible allocation");
290 
291  using PM = Acts::TrackStatePropMask;
292  // set kInvalid
293  using Acts::MultiTrajectoryTraits::kInvalid;
294 
295  ActsTrk::IndexType sourceIndex{kInvalid};
296  switch (shareSource) {
297  case PM::Predicted:
298  sourceIndex = m_trackStatesAux->predicted[iother];
299  break;
300  case PM::Filtered:
301  sourceIndex = m_trackStatesAux->filtered[iother];
302  break;
303  case PM::Smoothed:
304  sourceIndex = m_trackStatesAux->smoothed[iother];
305  break;
306  case PM::Jacobian:
307  sourceIndex = m_trackStatesAux->jacobian[iother];
308  break;
309  default:
310  throw std::domain_error{"MutableMultiTrajectory Unable to share this component"};
311  }
312 
313  assert(sourceIndex != kInvalid);
314 
315  switch (shareTarget) {
316  case PM::Predicted:
317  assert(shareSource != PM::Jacobian);
318  m_trackStatesAux->predicted[iself] = sourceIndex;
319  break;
320  case PM::Filtered:
321  assert(shareSource != PM::Jacobian);
322  m_trackStatesAux->filtered[iself] = sourceIndex;
323  break;
324  case PM::Smoothed:
325  assert(shareSource != PM::Jacobian);
326  m_trackStatesAux->smoothed[iself] = sourceIndex;
327  break;
328  case PM::Jacobian:
329  assert(shareSource == PM::Jacobian);
330  m_trackStatesAux->jacobian[iself] = sourceIndex;
331  break;
332  default:
333  throw std::domain_error{"MutableMultiTrajectory Unable to share this component"};
334  }
335 }

◆ size_impl()

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

size of the MTJ

Returns
size_t

Definition at line 290 of file MultiTrajectory.h.

290  {
291  return m_trackStatesSize;
292  }

◆ trackJacobiansAux()

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

Definition at line 367 of file MultiTrajectory.h.

367  {
368  return m_trackJacobiansAux.get();
369  }

◆ trackMeasurementsAux()

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

Definition at line 371 of file MultiTrajectory.h.

371  {
372  return m_trackMeasurementsAux.get();
373  }

◆ trackMeasurementsCov() [1/2]

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

Definition at line 218 of file MultiTrajectory.h.

218  {
219  return typename TrackStateProxy::Covariance{m_trackMeasurementsAux->covMatrix[index].data()};
220 
221  }

◆ 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 212 of file MultiTrajectory.h.

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

◆ trackParametersAux() [1/2]

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

Definition at line 363 of file MultiTrajectory.h.

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

◆ trackParametersAux() [2/2]

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

Definition at line 360 of file MultiTrajectory.h.

360  {
361  return m_trackParametersAux.get();
362  }

◆ trackStatesAux()

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

Definition at line 358 of file MultiTrajectory.h.

358 { return m_trackStatesAux.get(); }

◆ trackSurfacesAux()

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

Definition at line 375 of file MultiTrajectory.h.

375  {
376  return m_surfacesBackendAux.get();
377  }

◆ trim()

void ActsTrk::MutableMultiTrajectory::trim ( )
private

Definition at line 599 of file MultiTrajectory.cxx.

599  {
600  m_trackStatesIface.resize(m_trackStatesSize);
601  static const SG::Decorator<const xAOD::UncalibratedMeasurement*> decor{"uncalibratedMeasurement"};
602  if (m_trackStatesSize > 0) {
603  (void)decor.getDecorationSpan(m_trackStatesIface);
604  }
605  m_trackMeasurementsAux->resize(m_trackMeasurementsSize);
606  m_trackJacobiansAux->resize(m_trackJacobiansSize);
607  m_trackParametersAux->resize(m_trackParametersSize);
608 }

◆ 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 338 of file MultiTrajectory.cxx.

340  {
341 
342  using PM = Acts::TrackStatePropMask;
343  // set kInvalid
344  using Acts::MultiTrajectoryTraits::kInvalid;
345 
346  switch (target) {
347  case PM::Predicted:
348  m_trackStatesAux->predicted[istate] = kInvalid;
349  break;
350  case PM::Filtered:
351  m_trackStatesAux->filtered[istate] = kInvalid;
352 
353  break;
354  case PM::Smoothed:
355  m_trackStatesAux->smoothed[istate] = kInvalid;
356  break;
357  case PM::Jacobian:
358  m_trackStatesAux->jacobian[istate] = kInvalid;
359 
360  break;
361  case PM::Calibrated:
362  m_trackStatesAux->measDim[istate] = kInvalid;
363  // TODO here m_measOffset[istate] and m_measCovOffset[istate] should be
364  // set to kInvalid
365 
366  break;
367  default:
368  throw std::domain_error{"MutableMultiTrajectory Unable to unset this component"};
369  }
370 }

Member Data Documentation

◆ calibratedSize_impl

template<typename val_t , typename cov_t >
ActsTrk::IndexType ActsTrk::MutableMultiTrajectory::calibratedSize_impl

Implementation of allocation of calibrated measurements.

Implementation of calibrated size

Definition at line 323 of file MultiTrajectory.h.

◆ m_calibratedSourceLinks

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

Definition at line 401 of file MultiTrajectory.h.

◆ m_decorations

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

Definition at line 399 of file MultiTrajectory.h.

◆ m_geoContext

ActsGeometryContext ActsTrk::MutableMultiTrajectory::m_geoContext
private

Definition at line 405 of file MultiTrajectory.h.

◆ m_surfaces

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

Definition at line 404 of file MultiTrajectory.h.

◆ m_surfacesBackend

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

Definition at line 397 of file MultiTrajectory.h.

◆ m_surfacesBackendAux

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

Definition at line 398 of file MultiTrajectory.h.

◆ m_trackJacobiansAux

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

Definition at line 391 of file MultiTrajectory.h.

◆ m_trackJacobiansSize

size_t ActsTrk::MutableMultiTrajectory::m_trackJacobiansSize = 0
private

Definition at line 392 of file MultiTrajectory.h.

◆ m_trackMeasurementsAux

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

Definition at line 394 of file MultiTrajectory.h.

◆ m_trackMeasurementsSize

size_t ActsTrk::MutableMultiTrajectory::m_trackMeasurementsSize = 0
private

Definition at line 395 of file MultiTrajectory.h.

◆ m_trackParametersAux

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

Definition at line 388 of file MultiTrajectory.h.

◆ m_trackParametersSize

size_t ActsTrk::MutableMultiTrajectory::m_trackParametersSize = 0
private

Definition at line 389 of file MultiTrajectory.h.

◆ m_trackStatesAux

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

Definition at line 385 of file MultiTrajectory.h.

◆ m_trackStatesIface

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

Definition at line 407 of file MultiTrajectory.h.

◆ m_trackStatesSize

size_t ActsTrk::MutableMultiTrajectory::m_trackStatesSize = 0
private

Definition at line 386 of file MultiTrajectory.h.

◆ m_uncalibratedSourceLinks

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

Definition at line 402 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 379 of file MultiTrajectory.h.

The documentation for this class was generated from the following files:
CxxUtils::span
span(T *ptr, std::size_t sz) -> span< T >
A couple needed deduction guides.
ActsTrk::MutableMultiTrajectory::m_trackJacobiansSize
size_t m_trackJacobiansSize
Definition: MultiTrajectory.h:392
ActsTrk::MutableMultiTrajectory::m_trackStatesIface
xAOD::TrackStateContainer m_trackStatesIface
Definition: MultiTrajectory.h:407
ActsTrk::MutableMultiTrajectory::m_surfaces
std::vector< StoredSurface > m_surfaces
Definition: MultiTrajectory.h:404
SG
Forward declaration.
Definition: CaloCellPacker_400_500.h:32
MuonR4::SegmentFit::Parameters
AmgVector(toInt(ParamDefs::nPars)) Parameters
Definition: MuonHoughDefs.h:48
ActsTrk::MutableMultiTrajectory::m_decorations
std::vector< ActsTrk::detail::Decoration > m_decorations
Definition: MultiTrajectory.h:399
hist_file_dump.d
d
Definition: hist_file_dump.py:143
xAOD::UncalibratedMeasurement
UncalibratedMeasurement_v1 UncalibratedMeasurement
Define the version of the uncalibrated measurement class.
Definition: UncalibratedMeasurement.h:13
taskman.template
dictionary template
Definition: taskman.py:317
ActsTrk::MutableMultiTrajectory::m_trackParametersAux
std::unique_ptr< xAOD::TrackParametersAuxContainer > m_trackParametersAux
Definition: MultiTrajectory.h:388
xAOD
ICaloAffectedTool is abstract interface for tools checking if 4 mom is in calo affected region.
Definition: ICaloAffectedTool.h:24
SG::ConstAccessor
Helper class to provide constant type-safe access to aux data.
Definition: ConstAccessor.h:55
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
const
bool const RAWDATA *ch2 const
Definition: LArRodBlockPhysicsV0.cxx:560
to_const_ptr
const T * to_const_ptr(const std::unique_ptr< T > &ptr)
Definition: MultiTrajectory.cxx:89
python.utils.AtlRunQueryLookup.mask
string mask
Definition: AtlRunQueryLookup.py:460
ActsTrk::MutableMultiTrajectory::m_calibratedSourceLinks
std::vector< std::optional< Acts::SourceLink > > m_calibratedSourceLinks
Definition: MultiTrajectory.h:401
ActsTrk::detail::Decoration
Definition: Decoration.h:23
ActsGeometryContext::context
Acts::GeometryContext context() const
Definition: ActsGeometryContext.h:45
ActsTrk::MutableMultiTrajectory::has_impl
bool has_impl(Acts::HashedString key, ActsTrk::IndexType istate) const
checks if given state has requested component
Definition: MultiTrajectory.cxx:465
InvalidGeoID
constexpr uint64_t InvalidGeoID
Definition: MultiTrajectory.cxx:12
ActsTrk::MutableMultiTrajectory::m_trackMeasurementsAux
std::unique_ptr< xAOD::TrackMeasurementAuxContainer > m_trackMeasurementsAux
Definition: MultiTrajectory.h:394
ActsTrk::encodeSurface
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.
Definition: SurfaceEncoding.cxx:55
ActsTrk::IndexType
std::uint32_t IndexType
Definition: Decoration.h:14
xAOD::UncalibratedMeasurement_v1
Definition: UncalibratedMeasurement_v1.h:13
SG::Decorator
Helper class to provide type-safe access to aux data.
Definition: Decorator.h:59
dqt_zlumi_pandas.err
err
Definition: dqt_zlumi_pandas.py:182
Acts
Definition: ChamberAssembleTool.h:18
ActsTrk::ATLASUncalibSourceLink
const xAOD::UncalibratedMeasurement * ATLASUncalibSourceLink
Definition: ATLASSourceLink.h:24
xAOD::TrackSurface_v1
TrackSurface for Acts MultiTrajectory and TrackSummary.
Definition: TrackSurface_v1.h:22
ActsTrk::MutableMultiTrajectory::m_uncalibratedSourceLinks
std::vector< std::optional< Acts::SourceLink > > m_uncalibratedSourceLinks
Definition: MultiTrajectory.h:402
ActsTrk::MutableMultiTrajectory::m_surfacesBackendAux
std::unique_ptr< xAOD::TrackSurfaceAuxContainer > m_surfacesBackendAux
Definition: MultiTrajectory.h:398
INSPECTCALL
#define INSPECTCALL(_INFO)
Definition: MultiTrajectory.h:35
AthenaPoolTestRead.acc
acc
Definition: AthenaPoolTestRead.py:16
xAOD::TrackStateIndexType
uint32_t TrackStateIndexType
Definition: TrackState_v1.h:15
ActsTrk::MutableMultiTrajectory::MutableMultiTrajectory
MutableMultiTrajectory()
Construct a new Multi Trajectory object owning backends.
Definition: MultiTrajectory.cxx:93
DataVector::resize
void resize(size_type sz)
Resizes the collection to the specified number of elements.
ActsTrk::MutableMultiTrajectory::m_trackStatesSize
size_t m_trackStatesSize
Definition: MultiTrajectory.h:386
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
ActsTrk::MutableMultiTrajectory::m_trackStatesAux
std::unique_ptr< xAOD::TrackStateAuxContainer > m_trackStatesAux
Definition: MultiTrajectory.h:385
ActsTrk::MutableMultiTrajectory::m_trackMeasurementsSize
size_t m_trackMeasurementsSize
Definition: MultiTrajectory.h:395
ActsTrk::MutableMultiTrajectory::m_surfacesBackend
std::unique_ptr< xAOD::TrackSurfaceContainer > m_surfacesBackend
Definition: MultiTrajectory.h:397
DeMoScan.index
string index
Definition: DeMoScan.py:364
SG::Decorator::getDecorationSpan
span getDecorationSpan(const AuxVectorData &container) const
Get a span over the auxilary data array.
MuonR4::SegmentFit::Covariance
AmgSymMatrix(toInt(ParamDefs::nPars)) Covariance
Definition: MuonHoughDefs.h:49
InDetDD::other
@ other
Definition: InDetDD_Defs.h:16
copySelective.target
string target
Definition: copySelective.py:37
get
T * get(TKey *tobj)
get a TObject* from a TKey* (why can't a TObject be a TKey?)
Definition: hcg.cxx:127
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
ActsTrk::MutableMultiTrajectory::m_geoContext
ActsGeometryContext m_geoContext
Definition: MultiTrajectory.h:405
ActsTrk::MutableMultiTrajectory::m_trackJacobiansAux
std::unique_ptr< xAOD::TrackJacobianAuxContainer > m_trackJacobiansAux
Definition: MultiTrajectory.h:391
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
ActsTrk::MutableMultiTrajectory::m_trackParametersSize
size_t m_trackParametersSize
Definition: MultiTrajectory.h:389
Trk::previous
@ previous
Definition: BinningData.h:32
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
Generated on Sun Mar 16 2025 21:57:45 for ATLAS Offline Software by   doxygen 1.8.18