Class Acts::Navigator

class Navigator

Navigator class.

This is an Actor to be added to the ActorList in order to navigate through the static tracking geometry setup.

The current navigation stage is cached in the state struct and updated when necessary. If any surface in the extrapolation flow is hit, it is set to the propagation satate, such that other actors can deal wit it. This navigation actor thus always needs to run first! It does two things: it figures out the order of volumes, layers and surfaces.

The current target surface is the surface pointed to by of the index for the surfaces, layers or volume boundaries. If a surface is found, the state.navigation.currentSurface pointer is set. This enables subsequent actors to react. Secondly, this actor uses the ordered indices to figure out which surface, layer or volume boundary is supposed to be hit next. It then sets the maximum step size to the path length found out by straight line intersection. If the state is not on surface, it also re-computes the step size, to make sure we end up at the desired surface.

Public Types

using ExternalSurfaces = std::multimap<uint64_t, GeometryIdentifier>

using NavigationBoundaries = boost::container::small_vector<BoundaryIntersection, 4>

using NavigationLayers = boost::container::small_vector<LayerIntersection, 10>

using NavigationSurfaces = boost::container::small_vector<SurfaceIntersection, 10>

enum Stage

The navigation stage.

Values:

enumerator undefined

enumerator surfaceTarget

enumerator layerTarget

enumerator boundaryTarget

using Surfaces = std::vector<const Surface*>

Public Functions

inline explicit Navigator(Config cfg, std::shared_ptr<const Logger> _logger = getDefaultLogger("Navigator", Logging::Level::INFO))

Constructor with configuration object.

Parameters

• cfg – The navigator configuration

• _logger – a logger instance

inline const Surface *currentSurface(const State &state) const

inline void currentSurface(State &state, const Surface *surface) const

inline const TrackingVolume *currentVolume(const State &state) const

inline const IVolumeMaterial *currentVolumeMaterial(const State &state) const

inline void insertExternalSurface(State &state, GeometryIdentifier geoid) const

inline State makeState(const Surface *startSurface, const Surface *targetSurface) const

inline bool navigationBreak(const State &state) const

inline void navigationBreak(State &state, bool navigationBreak) const

inline void resetState(State &state, const GeometryContext &geoContext, const Vector3 &pos, const Vector3 &dir, NavigationDirection navDir, const Surface *ssurface, const Surface *tsurface) const

Reset state.

Parameters

• state – is the state

• geoContext – is the geometry context

• pos – is the global position

• dir – is the momentum direction

• navDir – is the navigation direction

• ssurface – is the new starting surface

• tsurface – is the target surface

inline const Surface *startSurface(const State &state) const

template<typename propagator_state_t, typename stepper_t>
inline void status(propagator_state_t &state, const stepper_t &stepper) const

Navigator status call, will be called in two modes.

(a) It initializes the Navigation stream if start volume is not yet defined:

• initialize the volume

• establish the start layer and start volume

• set the current surface to the start surface

(b) It establishes the currentSurface status during the propagation flow, currentSurface can be

• surfaces still to be handled within a layer

• layers still to be handled within a volume

• boundaries still to be handled to exit a volume

Template Parameters

• propagator_state_t – is the type of Propagatgor state

• stepper_t – is the used type of the Stepper by the Propagator

Parameters

• state – [inout] is the mutable propagator state object

• stepper – [in] Stepper in use

template<typename propagator_state_t, typename stepper_t>
inline void target(propagator_state_t &state, const stepper_t &stepper) const

Navigator target call.

Call options (a) there are still surfaces to be resolved: handle those (b) there no surfaces but still layers to be resolved, handle those (c) there are no surfaces nor layers to be resolved, handle boundary

Template Parameters

• propagator_state_t – is the type of Propagatgor state

• stepper_t – is the used type of the Stepper by the Propagator

Parameters

• state – [inout] is the mutable propagator state object

• stepper – [in] Stepper in use

inline bool targetReached(const State &state) const

inline void targetReached(State &state, bool targetReached) const

inline const Surface *targetSurface(const State &state) const

struct Config

Public Members

BoundaryCheck boundaryCheckLayerResolving = true

Wether to perform boundary checks for layer resolving (improves navigation for bended tracks)

bool resolveMaterial = true

stop at every material surface (whether it is passive or not)

bool resolvePassive = false

stop at every surface regardless what it is

bool resolveSensitive = true

Configuration for this Navigator stop at every sensitive surface (whether it has material or not)

double tolerance = s_onSurfaceTolerance

The tolerance used to defined “reached”.

std::shared_ptr<const TrackingGeometry> trackingGeometry = {nullptr}

Tracking Geometry for this Navigator.

struct State

Nested State struct.

It acts as an internal state which is created for every propagation/extrapolation step and keep thread-local navigation information

Public Functions

inline auto navBoundary() const

inline auto navLayer() const

inline auto navSurface() const

Public Members

const Surface *currentSurface = nullptr

Navigation state - external state: the current surface.

const TrackingVolume *currentVolume = nullptr

Navigation state: the current volume.

ExternalSurfaces externalSurfaces = {}

Externally provided surfaces - these are tried to be hit.

bool forceIntersectBoundaries = false

Force intersection with boundaries.

bool lastHierarchySurfaceReached = false

Indicator that the last VolumeHierarchy surface was reached skip the next layer targeting to the next boundary/volume.

NavigationBoundaries navBoundaries = {}

the vector of boundary surfaces to work through

std::size_t navBoundaryIndex = navBoundaries.size()

the current boundary index of the navigation state

bool navigationBreak = false

Navigation state : a break has been detected.

Stage navigationStage = Stage::undefined

std::size_t navLayerIndex = navLayers.size()

the current layer index of the navigation state

NavigationLayers navLayers = {}

the vector of navigation layers to work through

std::size_t navSurfaceIndex = navSurfaces.size()

the current surface index of the navigation state

NavigationSurfaces navSurfaces = {}

the vector of navigation surfaces to work through

const Layer *startLayer = nullptr

Navigation state: the start layer.

bool startLayerResolved = false

Indicator for start layer treatment.

const Surface *startSurface = nullptr

Navigation state: the start surface.

const TrackingVolume *startVolume = nullptr

Navigation state: the start volume.

const Layer *targetLayer = nullptr

Navigation state: the target layer.

bool targetReached = false

Indicator if the target is reached.

const Surface *targetSurface = nullptr

Navigation state: the target surface.

const TrackingVolume *targetVolume = nullptr

Navigation state: the target volume.

const TrackingVolume *worldVolume = nullptr

Navigation sate: the world volume.