ActsTrk::MutableTrackContainerHandlesHelper Class Reference

#include <TrackContainerHandlesHelper.h>

Collaboration diagram for ActsTrk::MutableTrackContainerHandlesHelper:

Public Member Functions
StatusCode	initialize (const std::string &prefix)
	Sets up the handles. More...
std::unique_ptr< ActsTrk::TrackContainer >	moveToConst (ActsTrk::MutableTrackContainer &&tc, const Acts::GeometryContext &geoContext, const EventContext &evtContext) const
	produces ActsTrk::ConstTrackContainer with all backends stored in SG More...

Private Member Functions
std::unique_ptr< ActsTrk::MultiTrajectory >	moveToConst (ActsTrk::MutableMultiTrajectory &&mmtj, const EventContext &context) const
	helper to record MTJ More...

Private Attributes
SG::WriteHandleKey< xAOD::TrackStateContainer >	m_statesKey
SG::WriteHandleKey< xAOD::TrackParametersContainer >	m_parametersKey
SG::WriteHandleKey< xAOD::TrackJacobianContainer >	m_jacobiansKey
SG::WriteHandleKey< xAOD::TrackMeasurementContainer >	m_measurementsKey
SG::WriteHandleKey< xAOD::TrackSurfaceContainer >	m_surfacesKey
SG::WriteHandleKey< ActsTrk::MultiTrajectory >	m_mtjKey
SG::WriteHandleKey< xAOD::TrackSummaryContainer >	m_xAODTrackSummaryKey
SG::WriteHandleKey< xAOD::TrackSurfaceContainer >	m_trackSurfacesKey
SG::WriteHandleKey< ActsTrk::TrackSummaryContainer >	m_trackSummaryKey

Detailed Description

Definition at line 33 of file TrackContainerHandlesHelper.h.

Member Function Documentation

initialize()

StatusCode ActsTrk::MutableTrackContainerHandlesHelper::initialize

(

const std::string &

prefix

)

Sets up the handles.

• prefix - common prefix for all the names the value would typically be taken from configurable string property

Definition at line 51 of file TrackContainerHandlesHelper.cxx.

                             {
  m_statesKey = prefix + "TrackStates";
  m_parametersKey = prefix + "TrackParameters";
  m_jacobiansKey = prefix + "TrackJacobians";
  m_measurementsKey = prefix + "TrackMeasurements";
  m_surfacesKey = prefix + "TrackStateSurfaces";
  m_mtjKey =
      prefix + "MultiTrajectory";  // identical names, underlying types are distinct
  INIT_CHECK(m_statesKey);
  INIT_CHECK(m_parametersKey);
  INIT_CHECK(m_jacobiansKey);
  INIT_CHECK(m_measurementsKey);
  INIT_CHECK(m_surfacesKey);
  INIT_CHECK(m_mtjKey);
 
  // Track Container backends
  m_xAODTrackSummaryKey = prefix + "TrackSummary";
  m_trackSurfacesKey = prefix + "TrackSurfaces";
  m_trackSummaryKey =
      prefix +
      "TrackSummary";  // identical names, underlying types are distinct
 
  INIT_CHECK(m_xAODTrackSummaryKey);
  INIT_CHECK(m_trackSurfacesKey);
  INIT_CHECK(m_trackSummaryKey);
  return StatusCode::SUCCESS;
}

moveToConst() [1/2]

std::unique_ptr< ActsTrk::MultiTrajectory > ActsTrk::MutableTrackContainerHandlesHelper::moveToConst ( ActsTrk::MutableMultiTrajectory &&  mmtj, const EventContext &  context  ) const

private

helper to record MTJ

Definition at line 81 of file TrackContainerHandlesHelper.cxx.

                                                                                {
 
  mmtj.trim();
 
  auto statesBackendHandle = SG::makeHandle(m_statesKey, evtContext);
  auto statesInterface =
      ActsTrk::makeInterfaceContainer<xAOD::TrackStateContainer>(
          mmtj.trackStatesAux());
  recordxAOD(m_statesKey, statesInterface, mmtj.m_trackStatesAux, evtContext);
 
  auto parametersInterface =
      ActsTrk::makeInterfaceContainer<xAOD::TrackParametersContainer>(
          mmtj.trackParametersAux());
  recordxAOD(m_parametersKey, parametersInterface, mmtj.m_trackParametersAux, evtContext);
 
  auto jacobiansInterface =
      ActsTrk::makeInterfaceContainer<xAOD::TrackJacobianContainer>(
          mmtj.trackJacobiansAux());
  recordxAOD(m_jacobiansKey, jacobiansInterface, mmtj.m_trackJacobiansAux, evtContext);
 
  auto measurementsInterface =
      ActsTrk::makeInterfaceContainer<xAOD::TrackMeasurementContainer>(
          mmtj.trackMeasurementsAux());
   recordxAOD(m_measurementsKey, measurementsInterface, mmtj.m_trackMeasurementsAux, evtContext);
 
  auto surfacesBackendHandle = SG::makeHandle(m_surfacesKey, evtContext);
  recordxAOD(m_surfacesKey, mmtj.m_surfacesBackend, mmtj.m_surfacesBackendAux, evtContext);
 
  // construct const MTJ version
  auto cmtj = std::make_unique<ActsTrk::MultiTrajectory>(
      DataLink<xAOD::TrackStateAuxContainer>(m_statesKey.key() + "Aux.",
                                             evtContext),
      DataLink<xAOD::TrackParametersAuxContainer>(
        m_parametersKey.key() + "Aux.", evtContext),
      DataLink<xAOD::TrackJacobianAuxContainer>(
        m_jacobiansKey.key() + "Aux.", evtContext),
      DataLink<xAOD::TrackMeasurementAuxContainer>(
        m_measurementsKey.key() + "Aux.", evtContext), 
      DataLink<xAOD::TrackSurfaceAuxContainer>(
        m_surfacesKey.key() + "Aux.", evtContext)
      );
  cmtj->moveSurfaces(&mmtj);
  cmtj->moveLinks(&mmtj);
 
  return cmtj;
}

moveToConst() [2/2]

std::unique_ptr< ActsTrk::TrackContainer > ActsTrk::MutableTrackContainerHandlesHelper::moveToConst	(	ActsTrk::MutableTrackContainer &&	tc,
		const Acts::GeometryContext &	geoContext,
		const EventContext &	evtContext
	)		const

produces ActsTrk::ConstTrackContainer with all backends stored in SG

• tc - MutableTrackContainer the source (will be disassembled after the operation)
• - geoContext - geometry context, needed in surfaces conversion
• evtContext - event context (needed for SG operations)

Definition at line 130 of file TrackContainerHandlesHelper.cxx.

                                                                                                                    {
 
 
  std::unique_ptr<ActsTrk::MultiTrajectory> constMtj =
      moveToConst(std::move(tc.trackStateContainer()), evtContext);
 
  auto constMtjHandle = SG::makeHandle(m_mtjKey, evtContext);
  if (constMtjHandle.record(std::move(constMtj)).isFailure()) {
    throw std::runtime_error(
        "MutableTrackContainerHandlesHelper::moveToConst, can't record "
        "ConstMultiTrajectory");
  }
 
  auto trackSurfacesAux = std::make_unique<xAOD::TrackSurfaceAuxContainer>();
  tc.container().encodeSurfaces(trackSurfacesAux.get(), geoContext);
 
  auto interfaceTrackSummaryContainer =
      ActsTrk::makeInterfaceContainer<xAOD::TrackSummaryContainer>(
          tc.container().m_mutableTrackBackendAux.get());
  recordxAOD(m_xAODTrackSummaryKey, interfaceTrackSummaryContainer, tc.container().m_mutableTrackBackendAux, evtContext);
 
  auto trackSurfaces = ActsTrk::makeInterfaceContainer<xAOD::TrackSurfaceContainer>(
                        trackSurfacesAux.get());
  recordxAOD(m_trackSurfacesKey, trackSurfaces, trackSurfacesAux, evtContext);
 
  auto constTrackSummary = std::make_unique<ActsTrk::TrackSummaryContainer>(
      DataLink<xAOD::TrackSummaryContainer>(m_xAODTrackSummaryKey.key(),
                                            evtContext));
  constTrackSummary->restoreDecorations();
  constTrackSummary->fillFrom(tc.container());
 
  auto constTrackSummaryHandle = SG::makeHandle(m_trackSummaryKey, evtContext);
  if (constTrackSummaryHandle.record(std::move(constTrackSummary))
          .isFailure()) {
    throw std::runtime_error(
        "MutableTrackContainerHandlesHelper::moveToConst, can't record "
        "TrackSummary");
  }
  auto constTrack = std::make_unique<ActsTrk::TrackContainer>(
      DataLink<ActsTrk::TrackSummaryContainer>(m_trackSummaryKey.key(),
                                               evtContext),
      DataLink<ActsTrk::MultiTrajectory>(m_mtjKey.key(), evtContext));
  return constTrack;
}

Member Data Documentation

m_jacobiansKey

SG::WriteHandleKey<xAOD::TrackJacobianContainer> ActsTrk::MutableTrackContainerHandlesHelper::m_jacobiansKey

private

Definition at line 58 of file TrackContainerHandlesHelper.h.

m_measurementsKey

SG::WriteHandleKey<xAOD::TrackMeasurementContainer> ActsTrk::MutableTrackContainerHandlesHelper::m_measurementsKey

private

Definition at line 59 of file TrackContainerHandlesHelper.h.

m_mtjKey

SG::WriteHandleKey<ActsTrk::MultiTrajectory> ActsTrk::MutableTrackContainerHandlesHelper::m_mtjKey

private

Definition at line 61 of file TrackContainerHandlesHelper.h.

m_parametersKey

SG::WriteHandleKey<xAOD::TrackParametersContainer> ActsTrk::MutableTrackContainerHandlesHelper::m_parametersKey

private

Definition at line 57 of file TrackContainerHandlesHelper.h.

m_statesKey

SG::WriteHandleKey<xAOD::TrackStateContainer> ActsTrk::MutableTrackContainerHandlesHelper::m_statesKey

private

Definition at line 56 of file TrackContainerHandlesHelper.h.

m_surfacesKey

SG::WriteHandleKey<xAOD::TrackSurfaceContainer> ActsTrk::MutableTrackContainerHandlesHelper::m_surfacesKey

private

Definition at line 60 of file TrackContainerHandlesHelper.h.

m_trackSummaryKey

SG::WriteHandleKey<ActsTrk::TrackSummaryContainer> ActsTrk::MutableTrackContainerHandlesHelper::m_trackSummaryKey

private

Definition at line 73 of file TrackContainerHandlesHelper.h.

m_trackSurfacesKey

SG::WriteHandleKey<xAOD::TrackSurfaceContainer> ActsTrk::MutableTrackContainerHandlesHelper::m_trackSurfacesKey

private

Definition at line 72 of file TrackContainerHandlesHelper.h.

m_xAODTrackSummaryKey

SG::WriteHandleKey<xAOD::TrackSummaryContainer> ActsTrk::MutableTrackContainerHandlesHelper::m_xAODTrackSummaryKey

private

Definition at line 71 of file TrackContainerHandlesHelper.h.

---

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

• TrackContainerHandlesHelper.h
• TrackContainerHandlesHelper.cxx