ATLAS Offline Software
Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
Trk::GsfExtrapolator Class Referencefinal

#include <GsfExtrapolator.h>

Inheritance diagram for Trk::GsfExtrapolator:
Collaboration diagram for Trk::GsfExtrapolator:

Public Member Functions

 GsfExtrapolator (const std::string &, const std::string &, const IInterface *)
 Constructor with AlgTool parameters. More...
 
virtual ~GsfExtrapolator () override final
 Destructor. More...
 
virtual StatusCode initialize () override final
 AlgTool initialise method. More...
 
virtual MultiComponentState extrapolate (const EventContext &ctx, Cache &, const MultiComponentState &, const Surface &, PropDirection direction, const BoundaryCheck &boundaryCheck, ParticleHypothesis particleHypothesis=nonInteracting) const override final
 Configured AlgTool extrapolation method (1) More...
 
virtual MultiComponentState extrapolateDirectly (const EventContext &ctx, const MultiComponentState &, const Surface &, PropDirection direction, const BoundaryCheck &boundaryCheck, ParticleHypothesis particleHypothesis=nonInteracting) const override final
 Configured AlgTool extrapolation without material effects method (2) More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Static Public Member Functions

static const InterfaceID & interfaceID ()
 AlgTool interface method. More...
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

MultiComponentState extrapolateImpl (const EventContext &ctx, Cache &cache, const MultiComponentState &, const Surface &, PropDirection direction, const BoundaryCheck &boundaryCheck, ParticleHypothesis particleHypothesis) const
 Implementation of main extrapolation method. More...
 
MultiComponentState extrapolateDirectlyImpl (const EventContext &ctx, const MultiComponentState &, const Surface &, PropDirection direction=anyDirection, const BoundaryCheck &boundaryCheck=true, ParticleHypothesis particleHypothesis=nonInteracting) const
 Implementation of extrapolation without material effects. More...
 
void extrapolateToVolumeBoundary (const EventContext &ctx, Cache &cache, const MultiComponentState &, const Layer *, const TrackingVolume &, PropDirection direction, ParticleHypothesis particleHypothesis) const
 Two primary private extrapolation methods. More...
 
MultiComponentState extrapolateInsideVolume (const EventContext &ctx, Cache &cache, const MultiComponentState &, const Surface &, const Layer *, const TrackingVolume &, PropDirection direction, const BoundaryCheck &boundaryCheck, ParticleHypothesis particleHypothesis) const
 
MultiComponentState extrapolateFromLayerToLayer (const EventContext &ctx, Cache &cache, const MultiComponentState &, const TrackingVolume &, const Layer *startLayer, const Layer *destinationLayer, PropDirection direction, ParticleHypothesis particleHypothesis) const
 Additional private extrapolation methods. More...
 
MultiComponentState extrapolateToIntermediateLayer (const EventContext &ctx, Cache &cache, const MultiComponentState &, const Layer &, const TrackingVolume &, PropDirection direction, ParticleHypothesis particleHypothesis, bool perpendicularCheck=true) const
 Single extrapolation step to an intermediate layer. More...
 
MultiComponentState extrapolateToDestinationLayer (const EventContext &ctx, Cache &cache, const MultiComponentState &, const Surface &, const Layer &, const Layer *, PropDirection direction, const BoundaryCheck &boundaryCheck, ParticleHypothesis particleHypothesis) const
 Final extrapolation step to a destination layer. More...
 
void initialiseNavigation (const EventContext &ctx, Cache &cache, const MultiComponentState &initialState, const Surface &surface, const Layer *&associatedLayer, const TrackingVolume *&currentVolume, const TrackingVolume *&destinationVolume, std::unique_ptr< TrackParameters > &referenceParameters, PropDirection direction) const
 Method to initialise navigation parameters including starting state, layer and volume, and destination volume. More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

ToolHandle< IPropagator > m_propagator { this, "Propagator", "", "" }
 
ToolHandle< INavigator > m_navigator
 
ToolHandle< IMaterialMixtureConvolution > m_materialUpdator
 Switch to turn on/off surface based material effects. More...
 
bool m_fastField
 
Trk::MagneticFieldProperties m_fieldProperties
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 45 of file GsfExtrapolator.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ GsfExtrapolator()

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

Constructor with AlgTool parameters.

Definition at line 145 of file GsfExtrapolator.cxx.

148  : AthAlgTool(type, name, parent)
149  , m_fastField(false)
150 {
151  declareInterface<IMultiStateExtrapolator>(this);
152  declareProperty("MagneticFieldProperties", m_fastField);
153 }

◆ ~GsfExtrapolator()

Trk::GsfExtrapolator::~GsfExtrapolator ( )
finaloverridevirtualdefault

Destructor.

Member Function Documentation

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyArrayType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extrapolate()

Trk::MultiComponentState Trk::GsfExtrapolator::extrapolate ( const EventContext &  ctx,
Cache &  cache,
const MultiComponentState &  multiComponentState,
const Surface &  surface,
Trk::PropDirection  direction,
const BoundaryCheck &  boundaryCheck,
Trk::ParticleHypothesis  particleHypothesis = nonInteracting 
) const
finaloverridevirtual

Configured AlgTool extrapolation method (1)

Implements Trk::IMultiStateExtrapolator.

Definition at line 181 of file GsfExtrapolator.cxx.

189 {
190  if (multiComponentState.empty()) {
191  return {};
192  }
193  return extrapolateImpl(ctx,
194  cache,
195  multiComponentState,
196  surface,
197  direction,
198  boundaryCheck,
199  particleHypothesis);
200 }

◆ extrapolateDirectly()

Trk::MultiComponentState Trk::GsfExtrapolator::extrapolateDirectly ( const EventContext &  ctx,
const MultiComponentState &  multiComponentState,
const Surface &  surface,
Trk::PropDirection  direction,
const BoundaryCheck &  boundaryCheck,
Trk::ParticleHypothesis  particleHypothesis = nonInteracting 
) const
finaloverridevirtual

Configured AlgTool extrapolation without material effects method (2)

Implements Trk::IMultiStateExtrapolator.

Definition at line 206 of file GsfExtrapolator.cxx.

213 {
214  if (multiComponentState.empty()) {
215  return {};
216  }
217 
218  const Trk::TrackingVolume* currentVolume = m_navigator->highestVolume(ctx);
219  if (!currentVolume) {
220  ATH_MSG_WARNING(
221  "Current tracking volume could not be determined... returning {}");
222  return {};
223  }
224  return extrapolateDirectlyImpl(ctx,
225  multiComponentState,
226  surface,
227  direction,
228  boundaryCheck,
229  particleHypothesis);
230 }

◆ extrapolateDirectlyImpl()

Trk::MultiComponentState Trk::GsfExtrapolator::extrapolateDirectlyImpl ( const EventContext &  ctx,
const MultiComponentState &  multiComponentState,
const Surface &  surface,
Trk::PropDirection  direction = anyDirection,
const BoundaryCheck &  boundaryCheck = true,
Trk::ParticleHypothesis  particleHypothesis = nonInteracting 
) const
private

Implementation of extrapolation without material effects.

Definition at line 452 of file GsfExtrapolator.cxx.

459 {
460  return m_propagator->multiStatePropagate(ctx,
461  multiComponentState,
462  surface,
463  m_fieldProperties,
464  direction,
465  boundaryCheck,
466  particleHypothesis);
467 }

◆ extrapolateFromLayerToLayer()

Trk::MultiComponentState Trk::GsfExtrapolator::extrapolateFromLayerToLayer ( const EventContext &  ctx,
Cache &  cache,
const MultiComponentState &  multiComponentState,
const TrackingVolume &  trackingVolume,
const Layer *  startLayer,
const Layer *  destinationLayer,
PropDirection  direction,
ParticleHypothesis  particleHypothesis 
) const
private

Additional private extrapolation methods.

Layer stepping, stopping at the last layer before destination

Definition at line 728 of file GsfExtrapolator.cxx.

737 {
738 
739  const Trk::Layer* currentLayer = startLayer;
740  Trk::MultiComponentState currentState{};
741 
742  const Trk::TrackParameters* combinedState =
743  multiComponentState.begin()->params.get();
744  Amg::Vector3D currentPosition = combinedState->position();
745  Amg::Vector3D currentDirection = direction * combinedState->momentum().unit();
746 
747  // No need to extrapolate to start layer, find the next one
748  const Trk::Layer* nextLayer =
749  currentLayer->nextLayer(currentPosition, currentDirection);
750 
751  using LayerSet = boost::container::flat_set<
752  const Trk::Layer*,
753  std::less<const Trk::Layer*>,
754  boost::container::small_vector<const Trk::Layer*, 8>>;
755  LayerSet layersHit;
756 
757  layersHit.insert(currentLayer);
758 
759  // Begin while loop over all intermediate layers
760  while (nextLayer && nextLayer != destinationLayer) {
761  layersHit.insert(nextLayer);
762  // Only extrapolate to an intermediate layer if it requires material
763  // update. Otherwise step over it
764  if (nextLayer->layerMaterialProperties()) {
765  currentState = extrapolateToIntermediateLayer(
766  ctx,
767  cache,
768  !currentState.empty() ? currentState : multiComponentState,
769  *nextLayer,
770  trackingVolume,
771  direction,
772  particleHypothesis);
773  }
774 
775  if (!currentState.empty()) {
776  combinedState = currentState.begin()->params.get();
777  currentPosition = combinedState->position();
778  currentDirection = direction * combinedState->momentum().unit();
779  }
780 
781  // Find the next layer
782  currentLayer = nextLayer;
783  nextLayer = currentLayer->nextLayer(currentPosition, currentDirection);
784  if (layersHit.find(nextLayer) != layersHit.end()) {
785  break;
786  }
787  }
788 
789  if (destinationLayer && nextLayer != destinationLayer &&
790  !currentState.empty()) {
791  currentState.clear();
792  }
793 
794  return currentState;
795 }

◆ extrapolateImpl()

Trk::MultiComponentState Trk::GsfExtrapolator::extrapolateImpl ( const EventContext &  ctx,
Cache &  cache,
const MultiComponentState &  multiComponentState,
const Surface &  surface,
Trk::PropDirection  direction,
const BoundaryCheck &  boundaryCheck,
Trk::ParticleHypothesis  particleHypothesis 
) const
private

Implementation of main extrapolation method.

Definition at line 243 of file GsfExtrapolator.cxx.

251 {
252 
253  // If the extrapolation is to be without material effects simply revert to the
254  // extrapolateDirectly method
255  if (particleHypothesis == Trk::nonInteracting) {
256  return extrapolateDirectlyImpl(ctx,
257  multiComponentState,
258  surface,
259  direction,
260  boundaryCheck,
261  particleHypothesis);
262  }
263 
264  const Trk::Layer* associatedLayer = nullptr;
265  const Trk::TrackingVolume* startVolume = nullptr;
266  const Trk::TrackingVolume* destinationVolume = nullptr;
267  std::unique_ptr<Trk::TrackParameters> referenceParameters = nullptr;
268 
269  initialiseNavigation(ctx,
270  cache,
271  multiComponentState,
272  surface,
273  associatedLayer,
274  startVolume,
275  destinationVolume,
276  referenceParameters,
277  direction);
278 
279  // Bail to direct extrapolation if the direction cannot be determined
280  if (direction == Trk::anyDirection) {
281  return extrapolateDirectlyImpl(ctx,
282  multiComponentState,
283  surface,
284  direction,
285  boundaryCheck,
286  particleHypothesis);
287  }
288 
289  const Trk::TrackParameters* combinedState =
290  multiComponentState.begin()->params.get();
291 
292  const Trk::MultiComponentState* currentState = &multiComponentState;
293 
294  /* Define the initial distance between destination and current position.
295  Destination should be determined from either
296  - reference parameters (prefered if they exist) or
297  - destination surface
298  */
299 
300  Amg::Vector3D globalSeparation =
301  referenceParameters
302  ? referenceParameters->position() - combinedState->position()
303  : surface.globalReferencePoint() - combinedState->position();
304  double initialDistance = globalSeparation.mag();
305  // Clean up memory from combiner. It is no longer needed
306  combinedState = nullptr;
307 
308  /* There are two parts to the extrapolation:
309  - Extrapolate from start point to volume boundary
310  - Extrapolate from volume boundary to destination surface
311  */
312  /*
313  * Extrapolation to destination volume boundary
314  */
315  bool foundFinalBoundary(true);
316  int fallbackOscillationCounter(0);
317  const Trk::TrackingVolume* currentVolume = startVolume;
318  const Trk::TrackingVolume* previousVolume = nullptr;
319 
320  while (currentVolume && currentVolume != destinationVolume) {
321  // Extrapolate to volume boundary
322  extrapolateToVolumeBoundary(ctx,
323  cache,
324  *currentState,
325  associatedLayer,
326  *currentVolume,
327  direction,
328  particleHypothesis);
329 
330  // New current state is the state extrapolated to the tracking volume
331  // boundary.
332  currentState = cache.m_stateAtBoundary;
333  // The volume that the extrapolation is about to enter into is called the
334  // nextVolume
335  const Trk::TrackingVolume* nextVolume = cache.m_trackingVolume;
336  // Break the loop if the next tracking volume is the same as the current one
337  if (!nextVolume || nextVolume == currentVolume) {
338  foundFinalBoundary = false;
339  break;
340  }
341  // Break the loop if an oscillation is detected
342  if (previousVolume == nextVolume) {
343  ++fallbackOscillationCounter;
344  }
345  if (fallbackOscillationCounter > 10) {
346  foundFinalBoundary = false;
347  break;
348  }
349  // Break the loop if the distance between the surface and the track
350  // parameters has increased
351  combinedState = currentState->begin()->params.get();
352 
353  auto parametersAtDestination =
354  m_propagator->propagateParameters(ctx,
355  *combinedState,
356  surface,
357  direction,
358  false,
359  m_fieldProperties,
360  particleHypothesis);
361  Amg::Vector3D newDestination;
362  if (parametersAtDestination) {
363  newDestination = parametersAtDestination->position();
364  // delete parametersAtDestination;
365  } else {
366  newDestination = surface.center();
367  }
368 
369  double revisedDistance =
370  (cache.m_navigationParameters->position() - newDestination).mag();
371 
372  double distanceChange = std::abs(revisedDistance - initialDistance);
373 
374  if (revisedDistance > initialDistance && distanceChange > 0.01) {
375  foundFinalBoundary = false;
376  break;
377  }
378 
379  combinedState = nullptr;
380  // Initialise the oscillation checker
381  previousVolume = currentVolume;
382  // As the extrapolation is moving into the next volume, the next volume ->
383  // current volume
384  currentVolume = nextVolume;
385  // Associated layer now needs to be reset
386  // if(!entryLayerFound)
387  associatedLayer = nullptr;
388  } // end while loop
389 
390  // catch failures now
391  if (!currentState || (currentVolume != destinationVolume)) {
392  currentState = &multiComponentState;
393  foundFinalBoundary = false;
394  }
395 
396  if (!foundFinalBoundary) {
397  Trk::MultiComponentState bailOutState =
398  m_propagator->multiStatePropagate(ctx,
399  *currentState,
400  surface,
401  m_fieldProperties,
402  Trk::anyDirection,
403  boundaryCheck,
404  particleHypothesis);
405 
406  emptyRecycleBins(cache);
407  return bailOutState;
408  }
409 
410  /*
411  * Extrapolation from volume boundary to surface
412  */
413 
414  // extrapolate inside destination volume
415  Trk::MultiComponentState destinationState =
416  extrapolateInsideVolume(ctx,
417  cache,
418  *currentState,
419  surface,
420  associatedLayer,
421  *currentVolume,
422  direction,
423  boundaryCheck,
424  particleHypothesis);
425 
426  // FALLBACK POINT: Crisis if extrapolation fails here... As per extrapolation
427  // to volume boundary, in emergency revert to extrapolateDirectly
428 
429  // or we failed to reach the target
430  if (!destinationState.empty() &&
431  &((*(destinationState.begin())).params->associatedSurface()) != &surface) {
432  destinationState.clear();
433  }
434 
435  if (destinationState.empty()) {
436  destinationState = m_propagator->multiStatePropagate(ctx,
437  *currentState,
438  surface,
439  m_fieldProperties,
440  Trk::anyDirection,
441  boundaryCheck,
442  particleHypothesis);
443  }
444  emptyRecycleBins(cache);
445  return destinationState;
446 }

◆ extrapolateInsideVolume()

Trk::MultiComponentState Trk::GsfExtrapolator::extrapolateInsideVolume ( const EventContext &  ctx,
Cache &  cache,
const MultiComponentState &  multiComponentState,
const Surface &  surface,
const Layer *  layer,
const TrackingVolume &  trackingVolume,
Trk::PropDirection  direction,
const BoundaryCheck &  boundaryCheck,
Trk::ParticleHypothesis  particleHypothesis 
) const
private

Definition at line 606 of file GsfExtrapolator.cxx.

616 {
617  //curent state is a plainn ptr to keep track
618  const Trk::MultiComponentState* currentState = &multiComponentState;
619 
620  // Retrieve the destination layer
621  // 1. Association
622  const Trk::Layer* destinationLayer = surface.associatedLayer();
623 
624  // 2. Recall and Global Search
625  if (!destinationLayer) {
626  destinationLayer =
627  (&surface == cache.m_recallSurface)
628  ? cache.m_recallLayer
629  : trackingVolume.associatedLayer(surface.globalReferencePoint());
630  }
631 
632  // Retrieve the current layer
633  // Produce a combined state
634  const Trk::TrackParameters* combinedState =
635  currentState->begin()->params.get();
636 
637  const Trk::Layer* associatedLayer = layer;
638 
639  Trk::MultiComponentState updatedState{};
640  if (!associatedLayer) {
641  // Get entry layer but do not use it as it should have already be hit if it
642  // was desired
643  associatedLayer = trackingVolume.associatedLayer(combinedState->position());
644  associatedLayer =
645  associatedLayer
646  ? associatedLayer
647  : trackingVolume.nextLayer(combinedState->position(),
648  direction * combinedState->momentum().unit(),
649  associatedLayer);
650  }
651 
652  else if (associatedLayer != destinationLayer &&
653  trackingVolume.confinedLayers() &&
654  associatedLayer->layerMaterialProperties()) {
655 
656  updatedState = m_materialUpdator->postUpdate(cache.m_materialEffectsCaches,
657  *currentState,
658  *associatedLayer,
659  direction,
660  particleHypothesis);
661 
662  if (!updatedState.empty()) {
663  // Refresh the current state pointer
664  currentState = &updatedState;
665  }
666  }
667 
668  // Reset combined state target
669  combinedState = nullptr;
670  Trk::MultiComponentState nextState{};
671  if (destinationLayer) {
672  // If there are intermediate layers then additional extrapolations need to
673  // be done
674  if (associatedLayer && associatedLayer != destinationLayer) {
675  nextState = extrapolateFromLayerToLayer(ctx,
676  cache,
677  *currentState,
678  trackingVolume,
679  associatedLayer,
680  destinationLayer,
681  direction,
682  particleHypothesis);
683 
684  // currentState is now the next
685  if (!nextState.empty()) {
686  // Refresh the current state pointer
687  currentState = &nextState;
688  }
689  }
690  // Final extrapolation to destination surface
691  Trk::MultiComponentState returnState =
692  extrapolateToDestinationLayer(ctx,
693  cache,
694  *currentState,
695  surface,
696  *destinationLayer,
697  associatedLayer,
698  direction,
699  boundaryCheck,
700  particleHypothesis);
701  // Set the information for the current layer, surface, tracking volume
702  setRecallInformation(cache, surface, *destinationLayer, trackingVolume);
703  return returnState;
704  }
705 
706  // FALLBACK POINT: If no destination layer is found fall-back and extrapolate
707  // directly
708  Trk::MultiComponentState returnState =
709  m_propagator->multiStatePropagate(ctx,
710  *currentState,
711  surface,
712  m_fieldProperties,
713  direction,
714  boundaryCheck,
715  particleHypothesis);
716 
717  // No destination layer exists so layer recall method cannot be used and
718  // should be reset
719  resetRecallInformation(cache);
720 
721  return returnState;
722 }

◆ extrapolateToDestinationLayer()

Trk::MultiComponentState Trk::GsfExtrapolator::extrapolateToDestinationLayer ( const EventContext &  ctx,
Cache &  cache,
const MultiComponentState &  multiComponentState,
const Surface &  surface,
const Layer &  layer,
const Layer *  startLayer,
Trk::PropDirection  direction,
const BoundaryCheck &  boundaryCheck,
Trk::ParticleHypothesis  particleHypothesis 
) const
private

Final extrapolation step to a destination layer.

Definition at line 872 of file GsfExtrapolator.cxx.

882 {
883 
884  const Trk::MultiComponentState* initialState = &multiComponentState;
885  const Trk::TrackParameters* combinedState = nullptr;
886 
887  // Propagate over all components
888  Trk::MultiComponentState destinationState =
889  m_propagator->multiStatePropagate(ctx,
890  multiComponentState,
891  surface,
892  m_fieldProperties,
893  direction,
894  boundaryCheck,
895  particleHypothesis);
896 
897  // Require a fall-back if the initial state is close to the destination
898  // surface then a fall-back solution is required
899 
900  if (destinationState.empty()) {
901  combinedState = initialState->begin()->params.get();
902  if (surface.isOnSurface(
903  combinedState->position(), true, 0.5 * layer.thickness())) {
904  destinationState = m_propagator->multiStatePropagate(ctx,
905  *initialState,
906  surface,
907  m_fieldProperties,
908  Trk::anyDirection,
909  boundaryCheck,
910  particleHypothesis);
911  }
912  combinedState = nullptr;
913  if (destinationState.empty()) {
914  return {};
915  }
916  }
917 
918  /* ----------------------------------------
919  Material effects
920  ---------------------------------------- */
921 
922  Trk::MultiComponentState updatedState{};
923  if (startLayer != &layer) {
924  updatedState = m_materialUpdator->preUpdate(cache.m_materialEffectsCaches,
925  destinationState,
926  layer,
927  direction,
928  particleHypothesis);
929  }
930 
931  if (updatedState.empty()) {
932  return destinationState;
933  }
934 
935  return updatedState;
936 }

◆ extrapolateToIntermediateLayer()

Trk::MultiComponentState Trk::GsfExtrapolator::extrapolateToIntermediateLayer ( const EventContext &  ctx,
Cache &  cache,
const MultiComponentState &  multiComponentState,
const Layer &  layer,
const TrackingVolume &  trackingVolume,
Trk::PropDirection  direction,
Trk::ParticleHypothesis  particleHypothesis,
bool  perpendicularCheck = true 
) const
private

Single extrapolation step to an intermediate layer.

Definition at line 801 of file GsfExtrapolator.cxx.

810 {
811  const Trk::MultiComponentState* initialState = &multiComponentState;
812 
813  // Propagate over all components
814  Trk::MultiComponentState destinationState =
815  m_propagator->multiStatePropagate(ctx,
816  *initialState,
817  layer.surfaceRepresentation(),
818  m_fieldProperties,
819  direction,
820  true,
821  particleHypothesis);
822 
823  if (destinationState.empty()) {
824  return {};
825  }
826 
827  // the layer has been intersected
828  // ------------------------------------------------------------------------
829  // check for radial direction change
830  // ---------------------------------------------------------------------
831  int rDirection = radialDirection(multiComponentState, direction);
832  int newrDirection = radialDirection(destinationState, direction);
833  if (newrDirection != rDirection && doPerpCheck) {
834  // it is unfortunate that the cancelling could invalidate the material
835  // collection
836  // reset the nextParameters if the radial change is not allowed
837  // resetting is ok - since the parameters are in the garbage bin already
838  if (!radialDirectionCheck(ctx,
839  *m_propagator,
840  multiComponentState,
841  destinationState,
842  trackingVolume,
843  m_fieldProperties,
844  direction,
845  particleHypothesis)) {
846  return {};
847  }
848  }
849 
850  /* -------------------------------------
851  Material effects
852  ------------------------------------- */
853 
854  Trk::MultiComponentState updatedState =
855  m_materialUpdator->update(cache.m_materialEffectsCaches,
856  destinationState,
857  layer,
858  direction,
859  particleHypothesis);
860 
861  if (updatedState.empty()) {
862  return destinationState;
863  }
864 
865  return updatedState;
866 }

◆ extrapolateToVolumeBoundary()

void Trk::GsfExtrapolator::extrapolateToVolumeBoundary ( const EventContext &  ctx,
Cache &  cache,
const MultiComponentState &  multiComponentState,
const Layer *  layer,
const TrackingVolume &  trackingVolume,
Trk::PropDirection  direction,
Trk::ParticleHypothesis  particleHypothesis 
) const
private

Two primary private extrapolation methods.

  • extrapolateToVolumeBoundary : extrapolates to the exit of the destination tracking volume The exit layer surface will be hit in this method.
  • extrapolateInsideVolume : extrapolates to the destination surface in the final tracking volume

Definition at line 473 of file GsfExtrapolator.cxx.

481 {
482 
483  //We 1st point to the input.
484  //As we move on we might change to point to the
485  //last element held by
486  //cache.m_mcsRecycleBin
487  cache.m_stateAtBoundary = &multiComponentState;
488 
489  const Trk::TrackParameters* combinedState =
490  cache.m_stateAtBoundary->begin()->params.get();
491  const Trk::Layer* associatedLayer = layer;
492 
493  if (!associatedLayer) {
494  // Get entry layer but do not use it as it should have already be hit if it
495  // was desired
496  associatedLayer = trackingVolume.associatedLayer(combinedState->position());
497  associatedLayer = associatedLayer
498  ? associatedLayer
499  : trackingVolume.nextLayer(
500  combinedState->position(),
501  direction * combinedState->momentum().unit(),
502  associatedLayer);
503  }
504  // Only loop over layers if they can be found within the tracking volume
505  else if (trackingVolume.confinedLayers() &&
506  associatedLayer->layerMaterialProperties()) {
507  Trk::MultiComponentState updatedState = m_materialUpdator->postUpdate(
508  cache.m_materialEffectsCaches,
509  *(cache.m_stateAtBoundary),
510  *layer,
511  direction,
512  particleHypothesis);
513 
514  if (!updatedState.empty()) {
515  addMultiComponentToCache(cache,std::move(updatedState));
516  }
517  }
518 
519  // If an associated surface can be found, extrapolation within the tracking
520  // volume is mandatory This will take extrapolate to the last layer in the
521  // volume
522  if (associatedLayer) {
523  Trk::MultiComponentState nextState = extrapolateFromLayerToLayer(
524  ctx,
525  cache,
526  *(cache.m_stateAtBoundary),
527  trackingVolume,
528  associatedLayer,
529  nullptr,
530  direction,
531  particleHypothesis);
532  // if we have a next State update the currentState
533  if (!nextState.empty()) {
534  addMultiComponentToCache(cache,std::move(nextState));
535  }
536  }
537 
538  /* =============================================
539  Find the boundary surface using the navigator
540  ============================================= */
541 
542  Trk::NavigationCell nextNavigationCell(nullptr, nullptr);
543 
544  combinedState = cache.m_stateAtBoundary->begin()->params.get();
545 
546  const Trk::TrackingVolume* nextVolume = nullptr;
547  const Trk::TrackParameters* navigationParameters =
548  cache.m_navigationParameters
549  ? cache.m_navigationParameters.get()
550  : combinedState;
551 
552  nextNavigationCell = m_navigator->nextTrackingVolume(
553  ctx, *m_propagator, *navigationParameters, direction, trackingVolume);
554 
555  nextVolume = nextNavigationCell.nextVolume;
556 
557  std::unique_ptr<Trk::TrackParameters> nextNavigationParameters =
558  std::move(nextNavigationCell.parametersOnBoundary);
559 
560  if (!nextVolume) {
561  // Reset the layer recall
562  resetRecallInformation(cache);
563  }
564 
565  if (useBoundaryMaterialUpdate) {
566  // Check for two things:
567  // 1. If the next volume was found
568  // 2. If there is material associated with the boundary layer.
569  // If so, apply material effects update.
570 
571  // Get layer associated with boundary surface.
572  const Trk::Layer* layerAtBoundary =
573  (nextNavigationCell.parametersOnBoundary)
574  ? (nextNavigationCell.parametersOnBoundary->associatedSurface())
575  .materialLayer()
576  : nullptr;
577  Trk::MultiComponentState matUpdatedState{};
578  if (nextVolume && layerAtBoundary) {
579  if (layerAtBoundary->layerMaterialProperties()) {
580  matUpdatedState = m_materialUpdator->postUpdate(
581  cache.m_materialEffectsCaches,
582  *(cache.m_stateAtBoundary),
583  *layerAtBoundary,
584  direction,
585  particleHypothesis);
586  }
587  }
588 
589  // If state has changed due to boundary material, modify state, parameters
590  // accordingly.
591  if (!matUpdatedState.empty()) {
592  addMultiComponentToCache(cache, std::move(matUpdatedState));
593  nextNavigationParameters =
594  cache.m_stateAtBoundary->begin()->params->uniqueClone();
595  }
596  }
597  // Update the rest of the boundary information in the cache
598  cache.m_navigationParameters = std::move(nextNavigationParameters);
599  cache.m_trackingVolume = nextVolume;
600 }

◆ initialiseNavigation()

void Trk::GsfExtrapolator::initialiseNavigation ( const EventContext &  ctx,
Cache &  cache,
const MultiComponentState &  initialState,
const Surface &  surface,
const Layer *&  associatedLayer,
const TrackingVolume *&  currentVolume,
const TrackingVolume *&  destinationVolume,
std::unique_ptr< TrackParameters > &  referenceParameters,
Trk::PropDirection  direction 
) const
private

Method to initialise navigation parameters including starting state, layer and volume, and destination volume.

Definition at line 942 of file GsfExtrapolator.cxx.

952 {
953 
954  // Empty the garbage bin
955  emptyRecycleBins(cache);
956  const Trk::TrackParameters* combinedState =
957  multiComponentState.begin()->params.get();
958  /* =============================================
959  Look for current volume
960  ============================================= */
961  // 1. See if the current layer is associated with a tracking volume
962 
963  const Trk::Surface* associatedSurface = &(combinedState->associatedSurface());
964  currentLayer =
965  associatedSurface ? associatedSurface->associatedLayer() : currentLayer;
966  currentVolume =
967  currentLayer ? currentLayer->enclosingTrackingVolume() : currentVolume;
968 
969  // If the association method failed then try the recall method
970 
971  if (!currentVolume && associatedSurface == cache.m_recallSurface) {
972  currentVolume = cache.m_recallTrackingVolume;
973  currentLayer = cache.m_recallLayer;
974  }
975  // Global search method if this fails
976 
977  else if (!currentVolume) {
978  // If the recall method fails then the cashed information needs to be reset
979  resetRecallInformation(cache);
980  currentVolume = m_navigator->volume(ctx, combinedState->position());
981  currentLayer = (currentVolume)
982  ? currentVolume->associatedLayer(combinedState->position())
983  : nullptr;
984  }
985  /* =============================================
986  Determine the resolved direction
987  ============================================= */
988  if (direction == Trk::anyDirection) {
989  referenceParameters =
990  currentVolume
991  ? m_propagator->propagateParameters(
992  ctx, *combinedState, surface, direction, false, m_fieldProperties)
993  : nullptr;
994  // These parameters will need to be deleted later. Add to list of garbage to
995  // be collected
996  if (referenceParameters) {
997  Amg::Vector3D surfaceDirection(referenceParameters->position() -
998  combinedState->position());
999  direction = (surfaceDirection.dot(combinedState->momentum()) > 0.)
1000  ? Trk::alongMomentum
1001  : Trk::oppositeMomentum;
1002  }
1003  }
1004 
1005  /* =============================================
1006  Look for destination volume
1007  ============================================= */
1008 
1009  // 1. See if the destination layer is associated with a tracking volume
1010  destinationVolume = surface.associatedLayer()
1011  ? surface.associatedLayer()->enclosingTrackingVolume()
1012  : nullptr;
1013 
1014  // 2. See if there is a cashed recall surface
1015  if (!destinationVolume && &surface == cache.m_recallSurface) {
1016  destinationVolume = cache.m_recallTrackingVolume;
1017  // If no reference parameters are defined, then determine them
1018  if (!referenceParameters) {
1019  referenceParameters =
1020  currentVolume
1021  ? m_propagator->propagateParameters(
1022  ctx, *combinedState, surface, direction, false, m_fieldProperties)
1023  : nullptr;
1024  }
1025  // 3. Global search
1026  } else {
1027  // If no reference parameters are defined try to determine them
1028  if (!referenceParameters) {
1029  referenceParameters =
1030  currentVolume
1031  ? m_propagator->propagateParameters(
1032  ctx, *combinedState, surface, direction, false, m_fieldProperties)
1033  : nullptr;
1034  }
1035  // Global search of tracking geometry to find the destination volume
1036  destinationVolume = m_navigator->volume(
1037  ctx, referenceParameters ? referenceParameters->position()
1038  : surface.globalReferencePoint());
1039  }
1040 }

◆ initialize()

StatusCode Trk::GsfExtrapolator::initialize ( )
finaloverridevirtual

AlgTool initialise method.

Definition at line 158 of file GsfExtrapolator.cxx.

159 {
160 
161  ATH_CHECK(m_propagator.retrieve());
162  ATH_CHECK(m_navigator.retrieve());
163  ATH_CHECK(m_materialUpdator.retrieve());
164 
165  m_fieldProperties = m_fastField
166  ? Trk::MagneticFieldProperties(Trk::FastField)
167  : Trk::MagneticFieldProperties(Trk::FullField);
168 
169  return StatusCode::SUCCESS;
170 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ interfaceID()

static const InterfaceID& Trk::IMultiStateExtrapolator::interfaceID ( )
inlinestaticinherited

AlgTool interface method.

Definition at line 82 of file IMultiStateExtrapolator.h.

83  {
84  return IID_IMultiStateExtrapolator;
85  };

◆ msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )
overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_fastField

bool Trk::GsfExtrapolator::m_fastField
private

Definition at line 190 of file GsfExtrapolator.h.

◆ m_fieldProperties

Trk::MagneticFieldProperties Trk::GsfExtrapolator::m_fieldProperties
private

Definition at line 191 of file GsfExtrapolator.h.

◆ m_materialUpdator

ToolHandle<IMaterialMixtureConvolution> Trk::GsfExtrapolator::m_materialUpdator
private
Initial value:
{
this,
"GsfMaterialConvolution",
"Trk::GsfMaterialMixtureConvolution/GsfMaterialMixtureConvolution",
""
}

Switch to turn on/off surface based material effects.

Definition at line 182 of file GsfExtrapolator.h.

◆ m_navigator

ToolHandle<INavigator> Trk::GsfExtrapolator::m_navigator
private
Initial value:
{ this,
"Navigator",
"Trk::Navigator/Navigator",
"" }

Definition at line 178 of file GsfExtrapolator.h.

◆ m_propagator

ToolHandle<IPropagator> Trk::GsfExtrapolator::m_propagator { this, "Propagator", "", "" }
private

Definition at line 177 of file GsfExtrapolator.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
Trk::anyDirection
@ anyDirection
Definition: PropDirection.h:22
Trk::GsfExtrapolator::m_navigator
ToolHandle< INavigator > m_navigator
Definition: GsfExtrapolator.h:178
Trk::GsfExtrapolator::extrapolateDirectlyImpl
MultiComponentState extrapolateDirectlyImpl(const EventContext &ctx, const MultiComponentState &, const Surface &, PropDirection direction=anyDirection, const BoundaryCheck &boundaryCheck=true, ParticleHypothesis particleHypothesis=nonInteracting) const
Implementation of extrapolation without material effects.
Definition: GsfExtrapolator.cxx:452
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
Trk::GsfExtrapolator::extrapolateInsideVolume
MultiComponentState extrapolateInsideVolume(const EventContext &ctx, Cache &cache, const MultiComponentState &, const Surface &, const Layer *, const TrackingVolume &, PropDirection direction, const BoundaryCheck &boundaryCheck, ParticleHypothesis particleHypothesis) const
Definition: GsfExtrapolator.cxx:606
Trk::MagneticFieldProperties
Definition: MagneticFieldProperties.h:31
Trk::ParametersBase::position
const Amg::Vector3D & position() const
Access method for the position.
Trk::oppositeMomentum
@ oppositeMomentum
Definition: PropDirection.h:21
Trk::ParametersBase::associatedSurface
virtual const Surface & associatedSurface() const override=0
Access to the Surface associated to the Parameters.
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
Trk::ParametersBase::uniqueClone
std::unique_ptr< ParametersBase< DIM, T > > uniqueClone() const
clone method for polymorphic deep copy returning unique_ptr; it is not overriden, but uses the existi...
Definition: ParametersBase.h:97
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
Trk::alongMomentum
@ alongMomentum
Definition: PropDirection.h:20
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
flat_set
boost::container::flat_set< Key > flat_set
Definition: CheckConfig.cxx:11
Trk::GsfExtrapolator::m_propagator
ToolHandle< IPropagator > m_propagator
Definition: GsfExtrapolator.h:177
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
Trk::GsfExtrapolator::initialiseNavigation
void initialiseNavigation(const EventContext &ctx, Cache &cache, const MultiComponentState &initialState, const Surface &surface, const Layer *&associatedLayer, const TrackingVolume *&currentVolume, const TrackingVolume *&destinationVolume, std::unique_ptr< TrackParameters > &referenceParameters, PropDirection direction) const
Method to initialise navigation parameters including starting state, layer and volume,...
Definition: GsfExtrapolator.cxx:942
Trk::FastField
@ FastField
call the fast field access method of the FieldSvc
Definition: MagneticFieldMode.h:20
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
test_pyathena.parent
parent
Definition: test_pyathena.py:15
Trk::MultiComponentState
std::vector< ComponentParameters > MultiComponentState
Definition: ComponentParameters.h:27
Trk::Layer::nextLayer
const Layer * nextLayer(const Amg::Vector3D &gp, const Amg::Vector3D &udir) const
getting the next/previous Layer if registered - unit for direction vector required
Definition: Layer.cxx:175
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Trk::GsfExtrapolator::m_materialUpdator
ToolHandle< IMaterialMixtureConvolution > m_materialUpdator
Switch to turn on/off surface based material effects.
Definition: GsfExtrapolator.h:182
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
Trk::GsfExtrapolator::m_fieldProperties
Trk::MagneticFieldProperties m_fieldProperties
Definition: GsfExtrapolator.h:191
Trk::ParametersBase
Definition: ParametersBase.h:55
Trk::FullField
@ FullField
Field is set to be realistic, but within a given Volume.
Definition: MagneticFieldMode.h:21
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
Trk
Ensure that the ATLAS eigen extensions are properly loaded.
Definition: FakeTrackBuilder.h:9
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
Trk::nonInteracting
@ nonInteracting
Definition: ParticleHypothesis.h:25
Trk::GsfExtrapolator::extrapolateToVolumeBoundary
void extrapolateToVolumeBoundary(const EventContext &ctx, Cache &cache, const MultiComponentState &, const Layer *, const TrackingVolume &, PropDirection direction, ParticleHypothesis particleHypothesis) const
Two primary private extrapolation methods.
Definition: GsfExtrapolator.cxx:473
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
Trk::NavigationCell
useful struct for a single navigation cell
Definition: INavigator.h:38
Trk::Surface::associatedLayer
const Trk::Layer * associatedLayer() const
return the associated Layer
Trk::ParametersBase::momentum
const Amg::Vector3D & momentum() const
Access method for the momentum.
Trk::GsfExtrapolator::extrapolateToDestinationLayer
MultiComponentState extrapolateToDestinationLayer(const EventContext &ctx, Cache &cache, const MultiComponentState &, const Surface &, const Layer &, const Layer *, PropDirection direction, const BoundaryCheck &boundaryCheck, ParticleHypothesis particleHypothesis) const
Final extrapolation step to a destination layer.
Definition: GsfExtrapolator.cxx:872
a
TList * a
Definition: liststreamerinfos.cxx:10
h
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
Trk::TrackingVolume::nextVolume
const TrackingVolume * nextVolume(const Amg::Vector3D &gp, const Amg::Vector3D &dir, PropDirection pDir=alongMomentum) const
Return the next volume along the navigation stream.
Definition: TrackingVolume.cxx:760
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
Trk::Layer::enclosingTrackingVolume
const TrackingVolume * enclosingTrackingVolume() const
get the confining TrackingVolume
Trk::Layer::layerMaterialProperties
const LayerMaterialProperties * layerMaterialProperties() const
getting the LayerMaterialProperties including full/pre/post update
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
Trk::Surface
Definition: Tracking/TrkDetDescr/TrkSurfaces/TrkSurfaces/Surface.h:75
Trk::TrackingVolume
Definition: TrackingVolume.h:121
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
mag
Scalar mag() const
mag method
Definition: AmgMatrixBasePlugin.h:25
Trk::GsfExtrapolator::extrapolateToIntermediateLayer
MultiComponentState extrapolateToIntermediateLayer(const EventContext &ctx, Cache &cache, const MultiComponentState &, const Layer &, const TrackingVolume &, PropDirection direction, ParticleHypothesis particleHypothesis, bool perpendicularCheck=true) const
Single extrapolation step to an intermediate layer.
Definition: GsfExtrapolator.cxx:801
Trk::GsfExtrapolator::m_fastField
bool m_fastField
Definition: GsfExtrapolator.h:190
Trk::GsfExtrapolator::extrapolateImpl
MultiComponentState extrapolateImpl(const EventContext &ctx, Cache &cache, const MultiComponentState &, const Surface &, PropDirection direction, const BoundaryCheck &boundaryCheck, ParticleHypothesis particleHypothesis) const
Implementation of main extrapolation method.
Definition: GsfExtrapolator.cxx:243
fitman.k
k
Definition: fitman.py:528
Trk::Layer
Definition: Layer.h:73
Trk::GsfExtrapolator::extrapolateFromLayerToLayer
MultiComponentState extrapolateFromLayerToLayer(const EventContext &ctx, Cache &cache, const MultiComponentState &, const TrackingVolume &, const Layer *startLayer, const Layer *destinationLayer, PropDirection direction, ParticleHypothesis particleHypothesis) const
Additional private extrapolation methods.
Definition: GsfExtrapolator.cxx:728
Generated on Fri Jun 28 2024 22:31:10 for ATLAS Offline Software by   doxygen 1.8.18