ActsTrk::ConstTrackContainerHandlesHelper Class Reference

#include <TrackContainerHandlesHelper.h>

Collaboration diagram for ActsTrk::ConstTrackContainerHandlesHelper:

Public Member Functions
StatusCode	initialize (const std::string &prefix)
	Sets up the handles. More...
std::unique_ptr< ActsTrk::TrackContainer >	build (const Acts::TrackingGeometry *geo, const Acts::GeometryContext &geoContext, const EventContext &context) const

Private Member Functions
void	restoreUncalibMeasurementPtr (xAOD::TrackStateAuxContainer &statesLink) const
std::unique_ptr< ActsTrk::MultiTrajectory >	buildMtj (const Acts::TrackingGeometry *geo, const Acts::GeometryContext &geoContext, const EventContext &context) const

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

Detailed Description

Definition at line 76 of file TrackContainerHandlesHelper.h.

Member Function Documentation

build()

std::unique_ptr< ActsTrk::TrackContainer > ActsTrk::ConstTrackContainerHandlesHelper::build	(	const Acts::TrackingGeometry *	geo,
		const Acts::GeometryContext &	geoContext,
		const EventContext &	context
	)		const

Definition at line 257 of file TrackContainerHandlesHelper.cxx.

                                                                              {
 
  std::unique_ptr<ActsTrk::MultiTrajectory> mtj =
      buildMtj(geo, geoContext, evtContext);
  auto mtjHandle = SG::makeHandle(m_mtjKey, evtContext);
  if (mtjHandle.record(std::move(mtj)).isFailure()) {
    throw std::runtime_error(
        "ConstTrackContainerHandle<C>::build failed recording MTJ");
  }
  DataLink<xAOD::TrackSummaryContainer> summaryLink(m_xAODTrackSummaryKey.key(),
                                                    evtContext);
  if (not summaryLink.isValid()) {
    throw std::runtime_error(
        "ConstTrackContainerHandle::build, SummaryLink is invalid");
  }
 
  auto surfacesHandle = SG::makeHandle(m_trackSurfacesKey, evtContext);
  if (not surfacesHandle.isValid()) {
    throw std::runtime_error(
        "ConstTrackContainerHandle::build, SurfaceHandle is invalid");
  }
 
  auto constTrackSummary = std::make_unique<ActsTrk::TrackSummaryContainer>(summaryLink);
  constTrackSummary->decodeSurfaces( surfacesHandle.cptr(),  geoContext); 
    
  auto summaryHandle = SG::makeHandle(m_trackSummaryKey, evtContext);
  if (summaryHandle.record(std::move(constTrackSummary)).isFailure()) {
    throw std::runtime_error(
        "MutableTrackContainerHandle::build, 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;
 
}

buildMtj()

std::unique_ptr< ActsTrk::MultiTrajectory > ActsTrk::ConstTrackContainerHandlesHelper::buildMtj ( const Acts::TrackingGeometry *  geo, const Acts::GeometryContext &  geoContext, const EventContext &  context  ) const

private

Definition at line 205 of file TrackContainerHandlesHelper.cxx.

                                                                              {
  // we need to build it from backends
  DataLink<xAOD::TrackStateAuxContainer> statesLink(m_statesKey.key() + "Aux.",
                                                    evtContext);
  if (not statesLink.isValid()) {
    throw std::runtime_error(
        "ConstMultiTrajectoryHandle::build, StatesLink is invalid");
  }
  // The restoration of the pointers to uncalibrated measurements should only
  // be done once, if it is done in parallel by multiple callers all callers should
  // write exactly the same value to exactly the same memory location
  xAOD::TrackStateAuxContainer *nonConstStatesLink ATLAS_THREAD_SAFE = const_cast<xAOD::TrackStateAuxContainer *>(statesLink.getDataPtr());
  restoreUncalibMeasurementPtr(*nonConstStatesLink);
 
  DataLink<xAOD::TrackParametersAuxContainer> parametersLink(
      m_parametersKey.key() + "Aux.", evtContext);
  if (not parametersLink.isValid()) {
    throw std::runtime_error(
        "ConstMultiTrajectoryHandle::build, ParametersLink is invalid");
  }
 
  DataLink<xAOD::TrackJacobianAuxContainer> jacobiansLink(
      m_jacobiansKey.key() + "Aux.", evtContext);
  if (not jacobiansLink.isValid()) {
    throw std::runtime_error(
        "ConstMultiTrajectoryHandle::build, JacobiansLink is invalid");
  }
 
  DataLink<xAOD::TrackMeasurementAuxContainer> measurementsLink(
      m_measurementsKey.key() + "Aux.", evtContext);
  if (not measurementsLink.isValid()) {
    throw std::runtime_error(
        "ConstMultiTrajectoryHandle::build, MeasurementsLink is invalid");
  }
 
  DataLink<xAOD::TrackSurfaceAuxContainer> surfacesLink(
      m_surfacesKey.key() + "Aux.", evtContext);
  if (not surfacesLink.isValid()) {
    throw std::runtime_error(
        "ConstMultiTrajectoryHandle::build, SurfacesLink is invalid");
  }
 
 
  auto cmtj = std::make_unique<ActsTrk::MultiTrajectory>(
      statesLink, parametersLink, jacobiansLink, measurementsLink, surfacesLink);
  cmtj->fillSurfaces(geo, geoContext);
  return cmtj;
}

initialize()

StatusCode ActsTrk::ConstTrackContainerHandlesHelper::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 177 of file TrackContainerHandlesHelper.cxx.

                             {
  m_statesKey = prefix + "TrackStates";
  m_parametersKey = prefix + "TrackParameters";
  m_jacobiansKey = prefix + "TrackJacobians";
  m_measurementsKey = prefix + "TrackMeasurements";
  m_surfacesKey = prefix + "TrackSurfaces";
  m_mtjKey = prefix + "MultiTrajectory";
 
  INIT_CHECK(m_statesKey);
  INIT_CHECK(m_parametersKey);
  INIT_CHECK(m_jacobiansKey);
  INIT_CHECK(m_measurementsKey);
  INIT_CHECK(m_surfacesKey);
  INIT_CHECK(m_mtjKey);
 
  m_xAODTrackSummaryKey = prefix + "TrackSummary";
  m_trackSurfacesKey = prefix + "TrackSurfaces";
  m_trackSummaryKey = prefix + "TrackSummary";
 
  INIT_CHECK(m_xAODTrackSummaryKey);
  INIT_CHECK(m_trackSurfacesKey);
  INIT_CHECK(m_trackSummaryKey);
 
  return StatusCode::SUCCESS;
}

restoreUncalibMeasurementPtr()

void ActsTrk::ConstTrackContainerHandlesHelper::restoreUncalibMeasurementPtr ( xAOD::TrackStateAuxContainer &  statesLink ) const

private

Definition at line 329 of file TrackContainerHandlesHelper.cxx.

                                                                                                                {
   using link_t = ElementLink< xAOD::UncalibratedMeasurementContainer >;
   static const SG::ConstAccessor< link_t > link_accessor("uncalibratedMeasurementLink");
 
   if (statesLink.getAuxIDs().test(link_accessor.auxid())){
      const_span<link_t> elementLinks = getElementVector(statesLink, link_accessor);
 
      static const SG::AuxElement::Decorator< const xAOD::UncalibratedMeasurement * >
         decor("uncalibratedMeasurement");
 
      std::span<const xAOD::UncalibratedMeasurement *> uncalibratedMeasurements
         = createDecoration( statesLink, decor);
 
      for (unsigned int index = 0; index < elementLinks.size(); ++index) {
         const link_t &el = elementLinks[index];
         const xAOD::UncalibratedMeasurement *a_measurement = (el.isValid() ? *el : nullptr);
         // @TODO is this check necessary ?
         if (uncalibratedMeasurements[index] != nullptr && a_measurement != uncalibratedMeasurements[index]) {
            throwConflictingUncalibratedMeasurementPointerValue(uncalibratedMeasurements[index], a_measurement);
         }
         uncalibratedMeasurements[index]=a_measurement;
      }
   }
   else {
      std::cerr << "WARNING no uncalibratedMeasurementLink aux data " << std::endl;
   }
}

Member Data Documentation

m_jacobiansKey

SG::ReadHandleKey<xAOD::TrackJacobianContainer> ActsTrk::ConstTrackContainerHandlesHelper::m_jacobiansKey

private

Definition at line 96 of file TrackContainerHandlesHelper.h.

m_measurementsKey

SG::ReadHandleKey<xAOD::TrackMeasurementContainer> ActsTrk::ConstTrackContainerHandlesHelper::m_measurementsKey

private

Definition at line 97 of file TrackContainerHandlesHelper.h.

m_mtjKey

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

private

Definition at line 100 of file TrackContainerHandlesHelper.h.

m_parametersKey

SG::ReadHandleKey<xAOD::TrackParametersContainer> ActsTrk::ConstTrackContainerHandlesHelper::m_parametersKey

private

Definition at line 95 of file TrackContainerHandlesHelper.h.

m_statesKey

SG::ReadHandleKey<xAOD::TrackStateContainer> ActsTrk::ConstTrackContainerHandlesHelper::m_statesKey

private

Definition at line 94 of file TrackContainerHandlesHelper.h.

m_surfacesKey

SG::ReadHandleKey<xAOD::TrackSurfaceContainer> ActsTrk::ConstTrackContainerHandlesHelper::m_surfacesKey

private

Definition at line 98 of file TrackContainerHandlesHelper.h.

m_trackSummaryKey

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

private

Definition at line 111 of file TrackContainerHandlesHelper.h.

m_trackSurfacesKey

SG::ReadHandleKey<xAOD::TrackSurfaceContainer> ActsTrk::ConstTrackContainerHandlesHelper::m_trackSurfacesKey

private

Definition at line 110 of file TrackContainerHandlesHelper.h.

m_xAODTrackSummaryKey

SG::ReadHandleKey<xAOD::TrackSummaryContainer> ActsTrk::ConstTrackContainerHandlesHelper::m_xAODTrackSummaryKey

private

Definition at line 109 of file TrackContainerHandlesHelper.h.

---

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

• TrackContainerHandlesHelper.h
• TrackContainerHandlesHelper.cxx