Namespace Acts::Experimental¶

namespace Experimental

Typedefs

using DetectorBlock = std::tuple<DetectorVolumes, ProtoContainer>: Current block (volumes and shell)

using DetectorBlockBuilder = std::function<void(DetectorBlock&, const GeometryContext&, Acts::Logging::Level)>: The detector builder function.

using DetectorVolumes = std::vector<std::shared_ptr<DetectorVolume>>: Current volumes (connected)

using DetectorVolumeUpdator = OwningDelegate<void(const GeometryContext &gctx, NavigationState &nState), INavigationDelegate>

Declare a Detctor Volume finding or switching delegate.

Param gctx: is the current geometry context
Param nState: [in, out] is the navigation state to be updated
Return: the new DetectorVolume into which one changes at this switch

using IndexedDetectorVolumeImpl = IndexedUpdatorImpl<grid_type, IndexedDetectorVolumeExtractor, DetectorVolumeFiller>

An indexed volume implementation access.

Template Parameters: grid_type – is the grid type used for this

using IndexedSurfacesAllPortalsImpl = ChainedUpdatorImpl<AllPortalsImpl, indexed_updator<grid_type>>

An indexed surface implementation with portal access.

Template Parameters: inexed_updator – is the updator for the indexed surfaces

using IndexedSurfacesImpl = IndexedUpdatorImpl<grid_type, IndexedSurfacesExtractor, SurfacesFiller>

An indexed surface implementation access.

Template Parameters: grid_type – is the grid type used for this indexed lookup

using PortalGenerator = Delegate<std::vector<std::shared_ptr<Portal>>(const Transform3&, const VolumeBounds&, const std::shared_ptr<DetectorVolume>&)>: The Portal generator definition.

using ProtoContainer = std::map<unsigned int, std::shared_ptr<Portal>>: Current shell (i.e. outside portals)

using SingleIndex = std::size_t

using SurfaceCandidatesUpdator = OwningDelegate<void(const GeometryContext &gctx, NavigationState &nState), INavigationDelegate>

Declare an updator for the local navigation, i.e.

the navigation inside a detector volume. This can be called either directly after a volume switch or in order to update within a volume after some progression

This delegate dispatches the local navigation action to a dedicated struct or function that is optimised for the given environment.

Note

it relies on the detector volume to be set to the state Memory managed navigation state updator

Param gctx: is the current geometry context
Param nState: [in,out] is the navigation state to be updated

using VariableBoundAxis = Acts::detail::Axis<Acts::detail::AxisType::Variable, Acts::detail::AxisBoundaryType::Bound>

using VariableBoundIndexGrid1 = Acts::detail::Grid<SingleIndex, VariableBoundAxis>

Enums

enum GsfError

Values:

enumerator StartParametersNotOnStartSurface

enumerator StartParametersHaveNoCovariance

enumerator NoMeasurementStatesCreatedForward

enumerator NoMeasurementStatesCreatedBackward

enumerator NoMeasurementStatesCreatedFinal

Functions

PortalGenerator defaultPortalAndSubPortalGenerator(): Create a default portal generator that connects to the static method.

Note

parameters are ignored in this case

PortalGenerator defaultPortalGenerator(): Create a default portal generator that connects to the static method.

std::vector<std::shared_ptr<Portal>> generatePortals(const Transform3 &dTransform, const VolumeBounds &dBounds, const std::shared_ptr<DetectorVolume> &dVolume) noexcept(false)

Generator function for creation of portal surfaces.

Parameters

dTransform – a contextually resolved transform
dBounds – the detecor volume bounds
dVolume – the reference to the detector volume which generates this volume

Returns

a vector of newly created portals with registered inside volume

std::vector<std::shared_ptr<Portal>> generatePortalsUpdateInternals(const Transform3 &dTransform, const VolumeBounds &dBounds, const std::shared_ptr<DetectorVolume> &dVolume) noexcept(false)

Calls the portal generation and adds registration to sub portals.

This code is split off the PortalGenerator code in order to allow unit testing of the portal generation without detector volume construction

Parameters

dTransform – a contextually resolved transform
dBounds – the detecor volume bounds
dVolume – the reference to the detector volume which generates this volume

Returns

a vector of newly created portals with registered inside volume

std::error_code make_error_code(GsfError e)

AtlasBetheHeitlerApprox<6, 5> makeDefaultBetheHeitlerApprox()

Creates a AtlasBetheHeitlerApprox object based on an ATLAS configuration, that are stored as static data in the source code.

This may not be an optimal configuration, but should allow to run the GSF without the need to load files

static inline SurfaceCandidatesUpdator tryAllPortals()

Generate a provider for all portals.

Returns: a connected navigationstate updator

static inline SurfaceCandidatesUpdator tryAllPortalsAndSurfaces()

Generate a provider for all portals and Surfacess.

Note

this is a try-and error navigation, not recommended for production setup with many surfaces

Returns: a connected navigationstate updator

static inline DetectorVolumeUpdator tryAllSubVolumes(): Generate a delegate to try all sub volumes.

static inline DetectorVolumeUpdator tryNoVolumes(): Generate a delegate to try no volume.

static inline DetectorVolumeUpdator tryRootVolumes(): Generate a delegate to try the root volumes.

static inline DetectorVolumeUpdator unconnectedUpdator(): A dummy constructed updator.

static inline void updateCandidates(const GeometryContext &gctx, NavigationState &nState)

Helper method to update the candidates (portals/surfaces), this can be called for initial surface/portal estimation, but also during the navigation to update the current list of candidates.

Parameters

gctx – is the Geometry context of this call
nState – [in,out] is the navigation state to be updated

struct AdditionalSurfacesImpl : public Acts::Experimental::INavigationDelegate

#include <Acts/Navigation/SurfaceCandidatesUpdators.hpp>

This holds and extracts a collection of surfaces without much checking, this could be e.g.

support surfaces for layer structures, e.g.

Public Functions

inline void update([[maybe_unused]] const GeometryContext &gctx, NavigationState &nState) const

Extract the sub volumes from the volume.

Parameters

gctx – the geometry contextfor this extraction call (ignored)
nState – is the navigation state

Public Members

std::vector<const Surface*> surfaces = {}: The volumes held by this collection.

struct AllPortalsAndSurfacesImpl : public Acts::Experimental::INavigationDelegate

#include <Acts/Navigation/SurfaceCandidatesUpdators.hpp>

Public Functions

inline void update(const GeometryContext &gctx, NavigationState &nState) const

An ordered list of portals and surfaces provider.

Note

that the intersections are ordered, such that the smallest intersection pathlength >= overstep tolerance is the lowest

Parameters

gctx – is the Geometry context of this call
nState – is the navigation state to be updated

Returns

an ordered list of portal and surface candidates

struct AllPortalsExtractor

#include <Acts/Detector/DetectorVolume.hpp>

Helper extractors: all portals.

Public Static Functions

static inline const std::vector<const Portal*> extract([[maybe_unused]] const GeometryContext &gctx, const NavigationState &nState)

Extract the portals from the volume.

Parameters

gctx – the geometry contextfor this extraction call
nState – is the current navigation state

Returns

a vector of raw Portal pointers

struct AllPortalsImpl : public Acts::Experimental::INavigationDelegate

#include <Acts/Navigation/SurfaceCandidatesUpdators.hpp>

Public Functions

inline void update(const GeometryContext &gctx, NavigationState &nState) const

A ordered portal provider.

Note

that the intersections are ordered, such that the smallest intersection pathlength >= overstep tolerance is the lowest

Parameters

gctx – is the Geometry context of this call
nState – is the navigation state to be updated

Returns

an ordered list of portal candidates

struct AllSubVolumesExtractor

#include <Acts/Detector/DetectorVolume.hpp>

Helper extractors: all sub volumes of a volume.

Public Static Functions

static inline const std::vector<const DetectorVolume*> extract([[maybe_unused]] const GeometryContext &gctx, const NavigationState &nState, [[maybe_unused]] const std::vector<size_t> &indices = {})

Extract the sub volumes from the volume.

Parameters

gctx – the geometry contextfor this extraction call
nState – is the current navigation state
indices – are access indices into the volume store (ignored)

Returns

a vector of raw DetectorVolume pointers

struct AllSurfacesExtractor

#include <Acts/Detector/DetectorVolume.hpp>

Helper extractors: all surfaces.

Public Static Functions

static inline const std::vector<const Surface*> extract([[maybe_unused]] const GeometryContext &gctx, const NavigationState &nState, [[maybe_unused]] const std::vector<size_t> &indices = {})

Extract the surfaces from the volume.

Parameters

gctx – the geometry contextfor this extraction call
nState – is the current navigation state
indices – is an ignored index vector

Returns

a vector of raw Surface pointers

template<int NComponents, int PolyDegree> class AtlasBetheHeitlerApprox

#include <Acts/TrackFitting/BetheHeitlerApprox.hpp>

This class approximates the Bethe-Heitler distribution as a gaussian mixture.

To enable an approximation for continuous input variables, the weights, means and variances are internally parametrized as a Nth order polynomial.

Public Types

using Data = std::array<PolyData, NComponents>

Public Functions

inline constexpr AtlasBetheHeitlerApprox(const Data &low_data, const Data &high_data, bool low_transform, bool high_transform)

Construct the Bethe-Heitler approximation description.

Additional to the coefficients of the polynomials, the information whether these values need to be transformed beforehand must be given (see ATLAS code).

Parameters

low_data – data for the lower x/x0 range
high_data – data for the higher x/x0 range
low_transform – whether the low data need to be transformed
high_transform – whether the high data need to be transformed

inline auto mixture(ActsScalar x) const

Generates the mixture from the polynomials and reweights them, so that the sum of all weights is 1.

Parameters: x – pathlength in terms of the radiation length

inline constexpr auto numComponents() const: Returns the number of components the returned mixture will have.

inline constexpr bool validXOverX0(ActsScalar x) const

Checks if an input is valid for the parameterization.

Parameters: x – pathlength in terms of the radiation length

Public Static Functions

static inline auto loadFromFiles(const std::string &low_parameters_path, const std::string &high_parameters_path)

Loads a parameterization from a file according to the Atlas file description.

Parameters

low_parameters_path – Path to the foo.par file that stores the parameterization for low x/x0
high_parameters_path – Path to the foo.par file that stores the parameterization for high x/x0

Public Static Attributes

static constexpr double higherLimit = 0.20

static constexpr double lowerLimit = 0.10

static constexpr double noChangeLimit = 0.0001

static constexpr double singleGaussianLimit = 0.002

struct PolyData

#include <Acts/TrackFitting/BetheHeitlerApprox.hpp>

Public Members

std::array<ActsScalar, PolyDegree + 1> meanCoeffs

std::array<ActsScalar, PolyDegree + 1> varCoeffs

std::array<ActsScalar, PolyDegree + 1> weightCoeffs

struct BetheHeitlerApproxSingleCmp

#include <Acts/TrackFitting/BetheHeitlerApprox.hpp>

This class approximates the Bethe-Heitler with only one component.

This is mainly inside AtlasBetheHeitlerApprox, but can also be used as the only component approximation (then probably for debugging)

Public Functions

inline constexpr auto numComponents() const: Returns the number of components the returned mixture will have.

inline constexpr bool validXOverX0(ActsScalar x) const

Checks if an input is valid for the parameterization.

The threshold for x/x0 is 0.002 and orientates on the values used in ATLAS

Public Static Functions

static inline auto mixture(const ActsScalar x)

Returns array with length 1 containing a 1-component-representation of the Bethe-Heitler-Distribution.

Parameters: x – pathlength in terms of the radiation length

struct BoundVolumesGrid1Impl : public Acts::Experimental::INavigationDelegate

#include <Acts/Navigation/DetectorVolumeUpdators.hpp>

This is used for volumes that are indexed in a bound 1-dimensional grid, e.g.

a z-spaced array, or an r-spaced array of volumes.

Public Types

using IndexedUpdator = IndexedUpdatorImpl<VariableBoundIndexGrid1, DetectorVolumesCollection, DetectorVolumeFiller>

Public Functions

inline BoundVolumesGrid1Impl(const std::vector<ActsScalar> &gBoundaries, BinningValue bValue, const std::vector<const DetectorVolume*> &cVolumes, const Transform3 &bTransform = Transform3::Identity()) noexcept(false)

Allowed constructor with explicit arguments.

Parameters

gBoundaries – the grid boundaries
bValue – the binning value
cVolumes – the contained volumes
bTransform – is the optional transform

BoundVolumesGrid1Impl() = delete

inline void update(const GeometryContext &gctx, NavigationState &nState) const

This updator relies on an 1D single index grid.

Parameters

gctx – the geometry context
nState – [in,out] the navigation state to be updated

Public Members

IndexedUpdator indexedUpdator

template<typename ...updators_t> class ChainedUpdatorImpl : public Acts::Experimental::INavigationDelegate

#include <Acts/Navigation/NavigationStateUpdators.hpp>

This is a chained extractor/filler implementation Since there is no control whether it is a static or payload extractor, these have to be provided by a tuple.

Template Parameters: updators_t – the updators that will be called in sequence

Public Functions

inline ChainedUpdatorImpl(const std::tuple<updators_t...> &&upts)

Constructor for chained updators in a tuple, this will unroll the tuple and call them in sequence.

Parameters: upts – the updators to be called in chain

inline void update(const GeometryContext &gctx, NavigationState &nState) const

A combined navigation state updator w/o intersection specifics.

Parameters

gctx – is the Geometry context of this call
nState – the navigation state to which the objects are attached

Public Members

std::tuple<updators_t...> updators: The stored updators.

class CylindricalContainerBuilder : public Acts::Experimental::IDetectorComponentBuilder

#include <Acts/Detector/CylindricalContainerBuilder.hpp>

A dedicated container builder for cylindrical detector containers.

It relies on the detailed implementation of the CylindricalDetectorHelper and allows for DetectorVolume attachment in z/r/phi, such as wrapping of bevelled cylinder objects in z/r

Note

the builder expects a fully consistent set of sub volume builders that will be executed in a chain

Note

allowed BinningValue(s) for the cylindrical container builder are {binZ}, {binR}, {binPhi}, {binZ, binR}, whereas the last option indicates a wrapping setup.

Public Functions

CylindricalContainerBuilder(const Config &cfg, std::unique_ptr<const Logger> logger = getDefaultLogger("CylindricalContainerBuilder", Logging::INFO))

Constructor with configuration arguments.

Parameters

cfg – is the configuration struct
logger – logging instance for screen output

virtual DetectorComponent construct(const GeometryContext &gctx) const final

The final implementation of the cylindrical container builder.

Parameters: gctx – The geometry context for this call
Returns: an outgoing detector component

struct Config

#include <Acts/Detector/CylindricalContainerBuilder.hpp>

Nested configuration object.

Public Members

std::string auxiliary = "": Auxiliary information, mainly for screen output.

std::vector<BinningValue> binning = {}: Binning prescription of attachment.

std::vector<std::shared_ptr<const IDetectorComponentBuilder>> builders = {}: The configured volume builders.

class Detector : public std::enable_shared_from_this<Detector>

#include <Acts/Detector/Detector.hpp>

Public Functions

const DetectorVolumeUpdator &detectorVolumeFinder() const: Const access to the volume finder.

const DetectorVolume *findDetectorVolume(const GeometryContext &gctx, const Vector3 &position) const

Find a volume from a position.

Note

this creates internally a NavigationState object

Parameters

gctx – is the Geometry context of the call
position – is the position of the call

Returns

the volume pointer or nullptr (if outside)

const DetectorVolume *findDetectorVolume(const std::string &name) const

Find a volume by name.

Parameters: name – with which the volume is searched for
Returns: the volume pointer or nullptr (if not found)

std::shared_ptr<Detector> getSharedPtr()

Retrieve a std::shared_ptr for this surface (non-const version)

Note

Will error if this was not created through the makeShared factory since it needs access to the original reference. In C++14 this is undefined behavior (but most likely implemented as a bad_weak_ptr exception), in C++17 it is defined as that exception.

Note

Only call this if you need shared ownership of this object.

Returns: The shared pointer

std::shared_ptr<const Detector> getSharedPtr() const

Retrieve a std::shared_ptr for this surface (const version)

Note

Will error if this was not created through the makeShared factory since it needs access to the original reference. In C++14 this is undefined behavior, but most likely implemented as a bad_weak_ptr exception, in C++17 it is defined as that exception.

Note

Only call this if you need shared ownership of this object.

Returns: The shared pointer

const std::string &name() const: Return the name of the detector.

std::vector<std::shared_ptr<DetectorVolume>> &rootVolumePtrs()

Non-const access to the root volumes.

Returns: the root volume shared pointer

const std::vector<const DetectorVolume*> &rootVolumes() const

Const access to the root volumes.

Returns: a vector to const DetectorVolume raw pointers

void updateDetectorVolume(const GeometryContext &gctx, NavigationState &nState) const

Update the current volume of a given navigation state.

Parameters

gctx – is the Geometry context of the call
nState – [in, out] is the navigation state

void updateDetectorVolumeFinder(DetectorVolumeUpdator detectorVolumeUpdator)

Update the volume finder.

Parameters: detectorVolumeUpdator – the new volume finder

std::vector<std::shared_ptr<DetectorVolume>> &volumePtrs()

Non-const access to the root volume.

Returns: the volumes shared pointer store

const std::vector<const DetectorVolume*> &volumes() const

Const access to sub volumes.

Returns: a vector to const DetectorVolume raw pointers

Public Static Functions

static std::shared_ptr<Detector> makeShared(std::string name, std::vector<std::shared_ptr<DetectorVolume>> rootVolumes, DetectorVolumeUpdator detectorVolumeUpdator): Factory for producing memory managed instances of Detector.

class DetectorBuilder : public Acts::Experimental::IDetectorBuilder

#include <Acts/Detector/DetectorBuilder.hpp>

Standard generic Detector builder that calls the top level component builder and transfers the result into a detector object.

Note

This is the last builder in the chain and the the returned detector object is const and cannot be modified anymore.

Public Functions

DetectorBuilder(const Config &cfg, std::unique_ptr<const Logger> mlogger = getDefaultLogger("DetectorBuilder", Logging::INFO))

Constructor with configuration arguments.

Parameters

cfg – is the configuration struct
mlogger – logging instance for screen output

virtual std::shared_ptr<const Detector> construct(const GeometryContext &gctx) const final

Final implementation of a volume builder that is purely defined by an internal and external structure builder.

Parameters: gctx – The geometry context for this call
Returns: an outgoing detector component

struct Config

#include <Acts/Detector/DetectorBuilder.hpp>

Nested configuration object.

Public Members

std::string auxiliary = "": Auxiliary information.

std::shared_ptr<const IDetectorComponentBuilder> builder = nullptr: An external builder.

std::string name = "unnamed": The name of the volume to be built.

struct DetectorComponent

#include <Acts/Detector/DetectorComponents.hpp>

The currently built detector components including the constructed volumes and the current shell/coating, i.e.

portals ordered in a map

Note

the map indices of the shell coating represent their respective index in the portal vector of the VolumeBounds derivative that is described by the given component.

Public Types

using PortalContainer = std::map<unsigned int, std::shared_ptr<Portal>>: Define a portal container.

Public Members

PortalContainer portals = {}: The current map of outside portals.

RootDetectorVolumes rootVolumes = {}: The root volumes finder.

std::vector<std::shared_ptr<DetectorVolume>> volumes = {}: The vector of constructed volume(s)

class DetectorNavigator

#include <Acts/Navigation/DetectorNavigator.hpp>

Public Functions

inline explicit DetectorNavigator(Config cfg, std::shared_ptr<const Logger> _logger = getDefaultLogger("DetectorNavigator", 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&) const

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

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

Initialize call - start of propagation.

Template Parameters

propagator_state_t – The state type of the propagagor
stepper_t – The type of stepper used for the propagation

Parameters

state – [inout] is the propagation state object
stepper – [in] Stepper in use

Returns

boolean return triggers exit to stepper

inline void insertExternalSurface(State&, GeometryIdentifier) 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

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

Navigator post step call.

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 preStep(propagator_state_t &state, const stepper_t &stepper) const

Navigator pre step call.

This will invalid the current surface and current portal in order to navigate to the next ones.

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 void resetState(State &state, const GeometryContext&, const Vector3&, const Vector3&, const Surface*, const Surface*) const

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

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

#include <Acts/Navigation/DetectorNavigator.hpp>

Public Members

const Detector *detector = nullptr: Detector for this Navigation.

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)

struct State : public Acts::Experimental::NavigationState

#include <Acts/Navigation/DetectorNavigator.hpp>

Nested State struct.

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

Public Members

const Surface *currentSurface = nullptr: Navigation state - external state: the current surface.

bool navigationBreak = false: Navigation state : a break has been detected.

const Surface *startSurface = nullptr: Navigation state - external state: the start surface.

bool targetReached = false: Indicator if the target is reached.

const Surface *targetSurface = nullptr: Navigation state - external state: the target surface.

class DetectorVolume : public std::enable_shared_from_this<DetectorVolume>

#include <Acts/Detector/DetectorVolume.hpp>

A detector volume description which can be:

Note

A detector volume holds non-const objects internally that are allowed to be modified as long as the geometry is not yet closed. Using this, material can be attached, and GeometryIdentifier can be set at construction time.

Note

The construction of DetectorVolumes is done via a dedicated factory, this is necessary as then the shared_ptr is non-weak and it can be registered in the portal generator for further geometry processing.

Note

Navigation is always done by plain pointers, while object ownership is done by shared/unique pointers.

Public Types

using BoundingBox = Acts::AxisAlignedBoundingBox<Acts::Experimental::DetectorVolume, Acts::ActsScalar, 3>

Public Functions

void assignDetector(const Detector &detector)

Assign Detector to this volume (for back navigation issues)

Parameters: detector – the parenting detector class

void assignSurfaceCandidatesUpdator(SurfaceCandidatesUpdator surfaceCandidateUpdator, const std::vector<std::shared_ptr<Surface>> &surfaces = {}, const std::vector<std::shared_ptr<DetectorVolume>> &volumes = {})

This method allows to udate the navigation state updator module.

Parameters

surfaceCandidateUpdator – the new navigation state updator for surfaces
surfaces – the surfaces the new navigation state updator points to
volumes – the volumes the new navigation state updator points to

void assignVolumeMaterial(std::shared_ptr<IVolumeMaterial> material)

Assign the volume material description.

This method allows to load a material description during the detector geometry building, and assigning it (potentially multiple) times to detector volumes.

Parameters: material – Material description associated to this volumw

Vector3 center(const GeometryContext &gctx = GeometryContext()) const

Const access to the center.

Note

the geometry context is currently ignored, but is a placeholder for eventually misaligned volumes

Parameters: gctx – the geometry context
Returns: a contextually created center

void closePortals(): Final closing of portal, i.e. this sets the end of world.

const Detector *detector() const: Const access to the detector.

const DetectorVolumeUpdator &detectorVolumeUpdator() const: Const access to the detector volume updator.

bool exclusivelyInside(const GeometryContext &gctx, const Vector3 &position) const

Check if a point is exclusively inside this volume i.e.

this point is not inside a subvolume.

Parameters

gctx – the geometry context
position – the position for the inside check

Returns

a bool to indicate inside/outside

Extent extent(const GeometryContext &gctx, size_t nseg = 1) const

The Extent for this volume.

Parameters

gctx – is the geometry context
nseg – is the number of segments to approximate

Returns

an Extent object

const GeometryIdentifier &geometryId() const

Returns: the geometry identifier

const BoundingBox &getBoundingBox() const

std::shared_ptr<DetectorVolume> getSharedPtr()

Retrieve a std::shared_ptr for this surface (non-const version)

Note

Will error if this was not created through the makeShared factory since it needs access to the original reference. In C++14 this is undefined behavior (but most likely implemented as a bad_weak_ptr exception), in C++17 it is defined as that exception.

Note

Only call this if you need shared ownership of this object.

Returns: The shared pointer

std::shared_ptr<const DetectorVolume> getSharedPtr() const

Retrieve a std::shared_ptr for this surface (const version)

Note

Will error if this was not created through the makeShared factory since it needs access to the original reference. In C++14 this is undefined behavior, but most likely implemented as a bad_weak_ptr exception, in C++17 it is defined as that exception.

Note

Only call this if you need shared ownership of this object.

Returns: The shared pointer

bool inside(const GeometryContext &gctx, const Vector3 &position) const

Check if a point is inside this volume.

Subvolumes will not be checked.

Parameters

gctx – the geometry context
position – the position for the inside check

Returns

a bool to indicate inside/outside

const std::string &name() const

Returns: the name of the volume

std::vector<std::shared_ptr<Portal>> &portalPtrs()

Non-const access to the portals.

Returns: the portal shared pointer store

const std::vector<const Portal*> &portals() const

Const access to the detector portals.

Note

an empty vector indicates a container volume that has not been properly connected

Returns: a vector to const Portal raw pointers

const SurfaceCandidatesUpdator &surfaceCandidatesUpdator() const: Const access to the navigation state updator.

std::vector<std::shared_ptr<Surface>> &surfacePtrs()

Non-const access to the surfaces.

Returns: the surfaces shared pointer store

const std::vector<const Surface*> &surfaces() const

Const access to the surfaces.

Note

an empty vector indicates either gap volume or container volume, a non-empty vector indicates a layer volume.

Returns: a vector to const Surface raw pointers

const Transform3 &transform(const GeometryContext &gctx = GeometryContext()) const

Const access to the transform.

Note

the geometry context is currently ignored, but is a placeholder for eventually misaligned volumes

Parameters: gctx – the geometry context
Returns: const reference to the contextual transform

void updateNavigationState(const GeometryContext &gctx, NavigationState &nState) const

Initialize/update the navigation status in this environment.

This method calls:

the local navigation delegate for candidate surfaces
the portal navigation delegate for candidate exit portals
set the current detector volume

Parameters

gctx – is the current geometry context
nState – [in,out] is the detector navigation state to be updated

void updatePortal(std::shared_ptr<Portal> portal, unsigned int pIndex) noexcept(false)

Update a portal given a portal index.

Note

throws exception if portal index out of bounds

Parameters

portal – the portal to be updated
pIndex – the portal index

const VolumeBounds &volumeBounds() const

Const access to the volume bounds.

Returns: const reference to the volume bounds object

const IVolumeMaterial *volumeMaterial() const: Const access to the volume amterial.

std::shared_ptr<IVolumeMaterial> volumeMaterialPtr(): Non-const access to the voume material (for scaling, e.g.)

std::vector<std::shared_ptr<DetectorVolume>> &volumePtrs()

Non-const access to the volumes.

Returns: the volumes shared pointer store

const std::vector<const DetectorVolume*> &volumes() const

Const access to sub volumes.

Note

and empty vector indicates this is either a gap volume or a layer volume, in any case it means the volume is on navigation level and the portals need to be connected

Returns: a vector to const DetectorVolume raw pointers

Friends

friend class DetectorVolumeFactory

template<typename internal_type> struct ObjectStore

#include <Acts/Detector/DetectorVolume.hpp>

Nested object store that holds the internal (non-const), reference counted objects and provides an external (const raw pointer) access.

Template Parameters: internal_type – is the internal storage representation, has to comply with std::shared_ptr semantics

Public Functions

inline ObjectStore(std::vector<internal_type> objects)

Store constructor.

Parameters: objects – are the ones copied into the internal store

ObjectStore() = default

Public Members

std::vector<const typename internal_type::element_type*> external = {}: The external storage vector, const raw pointer.

std::vector<internal_type> internal = {}: The internal storage vector.

class DetectorVolumeBuilder : public Acts::Experimental::IDetectorComponentBuilder

#include <Acts/Detector/DetectorVolumeBuilder.hpp>

A generic detector volume builder that uses an external builder for shape and portals and an internal structure builder for volume internals.

Note

Although this helper builds only a single volume, it is to the outside presented as a DetectorComponent with shell; like this it can be transparently be used for the downstream detector construction process.

Public Functions

DetectorVolumeBuilder(const Config &cfg, std::unique_ptr<const Logger> mlogger = getDefaultLogger("DetectorVolumeBuilder", Logging::INFO))

Constructor with configuration arguments.

Parameters

cfg – is the configuration struct
mlogger – logging instance for screen output

virtual DetectorComponent construct(const GeometryContext &gctx) const final

Final implementation of a volume builder that is purely defined by an internal and external structure builder.

Parameters: gctx – The geometry context for this call
Returns: an outgoing detector component

struct Config

#include <Acts/Detector/DetectorVolumeBuilder.hpp>

Nested configuration object.

Public Members

bool addInternalsToRoot = false: Add eventual internal volume to root.

std::string auxiliary = "": Auxiliary information.

std::shared_ptr<const IExternalStructureBuilder> externalsBuilder = nullptr: An external builder.

std::shared_ptr<const IInternalStructureBuilder> internalsBuilder = nullptr: An internal builder.

std::string name = "unnamed": The name of the volume to be built.

class DetectorVolumeFactory

#include <Acts/Detector/DetectorVolume.hpp>

A detector volume factory which first constructs the detector volume and then constructs the portals.

This ensures that the std::shared_ptr holding the detector volume is not weak when assigning to the portals.

Public Static Functions

static inline std::shared_ptr<DetectorVolume> construct(const PortalGenerator &portalGenerator, const GeometryContext &gctx, const std::string &name, const Transform3 &transform, std::shared_ptr<VolumeBounds> bounds, const std::vector<std::shared_ptr<Surface>> &surfaces, const std::vector<std::shared_ptr<DetectorVolume>> &volumes, DetectorVolumeUpdator detectorVolumeUpdator, SurfaceCandidatesUpdator surfaceCandidateUpdator): Create a detector volume - from factory.

static inline std::shared_ptr<DetectorVolume> construct(const PortalGenerator &portalGenerator, const GeometryContext &gctx, std::string name, const Transform3 &transform, std::shared_ptr<VolumeBounds> bounds, SurfaceCandidatesUpdator surfaceCandidateUpdator): Create a detector volume - from factory.

struct DetectorVolumeFiller

#include <Acts/Navigation/NavigationStateFillers.hpp>

Filler of the current volume.

Public Static Functions

static inline void fill(NavigationState &nState, const DetectorVolume *volume)

Helper struct that allows to fill a volume into the navigation state, it allows to use common navigation structs for volume, portal, surfaces.

Parameters

nState – the navigation state
volume – the volume that is filled

struct DetectorVolumesCollection

#include <Acts/Navigation/DetectorVolumeUpdators.hpp>

This holds and extracts a collection of detector volumes.

Alternatively an extractor could also use the detector and its associated detector volume container for volume extraction.

Public Functions

inline const DetectorVolume *extract(const GeometryContext&, const NavigationState&, const SingleIndex &index) const

Extract a voume from a collection.

Note

that geometry context and navigation state are ignored here

Parameters: index – are access indices into the surfaces store
Returns: the extracted volume

Public Members

std::vector<const DetectorVolume*> dVolumes = {}: The volumes held by this collection.

struct EndOfWorldImpl : public Acts::Experimental::INavigationDelegate

#include <Acts/Navigation/DetectorVolumeUpdators.hpp>

The end of world sets the volume pointer of the navigation state to nullptr, usually indicates the end of the known world, hence the name.

Public Functions

inline void update(const GeometryContext&, NavigationState &nState) const: a null volume link - explicitly

Note

the method parameters are ignored

struct ExternalStructure

#include <Acts/Detector/DetectorComponents.hpp>

Holder struct for the external structure components required to construct a detectorVolume.

Public Members

std::unique_ptr<VolumeBounds> bounds = nullptr: A shape definition.

PortalGenerator portalGenerator: And a portal generator.

Transform3 transform = Transform3::Identity(): A 3D transform where the volume should be positioned.

template<typename propagator_t, typename bethe_heitler_approx_t, typename traj_t> struct GaussianSumFitter

#include <Acts/TrackFitting/GaussianSumFitter.hpp>

Gaussian Sum Fitter implementation.

Note

This GSF implementation tries to be as compatible to the KalmanFitter as possible. However, strict compatibility is not garantueed.

Note

Currently there is no possibility to export the states of the individual components from the GSF, the only information returned in the MultiTrajectory are the means of the states. Therefore, also NO dedicated component smoothing is performed as described e.g. by R. Fruewirth.

Template Parameters

propagator_t – The propagator type on which the algorithm is built on
bethe_heitler_approx_t – The type of the Bethe-Heitler-Approximation
traj_t – The MultiTrajectory type (backend)

Public Types

using GsfActor = detail::GsfActor<bethe_heitler_approx_t, traj_t>: The actor type.

using GsfNavigator = typename propagator_t::Navigator: The navigator type.

Public Functions

inline GaussianSumFitter(propagator_t &&propagator, bethe_heitler_approx_t &&bha, std::unique_ptr<const Logger> _logger = getDefaultLogger("GSF", Logging::INFO))

template<typename source_link_it_t, typename start_parameters_t, typename track_container_t, template<typename> class holder_t> inline auto fit(source_link_it_t begin, source_link_it_t end, const start_parameters_t &sParameters, const GsfOptions<traj_t> &options, const std::vector<const Surface*> &sSequence, TrackContainer<track_container_t, traj_t, holder_t> &trackContainer) const: The fit function for the Direct navigator.

template<typename source_link_it_t, typename start_parameters_t, typename track_container_t, template<typename> class holder_t> inline auto fit(source_link_it_t begin, source_link_it_t end, const start_parameters_t &sParameters, const GsfOptions<traj_t> &options, TrackContainer<track_container_t, traj_t, holder_t> &trackContainer) const: The fit function for the standard navigator.

template<typename source_link_it_t, typename start_parameters_t, typename fwd_prop_initializer_t, typename bwd_prop_initializer_t, typename track_container_t, template<typename> class holder_t> inline Acts::Result<typename TrackContainer<track_container_t, traj_t, holder_t>::TrackProxy> fit_impl(source_link_it_t begin, source_link_it_t end, const start_parameters_t &sParameters, const GsfOptions<traj_t> &options, const fwd_prop_initializer_t &fwdPropInitializer, const bwd_prop_initializer_t &bwdPropInitializer, TrackContainer<track_container_t, traj_t, holder_t> &trackContainer) const

The generic implementation of the fit function.

TODO check what this function does with the referenceSurface is e.g. the first measuerementSurface

inline const Logger &logger() const

Public Members

std::unique_ptr<const Logger> m_actorLogger

bethe_heitler_approx_t m_betheHeitlerApproximation: The fitter holds the instance of the bethe heitler approx.

std::unique_ptr<const Logger> m_logger: The logger.

propagator_t m_propagator: The propagator instance used by the fit function.

template<typename traj_t> struct GsfExtensions

#include <Acts/TrackFitting/GsfOptions.hpp>

The extensions needed for the GSF.

Public Types

using Calibrator = Delegate<void(const GeometryContext&, TrackStateProxy)>

using ConstTrackStateProxy = typename traj_t::ConstTrackStateProxy

using OutlierFinder = Delegate<bool(ConstTrackStateProxy)>

using TrackStateProxy = typename traj_t::TrackStateProxy

using Updater = Delegate<Result<void>(const GeometryContext&, TrackStateProxy, Direction, const Logger&)>

Public Functions

inline GsfExtensions(): Default constructor which connects the default void components.

Public Members

Calibrator calibrator

The Calibrator is a dedicated calibration algorithm that allows to calibrate measurements using track information, this could be e.g.

sagging for wires, module deformations, etc.

OutlierFinder outlierFinder: Determines whether a measurement is supposed to be considered as an outlier.

Updater updater: The updater incorporates measurement information into the track parameters.

template<typename traj_t> struct GsfOptions

#include <Acts/TrackFitting/GsfOptions.hpp>

Public Functions

GsfOptions() = delete

Public Members

bool abortOnError = false

std::reference_wrapper<const CalibrationContext> calibrationContext

bool disableAllMaterialHandling = false

GsfExtensions<traj_t> extensions

std::string_view finalMultiComponentStateColumn = ""

std::reference_wrapper<const GeometryContext> geoContext

std::reference_wrapper<const MagneticFieldContext> magFieldContext

std::size_t maxComponents = 4

PropagatorPlainOptions propagatorPlainOptions

const Surface *referenceSurface = nullptr

MixtureReductionMethod stateReductionMethod = MixtureReductionMethod::eMaxWeight

double weightCutoff = 1.e-4

class IDetectorBuilder

#include <Acts/Detector/interface/IDetectorBuilder.hpp>

This is the interface for building a Detector object.

This is the top level interface, all lower level building blocks should be done with detector component builders.

Note

As this is the last builder, the returned detector object is const and cannot be modified anymore.

Subclassed by Acts::Experimental::DetectorBuilder

Public Functions

virtual ~IDetectorBuilder() = default

virtual std::shared_ptr<const Detector> construct(const GeometryContext &gctx) const = 0

The virtual interface definition for detector builders.

Parameters: gctx – the geometry context at the creation of the internal structure
Returns: a shared detector object

class IDetectorComponentBuilder

#include <Acts/Detector/interface/IDetectorComponentBuilder.hpp>

This is the interface for detector component builders; such a builder could be a simple detector volume builder, with or without internal structure, or more complicated objects.

Subclassed by Acts::Experimental::CylindricalContainerBuilder, Acts::Experimental::DetectorVolumeBuilder

Public Functions

virtual ~IDetectorComponentBuilder() = default

virtual DetectorComponent construct(const GeometryContext &gctx) const = 0

The interface method to be implemented by all detector component builder.

Parameters: gctx – The geometry context for this call
Returns: an outgoing detector component

class IExternalStructureBuilder

#include <Acts/Detector/interface/IExternalStructureBuilder.hpp>

This is the interface definition of external structure builders for DetectorVolume construction.

Subclassed by Acts::Experimental::VolumeStructureBuilder

Public Functions

virtual ~IExternalStructureBuilder() = default

virtual ExternalStructure construct(const GeometryContext &gctx) const = 0

The virtual interface definition for external structure creation.

Parameters: gctx – the geometry context at the creation of the internal structure
Returns: a consistent set of detector volume externals

class IInternalStructureBuilder

#include <Acts/Detector/interface/IInternalStructureBuilder.hpp>

This is the interface definition of internal structure builders for DetectorVolume construction.

It is assumed that each builder returns a consistent set of DetectorVolume internals, which in turn can be directly provided to a DetectorVolume constructor.

Subclassed by Acts::Experimental::LayerStructureBuilder

Public Functions

virtual ~IInternalStructureBuilder() = default

virtual InternalStructure construct(const GeometryContext &gctx) const = 0

The interface definition for internal structure creation.

Parameters: gctx – the geometry context at the creation of the internal structure
Returns: a consistent set of detector volume internals

class INavigationDelegate

#include <Acts/Navigation/NavigationDelegates.hpp>

Base class for navigation delegates This allows to define a common Owning delegate schema, which in turn allows for accessing the holder of the delegate implementation for e.g.

I/O or display

Public Functions

virtual ~INavigationDelegate() = default

struct IndexedDetectorVolumeExtractor

#include <Acts/Navigation/DetectorVolumeFinders.hpp>

A helper struct that allows to extrace a volume from the detector by its index.

Public Static Functions

static inline const DetectorVolume *extract([[maybe_unused]] const GeometryContext &gctx, const NavigationState &nState, size_t index) noexcept(false)

Extract the surfaces from the volume.

Parameters

gctx – the geometry contextfor this extraction call
nState – is the current navigation state
index – is the index in the global detector volume store

Returns

a raw DetectorVolume pointer

struct IndexedSubVolumesExtractor

#include <Acts/Detector/DetectorVolume.hpp>

Helper extractors: indexed sub volume of a volume.

Public Static Functions

static inline const std::vector<const DetectorVolume*> extract([[maybe_unused]] const GeometryContext &gctx, const NavigationState &nState, const std::vector<size_t> &indices)

Extract the sub volumes from the volume.

Parameters

gctx – the geometry contextfor this extraction call
nState – is the current navigation state
indices – are access indices into the volume store

Returns

a vector of raw DetectorVolume pointers

struct IndexedSurfacesExtractor

#include <Acts/Detector/DetectorVolume.hpp>

Helper extractors: indexed surfaces.

Public Static Functions

static inline const std::vector<const Surface*> extract([[maybe_unused]] const GeometryContext &gctx, const NavigationState &nState, const std::vector<size_t> &indices)

Extract the surfaces from the volume.

Note

no out of boudns checking is done

Parameters

gctx – the geometry contextfor this extraction call
nState – is the current navigation state
indices – are access indices into the surfaces store

Returns

a vector of raw Surface pointers

template<typename grid_t, typename extractor_type, typename filler_type> class IndexedUpdatorImpl : public Acts::Experimental::INavigationDelegate

#include <Acts/Navigation/NavigationStateUpdators.hpp>

This is an index grid based navigation state updator, it uses an extractor type and a filler type to handle the navigation state.

It can be used for volumes, surfaces at convenience

Note

a transform is applied p3l = transform * p3 in order to allow shifted, transformed grids

Template Parameters

grid_t – is the type of the grid
extractor_type – is the helper to extract the object
filler_type – is the helper to fill the object into the nState

Public Types

using grid_type = grid_t: Broadcast the grid type.

Public Functions

inline IndexedUpdatorImpl(grid_type &&igrid, const std::array<BinningValue, grid_type::DIM> &icasts, const Transform3 &itr = Transform3::Identity())

Constructor for a grid based surface attacher.

Parameters

igrid – the grid that is moved into this attacher
icasts – is the cast values array
itr – a transform applied to the global position

IndexedUpdatorImpl() = delete

inline std::array<ActsScalar, grid_type::DIM> castPosition(const Vector3 &position) const

Cast into a lookup position.

Parameters: position – is the position of the update call

inline void update(const GeometryContext &gctx, NavigationState &nState) const

updates the navigation state with objects from the grid according to the filling type AFTER applying p3loc = transform * p3

Note

this is attaching objects without intersecting nor checking

Parameters

gctx – is the Geometry context of this call
nState – the navigation state to which the surfaces are attached

Public Members

std::array<BinningValue, grid_type::DIM> casts = {}: These are the cast parameters - copied from constructor.

extractor_type extractor: An extractor helper to get the object(s) from the volume.

grid_type grid: The grid where the indices are stored.

Transform3 transform = Transform3::Identity(): A transform to be applied to the position.

struct InternalStructure

#include <Acts/Detector/DetectorComponents.hpp>

Holder struct for the internal structure components of a DetectorVolume.

Note

the surface surfacesUpdator needs to handle also portal providing of contained volumes.

Public Members

std::vector<std::shared_ptr<Surface>> surfaces = {}: Contained surfaces of this volume, handled by the surfacesUpdator.

SurfaceCandidatesUpdator surfacesUpdator: Navigation delegate for surfaces.

std::vector<std::shared_ptr<DetectorVolume>> volumes = {}: Contained volumes of this volume, handled by the volumeUpdator.

DetectorVolumeUpdator volumeUpdator

class ISurfacesProvider

#include <Acts/Detector/interface/ISurfacesProvider.hpp>

This is the interface for providing surfaces to the detector building process.

These surfaces manly describe the sensitive detector surfaces, but also passive (i.e. material carrying) surfaces are considered.

These could be prefilled, or created on demand when the detector is built (to increase memory locality)

Subclassed by Acts::Experimental::KdtSurfacesProvider< kDIM, bSize, reference_generator >, Acts::Experimental::LayerStructureBuilder::SurfacesHolder

Public Functions

virtual ~ISurfacesProvider() = default

virtual std::vector<std::shared_ptr<Surface>> surfaces(const GeometryContext &gctx) const = 0

The virtual interface definition for detector surface providers.

Parameters: gctx – the geometry context at the creation of the internal structure
Returns: a shared detector object

template<size_t kDIM = 2u, size_t bSize = 100u, typename reference_generator = detail::PolyhedronReferenceGenerator> class KdtSurfaces

#include <Acts/Detector/KdtSurfacesProvider.hpp>

A wrapper class around a KDTree of surfaces.

It also deals with the conversion from global query to KDTree lookup positions

Public Types

using Entry = std::pair<Query, std::shared_ptr<Surface>>: Broadcast the entry.

using KDTS = KDTree<kDIM, std::shared_ptr<Surface>, ActsScalar, std::array, bSize>: Broadcast the surface KDT type.

using Query = std::array<ActsScalar, kDIM>: Broadcast the query definition.

Public Functions

inline KdtSurfaces(const GeometryContext &gctx, const std::vector<std::shared_ptr<Surface>> &surfaces, const std::array<BinningValue, kDIM> &casts, const reference_generator &rgen = detail::PolyhedronReferenceGenerator{})

Constructor from a vector of surfaces.

Parameters

gctx – the geometry context of this call
surfaces – the surfaces to be filled into the tree
casts – the cast list from global position into kdtree local
rgen – the reference point generator

inline std::vector<std::shared_ptr<Surface>> surfaces(const RangeXD<kDIM, ActsScalar> &range) const

Query with a Range object.

Parameters: range – is the range to be queried
Returns: the matching surfaces from the KDT structure

inline std::vector<std::shared_ptr<Surface>> surfaces(const Extent &extent) const

Query with an Extent object.

Parameters: extent – is the range Extent to be queried
Returns: the matching surfaces fpulled from the KDT structure

template<size_t kDIM = 2u, size_t bSize = 100u, typename reference_generator = detail::PolyhedronReferenceGenerator> class KdtSurfacesProvider : public Acts::Experimental::ISurfacesProvider

#include <Acts/Detector/KdtSurfacesProvider.hpp>

Callable struct wrapper around the KDT surface structure.

This allows to create small region based callable structs at configuration level that are then connected to an InternalStructureBuilder

Public Functions

inline KdtSurfacesProvider(std::shared_ptr<KdtSurfaces<kDIM, bSize, reference_generator>> kdts, const Extent &kregion)

The prefilled surfaces in a KD tree structure, it is generally shared amongst different providers.

Parameters

kdts – the prefilled KDTree structure
kregion – the region where these are pulled from

inline std::vector<std::shared_ptr<Surface>> surfaces([[maybe_unused]] const GeometryContext &gctx) const final: The call to provide the surfaces.

class LayerStructureBuilder : public Acts::Experimental::IInternalStructureBuilder

#include <Acts/Detector/LayerStructureBuilder.hpp>

This is a builder of layer structures to be contained within a DetectorVolume, it extends the IInternalStructureBuilder interface and provides the internal structure components of DetectorVolume objects to be constructed.

It uses the IndexedSurfaceGrid to bin the internal surfaces, and allows for additional support surfaces that are added to the structure and indexing mechanism. Those support structures can also be approximated by planar surfaces, in order to facilitate vectorization of surface intersection calls.

The binning can be chosen with a so called expansion, a number which indicates the configured expanded bin window in which the surfaces are going to be filled, the details to this strategy can be found in the IndexedGridFiller and IndexedSurfacesGenerator classes.

No sub volumes are added to this structure builders, hence, the DetectorVolumeFinder navigation delegate uses the “NoopFinder” breakpoint to indicate the bottom of the volume hierarchy.

Public Functions

LayerStructureBuilder(const Config &cfg, std::unique_ptr<const Logger> logger = getDefaultLogger("LayerStructureBuilder", Logging::INFO))

Constructor.

Parameters

cfg – is the configuration struct
logger – logging instance for screen output

virtual InternalStructure construct(const GeometryContext &gctx) const final

The interface definition for internal structure creation.

Parameters: gctx – the geometry context at the creation of the internal structure
Returns: a consistent set of detector volume internals

struct Config

#include <Acts/Detector/LayerStructureBuilder.hpp>

Configuration struct for the LayerStructureBuilder.

It contain:

a source of the surfaces to be built
a definition of surface binning on this layer
a definition of supports to be built

Public Members

std::string auxiliary = "": Extra information, mainly for screen output.

std::vector<ProtoBinning> binnings = {}: Definition of Binnings.

unsigned int nSegments = 1u: Polyhedron approximations.

std::vector<Support> supports = {}: Definition of Supports.

std::shared_ptr<ISurfacesProvider> surfacesProvider = nullptr: Connection point for a function to provide surfaces.

struct Support

#include <Acts/Detector/LayerStructureBuilder.hpp>

Support parameter definitions.

Public Members

std::vector<BinningValue> constraints = s_binningValues: Define in which values the support should be constrained.

unsigned int splits = 1u: Potential splits into planar approximations.

std::optional<Transform3> transform = std::nullopt: The (optional) layer transform.

Surface::SurfaceType type = Surface::SurfaceType::Other: The surface type to be built.

std::array<ActsScalar, 5u> values = {}: Define whether you want to build support structures.

class SurfacesHolder : public Acts::Experimental::ISurfacesProvider

#include <Acts/Detector/LayerStructureBuilder.hpp>

A holder struct for surfaces.

Public Functions

inline SurfacesHolder(std::vector<std::shared_ptr<Surface>> isurfaces)

Constructor with predefined surfaces.

Parameters: isurfaces – is the vector of surfaces

inline std::vector<std::shared_ptr<Surface>> surfaces([[maybe_unused]] const GeometryContext &gctx) const final

Return the surfaces from the holder.

Parameters: gctx – is the geometry context

struct NavigationState

#include <Acts/Navigation/NavigationState.hpp>

A navigation state struct that is holding the current navigation information.

It relies on Surfaces and Portals, all navigation entities have to be described in these terms.

Subclassed by Acts::Experimental::DetectorNavigator::State

Public Types

using SurfaceCandidates = std::vector<SurfaceCandidate>

Surface candidate vector alias, this allows to use e.g.

boost_small vector or other stl like containers

Public Members

ActsScalar absCharge = 0.: The current absolute charge.

ActsScalar absMomentum = 0.: The current absolute momentum.

std::any auxiliary: Auxiliary attached information.

const Detector *currentDetector = nullptr: The current detector in processing.

const Portal *currentPortal = nullptr: The current portal, i.e the position is on portal.

const Surface *currentSurface = nullptr: The current surface, i.e the position is on surface.

const DetectorVolume *currentVolume = nullptr: The current volume in processing, i.e. the position is inside.

Vector3 direction = Vector3(0., 0., 0.): The current direction.

Vector3 magneticField = Vector3(0., 0., 0.): The current magnetic field.

ActsScalar overstepTolerance = -0.1: An overstep tolerance.

Vector3 position = Vector3(0., 0., 0.): The current position.

BoundaryCheck surfaceBoundaryCheck = true: Boundary directives for surfaces.

SurfaceCandidates::const_iterator surfaceCandidate = surfaceCandidates.cend()

SurfaceCandidates surfaceCandidates = {}: That are the candidate surfaces to process.

struct SurfaceCandidate

#include <Acts/Navigation/NavigationState.hpp>

A surface candidate and its intersection.

A candidates can either be a surface or a portal (which contain a surface)

Public Members

BoundaryCheck boundaryCheck = true: The boundary check used for the candidate, boundary checks can differ for sensitive surfaces and portals.

ObjectIntersection<Surface> objectIntersection: A candidate intersection, in Surface view.

const Portal *portal = nullptr: Or a portal.

const Surface *surface = nullptr: A candidate is either a detector Surface.

struct NoopFinder : public Acts::Experimental::INavigationDelegate

#include <Acts/Navigation/DetectorVolumeFinders.hpp>

Public Functions

inline void update(const GeometryContext&, NavigationState&) const

class Portal : public std::enable_shared_from_this<Portal>

#include <Acts/Detector/Portal.hpp>

A portal description between the detector volumes.

It has a Surface representation for navigation and propagation and guides from one volume to the next.

The surface can carry material to allow mapping onto portal positions if required.

Public Types

using AttachedDetectorVolumes = std::array<std::vector<std::shared_ptr<DetectorVolume>>, 2u>: The vector of attached volumes forward/backward, this is useful in the geometry building.

using DetectorVolumeUpdators = std::array<DetectorVolumeUpdator, 2u>: The volume links forward/backward with respect to the surface normal.

Public Functions

Portal() = delete

virtual ~Portal() = default

void assignDetectorVolumeUpdator(Direction dir, DetectorVolumeUpdator dVolumeUpdator, std::vector<std::shared_ptr<DetectorVolume>> attachedVolumes)

Update the volume link.

Note

this overwrites the existing link

Parameters

dir – the direction of the link
dVolumeUpdator – is the mangaged volume updator delegate
attachedVolumes – is the list of attached volumes for book keeping

void assignDetectorVolumeUpdator(DetectorVolumeUpdator dVolumeUpdator, std::vector<std::shared_ptr<DetectorVolume>> attachedVolumes) noexcept(false)

Update the volume link, w/o directive, i.e.

it relies that there’s only one remaining link to be set, throws an exception if that’s not the case

Note

this overwrites the existing link

Parameters

dVolumeUpdator – is the mangaged volume updator delegate
attachedVolumes – is the list of attached volumes for book keeping

void assignGeometryId(const GeometryIdentifier &geometryId)

Set the geometry identifier (to the underlying surface)

Parameters: geometryId – the geometry identifier to be assigned

AttachedDetectorVolumes &attachedDetectorVolumes()

const DetectorVolumeUpdators &detectorVolumeUpdators() const

void fuse(std::shared_ptr<Portal> &other) noexcept(false)

Fuse with another portal, this one is kept.

Note

this will move the portal links from the other into this volume, it will throw an exception if the portals are not fusable

Note

that other will be overwritten to point to this

Parameters: other – is the portal that will be fused

std::shared_ptr<Portal> getSharedPtr()

Retrieve a std::shared_ptr for this surface (non-const version)

Note

Will error if this was not created through the makeShared factory since it needs access to the original reference. In C++14 this is undefined behavior (but most likely implemented as a bad_weak_ptr exception), in C++17 it is defined as that exception.

Note

Only call this if you need shared ownership of this object.

Returns: The shared pointer

std::shared_ptr<const Portal> getSharedPtr() const

Retrieve a std::shared_ptr for this surface (const version)

Note

Will error if this was not created through the makeShared factory since it needs access to the original reference. In C++14 this is undefined behavior, but most likely implemented as a bad_weak_ptr exception, in C++17 it is defined as that exception.

Note

Only call this if you need shared ownership of this object.

Returns: The shared pointer

const Surface &surface() const: Const access to the surface representation.

Surface &surface(): Non-const access to the surface reference.

void updateDetectorVolume(const GeometryContext &gctx, NavigationState &nState) const noexcept(false)

Update the current volume.

Parameters

gctx – is the Geometry context of this call
nState – [in,out] the navigation state for the volume to be updated

Public Static Functions

static std::shared_ptr<Portal> makeShared(std::shared_ptr<Surface> surface): Factory for producing memory managed instances of Portal.

Friends

friend class DetectorVolume

struct PortalsFiller

#include <Acts/Navigation/NavigationStateFillers.hpp>

Fillers and attachers for portals to act on the navigation state.

Public Static Functions

static inline void fill(NavigationState &nState, const std::vector<const Portal*> &portals)

Helper struct that allows to fill surfaces into the candidate vector it allows to use common navigation structs for volume, portal, surfaces.

Parameters

nState – the navigation state
portals – the portals that are filled in

struct ProtoBinning

#include <Acts/Detector/ProtoBinning.hpp>

Simple helper class to define a binning structure.

Note

no checks are performed on the consistency, this is only for convenience that the binning can be defined and then translated into concrete axis types

Public Functions

inline ProtoBinning(BinningValue bValue, Acts::detail::AxisBoundaryType bType, const std::vector<ActsScalar> &e, std::size_t exp = 0u)

Convenience constructors - recommended for variable binning.

Parameters

bValue – the value/cast in which this is binned
bType – the axis boundary type
e – the bin edges (variable binning)
exp – the expansion (in bins)

inline ProtoBinning(BinningValue bValue, Acts::detail::AxisBoundaryType bType, ActsScalar minE, ActsScalar maxE, std::size_t nbins, std::size_t exp = 0u)

Convenience constructors - recommended for variable binning.

Parameters

bValue – the value/cast in which this is binned
bType – the axis boundary type
minE – the lowest edge of the binning
maxE – the highest edge of the binning
nbins – the number of bins
exp – the expansion (in bins)

inline std::size_t bins() const

Public Members

Acts::detail::AxisType axisType = Acts::detail::AxisType::Equidistant: The axis type: equidistant or variable.

BinningValue binValue = BinningValue::binValues: The binning value of this.

Acts::detail::AxisBoundaryType boundaryType = Acts::detail::AxisBoundaryType::Bound: The axis boundary type: Open, Bound or Closed.

std::vector<ActsScalar> edges = {}: The binning edges.

std::size_t expansion = 0u: An expansion for the filling (in bins)

struct RootDetectorVolumes

#include <Acts/Detector/DetectorComponents.hpp>

Container to collect root volumes for the construction of a Detector.

This struct collects all root volumes that will then be provided to the Detector object

Note

each root volume is expected to contain a full search tree for eventually contained sub volumes

Public Members

DetectorVolumeUpdator volumeFinder: The Root volumes finder.

std::vector<std::shared_ptr<DetectorVolume>> volumes = {}: The list of root volumes.

struct RootVolumeFinder : public Acts::Experimental::INavigationDelegate

#include <Acts/Navigation/DetectorVolumeFinders.hpp>

Public Functions

inline void update(const GeometryContext &gctx, NavigationState &nState) const

struct SingleDetectorVolumeImpl : public Acts::Experimental::INavigationDelegate

#include <Acts/Navigation/DetectorVolumeUpdators.hpp>

Single volume updator, it sets the current navigation volume to the volume in question.

Public Functions

inline SingleDetectorVolumeImpl(const DetectorVolume *sVolume) noexcept(false)

Allowed constructor.

Parameters: sVolume – the volume to which it points

SingleDetectorVolumeImpl() = delete

inline void update(const GeometryContext&, NavigationState &nState) const: a null volume link - explicitly

Note

the method parameters are ignored

Public Members

const DetectorVolume *dVolume = nullptr

template<typename object_type, typename filler_type> class SingleObjectImpl : public Acts::Experimental::INavigationDelegate

#include <Acts/Navigation/NavigationStateUpdators.hpp>

This sets a single object, e.g.

single surface or single volume

Template Parameters

object_type – the type of the object to be filled
filler_type – is the helper to fill the object into nState

Public Functions

inline SingleObjectImpl(const object_type *so)

Convenience constructor.

Parameters: so – the single object

inline void update([[maybe_unused]] const GeometryContext &gctx, NavigationState &nState) const

updates the navigation state with a single object that is filled in

Note

this is attaching objects without intersecting nor checking

Parameters

gctx – is the Geometry context of this call
nState – the navigation state to which the surfaces are attached

template<typename extractor_type, typename filler_type> class StaticUpdatorImpl : public Acts::Experimental::INavigationDelegate

#include <Acts/Navigation/NavigationStateUpdators.hpp>

This uses state less extractor and fillers to manipulate the navigation state.

Template Parameters

extractor_type – the helper to extract the objects from
filler_type – is the helper to fill the object into nState

Public Functions

inline void update([[maybe_unused]] const GeometryContext &gctx, NavigationState &nState) const

updates the navigation state with a single object that is filled in

Note

this is attaching objects without intersecting nor checking

Parameters

gctx – is the Geometry context of this call
nState – the navigation state to which the surfaces are attached

struct SurfacesFiller

#include <Acts/Navigation/NavigationStateFillers.hpp>

Fillers and attachers for surfaces to act on the navigation state.

Public Static Functions

static inline void fill(NavigationState &nState, const std::vector<const Surface*> &surfaces)

Helper struct that allows to fill surfaces into the candidate vector it allows to use common navigation structs for volume, portal, surfaces.

Parameters

nState – the navigation state
surfaces – the surfaces that are filled in

struct TrialAndErrorVolumeFinder : public Acts::Experimental::INavigationDelegate

#include <Acts/Navigation/DetectorVolumeFinders.hpp>

Public Functions

inline void update(const GeometryContext &gctx, NavigationState &nState) const

class VolumeStructureBuilder : public Acts::Experimental::IExternalStructureBuilder

#include <Acts/Detector/VolumeStructureBuilder.hpp>

This class provides the external detector volume structure, configured either from:

a volume extent
from an array with volume bounds identification

Note

A starting transform (defaulted to identity) can be provided, in case of volume bounds construction from an Acts::Extent object, the transform steming from the extent definition will be applied on top of the provided starting transform. In case of volume bounds construction from an array of values, the starting transform is already the final volume placement.

Public Functions

VolumeStructureBuilder(const Config &cfg, std::unique_ptr<const Logger> mlogger = getDefaultLogger("VolumeStructureBuilder", Logging::INFO))

Constructor.

Parameters

cfg – is the configuration struct
mlogger – logging instance for screen output

virtual ExternalStructure construct(const GeometryContext &gctx) const final

The interface definition for internal structure creation.

Parameters: gctx – the geometry context at the creation of the internal structure
Returns: a consistent set of detector volume internals

struct Config

#include <Acts/Detector/VolumeStructureBuilder.hpp>

Nexted configuration struct.

Public Members

std::string auxiliary = "": Some auxiliary information.

VolumeBounds::BoundsType boundsType = VolumeBounds::BoundsType::eOther: A defined volume bound type.

std::vector<ActsScalar> boundValues = {}: The values (if already defined)

std::optional<Extent> extent = std::nullopt: The optional extent to feed into the values.

Transform3 transform = Transform3::Identity(): The starting transform.

namespace GsfConstants

Typedefs

using FinalMultiComponentState = std::optional<Acts::MultiComponentBoundTrackParameters<SinglyCharged>>

Variables

constexpr std::string_view kFinalMultiComponentStateColumn = "gsf-final-multi-component-state"