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

Member Typedef Documentation

◆ ConstTrackStateProxy

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

Definition at line 83 of file MultiTrajectory.h.

◆ TrackStateProxy

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

Definition at line 81 of file MultiTrajectory.h.

Constructor & Destructor Documentation

◆ MutableMultiTrajectory() [1/3]

ActsTrk::MutableMultiTrajectory::MutableMultiTrajectory ( )

Construct a new Multi Trajectory object owning backends.

Definition at line 94 of file MultiTrajectory.cxx.

   : m_trackStatesAux (std::make_unique<xAOD::TrackStateAuxContainer>()),
     m_trackParametersAux (std::make_unique<xAOD::TrackParametersAuxContainer>()),
     m_trackJacobiansAux (std::make_unique<xAOD::TrackJacobianAuxContainer>()),
     m_trackMeasurementsAux (std::make_unique<xAOD::TrackMeasurementAuxContainer>()),
     m_surfacesBackend (std::make_unique<xAOD::TrackSurfaceContainer>()),
     m_surfacesBackendAux (std::make_unique<xAOD::TrackSurfaceAuxContainer>())
 {
   INSPECTCALL("c-tor " << this)
  
   m_surfacesBackend->setStore(m_surfacesBackendAux.get());
   m_trackStatesIface.setStore(m_trackStatesAux.get());
  
 }

◆ MutableMultiTrajectory() [2/3]

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

Definition at line 109 of file MultiTrajectory.cxx.

   : MutableMultiTrajectory()
   {
   INSPECTCALL("copy c-tor " << this <<  " src " << &other << " " << other.size())
  
   *m_trackStatesAux = *other.m_trackStatesAux;
   *m_trackParametersAux = *other.m_trackParametersAux;
   *m_trackJacobiansAux = *other.m_trackJacobiansAux;
   *m_trackMeasurementsAux = *other.m_trackMeasurementsAux;
   m_decorations = other.m_decorations;
   m_calibratedSourceLinks = other.m_calibratedSourceLinks;
   m_uncalibratedSourceLinks = other.m_uncalibratedSourceLinks;
  
   m_surfaces = other.m_surfaces;
   m_geoContext = other.m_geoContext;
   m_trackStatesIface.resize(m_trackStatesAux->size());
   INSPECTCALL("copy c-tor  done")
 }

◆ 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

T	type of decoration (usually POD)

Parameters

key	name 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 142 of file MultiTrajectory.cxx.

                                {
   using namespace Acts::HashedStringLiteral;
   INSPECTCALL( this << " " <<  mask << " " << m_trackStatesIface.size() << " " << previous);
   assert(m_trackStatesAux && "Missing Track States backend");
   stepResize(&m_trackStatesIface, m_trackStatesSize);
   m_surfaces.push_back(nullptr);
  
   // set kInvalid
   using Acts::MultiTrajectoryTraits::kInvalid;
  
   if (previous >= kInvalid - 1)
     previous = kInvalid;  // fix needed in Acts::MTJ
   m_trackStatesAux->previous[m_trackStatesSize] = previous;
   using namespace Acts;
  
   auto addParam = [this]() -> ActsTrk::IndexType {
     stepResize(m_trackParametersAux.get(), m_trackParametersSize, 60);
     // TODO ask AK if this resize could be method of aux container
     m_trackParametersAux->params[m_trackParametersSize].resize(Acts::eBoundSize);
     m_trackParametersAux->covMatrix[m_trackParametersSize].resize(Acts::eBoundSize*Acts::eBoundSize);
     m_trackParametersSize++;
     return m_trackParametersSize-1;
   };
  
   auto addJacobian = [this]() -> ActsTrk::IndexType {
     stepResize(m_trackJacobiansAux.get(), m_trackJacobiansSize);
     m_trackJacobiansAux->jac[m_trackJacobiansSize].resize(Acts::eBoundSize*Acts::eBoundSize);
     m_trackJacobiansSize++;
     return m_trackJacobiansSize-1;
   };
  
   auto addMeasurement = [this]() -> ActsTrk::IndexType {
     stepResize(m_trackMeasurementsAux.get(), m_trackMeasurementsSize );
     m_trackMeasurementsAux->meas[m_trackMeasurementsSize].resize(Acts::eBoundSize);
     m_trackMeasurementsAux->covMatrix[m_trackMeasurementsSize].resize(Acts::eBoundSize*Acts::eBoundSize);
     m_trackMeasurementsSize++;
     return m_trackMeasurementsSize-1;
   };
  
   m_trackStatesAux->predicted[m_trackStatesSize] = kInvalid;
   if (ACTS_CHECK_BIT(mask, TrackStatePropMask::Predicted)) {
     m_trackStatesAux->predicted[m_trackStatesSize] = addParam();
   }
  
   m_trackStatesAux->filtered[m_trackStatesSize] = kInvalid;
   if (ACTS_CHECK_BIT(mask, TrackStatePropMask::Filtered)) {
     m_trackStatesAux->filtered[m_trackStatesSize] = addParam();
   }
  
   m_trackStatesAux->smoothed[m_trackStatesSize] = kInvalid;
   if (ACTS_CHECK_BIT(mask, TrackStatePropMask::Smoothed)) {
     m_trackStatesAux->smoothed[m_trackStatesSize] = addParam();
   }
  
   m_trackStatesAux->jacobian[m_trackStatesSize] = kInvalid;
   if (ACTS_CHECK_BIT(mask, TrackStatePropMask::Jacobian)) {
     m_trackStatesAux->jacobian[m_trackStatesSize] = addJacobian();
   }
  
   m_uncalibratedSourceLinks.emplace_back(std::nullopt);
   m_trackStatesAux->calibrated[m_trackStatesSize] = kInvalid;
   m_trackStatesAux->measDim[m_trackStatesSize] = kInvalid;
   // @TODO uncalibrated ?
   if (ACTS_CHECK_BIT(mask, TrackStatePropMask::Calibrated)) {
     m_trackStatesAux->calibrated.at(m_trackStatesSize)  = addMeasurement();
     m_calibratedSourceLinks.emplace_back(std::nullopt);
   }
  
   m_trackStatesAux->geometryId[m_trackStatesSize] = InvalidGeoID; // surface is invalid until set
   m_trackStatesSize++;
   return m_trackStatesSize-1;
 }

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

                                  {
   using namespace Acts::HashedStringLiteral;
   INSPECTCALL( this << " " <<  mask << " " << m_trackStatesIface.size() << " " << istate);
  
   assert(m_trackStatesAux && "Missing Track States backend");
  
   // set kInvalid
   using Acts::MultiTrajectoryTraits::kInvalid;
  
   using namespace Acts;
  
   auto addParam = [this]() -> ActsTrk::IndexType {
     stepResize(m_trackParametersAux.get(), m_trackParametersSize, 60);
     // TODO ask AK if this resize could be method of aux container
     m_trackParametersAux->params[m_trackParametersSize].resize(Acts::eBoundSize);
     m_trackParametersAux->covMatrix[m_trackParametersSize].resize(Acts::eBoundSize*Acts::eBoundSize);
     m_trackParametersSize++;
     return m_trackParametersSize-1;
   };
  
   auto addJacobian = [this]() -> ActsTrk::IndexType {
     stepResize(m_trackJacobiansAux.get(), m_trackJacobiansSize);
     m_trackJacobiansAux->jac[m_trackJacobiansSize].resize(Acts::eBoundSize*Acts::eBoundSize);
     m_trackJacobiansSize++;
     return m_trackJacobiansSize-1;
   };
  
   auto addMeasurement = [this]() -> ActsTrk::IndexType {
     stepResize(m_trackMeasurementsAux.get(), m_trackMeasurementsSize );
     m_trackMeasurementsAux->meas[m_trackMeasurementsSize].resize(Acts::eBoundSize);
     m_trackMeasurementsAux->covMatrix[m_trackMeasurementsSize].resize(Acts::eBoundSize*Acts::eBoundSize);
     m_trackMeasurementsSize++;
     return m_trackMeasurementsSize-1;
   };
  
   if ((m_trackStatesAux->predicted[istate] == kInvalid) &&
       ACTS_CHECK_BIT(mask, TrackStatePropMask::Predicted)) {
     m_trackStatesAux->predicted[istate] = addParam();
   }
  
   if ((m_trackStatesAux->filtered[istate] == kInvalid) &&
       ACTS_CHECK_BIT(mask, TrackStatePropMask::Filtered)) {
     m_trackStatesAux->filtered[istate] = addParam();
   }
  
   if ((m_trackStatesAux->smoothed[istate] == kInvalid) &&
       ACTS_CHECK_BIT(mask, TrackStatePropMask::Smoothed)) {
     m_trackStatesAux->smoothed[istate] = addParam();
   }
  
   if ((m_trackStatesAux->jacobian[istate] == kInvalid) &&
       ACTS_CHECK_BIT(mask, TrackStatePropMask::Jacobian)) {
     m_trackStatesAux->jacobian[istate] = addJacobian();
   }
  
   if ((m_trackStatesAux->calibrated[istate] == kInvalid) &&
       ACTS_CHECK_BIT(mask, TrackStatePropMask::Calibrated)) {
     m_trackStatesAux->calibrated[istate]  = addMeasurement();
     m_calibratedSourceLinks.emplace_back(std::nullopt);
   }
 }

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

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

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

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

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

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

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

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

◆ clear_impl()

void ActsTrk::MutableMultiTrajectory::clear_impl ( )

clears backends decoration columns are still declared

Definition at line 494 of file MultiTrajectory.cxx.

                                                {
   INSPECTCALL(this);
   m_trackStatesIface.resize(0);
   m_trackStatesSize = 0;
  
   m_trackParametersAux->resize(0);
   m_trackParametersSize = 0;
  
   m_trackJacobiansAux->resize(0);
   m_trackJacobiansSize = 0;
  
   m_trackMeasurementsAux->resize(0);
   m_trackMeasurementsSize = 0;
  
   m_surfacesBackend->clear();
   m_surfaces.clear();
   m_calibratedSourceLinks.clear();
   m_uncalibratedSourceLinks.clear();
 }

◆ component_impl() [1/2]

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

Definition at line 373 of file MultiTrajectory.cxx.

                                                    {
   using namespace Acts::HashedStringLiteral;
   assert(istate < m_trackStatesIface.size() &&
          "Attempt to reach beyond the Track States container size");
   INSPECTCALL(key << " " << istate << " non-const component_impl")
  
   switch (key) {
     case "previous"_hash:
       return &(m_trackStatesAux->previous[istate]);
     case "next"_hash:
       return &(m_trackStatesAux->next[istate]);
     case "chi2"_hash:
       return &(m_trackStatesAux->chi2[istate]);
     case "pathLength"_hash:
       return &(m_trackStatesAux->pathLength[istate]);
     case "predicted"_hash:
       return &(m_trackStatesAux->predicted[istate]);
     case "filtered"_hash:
       return &(m_trackStatesAux->filtered[istate]);
     case "smoothed"_hash:
       return &(m_trackStatesAux->smoothed[istate]);
     case "projector"_hash: {
       auto idx = m_trackStatesAux->calibrated[istate];
       return &(m_trackMeasurementsAux->projector[idx]);
     }    
     case "measdim"_hash:
       return &(m_trackStatesAux->measDim[istate]);      
     case "typeFlags"_hash:
       return &(m_trackStatesAux->typeFlags[istate]);
  
     default: {
       for (auto& d : m_decorations) {
         if (d.hash == key) {
           return d.setter(m_trackStatesAux.get(), istate, d.auxid);
         }
       }
       throw std::runtime_error("MutableMultiTrajectory::component_impl no such component " + std::to_string(key));
     }
   }
 }

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

                                    {
   using namespace Acts::HashedStringLiteral;
   assert(istate < m_trackStatesIface.size() &&
          "Attempt to reach beyond the Track States container size");
   INSPECTCALL(key << " " << istate << " const component_impl")
   switch (key) {
     case "previous"_hash:
       return &(to_const_ptr(m_trackStatesAux)->previous[istate]);
     case "next"_hash:
       return &(to_const_ptr(m_trackStatesAux)->next[istate]);
     case "chi2"_hash:
       return &(to_const_ptr(m_trackStatesAux)->chi2[istate]);
     case "pathLength"_hash:
       return &(to_const_ptr(m_trackStatesAux)->pathLength[istate]);
     case "predicted"_hash:
       return &(to_const_ptr(m_trackStatesAux)->predicted[istate]);
     case "filtered"_hash:
       return &(to_const_ptr(m_trackStatesAux)->filtered[istate]);
     case "smoothed"_hash:
       return &(to_const_ptr(m_trackStatesAux)->smoothed[istate]);
     case "jacobian"_hash:
       return &(to_const_ptr(m_trackStatesAux)->jacobian[istate]);
     case "projector"_hash:{
       auto idx = to_const_ptr(m_trackStatesAux)->calibrated[istate];
       return &(to_const_ptr(m_trackMeasurementsAux)->projector[idx]);
     }
     case "calibrated"_hash: {
       return &(to_const_ptr(m_trackStatesAux)->calibrated[istate]);
     }
     case "calibratedCov"_hash: {
       return &(to_const_ptr(m_trackStatesAux)->calibrated[istate]);
     }
     case "measdim"_hash:
       return &(to_const_ptr(m_trackStatesAux)->measDim[istate]);
     case "typeFlags"_hash:
       return &(to_const_ptr(m_trackStatesAux)->typeFlags[istate]);
     default: {
       for (auto& d : m_decorations) {
         if (d.hash == key) {
           INSPECTCALL("getting dynamic variable " << d.name << " " << istate);
           return d.getter(m_trackStatesAux.get(), istate, d.auxid);
         }
       }
       throw std::runtime_error("MutableMultiTrajectory::component_impl const no such component " + std::to_string(key));
     }
   }
 }

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

                                                    {
   INSPECTCALL("copy dynamic decoration of key " << key << " destination MTJ has " << m_decorations.size() << " decorations");
   for (const ActsTrk::detail::Decoration& d : m_decorations) {
     INSPECTCALL("checking for destination of dynamic decoration " << d.name << " hash " << d.hash << " while looking for the key " << key);
     if (d.hash == key) {
       d.copier(m_trackStatesAux.get(), istate, d.auxid, src_ptr);
       return;
     }
   }
   throw std::invalid_argument("MultiTrajectory::copyDynamicFrom_impl no such decoration in destination MTJ " + std::to_string(key));
 }

◆ covariance_impl() [1/2]

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

inline

Definition at line 199 of file MultiTrajectory.h.

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

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

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

◆ dynamicKeys_impl()

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

returns the keys of all the dynamic columns

Definition at line 593 of file MultiTrajectory.cxx.

                                                                                   {
   std::vector<Acts::HashedString> keys;
   for ( const ActsTrk::detail::Decoration& d: m_decorations) {
     keys.push_back(d.hash);
     INSPECTCALL("collecting dynamic decoration " << d.name << " hash " << d.hash);
   }
   return keys;
 }

◆ getUncalibratedSourceLink_impl()

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

Implementation of uncalibrated link fetch.

Definition at line 793 of file MultiTrajectory.cxx.

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

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

                                                        {
   return m_trackStatesAux != nullptr and m_trackParametersAux != nullptr and
          m_trackJacobiansAux != nullptr and m_trackMeasurementsAux != nullptr
          and m_surfacesBackend != nullptr;
 }

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

                                                          {
   std::optional<bool> inTrackState = ::has_impl(m_trackStatesAux.get(), key, istate);
   if (inTrackState.has_value())
     return inTrackState.value();
  
   // TODO remove once EL based source links are in use only
   using namespace Acts::HashedStringLiteral;
   if (key == "uncalibratedSourceLink"_hash){
     INSPECTCALL(key << " " << istate << " uncalibratedSourceLink")
     static const SG::ConstAccessor<const xAOD::UncalibratedMeasurement*> acc{"uncalibratedMeasurement"};
     if (acc.isAvailable (m_trackStatesIface)) {
        if (acc(m_trackStatesIface, istate) != nullptr) return true;
     }
  
     return (istate < m_uncalibratedSourceLinks.size() &&  m_uncalibratedSourceLinks[istate].has_value());
   }
  
   for (auto& d : m_decorations) {
     if (d.hash == key) {
       INSPECTCALL(key << " " << istate << " d.name")
       return true;
     }
   }
  
   return false;
 }

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

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

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

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

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

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

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

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

◆ referenceSurface_impl()

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

Definition at line 574 of file MultiTrajectory.cxx.

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

◆ setReferenceSurface_impl()

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

Definition at line 548 of file MultiTrajectory.cxx.

                                                                           {
   if ( istate >= m_surfaces.size() )
     m_surfaces.resize(istate+1, nullptr);
  
   m_trackStatesAux->geometryId[istate] = surface->geometryId().value();
   if (surface->geometryId().value() == 0) { // free surface, needs recording of properties
     m_surfacesBackend->push_back(new xAOD::TrackSurface());
     encodeSurface(m_surfacesBackendAux.get(), m_surfacesBackendAux->size()-1, surface.get(), m_geoContext.context());
     m_trackStatesAux->surfaceIndex[istate] =  m_surfacesBackend->size()-1;
     m_surfaces[istate] = std::move(surface); // and memory management
  
   } else {
     m_surfaces[istate] = surface.get(); // no memory management, bare pointer
   }
   // store surface representation in
 }

◆ setUncalibratedSourceLink_impl()

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

Implementation of uncalibrated link insertion.

Definition at line 522 of file MultiTrajectory.cxx.

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

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

                                         {
  
   assert(ACTS_CHECK_BIT(this->getTrackState(iother).getMask(), shareSource) &&
          "Source has incompatible allocation");
  
   using PM = Acts::TrackStatePropMask;
   // set kInvalid
   using Acts::MultiTrajectoryTraits::kInvalid;
  
   ActsTrk::IndexType sourceIndex{kInvalid};
   switch (shareSource) {
     case PM::Predicted:
       sourceIndex = m_trackStatesAux->predicted[iother];
       break;
     case PM::Filtered:
       sourceIndex = m_trackStatesAux->filtered[iother];
       break;
     case PM::Smoothed:
       sourceIndex = m_trackStatesAux->smoothed[iother];
       break;
     case PM::Jacobian:
       sourceIndex = m_trackStatesAux->jacobian[iother];
       break;
     default:
       throw std::domain_error{"MutableMultiTrajectory Unable to share this component"};
   }
  
   assert(sourceIndex != kInvalid);
  
   switch (shareTarget) {
     case PM::Predicted:
       assert(shareSource != PM::Jacobian);
       m_trackStatesAux->predicted[iself] = sourceIndex;
       break;
     case PM::Filtered:
       assert(shareSource != PM::Jacobian);
       m_trackStatesAux->filtered[iself] = sourceIndex;
       break;
     case PM::Smoothed:
       assert(shareSource != PM::Jacobian);
       m_trackStatesAux->smoothed[iself] = sourceIndex;
       break;
     case PM::Jacobian:
       assert(shareSource == PM::Jacobian);
       m_trackStatesAux->jacobian[iself] = sourceIndex;
       break;
     default:
       throw std::domain_error{"MutableMultiTrajectory Unable to share this component"};
   }
 }

◆ size_impl()

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

inline

size of the MTJ

Returns: size_t

Definition at line 287 of file MultiTrajectory.h.

                                               {
     return m_trackStatesSize;
   }

◆ trackJacobiansAux()

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

inline

Definition at line 364 of file MultiTrajectory.h.

                                                             {
     return m_trackJacobiansAux.get();
   }

◆ trackMeasurementsAux()

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

inline

Definition at line 368 of file MultiTrajectory.h.

                                                                   {
     return m_trackMeasurementsAux.get();
   }

◆ trackMeasurementsCov() [1/2]

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

inline

Definition at line 215 of file MultiTrajectory.h.

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

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

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

◆ trackParametersAux() [1/2]

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

inline

Definition at line 360 of file MultiTrajectory.h.

                                                                {
     return m_trackParametersAux.get();
   }

◆ trackParametersAux() [2/2]

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

inline

Definition at line 357 of file MultiTrajectory.h.

                                                                            {
     return m_trackParametersAux.get();
   }

◆ trackStatesAux()

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

inline

Definition at line 355 of file MultiTrajectory.h.

355 { return m_trackStatesAux.get(); }

◆ trackSurfacesAux()

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

inline

Definition at line 372 of file MultiTrajectory.h.

                                                           {
     return m_surfacesBackendAux.get();
   }

◆ trim()

void ActsTrk::MutableMultiTrajectory::trim ( )

private

Definition at line 603 of file MultiTrajectory.cxx.

                                          {
   m_trackStatesIface.resize(m_trackStatesSize);
   static const SG::Decorator<const xAOD::UncalibratedMeasurement*> decor{"uncalibratedMeasurement"};
   if (m_trackStatesSize > 0) {
     (void)decor.getDecorationSpan(m_trackStatesIface);
   }
   m_trackMeasurementsAux->resize(m_trackMeasurementsSize);
   m_trackJacobiansAux->resize(m_trackJacobiansSize);
   m_trackParametersAux->resize(m_trackParametersSize);
 }

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

                              {
  
   using PM = Acts::TrackStatePropMask;
   // set kInvalid
   using Acts::MultiTrajectoryTraits::kInvalid;
  
   switch (target) {
     case PM::Predicted:
       m_trackStatesAux->predicted[istate] = kInvalid;
       break;
     case PM::Filtered:
       m_trackStatesAux->filtered[istate] = kInvalid;
  
       break;
     case PM::Smoothed:
       m_trackStatesAux->smoothed[istate] = kInvalid;
       break;
     case PM::Jacobian:
       m_trackStatesAux->jacobian[istate] = kInvalid;
  
       break;
     case PM::Calibrated:
       m_trackStatesAux->measDim[istate] = kInvalid;
       // TODO here m_measOffset[istate] and m_measCovOffset[istate] should be
       // set to kInvalid
  
       break;
     default:
       throw std::domain_error{"MutableMultiTrajectory Unable to unset this component"};
   }
 }

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

◆ m_calibratedSourceLinks

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

private

Definition at line 398 of file MultiTrajectory.h.

◆ m_decorations

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

private

Definition at line 396 of file MultiTrajectory.h.

◆ m_geoContext

ActsGeometryContext ActsTrk::MutableMultiTrajectory::m_geoContext

private

Definition at line 402 of file MultiTrajectory.h.

◆ m_surfaces

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

private

Definition at line 401 of file MultiTrajectory.h.

◆ m_surfacesBackend

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

private

Definition at line 394 of file MultiTrajectory.h.

◆ m_surfacesBackendAux

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

private

Definition at line 395 of file MultiTrajectory.h.

◆ m_trackJacobiansAux

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

private

Definition at line 388 of file MultiTrajectory.h.

◆ m_trackJacobiansSize

size_t ActsTrk::MutableMultiTrajectory::m_trackJacobiansSize = 0

private

Definition at line 389 of file MultiTrajectory.h.

◆ m_trackMeasurementsAux

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

private

Definition at line 391 of file MultiTrajectory.h.

◆ m_trackMeasurementsSize

size_t ActsTrk::MutableMultiTrajectory::m_trackMeasurementsSize = 0

private

Definition at line 392 of file MultiTrajectory.h.

◆ m_trackParametersAux

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

private

Definition at line 385 of file MultiTrajectory.h.

◆ m_trackParametersSize

size_t ActsTrk::MutableMultiTrajectory::m_trackParametersSize = 0

private

Definition at line 386 of file MultiTrajectory.h.

◆ m_trackStatesAux

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

private

Definition at line 382 of file MultiTrajectory.h.

◆ m_trackStatesIface

xAOD::TrackStateContainer ActsTrk::MutableMultiTrajectory::m_trackStatesIface

private

Definition at line 404 of file MultiTrajectory.h.

◆ m_trackStatesSize

size_t ActsTrk::MutableMultiTrajectory::m_trackStatesSize = 0

private

Definition at line 383 of file MultiTrajectory.h.

◆ m_uncalibratedSourceLinks

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

private

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

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

Public Types

Public Member Functions

Public Attributes

Static Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ConstTrackStateProxy

◆ TrackStateProxy

Constructor & Destructor Documentation

◆ MutableMultiTrajectory() [1/3]

◆ MutableMultiTrajectory() [2/3]

◆ MutableMultiTrajectory() [3/3]

Member Function Documentation

◆ addColumn_impl()

◆ addTrackState_impl()

◆ addTrackStateComponents_impl()

◆ calibrated_impl() [1/2]

◆ calibrated_impl() [2/2]

◆ calibratedCovariance_impl() [1/2]

◆ calibratedCovariance_impl() [2/2]

◆ clear_impl()

◆ component_impl() [1/2]

◆ component_impl() [2/2]

◆ copyDynamicFrom_impl()

◆ covariance_impl() [1/2]

◆ covariance_impl() [2/2]

◆ dynamicKeys_impl()

◆ getUncalibratedSourceLink_impl()

◆ has_backends()

◆ has_impl()

◆ hasColumn_impl()

◆ jacobian_impl() [1/2]

◆ jacobian_impl() [2/2]

◆ operator=()

◆ parameters_impl() [1/2]

◆ parameters_impl() [2/2]

◆ referenceSurface_impl()

◆ setReferenceSurface_impl()

◆ setUncalibratedSourceLink_impl()

◆ shareFrom_impl()

◆ size_impl()

◆ trackJacobiansAux()

◆ trackMeasurementsAux()

◆ trackMeasurementsCov() [1/2]

◆ trackMeasurementsCov() [2/2]

◆ trackParametersAux() [1/2]

◆ trackParametersAux() [2/2]

◆ trackStatesAux()

◆ trackSurfacesAux()

◆ trim()

◆ unset_impl()

Member Data Documentation

◆ calibratedSize_impl

◆ m_calibratedSourceLinks

◆ m_decorations

◆ m_geoContext

◆ m_surfaces

◆ m_surfacesBackend

◆ m_surfacesBackendAux

◆ m_trackJacobiansAux

◆ m_trackJacobiansSize

◆ m_trackMeasurementsAux

◆ m_trackMeasurementsSize

◆ m_trackParametersAux

◆ m_trackParametersSize

◆ m_trackStatesAux

◆ m_trackStatesIface

◆ m_trackStatesSize

◆ m_uncalibratedSourceLinks

◆ s_staticVariables