Class LineSurface

Inheritance Relationships

Base Type

Derived Types

Class Documentation

class Acts::LineSurface : public Acts::Surface

Base class for a linear surfaces in the TrackingGeometry to describe dirft tube, straw like detectors or the Perigee It inherits from Surface.

_build/doxygen-xml/LineSurface.png

Note

It leaves the type() method virtual, so it can not be instantiated

Subclassed by Acts::PerigeeSurface, Acts::StrawSurface

Public Functions

LineSurface() = delete

Default Constructor - deleted.

~LineSurface() override = default

Destructor - defaulted.

const Vector3D binningPosition(const GeometryContext &gctx, BinningValue bValue) const final

The binning position is the position calcualted for a certain binning type.

Return

position that can beused for this binning

Parameters

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

  • bValue: is the binning type to be used

const SurfaceBounds &bounds() const final

This method returns the bounds of the Surface by reference */.

const BoundRowVector derivativeFactors(const GeometryContext &gctx, const Vector3D &position, const Vector3D &direction, const RotationMatrix3D &rft, const BoundToFreeMatrix &jacobian) const final

Calculate the form factors for the derivatives the calculation is identical for all surfaces where the reference frame does not depend on the direction.

Return

a five-dim vector

Parameters

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

  • position: is the position of the paramters in global

  • direction: is the direction of the track

  • rft: is the transposed reference frame (avoids recalculation)

  • jacobian: is the transport jacobian

bool globalToLocal(const GeometryContext &gctx, const Vector3D &position, const Vector3D &momentum, Vector2D &lposition) const final

Specified for LineSurface: global to local method without dynamic memory allocation.

This method is the true global->local transformation.

makes use of globalToLocal and indicates the sign of the Acts::eLOC_R by the given momentum

The calculation of the sign of the radius (or \( d_0 \)) can be done as follows:

May

\( \vec d = \vec m - \vec c \) denote the difference between the center of the line and the global position of the measurement/predicted state, then \( \vec d \) lies within the so called measurement plane. The measurement plane is determined by the two orthogonal vectors \( \vec{measY}= \vec{Acts::eLOC_Z} \) and \( \vec{measX} = \vec{measY} \times \frac{\vec{p}}{|\vec{p}|} \).

The sign of the radius ( \( d_{0} \) ) is then defined by the projection of \( \vec{d} \) onto \( \vec{measX} \):\( sign = -sign(\vec{d} \cdot \vec{measX}) \)

_build/doxygen-xml/SignOfDriftCircleD0.gif

Return

boolean indication if operation was successful (fail means global position was not on surface)

Parameters

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

  • position: global 3D position - considered to be on surface but not inside bounds (check is done)

  • momentum: global 3D momentum representation (optionally ignored)

  • lposition: local 2D position to be filled (given by reference for method symmetry)

void initJacobianToGlobal(const GeometryContext &gctx, BoundToFreeMatrix &jacobian, const Vector3D &position, const Vector3D &direction, const BoundVector &pars) const final

Initialize the jacobian from local to global the surface knows best, hence the calculation is done here.

The jacobian is assumed to be initialised, so only the relevant entries are filled

Parameters

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

  • jacobian: is the jacobian to be initialized

  • position: is the global position of the parameters

  • direction: is the direction at of the parameters

  • pars: is the paranmeters vector

Intersection intersectionEstimate(const GeometryContext &gctx, const Vector3D &position, const Vector3D &direction, const BoundaryCheck &bcheck = false) const final

Straight line intersection schema.

mathematical motivation: Given two lines in parameteric form:

  • \( \vec l_{a}(\lambda) = \vec m_a + \lambda \cdot \vec e_{a} \)

  • \( \vec l_{b}(\mu) = \vec m_b + \mu \cdot \vec e_{b} \)

    the vector between any two points on the two lines is given by:

  • \( \vec s(\lambda, \mu) = \vec l_{b} - l_{a} = \vec m_{ab} + \mu \cdot \vec e_{b} - \lambda \cdot \vec e_{a} \),

    when

    \( \vec m_{ab} = \vec m_{b} - \vec m_{a} \).\( \vec s(u, \mu_0) \) denotes the vector between the two closest points \( \vec l_{a,0} = l_{a}(u) \) and \( \vec l_{b,0} = l_{b}(\mu_0) \)

    and is perpendicular to both,

    \( \vec e_{a} \) and \( \vec e_{b} \).

Note

exptected to be normalized

Parameters

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

  • position: The global position as a starting point

  • direction: The global direction at the starting point

Parameters

  • bcheck: The boundary check directive for the estimate

This results in a system of two linear equations:

  • (i) \( 0 = \vec s(u, \mu_0) \cdot \vec e_a = \vec m_ab \cdot \vec e_a + \mu_0 \vec e_a \cdot \vec e_b - u \)

  • (ii) \( 0 = \vec s(u, \mu_0) \cdot \vec e_b = \vec m_ab \cdot \vec e_b + \mu_0 - u \vec e_b \cdot \vec e_a \)

Solving (i), (ii) for \( u \) and \( \mu_0 \) yields:

  • \( u = \frac{(\vec m_ab \cdot \vec e_a)-(\vec m_ab \cdot \vec e_b)(\vec e_a \cdot \vec e_b)}{1-(\vec e_a \cdot \vec e_b)^2} \)

  • \( \mu_0 = - \frac{(\vec m_ab \cdot \vec e_b)-(\vec m_ab \cdot \vec e_a)(\vec e_a \cdot \vec e_b)}{1-(\vec e_a \cdot \vec e_b)^2} \)

Return

is the intersection object

void localToGlobal(const GeometryContext &gctx, const Vector2D &lposition, const Vector3D &momentum, Vector3D &position) const final

Local to global transformation for line surfaces the momentum is used in order to interpret the drift radius.

Parameters

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

  • lposition: is the local position to be transformed

  • momentum: is the global momentum (used to sign the closest approach)

  • position: is the global position which is filled

std::string name() const override

Return properly formatted class name for screen output */.

const Vector3D normal(const GeometryContext &gctx, const Vector2D &lposition) const final

Normal vector return.

Return

a Vector3D by value

Parameters

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

  • lposition: is the local position is ignored

LineSurface &operator=(const LineSurface &other)

Assignment operator.

Parameters

  • slsf: is the source surface dor copying

double pathCorrection(const GeometryContext &gctx, const Vector3D &position, const Vector3D &momentum) const override

the pathCorrection for derived classes with thickness is by definition 1 for LineSurfaces

Note

input parameters are ignored

Note

there’s no material associated to the line surface

const RotationMatrix3D referenceFrame(const GeometryContext &gctx, const Vector3D &position, const Vector3D &momentum) const final

Return the measurement frame - this is needed for alignment, in particular.

for StraightLine and Perigee Surface

  • the default implementation is the the RotationMatrix3D of the transform

Return

is a rotation matrix that indicates the measurement frame

Parameters

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

  • position: is the global position where the measurement frame is constructed

  • momentum: is the momentum used for the measurement frame construction

Protected Functions

LineSurface(std::shared_ptr<const Transform3D> htrans, double radius, double halez)

Constructor from Transform3D and bounds.

Parameters

  • htrans: The transform that positions the surface in the global frame

  • radius: The straw radius

  • halez: The half length in z

LineSurface(std::shared_ptr<const Transform3D> htrans, std::shared_ptr<const LineBounds> lbounds = nullptr)

Constructor from Transform3D and a shared bounds object.

Parameters

  • htrans: The transform that positions the surface in the global frame

  • lbounds: The bounds describing the straw dimensions, can be optionally nullptr

LineSurface(const std::shared_ptr<const LineBounds> &lbounds, const DetectorElementBase &detelement)

Constructor from DetectorElementBase : Element proxy.

Parameters

  • lbounds: The bounds describing the straw dimensions

  • detelement: for which this surface is (at least) one representation

LineSurface(const LineSurface &other)

Copy constructor.

Parameters

  • other: The source surface for copying

LineSurface(const GeometryContext &gctx, const LineSurface &other, const Transform3D &transf)

Copy constructor - with shift.

Parameters

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

  • other: is the source cone surface

  • transf: is the additional transfrom applied after copying

Protected Attributes

std::shared_ptr<const LineBounds> m_bounds

bounds (shared)