#include <ExtrapolationTool.h>

Inheritance diagram for ActsTrk::ExtrapolationTool:

Collaboration diagram for ActsTrk::ExtrapolationTool:

Public Member Functions
virtual StatusCode	initialize () override
	ExtrapolationTool (const std::string &type, const std::string &name, const IInterface *parent)
	~ExtrapolationTool ()
virtual Acts::Result< PropagationOutput >	propagationSteps (const EventContext &ctx, const Acts::BoundTrackParameters &startParameters, Acts::Direction navDir=Acts::Direction::Forward(), double pathLimit=std::numeric_limits< double >::max()) const override
virtual Acts::Result< Acts::BoundTrackParameters >	propagate (const EventContext &ctx, const Acts::BoundTrackParameters &startParameters, Acts::Direction navDir=Acts::Direction::Forward(), double pathLimit=std::numeric_limits< double >::max()) const override
virtual Acts::Result< PropagationOutput >	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 Acts::Result< 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 Acts::MagneticFieldContext	getMagneticFieldContext (const EventContext &ctx) const override

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"}
PublicToolHandle< ActsTrk::ITrackingGeometryTool >	m_trackingGeometryTool {this, "TrackingGeometryTool", "ActsTrackingGeometryTool"}
Gaudi::Property< std::string >	m_fieldMode {this, "FieldMode", "ATLAS", "Either ATLAS or Constant or StraightLine"}
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< unsigned >	m_maxStep {this, "MaxSteps", 100000, "Max number of steps"}
Gaudi::Property< unsigned >	m_maxSurfSkip {this, "MaxSurfaceSkip" ,100, "Maximum number of surfaces to be tried by the navigator"}
Gaudi::Property< double >	m_surfTolerance
Gaudi::Property< unsigned >	m_pathLimit {this, "PathLimit", 50, "Maximum path length to be considered during propagation in Acts m unit"}
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 54 of file ExtrapolationTool.h.

Constructor & Destructor Documentation

◆ ExtrapolationTool()

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

Definition at line 59 of file ExtrapolationTool.cxx.

61 :

62 base_class{type,name, parent} {}

extractSporadic.name

name

Definition extractSporadic.py:101

python.CaloAddPedShiftConfig.type

type

Definition CaloAddPedShiftConfig.py:42

test_pyathena.parent

parent

Definition test_pyathena.py:15

◆ ~ExtrapolationTool()

ActsTrk::ExtrapolationTool::~ExtrapolationTool ( )

default

Member Function Documentation

◆ getMagneticFieldContext()

Acts::MagneticFieldContext ActsTrk::ExtrapolationTool::getMagneticFieldContext ( const EventContext & ctx ) const

overridevirtual

Definition at line 318 of file ExtrapolationTool.cxx.

                                                                                                 {
  const AtlasFieldCacheCondObj* fieldCondObj{nullptr};
  if (!SG::get(fieldCondObj,m_fieldCacheCondObjInputKey, ctx).isSuccess()) {
     throw std::runtime_error("Failed to retrieve conditions data from "+m_fieldCacheCondObjInputKey.key() + ".");
  }
  return Acts::MagneticFieldContext{fieldCondObj};
}

◆ initialize()

StatusCode ActsTrk::ExtrapolationTool::initialize ( )

overridevirtual

Definition at line 67 of file ExtrapolationTool.cxx.

{
 
 
  ATH_MSG_INFO("Initializing ACTS extrapolation");
 
  m_logger = makeActsAthenaLogger(this, name());
 
  ATH_CHECK( m_trackingGeometryTool.retrieve() );
 
  Acts::Navigator::Config navConfig{m_trackingGeometryTool->trackingGeometry()};
  Acts::Navigator navigator{std::move(navConfig), logger().clone()};
  
  ATH_CHECK(m_fieldCacheCondObjInputKey.initialize());
  if (m_fieldMode == "ATLAS") {    
    ATH_MSG_INFO("Using ATLAS magnetic field service");
 
    auto bField = std::make_shared<ATLASMagneticFieldWrapper>();
 
    CurvedStepper_t stepper{std::move(bField)};
    CurvedPropagator_t propagator{std::move(stepper), std::move(navigator),
                                  logger().clone()};
    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) = "
                <<Amg::toString(constantFieldVector));
 
    auto bField = std::make_shared<Acts::ConstantBField>(constantFieldVector);
    CurvedStepper_t stepper{std::move(bField)};
    CurvedPropagator_t propagator{std::move(stepper), std::move(navigator), logger().clone()};
    m_varProp = std::make_unique<VariantPropagator>(propagator);
  } else if (m_fieldMode == "StraightLine") {
      Acts::StraightLineStepper stepper{};
      StraightPropagator_t propagator{stepper, std::move(navigator), logger().clone()};
      m_varProp = std::make_unique<VariantPropagator>(propagator);
  } else {
     ATH_MSG_FATAL("Invalid mode provided "<<m_fieldMode<<". Allowed  : \"ATLAS\", \"Constant\", \"StraightLine\".");
     return StatusCode::FAILURE;
  }
 
  ATH_MSG_INFO("ACTS extrapolation successfully initialized");
  return StatusCode::SUCCESS;
}

◆ logger()

const Acts::Logger & ActsTrk::ExtrapolationTool::logger ( ) const

inlineprivate

Definition at line 100 of file ExtrapolationTool.h.

100{ return *m_logger; }

◆ prepareOptions()

template<typename OptionsType>

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

private

Definition at line 327 of file ExtrapolationTool.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;
  options.maxTargetSkipping = m_maxSurfSkip;
  options.surfaceTolerance = m_surfTolerance;
  options.pathLimit = m_pathLimit * 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]

Acts::Result< Acts::BoundTrackParameters > ActsTrk::ExtrapolationTool::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 184 of file ExtrapolationTool.cxx.

{
  ATH_MSG_VERBOSE(name() << "::" << __FUNCTION__ << " begin");
 
  Acts::MagneticFieldContext mctx = getMagneticFieldContext(ctx);
  const GeometryContext& geo_ctx
    = m_trackingGeometryTool->getGeometryContext(ctx);
  auto anygctx = geo_ctx.context();
 
  auto parameters = boost::apply_visitor([&](const auto& propagator) -> Acts::Result<Acts::BoundTrackParameters> {
      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_DEBUG("Got error during propagation:" << result.error());
        return result.error();
      }
      if (!result.value().endParameters.has_value()) {
        ATH_MSG_DEBUG("Propagation did not result in valid end parameters.");
        return Acts::PropagatorError::Failure;
      }
      return result.value().endParameters.value();
    }, *m_varProp);
 
  return parameters;
}

◆ propagate() [2/2]

Acts::Result< Acts::BoundTrackParameters > ActsTrk::ExtrapolationTool::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 278 of file ExtrapolationTool.cxx.

{
  
  ATH_MSG_VERBOSE(name() << "::" << __FUNCTION__ << " begin");
  
  Acts::MagneticFieldContext mctx = getMagneticFieldContext(ctx);
  const GeometryContext& geo_ctx
    = m_trackingGeometryTool->getGeometryContext(ctx);
  auto anygctx = geo_ctx.context();
 
  auto parameters = boost::apply_visitor([&](const auto& propagator) -> Acts::Result<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<Options, Acts::ForcedSurfaceReached, Acts::PathLimitReached>(startParameters, target, options) :
        propagator.template propagate<Options, Acts::SurfaceReached, Acts::PathLimitReached>(startParameters, target, options);
      if (!result.ok()) {
        ATH_MSG_DEBUG("Got error during propagation: " << result.error());
        return result.error();
      }
      if (!result.value().endParameters.has_value()) {
        ATH_MSG_DEBUG("Propagation did not result in valid end parameters.");
        return Acts::PropagatorError::Failure;
      }
      return result.value().endParameters.value();
    }, *m_varProp);
 
  return parameters;
}

◆ propagationSteps() [1/2]

Acts::Result< ExtrapolationTool::PropagationOutput > ActsTrk::ExtrapolationTool::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 124 of file ExtrapolationTool.cxx.

{
 
  ATH_MSG_VERBOSE(name() << "::" << __FUNCTION__ << " begin");
 
  Acts::MagneticFieldContext mctx = getMagneticFieldContext(ctx);
  const GeometryContext& geo_ctx
    = m_trackingGeometryTool->getGeometryContext(ctx);
  auto anygctx = geo_ctx.context();
 
  PropagationOutput output;
 
  auto res = boost::apply_visitor([&](const auto& propagator) -> Acts::Result<ExtrapolationTool::PropagationOutput> {
      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_DEBUG("Got error during propagation: "
                      << res.error() << " " << res.error().message()
                  << ". Returning empty step vector.");
    return res.error();
  }
  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]

Acts::Result< ExtrapolationTool::PropagationOutput > ActsTrk::ExtrapolationTool::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 223 of file ExtrapolationTool.cxx.

{
  ATH_MSG_VERBOSE(name() << "::" << __FUNCTION__ << " begin");
 
  PropagationOutput output;
 
  Acts::MagneticFieldContext mctx = getMagneticFieldContext(ctx);
  const GeometryContext& geo_ctx
    = m_trackingGeometryTool->getGeometryContext(ctx);
  auto anygctx = geo_ctx.context();
 
  auto res = boost::apply_visitor([&](const auto& propagator) -> Acts::Result<ExtrapolationTool::PropagationOutput> {
      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<Options, Acts::ForcedSurfaceReached, Acts::PathLimitReached>(startParameters, target, options) :
        propagator.template propagate<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_DEBUG("Got error during propagation:" << res.error()
                  << ". Returning empty step vector.");
    return res.error();
  }
  output = std::move(*res);
 
  ATH_MSG_VERBOSE("Collected " << output.first.size() << " steps");
  ATH_MSG_VERBOSE(name() << "::" << __FUNCTION__ << " end");
 
  return output;
}

Member Data Documentation

◆ m_constantFieldVector

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

private

Definition at line 110 of file ExtrapolationTool.h.

110{this, "ConstantFieldVector", {0, 0, 0}, "Constant field value to use if FieldMode == Constant"};

◆ m_fieldCacheCondObjInputKey

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

private

Definition at line 105 of file ExtrapolationTool.h.

105{this, "AtlasFieldCacheCondObj", "fieldCondObj", "Name of the Magnetic Field conditions object key"};

◆ m_fieldMode

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

private

Definition at line 109 of file ExtrapolationTool.h.

109{this, "FieldMode", "ATLAS", "Either ATLAS or Constant or StraightLine"};

◆ m_interactionEloss

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

private

Definition at line 121 of file ExtrapolationTool.h.

121{this, "InteractionEloss", false, "Whether to consider energy loss in the interactor"};

◆ m_interactionMultiScatering

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

private

Definition at line 120 of file ExtrapolationTool.h.

120{this, "InteractionMultiScatering", false, "Whether to consider multiple scattering in the interactor"};

◆ m_interactionRecord

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

private

Definition at line 122 of file ExtrapolationTool.h.

122{this, "InteractionRecord", false, "Whether to record all material interactions"};

◆ m_logger

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

private

Definition at line 103 of file ExtrapolationTool.h.

103{nullptr};

◆ m_maxStep

Gaudi::Property<unsigned> ActsTrk::ExtrapolationTool::m_maxStep {this, "MaxSteps", 100000, "Max number of steps"}

private

Definition at line 114 of file ExtrapolationTool.h.

114{this, "MaxSteps", 100000, "Max number of steps"};

◆ m_maxStepSize

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

private

Definition at line 113 of file ExtrapolationTool.h.

113{this, "MaxStepSize", 10, "Max step size in Acts m unit"};

◆ m_maxSurfSkip

Gaudi::Property<unsigned> ActsTrk::ExtrapolationTool::m_maxSurfSkip {this, "MaxSurfaceSkip" ,100, "Maximum number of surfaces to be tried by the navigator"}

private

Definition at line 115 of file ExtrapolationTool.h.

115{this, "MaxSurfaceSkip" ,100, "Maximum number of surfaces to be tried by the navigator"};

◆ m_pathLimit

Gaudi::Property<unsigned> ActsTrk::ExtrapolationTool::m_pathLimit {this, "PathLimit", 50, "Maximum path length to be considered during propagation in Acts m unit"}

private

Definition at line 118 of file ExtrapolationTool.h.

118{this, "PathLimit", 50, "Maximum path length to be considered during propagation in Acts m unit"};

◆ m_ptLoopers

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

private

Definition at line 112 of file ExtrapolationTool.h.

112{this, "PtLoopers", 300, "PT loop protection threshold. Will be converted to Acts MeV unit"};

◆ m_surfTolerance

Gaudi::Property<double> ActsTrk::ExtrapolationTool::m_surfTolerance

private

Initial value:

{this, "OnSurfaceTolerance", Acts::s_onSurfaceTolerance,

"Tolerance to consider track parameters on surface"}

Definition at line 116 of file ExtrapolationTool.h.

116 {this, "OnSurfaceTolerance", Acts::s_onSurfaceTolerance,

117 "Tolerance to consider track parameters on surface"};

◆ m_trackingGeometryTool

PublicToolHandle<ActsTrk::ITrackingGeometryTool> ActsTrk::ExtrapolationTool::m_trackingGeometryTool {this, "TrackingGeometryTool", "ActsTrackingGeometryTool"}

private

Definition at line 107 of file ExtrapolationTool.h.

107{this, "TrackingGeometryTool", "ActsTrackingGeometryTool"};

◆ m_varProp

std::unique_ptr<const ActsExtrapolationDetail::VariantPropagator> ActsTrk::ExtrapolationTool::m_varProp

private

Definition at line 102 of file ExtrapolationTool.h.

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ExtrapolationTool()

◆ ~ExtrapolationTool()

Member Function Documentation

◆ getMagneticFieldContext()

◆ initialize()

◆ logger()

◆ prepareOptions()

◆ propagate() [1/2]

◆ propagate() [2/2]

◆ propagationSteps() [1/2]

◆ propagationSteps() [2/2]

Member Data Documentation

◆ m_constantFieldVector

◆ m_fieldCacheCondObjInputKey

◆ m_fieldMode

◆ m_interactionEloss

◆ m_interactionMultiScatering

◆ m_interactionRecord

◆ m_logger

◆ m_maxStep

◆ m_maxStepSize

◆ m_maxSurfSkip

◆ m_pathLimit

◆ m_ptLoopers

◆ m_surfTolerance

◆ m_trackingGeometryTool

◆ m_varProp