#include <ActsExtrapolationTool.h>

Inheritance diagram for ActsExtrapolationTool:

Collaboration diagram for ActsExtrapolationTool:

Public Member Functions
virtual StatusCode	initialize () override

	ActsExtrapolationTool (const std::string &type, const std::string &name, const IInterface *parent)

	~ActsExtrapolationTool ()

virtual ActsPropagationOutput	propagationSteps (const EventContext &ctx, const Acts::BoundTrackParameters &startParameters, Acts::Direction navDir=Acts::Direction::Forward, double pathLimit=std::numeric_limits< double >::max()) const override

virtual std::optional< const Acts::CurvilinearTrackParameters >	propagate (const EventContext &ctx, const Acts::BoundTrackParameters &startParameters, Acts::Direction navDir=Acts::Direction::Forward, double pathLimit=std::numeric_limits< double >::max()) const override

virtual ActsPropagationOutput	propagationSteps (const EventContext &ctx, const Acts::BoundTrackParameters &startParameters, const Acts::Surface &target, Acts::Direction navDir=Acts::Direction::Forward, double pathLimit=std::numeric_limits< double >::max()) const override

virtual std::optional< const Acts::BoundTrackParameters >	propagate (const EventContext &ctx, const Acts::BoundTrackParameters &startParameters, const Acts::Surface &target, Acts::Direction navDir=Acts::Direction::Forward, double pathLimit=std::numeric_limits< double >::max()) const override

virtual const IActsTrackingGeometryTool *	trackingGeometryTool () const override

virtual Acts::MagneticFieldContext	getMagneticFieldContext (const EventContext &ctx) const override

Private Types
using	SteppingLogger = Acts::detail::SteppingLogger

using	EndOfWorld = Acts::EndOfWorldReached

using	ResultType = Acts::Result< ActsPropagationOutput >

Private Member Functions
const Acts::Logger &	logger () const

template<typename OptionsType >
OptionsType	prepareOptions (const Acts::GeometryContext &gctx, const Acts::MagneticFieldContext &mctx, const Acts::BoundTrackParameters &startParameters, Acts::Direction navDir, double pathLimit) const

Private Attributes
std::unique_ptr< const ActsExtrapolationDetail::VariantPropagator >	m_varProp

std::unique_ptr< const Acts::Logger >	m_logger {nullptr}

SG::ReadCondHandleKey< AtlasFieldCacheCondObj >	m_fieldCacheCondObjInputKey {this, "AtlasFieldCacheCondObj", "fieldCondObj", "Name of the Magnetic Field conditions object key"}

ToolHandle< IActsTrackingGeometryTool >	m_trackingGeometryTool {this, "TrackingGeometryTool", "ActsTrackingGeometryTool"}

Gaudi::Property< std::string >	m_fieldMode {this, "FieldMode", "ATLAS", "Either ATLAS or Constant"}

Gaudi::Property< std::vector< double > >	m_constantFieldVector {this, "ConstantFieldVector", {0, 0, 0}, "Constant field value to use if FieldMode == Constant"}

Gaudi::Property< double >	m_ptLoopers {this, "PtLoopers", 300, "PT loop protection threshold. Will be converted to Acts MeV unit"}

Gaudi::Property< double >	m_maxStepSize {this, "MaxStepSize", 10, "Max step size in Acts m unit"}

Gaudi::Property< double >	m_maxStep {this, "MaxSteps", 4000, "Max number of steps"}

Gaudi::Property< bool >	m_interactionMultiScatering {this, "InteractionMultiScatering", false, "Whether to consider multiple scattering in the interactor"}

Gaudi::Property< bool >	m_interactionEloss {this, "InteractionEloss", false, "Whether to consider energy loss in the interactor"}

Gaudi::Property< bool >	m_interactionRecord {this, "InteractionRecord", false, "Whether to record all material interactions"}

Detailed Description

Definition at line 53 of file ActsExtrapolationTool.h.

Member Typedef Documentation

◆ EndOfWorld

using ActsExtrapolationTool::EndOfWorld = Acts::EndOfWorldReached

private

Definition at line 66 of file ActsExtrapolationTool.h.

◆ ResultType

using ActsExtrapolationTool::ResultType = Acts::Result<ActsPropagationOutput>

private

Definition at line 67 of file ActsExtrapolationTool.h.

◆ SteppingLogger

using ActsExtrapolationTool::SteppingLogger = Acts::detail::SteppingLogger

private

Definition at line 65 of file ActsExtrapolationTool.h.

Constructor & Destructor Documentation

◆ ActsExtrapolationTool()

ActsExtrapolationTool::ActsExtrapolationTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Definition at line 52 of file ActsExtrapolationTool.cxx.

   : base_class(type, name, parent)
 {
 }

◆ ~ActsExtrapolationTool()

ActsExtrapolationTool::~ActsExtrapolationTool ( )

Definition at line 59 of file ActsExtrapolationTool.cxx.

60 {

61 }

Member Function Documentation

◆ getMagneticFieldContext()

Acts::MagneticFieldContext ActsExtrapolationTool::getMagneticFieldContext ( const EventContext & ctx ) const

overridevirtual

Definition at line 315 of file ActsExtrapolationTool.cxx.

                                                                                                      {
   SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle{m_fieldCacheCondObjInputKey, ctx};
   if (!readHandle.isValid()) {
      std::stringstream msg;
      msg << "Failed to retrieve magnetic field condition data " << m_fieldCacheCondObjInputKey.key() << ".";
      throw std::runtime_error(msg.str());
   }
   const AtlasFieldCacheCondObj* fieldCondObj{*readHandle};
  
   return Acts::MagneticFieldContext(fieldCondObj);
 }

◆ initialize()

StatusCode ActsExtrapolationTool::initialize ( )

overridevirtual

Definition at line 65 of file ActsExtrapolationTool.cxx.

 {
   using namespace std::literals::string_literals;
   m_logger = makeActsAthenaLogger(this, std::string("ActsExtrapTool"), std::string("Prop"));
  
   ATH_MSG_INFO("Initializing ACTS extrapolation");
  
   m_logger = makeActsAthenaLogger(this, std::string("Prop"), std::string("ActsExtrapTool"));
  
   ATH_CHECK( m_trackingGeometryTool.retrieve() );
   std::shared_ptr<const Acts::TrackingGeometry> trackingGeometry
     = m_trackingGeometryTool->trackingGeometry();
  
   Acts::Navigator navigator( Acts::Navigator::Config{ trackingGeometry } );
  
   if (m_fieldMode == "ATLAS"s) {    
     ATH_MSG_INFO("Using ATLAS magnetic field service");
     using Stepper = Acts::EigenStepper<Acts::EigenStepperDefaultExtension>;
  
     ATH_CHECK( m_fieldCacheCondObjInputKey.initialize() );
     auto bField = std::make_shared<ATLASMagneticFieldWrapper>();
  
     auto stepper = Stepper(std::move(bField));
     auto propagator = Acts::Propagator<Stepper, Acts::Navigator>(std::move(stepper),
                                                                  std::move(navigator),
                                  logger().cloneWithSuffix("Prop"));
     m_varProp = std::make_unique<VariantPropagator>(propagator);
   }
   else if (m_fieldMode == "Constant") {
     if (m_constantFieldVector.value().size() != 3)
     {
       ATH_MSG_ERROR("Incorrect field vector size. Using empty field.");
       return StatusCode::FAILURE; 
     }
     
     Acts::Vector3 constantFieldVector = Acts::Vector3(m_constantFieldVector[0], 
                                                       m_constantFieldVector[1], 
                                                       m_constantFieldVector[2]);
  
     ATH_MSG_INFO("Using constant magnetic field: (Bx, By, Bz) = (" << m_constantFieldVector[0] << ", " 
                                                                    << m_constantFieldVector[1] << ", " 
                                                                    << m_constantFieldVector[2] << ")");
     
     using Stepper = Acts::EigenStepper<Acts::EigenStepperDefaultExtension>;
  
     auto bField = std::make_shared<Acts::ConstantBField>(constantFieldVector);
     auto stepper = Stepper(std::move(bField));
     auto propagator = Acts::Propagator<Stepper, Acts::Navigator>(std::move(stepper),
                                                                  std::move(navigator));
     m_varProp = std::make_unique<VariantPropagator>(propagator);
   }
  
   ATH_MSG_INFO("ACTS extrapolation successfully initialized");
   return StatusCode::SUCCESS;
 }

◆ logger()

const Acts::Logger& ActsExtrapolationTool::logger ( ) const

inlineprivate

Definition at line 114 of file ActsExtrapolationTool.h.

114 { return *m_logger; }

◆ prepareOptions()

template<typename OptionsType >

OptionsType ActsExtrapolationTool::prepareOptions	(	const Acts::GeometryContext &	gctx,
		const Acts::MagneticFieldContext &	mctx,
		const Acts::BoundTrackParameters &	startParameters,
		Acts::Direction	navDir,
		double	pathLimit
	)		const

private

Definition at line 328 of file ActsExtrapolationTool.cxx.

                                                                           { 
   using namespace Acts::UnitLiterals;
   OptionsType options(gctx, mctx);
  
   options.pathLimit = pathLimit;
   options.loopProtection
     = (Acts::VectorHelpers::perp(startParameters.momentum())
       < m_ptLoopers * 1_MeV);
   options.maxSteps = m_maxStep;
   options.direction = navDir;
   options.stepping.maxStepSize = m_maxStepSize * 1_m;
  
   auto& mInteractor = options.actorList.template get<Acts::MaterialInteractor>();
   mInteractor.multipleScattering = m_interactionMultiScatering;
   mInteractor.energyLoss = m_interactionEloss;
   mInteractor.recordInteractions = m_interactionRecord;
  
   return options;
 }

◆ propagate() [1/2]

std::optional< const Acts::CurvilinearTrackParameters > ActsExtrapolationTool::propagate	(	const EventContext &	ctx,
		const Acts::BoundTrackParameters &	startParameters,
		Acts::Direction	navDir = `Acts::Direction::Forward`,
		double	pathLimit = `std::numeric_limits<double>::max()`
	)		const

overridevirtual

Definition at line 183 of file ActsExtrapolationTool.cxx.

 {
   ATH_MSG_VERBOSE(name() << "::" << __FUNCTION__ << " begin");
  
   Acts::MagneticFieldContext mctx = getMagneticFieldContext(ctx);
   const ActsGeometryContext& geo_ctx
     = m_trackingGeometryTool->getGeometryContext(ctx);
   auto anygctx = geo_ctx.context();
  
   auto parameters = boost::apply_visitor([&](const auto& propagator) -> std::optional<const Acts::CurvilinearTrackParameters> {
       using Propagator = std::decay_t<decltype(propagator)>;
  
       // Action list and abort list
       using ActorList =
       Acts::ActorList<Acts::MaterialInteractor, EndOfWorld>;
       using Options = typename Propagator::template Options<ActorList>;
  
       Options options = prepareOptions<Options>(anygctx, mctx, startParameters, navDir, pathLimit);
  
       
       auto result = propagator.propagate(startParameters, options);
       if (!result.ok()) {
         ATH_MSG_ERROR("Got error during propagation:" << result.error()
                       << ". Returning empty parameters.");
         return std::nullopt;
       }
       return result.value().endParameters;
     }, *m_varProp);
  
   return parameters;
 }

◆ propagate() [2/2]

std::optional< const Acts::BoundTrackParameters > ActsExtrapolationTool::propagate	(	const EventContext &	ctx,
		const Acts::BoundTrackParameters &	startParameters,
		const Acts::Surface &	target,
		Acts::Direction	navDir = `Acts::Direction::Forward`,
		double	pathLimit = `std::numeric_limits<double>::max()`
	)		const

overridevirtual

Definition at line 276 of file ActsExtrapolationTool.cxx.

 {
   
   ATH_MSG_VERBOSE(name() << "::" << __FUNCTION__ << " begin");
   
   Acts::MagneticFieldContext mctx = getMagneticFieldContext(ctx);
   const ActsGeometryContext& geo_ctx
     = m_trackingGeometryTool->getGeometryContext(ctx);
   auto anygctx = geo_ctx.context();
  
   auto parameters = boost::apply_visitor([&](const auto& propagator) -> std::optional<const Acts::BoundTrackParameters> {
       using Propagator = std::decay_t<decltype(propagator)>;
  
       // Action list and abort list
       using ActorList =
       Acts::ActorList<Acts::MaterialInteractor>;
       using Options = typename Propagator::template Options<ActorList>;
  
       Options options = prepareOptions<Options>(anygctx, mctx, startParameters, navDir, pathLimit);
       auto result = target.type() == Acts::Surface::Perigee  ?
         propagator.template propagate<Acts::BoundTrackParameters, Options,
                                     Acts::ForcedSurfaceReached, Acts::PathLimitReached>(startParameters, target, options) :
         propagator.template propagate<Acts::BoundTrackParameters, Options,
                                     Acts::SurfaceReached, Acts::PathLimitReached>(startParameters, target, options);
       if (!result.ok()) {
         ATH_MSG_ERROR("Got error during propagation: " << result.error()
                       << ". Returning empty parameters.");
         return std::nullopt;
       }
       return result.value().endParameters;
     }, *m_varProp);
  
   return parameters;
 }

◆ propagationSteps() [1/2]

ActsPropagationOutput ActsExtrapolationTool::propagationSteps	(	const EventContext &	ctx,
		const Acts::BoundTrackParameters &	startParameters,
		Acts::Direction	navDir = `Acts::Direction::Forward`,
		double	pathLimit = `std::numeric_limits<double>::max()`
	)		const

overridevirtual

Definition at line 123 of file ActsExtrapolationTool.cxx.

 {
  
   ATH_MSG_VERBOSE(name() << "::" << __FUNCTION__ << " begin");
  
   Acts::MagneticFieldContext mctx = getMagneticFieldContext(ctx);
   const ActsGeometryContext& geo_ctx
     = m_trackingGeometryTool->getGeometryContext(ctx);
   auto anygctx = geo_ctx.context();
  
   ActsPropagationOutput output;
  
   auto res = boost::apply_visitor([&](const auto& propagator) -> ResultType {
       using Propagator = std::decay_t<decltype(propagator)>;
  
       // Action list and abort list
       using ActorList =
       Acts::ActorList<SteppingLogger, Acts::MaterialInteractor, EndOfWorld>;
       using Options = typename Propagator::template Options<ActorList>;
  
        Options options = prepareOptions<Options>(anygctx, mctx, startParameters, navDir, pathLimit);
  
       auto result = propagator.propagate(startParameters, options);
       if (!result.ok()) {
         return result.error();
       }
       auto& propRes = *result;
  
       auto steppingResults = propRes.template get<SteppingLogger::result_type>();
       auto materialResult = propRes.template get<Acts::MaterialInteractor::result_type>();
       output.first = std::move(steppingResults.steps);
       output.second = std::move(materialResult);
       // try to force return value optimization, not sure this is necessary
       return std::move(output);
     }, *m_varProp);
  
   if (!res.ok()) {
     ATH_MSG_ERROR("Got error during propagation: "
                       << res.error() << " " << res.error().message()
                   << ". Returning empty step vector.");
     return {};
   }
   output = std::move(*res);
  
   ATH_MSG_VERBOSE("Collected " << output.first.size() << " steps");
   if(output.first.size() == 0) {
     ATH_MSG_WARNING("ZERO steps returned by stepper, that is not typically a good sign");
   }
  
   ATH_MSG_VERBOSE(name() << "::" << __FUNCTION__ << " end");
  
   return output;
 }

◆ propagationSteps() [2/2]

ActsPropagationOutput ActsExtrapolationTool::propagationSteps	(	const EventContext &	ctx,
		const Acts::BoundTrackParameters &	startParameters,
		const Acts::Surface &	target,
		Acts::Direction	navDir = `Acts::Direction::Forward`,
		double	pathLimit = `std::numeric_limits<double>::max()`
	)		const

overridevirtual

Definition at line 219 of file ActsExtrapolationTool.cxx.

 {
   ATH_MSG_VERBOSE(name() << "::" << __FUNCTION__ << " begin");
  
   ActsPropagationOutput output;
  
   Acts::MagneticFieldContext mctx = getMagneticFieldContext(ctx);
   const ActsGeometryContext& geo_ctx
     = m_trackingGeometryTool->getGeometryContext(ctx);
   auto anygctx = geo_ctx.context();
  
   auto res = boost::apply_visitor([&](const auto& propagator) -> ResultType {
       using Propagator = std::decay_t<decltype(propagator)>;
  
       // Action list and abort list
       using ActorList =
       Acts::ActorList<SteppingLogger, Acts::MaterialInteractor>;
       using Options = typename Propagator::template Options<ActorList>;
  
       Options options = prepareOptions<Options>(anygctx, mctx, startParameters, navDir, pathLimit);
       auto result = target.type() == Acts::Surface::Perigee  ?
         propagator.template propagate<Acts::BoundTrackParameters, Options,
                                     Acts::ForcedSurfaceReached, Acts::PathLimitReached>(startParameters, target, options) :
         propagator.template propagate<Acts::BoundTrackParameters, Options,
                                     Acts::SurfaceReached, Acts::PathLimitReached>(startParameters, target, options);
  
       
       if (!result.ok()) {
         return result.error();
       }
       auto& propRes = *result;
  
       auto steppingResults = propRes.template get<SteppingLogger::result_type>();
       auto materialResult = propRes.template get<Acts::MaterialInteractor::result_type>();
       output.first = std::move(steppingResults.steps);
       output.second = std::move(materialResult);
       return std::move(output);
     }, *m_varProp);
  
   if (!res.ok()) {
     ATH_MSG_ERROR("Got error during propagation:" << res.error()
                   << ". Returning empty step vector.");
     return {};
   }
   output = std::move(*res);
  
   ATH_MSG_VERBOSE("Collected " << output.first.size() << " steps");
   ATH_MSG_VERBOSE(name() << "::" << __FUNCTION__ << " end");
  
   return output;
 }

◆ trackingGeometryTool()

virtual const IActsTrackingGeometryTool* ActsExtrapolationTool::trackingGeometryTool ( ) const

inlineoverridevirtual

Definition at line 103 of file ActsExtrapolationTool.h.

   {
     return m_trackingGeometryTool.get();
   }

Member Data Documentation

◆ m_constantFieldVector

Gaudi::Property<std::vector<double> > ActsExtrapolationTool::m_constantFieldVector {this, "ConstantFieldVector", {0, 0, 0}, "Constant field value to use if FieldMode == Constant"}

private

Definition at line 125 of file ActsExtrapolationTool.h.

◆ m_fieldCacheCondObjInputKey

SG::ReadCondHandleKey<AtlasFieldCacheCondObj> ActsExtrapolationTool::m_fieldCacheCondObjInputKey {this, "AtlasFieldCacheCondObj", "fieldCondObj", "Name of the Magnetic Field conditions object key"}

private

Definition at line 120 of file ActsExtrapolationTool.h.

◆ m_fieldMode

Gaudi::Property<std::string> ActsExtrapolationTool::m_fieldMode {this, "FieldMode", "ATLAS", "Either ATLAS or Constant"}

private

Definition at line 124 of file ActsExtrapolationTool.h.

◆ m_interactionEloss

Gaudi::Property<bool> ActsExtrapolationTool::m_interactionEloss {this, "InteractionEloss", false, "Whether to consider energy loss in the interactor"}

private

Definition at line 133 of file ActsExtrapolationTool.h.

◆ m_interactionMultiScatering

Gaudi::Property<bool> ActsExtrapolationTool::m_interactionMultiScatering {this, "InteractionMultiScatering", false, "Whether to consider multiple scattering in the interactor"}

private

Definition at line 132 of file ActsExtrapolationTool.h.

◆ m_interactionRecord

Gaudi::Property<bool> ActsExtrapolationTool::m_interactionRecord {this, "InteractionRecord", false, "Whether to record all material interactions"}

private

Definition at line 134 of file ActsExtrapolationTool.h.

◆ m_logger

std::unique_ptr<const Acts::Logger> ActsExtrapolationTool::m_logger {nullptr}

private

Definition at line 118 of file ActsExtrapolationTool.h.

◆ m_maxStep

Gaudi::Property<double> ActsExtrapolationTool::m_maxStep {this, "MaxSteps", 4000, "Max number of steps"}

private

Definition at line 129 of file ActsExtrapolationTool.h.

◆ m_maxStepSize

Gaudi::Property<double> ActsExtrapolationTool::m_maxStepSize {this, "MaxStepSize", 10, "Max step size in Acts m unit"}

private

Definition at line 128 of file ActsExtrapolationTool.h.

◆ m_ptLoopers

Gaudi::Property<double> ActsExtrapolationTool::m_ptLoopers {this, "PtLoopers", 300, "PT loop protection threshold. Will be converted to Acts MeV unit"}

private

Definition at line 127 of file ActsExtrapolationTool.h.

◆ m_trackingGeometryTool

ToolHandle<IActsTrackingGeometryTool> ActsExtrapolationTool::m_trackingGeometryTool {this, "TrackingGeometryTool", "ActsTrackingGeometryTool"}

private

Definition at line 122 of file ActsExtrapolationTool.h.

◆ m_varProp

std::unique_ptr<const ActsExtrapolationDetail::VariantPropagator> ActsExtrapolationTool::m_varProp

private

Definition at line 117 of file ActsExtrapolationTool.h.

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

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ EndOfWorld

◆ ResultType

◆ SteppingLogger

Constructor & Destructor Documentation

◆ ActsExtrapolationTool()

◆ ~ActsExtrapolationTool()

Member Function Documentation

◆ getMagneticFieldContext()

◆ initialize()

◆ logger()

◆ prepareOptions()

◆ propagate() [1/2]

◆ propagate() [2/2]

◆ propagationSteps() [1/2]

◆ propagationSteps() [2/2]

◆ trackingGeometryTool()

Member Data Documentation

◆ m_constantFieldVector

◆ m_fieldCacheCondObjInputKey

◆ m_fieldMode

◆ m_interactionEloss

◆ m_interactionMultiScatering

◆ m_interactionRecord

◆ m_logger

◆ m_maxStep

◆ m_maxStepSize

◆ m_ptLoopers

◆ m_trackingGeometryTool

◆ m_varProp