ActsTrk::MutableMultiTrajectory Class Reference

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

#include <MultiTrajectory.h>

Inheritance diagram for ActsTrk::MutableMultiTrajectory:

Public Types
using	TrackStateProxy
using	ConstTrackStateProxy

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

Static Public Attributes
static const std::set< std::string >	s_staticVariables

Private Member Functions
void	trim ()

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

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

Initial value:

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

Definition at line 83 of file MultiTrajectory.h.

TrackStateProxy

using ActsTrk::MutableMultiTrajectory::TrackStateProxy

Initial value:

 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);
  }
}

allocateCalibrated_impl()

template<typename val_t, typename cov_t>
requires (Eigen::PlainObjectBase<val_t>::RowsAtCompileTime > 0 && Eigen::PlainObjectBase<val_t>::RowsAtCompileTime <= Acts::eBoundSize && Eigen::PlainObjectBase<val_t>::RowsAtCompileTime == Eigen::PlainObjectBase<cov_t>::RowsAtCompileTime && Eigen::PlainObjectBase<cov_t>::RowsAtCompileTime == Eigen::PlainObjectBase<cov_t>::ColsAtCompileTime)

void ActsTrk::MutableMultiTrajectory::allocateCalibrated_impl	(	IndexType	istate,
		const Eigen::DenseBase< val_t > &	val,
		const Eigen::DenseBase< cov_t > &	cov )

Implementation of allocation of calibrated measurements.

calibrated_impl() [1/2]

template<std::size_t measdim, bool Enable = true>

std::enable_if_t< Enable, typename TrackStateProxy::template Calibrated< measdim > > ActsTrk::MutableMultiTrajectory::calibrated_impl ( ActsTrk::IndexType index )

inline

Definition at line 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()};
  }

calibratedSize_impl()

ActsTrk::IndexType ActsTrk::MutableMultiTrajectory::calibratedSize_impl

(

ActsTrk::IndexType

istate

)

const

Implementation of calibrated size.

Definition at line 515 of file MultiTrajectory.cxx.

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

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

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.

{ return m_trackStatesAux.get(); }

trackSurfaces() [1/2]

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

inline

Definition at line 375 of file MultiTrajectory.h.

                                                    {
    return m_surfacesBackend.get();
  }

trackSurfaces() [2/2]

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

inline

Definition at line 378 of file MultiTrajectory.h.

                                                                  {
    return m_surfacesBackend.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

m_calibratedSourceLinks

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

private

Definition at line 404 of file MultiTrajectory.h.

m_decorations

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

private

Definition at line 402 of file MultiTrajectory.h.

m_geoContext

GeometryContext ActsTrk::MutableMultiTrajectory::m_geoContext

private

Definition at line 408 of file MultiTrajectory.h.

m_surfaces

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

private

Definition at line 407 of file MultiTrajectory.h.

m_surfacesBackend

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

private

Definition at line 400 of file MultiTrajectory.h.

m_surfacesBackendAux

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

private

Definition at line 401 of file MultiTrajectory.h.

m_trackJacobiansAux

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

private

Definition at line 394 of file MultiTrajectory.h.

m_trackJacobiansSize

size_t ActsTrk::MutableMultiTrajectory::m_trackJacobiansSize = 0

private

Definition at line 395 of file MultiTrajectory.h.

m_trackMeasurementsAux

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

private

Definition at line 397 of file MultiTrajectory.h.

m_trackMeasurementsSize

size_t ActsTrk::MutableMultiTrajectory::m_trackMeasurementsSize = 0

private

Definition at line 398 of file MultiTrajectory.h.

m_trackParametersAux

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

private

Definition at line 391 of file MultiTrajectory.h.

m_trackParametersSize

size_t ActsTrk::MutableMultiTrajectory::m_trackParametersSize = 0

private

Definition at line 392 of file MultiTrajectory.h.

m_trackStatesAux

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

private

Definition at line 388 of file MultiTrajectory.h.

m_trackStatesIface

xAOD::TrackStateContainer ActsTrk::MutableMultiTrajectory::m_trackStatesIface

private

Definition at line 410 of file MultiTrajectory.h.

m_trackStatesSize

size_t ActsTrk::MutableMultiTrajectory::m_trackStatesSize = 0

private

Definition at line 389 of file MultiTrajectory.h.

m_uncalibratedSourceLinks

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

private

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

---

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

• MultiTrajectory.h
• MultiTrajectory.cxx