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:

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	allocateCalibrated_impl (ActsTrk::IndexType istate, std::size_t measdim)
	Implementation of allocation of calibrated measurements. More...
ActsTrk::IndexType	calibratedSize_impl (ActsTrk::IndexType istate) const
	Implementation of calibrated size. 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, Acts::HashedString, const std::any &)
std::vector< Acts::HashedString >	dynamicKeys_impl () const
xAOD::TrackStateAuxContainer *	trackStatesAux ()
const xAOD::TrackParametersAuxContainer *	trackParametersAux () const
xAOD::TrackParametersAuxContainer *	trackParametersAux ()
xAOD::TrackJacobianAuxContainer *	trackJacobiansAux ()
xAOD::TrackMeasurementAuxContainer *	trackMeasurementsAux ()
xAOD::TrackSurfaceAuxContainer *	trackSurfacesAux ()

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

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

MutableMultiTrajectory() [2/3]

ActsTrk::MutableMultiTrajectory::MutableMultiTrajectory

(

const ActsTrk::MutableMultiTrajectory &

other

)

Definition at line 87 of file MultiTrajectory.cxx.

  : MutableMultiTrajectory()
  {
  INSPECTCALL("copy c-tor " << this <<  " src " << &other << " " << other.size())
 
  *m_trackStatesAux.get() = *other.m_trackStatesAux.get();
  *m_trackParametersAux.get() = *other.m_trackParametersAux.get();
  *m_trackJacobiansAux.get() = *other.m_trackJacobiansAux.get();
  *m_trackMeasurementsAux.get() = *other.m_trackMeasurementsAux.get();
  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;
  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 119 of file MultiTrajectory.cxx.

                               {
  using namespace Acts::HashedStringLiteral;
  INSPECTCALL( this << " " <<  mask << " " << m_trackStatesAux->size() << " " << previous);
  assert(m_trackStatesAux && "Missing Track States backend");
  constexpr size_t NDim = 6; // TODO take this from somewhere
  stepResize(m_trackStatesAux.get(), 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(NDim);
    m_trackParametersAux->covMatrix[m_trackParametersSize].resize(NDim*NDim);
    m_trackParametersSize++;
    return m_trackParametersSize-1;
  };
 
  auto addJacobian = [this]() -> ActsTrk::IndexType {
    stepResize(m_trackJacobiansAux.get(), m_trackJacobiansSize);
    m_trackJacobiansAux->jac[m_trackJacobiansSize].resize(NDim*NDim);
    m_trackJacobiansSize++;
    return m_trackJacobiansSize-1;
  };
 
  auto addMeasurement = [this]() -> ActsTrk::IndexType {
    stepResize(m_trackMeasurementsAux.get(), m_trackMeasurementsSize );
    m_trackMeasurementsAux->meas[m_trackMeasurementsSize].resize(NDim);
    m_trackMeasurementsAux->covMatrix[m_trackMeasurementsSize].resize(NDim*NDim);
    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] = 0;
  // @TODO uncalibrated ?
  if (ACTS_CHECK_BIT(mask, TrackStatePropMask::Calibrated)) {
    m_trackStatesAux->calibrated[m_trackStatesSize]  = addMeasurement();
    m_calibratedSourceLinks.emplace_back(std::nullopt);
    m_trackStatesAux->measDim[m_trackStatesSize] = m_trackMeasurementsAux->meas[m_trackStatesAux->calibrated[m_trackStatesSize]].size();
  }
 
  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 197 of file MultiTrajectory.cxx.

                                 {
  using namespace Acts::HashedStringLiteral;
  INSPECTCALL( this << " " <<  mask << " " << m_trackStatesAux->size() << " " << previous);
 
  assert(m_trackStatesAux && "Missing Track States backend");
  constexpr size_t NDim = 6; // TODO take this from somewhere
 
  // 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(NDim);
    m_trackParametersAux->covMatrix[m_trackParametersSize].resize(NDim*NDim);
    m_trackParametersSize++;
    return m_trackParametersSize-1;
  };
 
  auto addJacobian = [this]() -> ActsTrk::IndexType {
    stepResize(m_trackJacobiansAux.get(), m_trackJacobiansSize);
    m_trackJacobiansAux->jac[m_trackJacobiansSize].resize(NDim*NDim);
    m_trackJacobiansSize++;
    return m_trackJacobiansSize-1;
  };
 
  auto addMeasurement = [this]() -> ActsTrk::IndexType {
    stepResize(m_trackMeasurementsAux.get(), m_trackMeasurementsSize );
    m_trackMeasurementsAux->meas[m_trackMeasurementsSize].resize(NDim);
    m_trackMeasurementsAux->covMatrix[m_trackMeasurementsSize].resize(NDim*NDim);
    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);
    m_trackStatesAux->measDim[istate] = m_trackMeasurementsAux->meas[m_trackStatesAux->calibrated[istate]].size();
  }
}

allocateCalibrated_impl()

void ActsTrk::MutableMultiTrajectory::allocateCalibrated_impl	(	ActsTrk::IndexType	istate,
		std::size_t	measdim
	)

Implementation of allocation of calibrated measurements.

Definition at line 497 of file MultiTrajectory.cxx.

                                                                                                      {
  m_trackStatesAux->measDim[istate] = measdim;
  auto idx = m_trackStatesAux->calibrated[istate];
  m_trackMeasurementsAux->meas[idx].resize(measdim);
  m_trackMeasurementsAux->covMatrix[idx].resize(measdim*measdim);
}

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.

                                          {
    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 250 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 279 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 272 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 505 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 476 of file MultiTrajectory.cxx.

                                               {
  INSPECTCALL(this);
  m_trackStatesAux->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 354 of file MultiTrajectory.cxx.

                                                   {
  using namespace Acts::HashedStringLiteral;
  assert(istate < m_trackStatesAux->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 397 of file MultiTrajectory.cxx.

                                   {
  using namespace Acts::HashedStringLiteral;
  assert(istate < m_trackStatesAux->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 "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 dymaic 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  , Acts::HashedString  , const std::any &    )

inline

Definition at line 333 of file MultiTrajectory.h.

                                              {
      // @TODO: This is currently unimplemented
  }

covariance_impl() [1/2]

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

inline

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

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

dynamicKeys_impl()

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

inline

Definition at line 339 of file MultiTrajectory.h.

                                                       {
      // @TODO: This currently does not do anything useful
      return {};
  }

getUncalibratedSourceLink_impl()

Acts::SourceLink ActsTrk::MutableMultiTrajectory::getUncalibratedSourceLink_impl

(

ActsTrk::IndexType

istate

)

const

Implementation of uncalibrated link fetch.

Definition at line 732 of file MultiTrajectory.cxx.

                                   {
  assert(istate < m_trackStatesAux->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::Accessor<const xAOD::UncalibratedMeasurement*> acc{"uncalibratedMeasurement"};
  if (m_trackStatesAux->getAuxIDs().test(acc.auxid())){
     return Acts::SourceLink( getElement(*m_trackStatesAux, acc, istate) );
  }
  else {
    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 106 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 445 of file MultiTrajectory.cxx.

                                                         {
  std::optional<bool> inTrackState =
      ActsTrk::details::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::Accessor<const xAOD::UncalibratedMeasurement*> acc{"uncalibratedMeasurement"};
    bool has_auxid= m_trackStatesAux->getAuxIDs().test(acc.auxid());
    if (has_auxid) {
       return getElement(*m_trackStatesAux, acc, istate) != nullptr;
    }
    else {
       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 236 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 230 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 188 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 183 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 563 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 537 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 512 of file MultiTrajectory.cxx.

                                                                      {
  INSPECTCALL( istate );
 
  static const SG::Decorator<const xAOD::UncalibratedMeasurement*> decor{"uncalibratedMeasurement"};
  if (istate>= m_trackStatesAux->size()) {
     throw std::range_error("istate out of range on TrackStates when attempting to acces uncalibrated measurements");
  }
  std::span<const xAOD::UncalibratedMeasurement*> uncalibratedMeasurements = createDecoration(*m_trackStatesAux, decor);
 
  // @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[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 264 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 290 of file MultiTrajectory.h.

                                              { 
    return m_trackStatesSize;
  }

trackJacobiansAux()

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

inline

Definition at line 355 of file MultiTrajectory.h.

                                                            {
    return m_trackJacobiansAux.get();
  }

trackMeasurementsAux()

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

inline

Definition at line 359 of file MultiTrajectory.h.

                                                                  {
    return m_trackMeasurementsAux.get();
  }

trackMeasurementsCov() [1/2]

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

inline

Definition at line 218 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 212 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 351 of file MultiTrajectory.h.

                                                               {
    return m_trackParametersAux.get();
  }

trackParametersAux() [2/2]

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

inline

Definition at line 348 of file MultiTrajectory.h.

                                                                           {
    return m_trackParametersAux.get();
  }

trackStatesAux()

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

inline

Definition at line 346 of file MultiTrajectory.h.

{ return m_trackStatesAux.get(); }

trackSurfacesAux()

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

inline

Definition at line 363 of file MultiTrajectory.h.

                                                          {
    return m_surfacesBackendAux.get();
  }

trim()

void ActsTrk::MutableMultiTrajectory::trim ( )

private

Definition at line 568 of file MultiTrajectory.cxx.

                                         {
  m_trackStatesAux->resize(m_trackStatesSize);
  static const SG::Decorator<const xAOD::UncalibratedMeasurement*> decor{"uncalibratedMeasurement"};
  std::span<const xAOD::UncalibratedMeasurement*> uncalibratedMeasurements = createDecoration(*m_trackStatesAux, decor);
  (void) uncalibratedMeasurements;
  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 320 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->calibrated[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 389 of file MultiTrajectory.h.

m_decorations

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

private

Definition at line 387 of file MultiTrajectory.h.

m_geoContext

ActsGeometryContext ActsTrk::MutableMultiTrajectory::m_geoContext

private

Definition at line 393 of file MultiTrajectory.h.

m_surfaces

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

private

Definition at line 392 of file MultiTrajectory.h.

m_surfacesBackend

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

private

Definition at line 385 of file MultiTrajectory.h.

m_surfacesBackendAux

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

private

Definition at line 386 of file MultiTrajectory.h.

m_trackJacobiansAux

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

private

Definition at line 379 of file MultiTrajectory.h.

m_trackJacobiansSize

size_t ActsTrk::MutableMultiTrajectory::m_trackJacobiansSize = 0

private

Definition at line 380 of file MultiTrajectory.h.

m_trackMeasurementsAux

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

private

Definition at line 382 of file MultiTrajectory.h.

m_trackMeasurementsSize

size_t ActsTrk::MutableMultiTrajectory::m_trackMeasurementsSize = 0

private

Definition at line 383 of file MultiTrajectory.h.

m_trackParametersAux

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

private

Definition at line 376 of file MultiTrajectory.h.

m_trackParametersSize

size_t ActsTrk::MutableMultiTrajectory::m_trackParametersSize = 0

private

Definition at line 377 of file MultiTrajectory.h.

m_trackStatesAux

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

private

Definition at line 373 of file MultiTrajectory.h.

m_trackStatesSize

size_t ActsTrk::MutableMultiTrajectory::m_trackStatesSize = 0

private

Definition at line 374 of file MultiTrajectory.h.

m_uncalibratedSourceLinks

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

private

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

---

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

• MultiTrajectory.h
• MultiTrajectory.cxx