ActsTrk::ExtrapolationTool Class Reference

#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)
	Explicitly define the constrcutor due to the variant forward declaration.
	~ExtrapolationTool ()
	Destructor needs to implemented due to the variant.
virtual Acts::Result< PropagationOutput >	propagationSteps (const EventContext &ctx, const Acts::BoundTrackParameters &startParameters, const Acts::Direction navDir, const double pathLimit) const override final
	Extrapolate the track parameters until the end of the world and record the performed steps & the allocated material.
virtual Acts::Result< Acts::BoundTrackParameters >	propagate (const EventContext &ctx, const Acts::BoundTrackParameters &startParameters, const Acts::Direction navDir, const double pathLimit) const override final
	Extrapolates the track parameters from a start to a target surface and returns the extrapolated track parameters on that surface.
virtual Acts::Result< PropagationOutput >	propagationSteps (const EventContext &ctx, const Acts::BoundTrackParameters &startParameters, const Acts::Surface &target, const Acts::Direction navDir, const double pathLimit) const override
	Extrapolate the track parameters until the end of the world and record the performed steps & the allocated material.
virtual Acts::Result< Acts::BoundTrackParameters >	propagate (const EventContext &ctx, const Acts::BoundTrackParameters &startParameters, const Acts::Surface &target, const Acts::Direction navDir, const double pathLimit) const override
	Extrapolates the track parameters from a start to a target surface and returns the extrapolated track parameters on that surface.
virtual Acts::Result< Acts::BoundTrackParameters >	propagate (const EventContext &ctx, const Acts::BoundTrackParameters &startParameters, const Acts::TrackingVolume &target, const VolumeAbort stopVolumeFlag, const Acts::Direction navDir, const double pathLimit) const override
	Extrapolates the track parameters from a start to a target surface and returns the extrapolated track parameters on that surface.
virtual Acts::Result< BoundParamVec_t >	propagateAndRecord (const EventContext &ctx, const Acts::BoundTrackParameters &startParameters, const SurfaceRecordOptions &recordOpts) const override
	Propagate the track parameters forward throuht the detector and record the surface crossings along the trajectory.

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}
ContextUtility	m_ctxProvider {this}
	Utility to fetch the geometry, magnetic field and calibration context in the event.
ServiceHandle< ActsTrk::ITrackingGeometrySvc >	m_trackingGeometrySvc {this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"}
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< 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 ExtrapolationTool.h.

Constructor & Destructor Documentation

ExtrapolationTool()

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

Explicitly define the constrcutor due to the variant forward declaration.

Definition at line 155 of file ExtrapolationTool.cxx.

                                                              :
    base_class{type,name, parent} {}

~ExtrapolationTool()

ActsTrk::ExtrapolationTool::~ExtrapolationTool ( )

default

Destructor needs to implemented due to the variant.

Member Function Documentation

initialize()

StatusCode ActsTrk::ExtrapolationTool::initialize ( )

overridevirtual

Definition at line 163 of file ExtrapolationTool.cxx.

{
 
 
  ATH_MSG_INFO("Initializing ACTS extrapolation");
 
  m_logger = makeActsAthenaLogger(this, name());
 
  ATH_CHECK( m_trackingGeometrySvc.retrieve() );
 
  Acts::Navigator::Config navConfig{m_trackingGeometrySvc->trackingGeometry()};
  Acts::Navigator navigator{std::move(navConfig), logger().clone()};
  
  ATH_CHECK(m_ctxProvider.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 106 of file ExtrapolationTool.h.

{ 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 405 of file ExtrapolationTool.cxx.

                                                                                            { 
  using namespace Acts::UnitLiterals;
  OptionsType options(gctx, mfContext);
 
  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;
  auto& mInteractor = options.actorList.template get<Acts::MaterialInteractor>();
  mInteractor.multipleScattering = m_interactionMultiScatering;
  mInteractor.energyLoss = m_interactionEloss;
  mInteractor.recordInteractions = m_interactionRecord;
  return options;
}

propagate() [1/3]

Acts::Result< Acts::BoundTrackParameters > ActsTrk::ExtrapolationTool::propagate ( const EventContext & ctx, const Acts::BoundTrackParameters & startParameters, const Acts::Direction navDir, const double pathLimit ) const

finaloverridevirtual

Extrapolates the track parameters from a start to a target surface and returns the extrapolated track parameters on that surface.

If the extrapolation fails, a nullopt is returned

Parameters

ctx	EventContext to fetch the alignment & magnetic field from the conditions store
startParameters	Reference to the bound track parameters encoding the start surface & the associated track parameters on the surface
target	Reference to the surface onto which the track shall be extrapolated
navDir	Run the propagation along (Foward) or opposite (Backward) to the track parameter's direction
pathLimit	Maximum length of the propagated trajectory. The extrapolation is aborted if the limit is exceeded and the surface not yet reached.

Definition at line 277 of file ExtrapolationTool.cxx.

{
  ATH_MSG_VERBOSE(name() << "::" << __FUNCTION__ << " begin");
 
  const Acts::MagneticFieldContext mfContext = m_ctxProvider.getMagneticFieldContext(ctx);
  const Acts::GeometryContext tgContext = m_ctxProvider.getGeometryContext(ctx);
 
  auto parameters = std::visit([&](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>(tgContext, mfContext, 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/3]

Acts::Result< Acts::BoundTrackParameters > ActsTrk::ExtrapolationTool::propagate ( const EventContext & ctx, const Acts::BoundTrackParameters & startParameters, const Acts::Surface & target, const Acts::Direction navDir, const double pathLimit ) const

overridevirtual

Extrapolates the track parameters from a start to a target surface and returns the extrapolated track parameters on that surface.

If the extrapolation fails, a nullopt is returned

Parameters

ctx	EventContext to fetch the alignment & magnetic field from the conditions store
startParameters	Reference to the bound track parameters encoding the start surface & the associated track parameters on the surface
target	Reference to the surface onto which the track shall be extrapolated
navDir	Run the propagation along (Foward) or opposite (Backward) to the track parameter's direction
pathLimit	Maximum length of the propagated trajectory. The extrapolation is aborted if the limit is exceeded and the surface not yet reached.

Definition at line 366 of file ExtrapolationTool.cxx.

{
  
  ATH_MSG_VERBOSE(name() << "::" << __FUNCTION__ << " begin");
  
  const Acts::MagneticFieldContext mfContext = m_ctxProvider.getMagneticFieldContext(ctx);
  const Acts::GeometryContext tgContext = m_ctxProvider.getGeometryContext(ctx);
 
  auto parameters = std::visit([&](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>(tgContext, mfContext, 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;
}

propagate() [3/3]

Acts::Result< Acts::BoundTrackParameters > ActsTrk::ExtrapolationTool::propagate ( const EventContext & ctx, const Acts::BoundTrackParameters & startParameters, const Acts::TrackingVolume & target, const VolumeAbort stopVolumeFlag, const Acts::Direction navDir, const double pathLimit ) const

overridevirtual

Extrapolates the track parameters from a start to a target surface and returns the extrapolated track parameters on that surface.

If the extrapolation fails, a nullopt is returned

Parameters

ctx	EventContext to fetch the alignment & magnetic field from the conditions store
startParameters	Reference to the bound track parameters encoding the start surface & the associated track parameters on the surface
target	Reference to the surface onto which the track shall be extrapolated
navDir	Run the propagation along (Foward) or opposite (Backward) to the track parameter's direction
pathLimit	Maximum length of the propagated trajectory. The extrapolation is aborted if the limit is exceeded and the surface not yet reached.

Execute the propagation

Definition at line 482 of file ExtrapolationTool.cxx.

                                                                                                      {
    const Acts::MagneticFieldContext mfContext = m_ctxProvider.getMagneticFieldContext(ctx);
    const Acts::GeometryContext tgContext = m_ctxProvider.getGeometryContext(ctx);
 
    return std::visit([&](const auto& propagator) -> Acts::Result<Acts::BoundTrackParameters> {
      using Propagator = std::decay_t<decltype(propagator)>;
      using ActorList = Acts::ActorList<Acts::MaterialInteractor, PassedVolumeAborter, EndOfWorld>;
 
      using Options = typename Propagator::template Options<ActorList>;
 
      auto propOptions = prepareOptions<Options>(tgContext, mfContext, startParameters, 
                                                 navDir, pathLimit);
 
      auto& aborter = propOptions.actorList.template get<PassedVolumeAborter>();
      aborter.targetVolumeId = target.geometryId();
      aborter.stopVolumeFlag = stopVolumeFlag;
        
      auto propResult = propagator.propagate(startParameters, propOptions);
      if (!propResult.ok()) {
          ATH_MSG_WARNING(__func__<<"() "<<__LINE__<<" - Propagation failed.");
          return Acts::PropagatorError::Failure;
      }
      if (!propResult.ok()) {
        ATH_MSG_DEBUG("Got error during propagation: " << propResult.error());
        return propResult.error();
      }
      if (!propResult.value().endParameters.has_value()) {
        ATH_MSG_DEBUG("Propagation did not result in valid end parameters.");
        return Acts::PropagatorError::Failure;
      }
      return propResult.value().endParameters.value();
    }, *m_varProp);
  }

propagateAndRecord()

Acts::Result< ExtrapolationTool::BoundParamVec_t > ActsTrk::ExtrapolationTool::propagateAndRecord ( const EventContext & ctx, const Acts::BoundTrackParameters & startParameters, const SurfaceRecordOptions & recordOpts ) const

overridevirtual

Propagate the track parameters forward throuht the detector and record the surface crossings along the trajectory.

Parameters

ctx	EventContext to access the alignment and the magnetic field
startParameters	The track parameters from which the propagation shall start
recordOpts	Record options specifying the target and also the flags at which surface types the track parameters shall be recorded

Define the volume abort condition. If the propagation leaves the volume or enters the volume

Execute the propagation

Definition at line 429 of file ExtrapolationTool.cxx.

                                                                                        {
 
  const Acts::MagneticFieldContext mfContext = m_ctxProvider.getMagneticFieldContext(ctx);
  const Acts::GeometryContext tgContext = m_ctxProvider.getGeometryContext(ctx);
 
    return std::visit([&](const auto& propagator) -> Acts::Result<BoundParamVec_t> {
        using Propagator = std::decay_t<decltype(propagator)>;
 
        // Action list and abort list
        using ParamRecorder_t = Acts::BoundParameterRecorder<Acts::SurfaceSelector>;
        return std::visit([&](const auto target) -> Acts::Result<BoundParamVec_t> {
            using Target_t = std::decay_t<decltype(target)>;
 
            using TargetAborter_t = std::conditional_t<std::is_same_v<Target_t, const Acts::Surface*>,
                                                       PassedSurfaceAborter, PassedVolumeAborter>;
   
            using ActorList = Acts::ActorList<ParamRecorder_t, Acts::MaterialInteractor,  
                                              TargetAborter_t, EndOfWorld>;
   
            using Options = typename Propagator::template Options<ActorList>;
 
            auto propOptions = prepareOptions<Options>(tgContext, mfContext, startParameters, 
                                                        recordOpts.navDir, recordOpts.pathLimit);
 
            auto& surfaceRecorder = propOptions.actorList.template get<ParamRecorder_t>();
            surfaceRecorder.selector.selectSensitive = recordOpts.recordSensitive;
            surfaceRecorder.selector.selectMaterial = recordOpts.recordMaterial;
            surfaceRecorder.selector.selectPassive = recordOpts.recordPassive;
 
            auto& aborter = propOptions.actorList.template get<TargetAborter_t>();
            if constexpr(std::is_same_v<Target_t, const Acts::Surface*>) {
              aborter.targetSurface = target;
              aborter.surpassedDistance = recordOpts.extraPathLength;
            } else {
              aborter.targetVolumeId = target->geometryId();
              aborter.stopVolumeFlag = recordOpts.stopVolumeFlag;
            }
            auto propResult = propagator.propagate(startParameters, propOptions);
            if (!propResult.ok()) {
                ATH_MSG_WARNING(__func__<<"() "<<__LINE__<<" - Propagation failed.");
                return Acts::Result<BoundParamVec_t>::failure(std::make_error_code(std::errc::invalid_argument));
            }
            auto& result = *propResult;
            return Acts::Result<BoundParamVec_t>::success(std::move(result.template get<BoundParamVec_t>()));
        }, recordOpts.target);
    }, *m_varProp);
  }

propagationSteps() [1/2]

Acts::Result< ExtrapolationTool::PropagationOutput > ActsTrk::ExtrapolationTool::propagationSteps ( const EventContext & ctx, const Acts::BoundTrackParameters & startParameters, const Acts::Direction navDir, const double pathLimit ) const

finaloverridevirtual

Extrapolate the track parameters until the end of the world and record the performed steps & the allocated material.

Parameters

ctx	EventContext to fetch the alignment & magnetic field from the conditions store
startParameters	Reference to the bound track parameters encoding the start surface & the associated track parameters on the surface
navDir	Run the propagation along (Foward) or opposite (Backward) to the track parameter's direction
pathLimit	Maximum length of the propagated trajectory, if not aborted by the end of the world condition otherwise.

Definition at line 220 of file ExtrapolationTool.cxx.

                                                                  {
 
  ATH_MSG_VERBOSE(name() << "::" << __FUNCTION__ << " begin");
 
  const Acts::MagneticFieldContext mfContext = m_ctxProvider.getMagneticFieldContext(ctx);
  const Acts::GeometryContext tgContext = m_ctxProvider.getGeometryContext(ctx);
  
  PropagationOutput output;
 
  auto res = std::visit([&](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>(tgContext, mfContext, 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, const Acts::Direction navDir, const double pathLimit ) const

overridevirtual

Extrapolate the track parameters until the end of the world and record the performed steps & the allocated material.

Parameters

ctx	EventContext to fetch the alignment & magnetic field from the conditions store
startParameters	Reference to the bound track parameters encoding the start surface & the associated track parameters on the surface
navDir	Run the propagation along (Foward) or opposite (Backward) to the track parameter's direction
pathLimit	Maximum length of the propagated trajectory, if not aborted by the end of the world condition otherwise.

Definition at line 314 of file ExtrapolationTool.cxx.

                                                                    {
  ATH_MSG_VERBOSE(name() << "::" << __FUNCTION__ << " begin");
 
  PropagationOutput output;
 
  const Acts::MagneticFieldContext mfContext = m_ctxProvider.getMagneticFieldContext(ctx);
  const Acts::GeometryContext tgContext = m_ctxProvider.getGeometryContext(ctx);
 
  auto res = std::visit([&](const auto& propagator) -> Acts::Result<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>(tgContext, mfContext, 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 116 of file ExtrapolationTool.h.

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

m_ctxProvider

ContextUtility ActsTrk::ExtrapolationTool::m_ctxProvider {this}

private

Utility to fetch the geometry, magnetic field and calibration context in the event.

Definition at line 111 of file ExtrapolationTool.h.

{this};

m_fieldMode

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

private

Definition at line 115 of file ExtrapolationTool.h.

{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 126 of file ExtrapolationTool.h.

{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 125 of file ExtrapolationTool.h.

{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 127 of file ExtrapolationTool.h.

{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 109 of file ExtrapolationTool.h.

{nullptr};

m_maxStep

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

private

Definition at line 120 of file ExtrapolationTool.h.

{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 119 of file ExtrapolationTool.h.

{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 121 of file ExtrapolationTool.h.

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

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 118 of file ExtrapolationTool.h.

{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 122 of file ExtrapolationTool.h.

                                       {this, "OnSurfaceTolerance", Acts::s_onSurfaceTolerance, 
                                          "Tolerance to consider track parameters on surface"};

m_trackingGeometrySvc

ServiceHandle<ActsTrk::ITrackingGeometrySvc> ActsTrk::ExtrapolationTool::m_trackingGeometrySvc {this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"}

private

Definition at line 113 of file ExtrapolationTool.h.

{this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"};

m_varProp

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

private

Definition at line 108 of file ExtrapolationTool.h.

---

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

• ExtrapolationTool.h
• ExtrapolationTool.cxx