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...
template<class PropOwner >
	ConstTrackContainerHandlesHelper (PropOwner *owner)
	Constructor taking the pointer to the class holding the object used to declare the data dependency from the WriteHandleKeys to the AvalancheScheduler. More...
std::unique_ptr< ActsTrk::PersistentTrackContainer >	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 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 85 of file TrackContainerHandlesHelper.h.

Constructor & Destructor Documentation

ConstTrackContainerHandlesHelper()

template<class PropOwner >

ActsTrk::ConstTrackContainerHandlesHelper::ConstTrackContainerHandlesHelper

(

PropOwner *

owner

)

Constructor taking the pointer to the class holding the object used to declare the data dependency from the WriteHandleKeys to the AvalancheScheduler.

The object should be defined in the header like ActsTrk::ConstTrackContainerHandlesHelper m_trackHelper{this};

Member Function Documentation

build()

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

Definition at line 252 of file TrackContainerHandlesHelper.cxx.

                                                                              {
 
  std::unique_ptr<ActsTrk::MultiTrajectory> mtj = buildMtj(geo,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()); 
    
  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::PersistentTrackContainer>(
      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 EventContext &  context  ) const

private

Definition at line 201 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);
  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 173 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 323 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 113 of file TrackContainerHandlesHelper.h.

m_measurementsKey

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

private

Definition at line 114 of file TrackContainerHandlesHelper.h.

m_mtjKey

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

private

Definition at line 117 of file TrackContainerHandlesHelper.h.

m_parametersKey

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

private

Definition at line 112 of file TrackContainerHandlesHelper.h.

m_statesKey

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

private

Definition at line 111 of file TrackContainerHandlesHelper.h.

m_surfacesKey

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

private

Definition at line 115 of file TrackContainerHandlesHelper.h.

m_trackSummaryKey

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

private

Definition at line 127 of file TrackContainerHandlesHelper.h.

m_trackSurfacesKey

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

private

Definition at line 126 of file TrackContainerHandlesHelper.h.

m_xAODTrackSummaryKey

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

private

Definition at line 125 of file TrackContainerHandlesHelper.h.

---

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

• TrackContainerHandlesHelper.h
• TrackContainerHandlesHelper.cxx