ATLAS Offline Software
Public Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
ActsExtrapolationTool Class Reference

#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
 

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 64 of file ActsExtrapolationTool.cxx.

66  : base_class(type, name, parent)
67 {
68 }

◆ ~ActsExtrapolationTool()

ActsExtrapolationTool::~ActsExtrapolationTool ( )

Definition at line 71 of file ActsExtrapolationTool.cxx.

72 {
73 }

Member Function Documentation

◆ getMagneticFieldContext()

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

Definition at line 377 of file ActsExtrapolationTool.cxx.

377  {
378  SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle{m_fieldCacheCondObjInputKey, ctx};
379  if (!readHandle.isValid()) {
380  std::stringstream msg;
381  msg << "Failed to retrieve magnetic field condition data " << m_fieldCacheCondObjInputKey.key() << ".";
382  throw std::runtime_error(msg.str());
383  }
384  const AtlasFieldCacheCondObj* fieldCondObj{*readHandle};
385 
386  return Acts::MagneticFieldContext(fieldCondObj);
387 }

◆ initialize()

StatusCode ActsExtrapolationTool::initialize ( )
overridevirtual

Definition at line 77 of file ActsExtrapolationTool.cxx.

78 {
79  using namespace std::literals::string_literals;
80  m_logger = makeActsAthenaLogger(this, std::string("ActsExtrapTool"), std::string("Prop"));
81 
82  ATH_MSG_INFO("Initializing ACTS extrapolation");
83 
84  m_logger = makeActsAthenaLogger(this, std::string("Prop"), std::string("ActsExtrapTool"));
85 
86  ATH_CHECK( m_trackingGeometryTool.retrieve() );
87  std::shared_ptr<const Acts::TrackingGeometry> trackingGeometry
88  = m_trackingGeometryTool->trackingGeometry();
89 
90  Acts::Navigator navigator( Acts::Navigator::Config{ trackingGeometry } );
91 
92  if (m_fieldMode == "ATLAS"s) {
93  ATH_MSG_INFO("Using ATLAS magnetic field service");
94  using Stepper = Acts::EigenStepper<Acts::StepperExtensionList<Acts::DefaultExtension,
95  Acts::DenseEnvironmentExtension>,
96  Acts::detail::HighestValidAuctioneer>;
97 
98  ATH_CHECK( m_fieldCacheCondObjInputKey.initialize() );
99  auto bField = std::make_shared<ATLASMagneticFieldWrapper>();
100 
101  auto stepper = Stepper(std::move(bField));
102  auto propagator = Acts::Propagator<Stepper, Acts::Navigator>(std::move(stepper),
103  std::move(navigator),
104  logger().cloneWithSuffix("Prop"));
105  m_varProp = std::make_unique<VariantPropagator>(propagator);
106  }
107  else if (m_fieldMode == "Constant") {
108  if (m_constantFieldVector.value().size() != 3)
109  {
110  ATH_MSG_ERROR("Incorrect field vector size. Using empty field.");
111  return StatusCode::FAILURE;
112  }
113 
114  Acts::Vector3 constantFieldVector = Acts::Vector3(m_constantFieldVector[0],
115  m_constantFieldVector[1],
116  m_constantFieldVector[2]);
117 
118  ATH_MSG_INFO("Using constant magnetic field: (Bx, By, Bz) = (" << m_constantFieldVector[0] << ", "
119  << m_constantFieldVector[1] << ", "
120  << m_constantFieldVector[2] << ")");
121 
122  using Stepper = Acts::EigenStepper<Acts::StepperExtensionList<Acts::DefaultExtension,
123  Acts::DenseEnvironmentExtension>,
124  Acts::detail::HighestValidAuctioneer>;
125 
126  auto bField = std::make_shared<Acts::ConstantBField>(constantFieldVector);
127  auto stepper = Stepper(std::move(bField));
128  auto propagator = Acts::Propagator<Stepper, Acts::Navigator>(std::move(stepper),
129  std::move(navigator));
130  m_varProp = std::make_unique<VariantPropagator>(propagator);
131  }
132 
133  ATH_MSG_INFO("ACTS extrapolation successfully initialized");
134  return StatusCode::SUCCESS;
135 }

◆ logger()

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

Definition at line 114 of file ActsExtrapolationTool.h.

114 { return *m_logger; }

◆ 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 213 of file ActsExtrapolationTool.cxx.

217 {
218  using namespace Acts::UnitLiterals;
219  ATH_MSG_VERBOSE(name() << "::" << __FUNCTION__ << " begin");
220 
221  Acts::MagneticFieldContext mctx;
222  const ActsGeometryContext& gctx
223  = m_trackingGeometryTool->getGeometryContext(ctx);
224 
225  auto anygctx = gctx.context();
226 
227  // Action list and abort list
228  using ActionList =
229  Acts::ActionList<Acts::MaterialInteractor>;
230  using AbortConditions = Acts::AbortList<EndOfWorld>;
231  using Options = Acts::DenseStepperPropagatorOptions<ActionList, AbortConditions>;
232 
233  Options options(anygctx, mctx);
234  options.pathLimit = pathLimit;
235 
236  options.loopProtection
237  = (Acts::VectorHelpers::perp(startParameters.momentum())
238  < m_ptLoopers * 1_MeV);
239  options.maxStepSize = m_maxStepSize * 1_m;
240  options.maxSteps = m_maxStep;
241  options.direction = navDir;
242 
243  auto& mInteractor = options.actionList.get<Acts::MaterialInteractor>();
244  mInteractor.multipleScattering = m_interactionMultiScatering;
245  mInteractor.energyLoss = m_interactionEloss;
246  mInteractor.recordInteractions = m_interactionRecord;
247 
248  auto parameters = boost::apply_visitor([&](const auto& propagator) -> std::optional<const Acts::CurvilinearTrackParameters> {
249  auto result = propagator.propagate(startParameters, options);
250  if (!result.ok()) {
251  ATH_MSG_ERROR("Got error during propagation:" << result.error()
252  << ". Returning empty parameters.");
253  return std::nullopt;
254  }
255  return result.value().endParameters;
256  }, *m_varProp);
257 
258  return parameters;
259 }

◆ 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 328 of file ActsExtrapolationTool.cxx.

333 {
334  using namespace Acts::UnitLiterals;
335  ATH_MSG_VERBOSE(name() << "::" << __FUNCTION__ << " begin");
336 
337  Acts::MagneticFieldContext mctx = getMagneticFieldContext(ctx);
338  const ActsGeometryContext& gctx
339  = m_trackingGeometryTool->getGeometryContext(ctx);
340 
341  auto anygctx = gctx.context();
342 
343  // Action list and abort list
344  using ActionList =
345  Acts::ActionList<Acts::MaterialInteractor>;
346  using AbortConditions = Acts::AbortList<EndOfWorld>;
347  using Options = Acts::DenseStepperPropagatorOptions<ActionList, AbortConditions>;
348 
349  Options options(anygctx, mctx);
350  options.pathLimit = pathLimit;
351 
352  options.loopProtection
353  = (Acts::VectorHelpers::perp(startParameters.momentum())
354  < m_ptLoopers * 1_MeV);
355  options.maxStepSize = m_maxStepSize * 1_m;
356  options.maxSteps = m_maxStep;
357  options.direction = navDir;
358 
359  auto& mInteractor = options.actionList.get<Acts::MaterialInteractor>();
360  mInteractor.multipleScattering = m_interactionMultiScatering;
361  mInteractor.energyLoss = m_interactionEloss;
362  mInteractor.recordInteractions = m_interactionRecord;
363 
364  auto parameters = boost::apply_visitor([&](const auto& propagator) -> std::optional<const Acts::BoundTrackParameters> {
365  auto result = propagator.propagate(startParameters, target, options);
366  if (!result.ok()) {
367  ATH_MSG_ERROR("Got error during propagation: " << result.error()
368  << ". Returning empty parameters.");
369  return std::nullopt;
370  }
371  return result.value().endParameters;
372  }, *m_varProp);
373 
374  return parameters;
375 }

◆ 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 139 of file ActsExtrapolationTool.cxx.

143 {
144  using namespace Acts::UnitLiterals;
145  ATH_MSG_VERBOSE(name() << "::" << __FUNCTION__ << " begin");
146 
147  Acts::MagneticFieldContext mctx = getMagneticFieldContext(ctx);
148  const ActsGeometryContext& gctx
149  = m_trackingGeometryTool->getGeometryContext(ctx);
150 
151  auto anygctx = gctx.context();
152 
153  // Action list and abort list
154  using ActionList =
155  Acts::ActionList<SteppingLogger, Acts::MaterialInteractor>;
156  using AbortConditions = Acts::AbortList<EndOfWorld>;
157 
158  using Options = Acts::DenseStepperPropagatorOptions<ActionList, AbortConditions>;
159 
160  Options options(anygctx, mctx);
161  options.pathLimit = pathLimit;
162 
163  options.loopProtection
164  = (Acts::VectorHelpers::perp(startParameters.momentum())
165  < m_ptLoopers * 1_MeV);
166  options.maxStepSize = m_maxStepSize * 1_m;
167  options.maxSteps = m_maxStep;
168  options.direction = navDir;
169 
170  auto &mInteractor = options.actionList.get<Acts::MaterialInteractor>();
171  mInteractor.multipleScattering = m_interactionMultiScatering;
172  mInteractor.energyLoss = m_interactionEloss;
173  mInteractor.recordInteractions = m_interactionRecord;
174 
175  ActsPropagationOutput output;
176 
177  auto res = boost::apply_visitor([&](const auto& propagator) -> ResultType {
178  auto result = propagator.propagate(startParameters, options);
179  if (!result.ok()) {
180  return result.error();
181  }
182  auto& propRes = *result;
183 
184  auto steppingResults = propRes.template get<SteppingLogger::result_type>();
185  auto materialResult = propRes.template get<Acts::MaterialInteractor::result_type>();
186  output.first = std::move(steppingResults.steps);
187  output.second = std::move(materialResult);
188  // try to force return value optimization, not sure this is necessary
189  return std::move(output);
190  }, *m_varProp);
191 
192  if (!res.ok()) {
193  ATH_MSG_ERROR("Got error during propagation: "
194  << res.error() << " " << res.error().message()
195  << ". Returning empty step vector.");
196  return {};
197  }
198  output = std::move(*res);
199 
200  ATH_MSG_VERBOSE("Collected " << output.first.size() << " steps");
201  if(output.first.size() == 0) {
202  ATH_MSG_WARNING("ZERO steps returned by stepper, that is not typically a good sign");
203  }
204 
205  ATH_MSG_VERBOSE(name() << "::" << __FUNCTION__ << " end");
206 
207  return output;
208 }

◆ 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 262 of file ActsExtrapolationTool.cxx.

267 {
268  using namespace Acts::UnitLiterals;
269  ATH_MSG_VERBOSE(name() << "::" << __FUNCTION__ << " begin");
270 
271  Acts::MagneticFieldContext mctx = getMagneticFieldContext(ctx);;
272  const ActsGeometryContext& gctx
273  = m_trackingGeometryTool->getGeometryContext(ctx);
274 
275  auto anygctx = gctx.context();
276 
277  // Action list and abort list
278  using ActionList =
279  Acts::ActionList<SteppingLogger, Acts::MaterialInteractor>;
280  using AbortConditions = Acts::AbortList<EndOfWorld>;
281  using Options = Acts::DenseStepperPropagatorOptions<ActionList, AbortConditions>;
282 
283  Options options(anygctx, mctx);
284  options.pathLimit = pathLimit;
285 
286  options.loopProtection
287  = (Acts::VectorHelpers::perp(startParameters.momentum())
288  < m_ptLoopers * 1_MeV);
289  options.maxStepSize = m_maxStepSize * 1_m;
290  options.maxSteps = m_maxStep;
291  options.direction = navDir;
292 
293  auto& mInteractor = options.actionList.get<Acts::MaterialInteractor>();
294  mInteractor.multipleScattering = m_interactionMultiScatering;
295  mInteractor.energyLoss = m_interactionEloss;
296  mInteractor.recordInteractions = m_interactionRecord;
297 
298  ActsPropagationOutput output;
299 
300  auto res = boost::apply_visitor([&](const auto& propagator) -> ResultType {
301  auto result = propagator.propagate(startParameters, target, options);
302  if (!result.ok()) {
303  return result.error();
304  }
305  auto& propRes = *result;
306 
307  auto steppingResults = propRes.template get<SteppingLogger::result_type>();
308  auto materialResult = propRes.template get<Acts::MaterialInteractor::result_type>();
309  output.first = std::move(steppingResults.steps);
310  output.second = std::move(materialResult);
311  return std::move(output);
312  }, *m_varProp);
313 
314  if (!res.ok()) {
315  ATH_MSG_ERROR("Got error during propagation:" << res.error()
316  << ". Returning empty step vector.");
317  return {};
318  }
319  output = std::move(*res);
320 
321  ATH_MSG_VERBOSE("Collected " << output.first.size() << " steps");
322  ATH_MSG_VERBOSE(name() << "::" << __FUNCTION__ << " end");
323 
324  return output;
325 }

◆ trackingGeometryTool()

virtual const IActsTrackingGeometryTool* ActsExtrapolationTool::trackingGeometryTool ( ) const
inlineoverridevirtual

Definition at line 103 of file ActsExtrapolationTool.h.

104  {
105  return m_trackingGeometryTool.get();
106  }

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:
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
get_generator_info.result
result
Definition: get_generator_info.py:21
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
AtlasFieldCacheCondObj
Definition: AtlasFieldCacheCondObj.h:19
perp
Scalar perp() const
perp method - perpenticular length
Definition: AmgMatrixBasePlugin.h:35
ActsExtrapolationTool::getMagneticFieldContext
virtual Acts::MagneticFieldContext getMagneticFieldContext(const EventContext &ctx) const override
Definition: ActsExtrapolationTool.cxx:377
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
ActsExtrapolationTool::ResultType
Acts::Result< ActsPropagationOutput > ResultType
Definition: ActsExtrapolationTool.h:67
makeActsAthenaLogger
std::unique_ptr< const Acts::Logger > makeActsAthenaLogger(IMessageSvc *svc, const std::string &name, int level, std::optional< std::string > parent_name)
Definition: Tracking/Acts/ActsInterop/src/Logger.cxx:64
ActsGeometryContext::context
Acts::GeometryContext context() const
Definition: ActsGeometryContext.h:46
ActsExtrapolationTool::logger
const Acts::Logger & logger() const
Definition: ActsExtrapolationTool.h:114
ActsExtrapolationTool::m_maxStep
Gaudi::Property< double > m_maxStep
Definition: ActsExtrapolationTool.h:129
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
ActsExtrapolationTool::m_ptLoopers
Gaudi::Property< double > m_ptLoopers
Definition: ActsExtrapolationTool.h:127
res
std::pair< std::vector< unsigned int >, bool > res
Definition: JetGroupProductTest.cxx:14
test_pyathena.parent
parent
Definition: test_pyathena.py:15
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
python.AtlRunQueryLib.options
options
Definition: AtlRunQueryLib.py:379
ActsExtrapolationTool::m_trackingGeometryTool
ToolHandle< IActsTrackingGeometryTool > m_trackingGeometryTool
Definition: ActsExtrapolationTool.h:122
ActsExtrapolationTool::m_interactionMultiScatering
Gaudi::Property< bool > m_interactionMultiScatering
Definition: ActsExtrapolationTool.h:132
ActsGeometryContext
Include the GeoPrimitives which need to be put first.
Definition: ActsGeometryContext.h:28
merge.output
output
Definition: merge.py:17
ActsExtrapolationTool::m_interactionRecord
Gaudi::Property< bool > m_interactionRecord
Definition: ActsExtrapolationTool.h:134
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
ActsExtrapolationTool::m_fieldCacheCondObjInputKey
SG::ReadCondHandleKey< AtlasFieldCacheCondObj > m_fieldCacheCondObjInputKey
Definition: ActsExtrapolationTool.h:120
checkNSWValTree.Options
Options
Definition: checkNSWValTree.py:15
ActsExtrapolationTool::m_interactionEloss
Gaudi::Property< bool > m_interactionEloss
Definition: ActsExtrapolationTool.h:133
ActsExtrapolationTool::m_fieldMode
Gaudi::Property< std::string > m_fieldMode
Definition: ActsExtrapolationTool.h:124
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
ActsExtrapolationTool::m_varProp
std::unique_ptr< const ActsExtrapolationDetail::VariantPropagator > m_varProp
Definition: ActsExtrapolationTool.h:117
ActsExtrapolationTool::m_maxStepSize
Gaudi::Property< double > m_maxStepSize
Definition: ActsExtrapolationTool.h:128
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
ActsExtrapolationTool::m_logger
std::unique_ptr< const Acts::Logger > m_logger
Definition: ActsExtrapolationTool.h:118
physics_parameters.parameters
parameters
Definition: physics_parameters.py:144
ActsExtrapolationTool::m_constantFieldVector
Gaudi::Property< std::vector< double > > m_constantFieldVector
Definition: ActsExtrapolationTool.h:125
COOLRates.target
target
Definition: COOLRates.py:1106
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
ActsPropagationOutput
std::pair< std::vector< Acts::detail::Step >, ActsRecordedMaterial > ActsPropagationOutput
Finally the output of the propagation test.
Definition: IActsExtrapolationTool.h:25
Generated on Tue Jul 2 2024 21:36:32 for ATLAS Offline Software by   doxygen 1.8.18