Class Layer

Inheritance Relationships

Base Type

Derived Types

Class Documentation

class Acts::Layer : public virtual Acts::GeometryObject

Base Class for a Detector Layer in the Tracking Geometry.

An actual implemented Detector Layer inheriting from this base class has to inherit from a specific type of Surface as well. In addition, a Layer can carry:

A SurfaceArray of Surfaces holding the actual detector elements or subSurfaces. A pointer to the TrackingVolume (can only be set by such) An active/passive code : 0 - activ 1 - passive [….] - other

The search type for compatible surfaces on a layer is [ the higher the number, the faster ]: —— Layer internal ——————————————— -1 - provide all intersection tested without boundary check 0 - provide all intersection tested with boundary check 1 - provide overlap descriptor based without boundary check 2 - provide overlap descriptor based with boundary check

A layer can have substructure regarding:

  • m_ssRepresentingSurface -> always exists (1), can have material (2)

  • m_ssSensitiveSurfaces -> can or not exist (0,1), can have material (2)

  • m_ssApproachSurfaces -> can or not exist (0,1) cam have material (2)

Subclassed by Acts::ConeLayer, Acts::CylinderLayer, Acts::DiscLayer, Acts::NavigationLayer, Acts::PlaneLayer

Public Functions

Layer() = delete

Default Constructor - deleted.

Layer(const Layer&) = delete

Copy Constructor - deleted.

~Layer() = default

Destructor.

const ApproachDescriptor *approachDescriptor() const

Return method for the approach descriptor, can be nullptr.

ApproachDescriptor *approachDescriptor()

Non-const version of the approach descriptor.

template<typename options_t>
std::vector<SurfaceIntersection> compatibleSurfaces(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, const options_t &options) const

Decompose Layer into (compatible) surfaces.

Return

list of intersection of surfaces on the layer

Template Parameters

  • options_t: The navigation options type

Parameters

  • gctx: The current geometry context object, e.g. alignment

  • position: Position parameter for searching

  • momentum: Momentum parameter for searching

  • options: The templated naivation options

bool isOnLayer(const GeometryContext &gctx, const Vector3 &position, const BoundaryCheck &bcheck = true) const

geometrical isOnLayer() method

Note

using isOnSurface() with Layer specific tolerance

Return

boolean that indicates success of the operation

Parameters

  • gctx: The current geometry context object, e.g. alignment

  • position: is the gobal position to be checked

  • bcheck: is the boundary check directive

LayerType layerType() const

return the LayerType

const Layer *nextLayer(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction) const

Fast navigation to next layer.

Return

the pointer to the next layer

Parameters

  • gctx: The current geometry context object, e.g. alignment

  • position: is the start position for the search

  • direction: is the direction for the search

Layer &operator=(const Layer&) = delete

Assignment operator - forbidden, layer assignment must not be ambiguous.

Parameters

  • lay: is the source layer for assignment

const AbstractVolume *representingVolume() const

Return the abstract volume that represents the layer.

Return

the representing volume of the layer

template<typename options_t>
bool resolve(const options_t &options) const

Accept layer according to the following collection directives.

Return

a boolean whether the layer is accepted for processing

Template Parameters

  • options_t: Type of the options for navigation

bool resolve(bool resolveSensitive, bool resolveMaterial, bool resolvePassive) const

Accept layer according to the following collection directives.

Return

a boolean whether the layer is accepted for processing

Parameters

  • resolveSensitive: is the prescription to find the sensitive surfaces

  • resolveMaterial: is the precription to find material surfaces

  • resolvePassive: is the prescription to find all passive surfaces

const SurfaceArray *surfaceArray() const

Return the entire SurfaceArray, returns a nullptr if no SurfaceArray.

SurfaceArray *surfaceArray()

Non-const version.

template<typename options_t>
const SurfaceIntersection surfaceOnApproach(const GeometryContext &gctx, const Vector3 &position, const Vector3 &direction, const options_t &options) const

Surface seen on approach.

for layers without sub structure, this is the surfaceRepresentation for layers with sub structure, this is the approachSurface

Template Parameters

  • options_t: The navigation options type

Return

the Surface intersection of the approach surface

Parameters

  • gctx: The current geometry context object, e.g. alignment

  • position: Position for searching

  • direction: Direction for searching

  • options: The templated naivation options

const Surface &surfaceRepresentation() const = 0

Transforms the layer into a Surface representation for extrapolation.

Note

the layer can be hosting many surfaces, but this is the global one to which one can extrapolate

Surface &surfaceRepresentation() = 0
double thickness() const

Return the Thickness of the Layer this is by definition along the normal vector of the surfaceRepresentation.

const TrackingVolume *trackingVolume() const

Get the confining TrackingVolume.

Return

the pointer to the enclosing volume

Protected Functions

Layer(std::unique_ptr<SurfaceArray> surfaceArray, double thickness = 0., std::unique_ptr<ApproachDescriptor> ades = nullptr, LayerType laytyp = passive)

Constructor with pointer to SurfaceArray (passing ownership)

Parameters

  • surfaceArray: is the array of sensitive surfaces

  • thickness: is the normal thickness of the Layer

  • ades: oapproach descriptor

  • laytyp: is the layer type if active or passive

void encloseTrackingVolume(const TrackingVolume &tvol)

private method to set enclosing TrackingVolume, called by friend class only optionally, the layer can be resized to the dimensions of the TrackingVolume

  • Bounds of the Surface are resized

  • MaterialSlab dimensions are resized

  • SubSurface array boundaries are NOT resized

Parameters

  • tvol: is the tracking volume the layer is confined

Protected Attributes

std::unique_ptr<const ApproachDescriptor> m_approachDescriptor = nullptr

descriptor for surface on approach

The descriptor may need to be modified during geometry building, and will remain constant afterwards, but again C++ cannot currently express this.

double m_layerThickness = 0.

Thickness of the Layer.

LayerType m_layerType

make a passive/active either way

NextLayers m_nextLayers

the previous Layer according to BinGenUtils

const BinUtility *m_nextLayerUtility = nullptr

A binutility to find the next layer check if this is needed.

std::unique_ptr<AbstractVolume> m_representingVolume = nullptr

Representing Volume can be used as approach surface sources.

int m_ssApproachSurfaces = 0
int m_ssRepresentingSurface = 0

sub structure indication

int m_ssSensitiveSurfaces = 0
std::unique_ptr<const SurfaceArray> m_surfaceArray = nullptr

SurfaceArray on this layer Surface.

This array will be modified during signature and constant afterwards, but the C++ type system unfortunately cannot cleanly express this.

const TrackingVolume *m_trackingVolume = nullptr

the enclosing TrackingVolume