EIC code displayed by LXR |
|
|
|
|||
File indexing completed on 2026-07-12 07:50:20
0001 // This file is part of the ACTS project. 0002 // 0003 // Copyright (C) 2016 CERN for the benefit of the ACTS project 0004 // 0005 // This Source Code Form is subject to the terms of the Mozilla Public 0006 // License, v. 2.0. If a copy of the MPL was not distributed with this 0007 // file, You can obtain one at https://mozilla.org/MPL/2.0/. 0008 0009 #pragma once 0010 0011 #include "Acts/Definitions/Algebra.hpp" 0012 #include "Acts/Definitions/Alignment.hpp" 0013 #include "Acts/Definitions/Tolerance.hpp" 0014 #include "Acts/Definitions/TrackParametrization.hpp" 0015 #include "Acts/Geometry/DetectorElementBase.hpp" 0016 #include "Acts/Geometry/GeometryContext.hpp" 0017 #include "Acts/Geometry/GeometryObject.hpp" 0018 #include "Acts/Geometry/Polyhedron.hpp" 0019 #include "Acts/Surfaces/BoundaryTolerance.hpp" 0020 #include "Acts/Surfaces/SurfaceBounds.hpp" 0021 #include "Acts/Surfaces/SurfacePlacementBase.hpp" 0022 #include "Acts/Utilities/CloneablePtr.hpp" 0023 #include "Acts/Utilities/Intersection.hpp" 0024 #include "Acts/Utilities/Result.hpp" 0025 #include "Acts/Visualization/ViewConfig.hpp" 0026 0027 #include <array> 0028 #include <memory> 0029 #include <ostream> 0030 #include <string> 0031 #include <string_view> 0032 #include <utility> 0033 0034 namespace Acts { 0035 0036 class SurfaceBounds; 0037 class ISurfaceMaterial; 0038 class Layer; 0039 class TrackingVolume; 0040 class IVisualization3D; 0041 0042 /// @class Surface 0043 /// 0044 /// @brief Abstract Base Class for tracking surfaces 0045 /// 0046 /// The Surface class builds the core of the Acts Tracking Geometry. 0047 /// All other geometrical objects are either extending the surface or 0048 /// are built from it. 0049 /// 0050 /// Surfaces are either owned by Detector elements or the Tracking Geometry, 0051 /// in which case they are not copied within the data model objects. 0052 /// 0053 class Surface : public virtual GeometryObject, 0054 public std::enable_shared_from_this<Surface> { 0055 public: 0056 friend struct GeometryContextOstreamWrapper<Surface>; 0057 0058 /// @enum SurfaceType 0059 /// 0060 /// This enumerator simplifies the persistency & calculations, 0061 /// by saving a dynamic_cast, e.g. for persistency 0062 enum SurfaceType { 0063 Cone = 0, 0064 Cylinder = 1, 0065 Disc = 2, 0066 Perigee = 3, 0067 Plane = 4, 0068 Straw = 5, 0069 Curvilinear = 6, 0070 Other = 7 0071 }; 0072 0073 /// Helper strings for screen output 0074 static constexpr std::array<std::string_view, Surface::SurfaceType::Other + 1> 0075 s_surfaceTypeNames = {"Cone", "Cylinder", "Disc", "Perigee", 0076 "Plane", "Straw", "Curvilinear", "Other"}; 0077 0078 friend std::ostream& operator<<(std::ostream& os, SurfaceType type); 0079 0080 protected: 0081 /// Constructor with Transform3 as a shared object 0082 /// 0083 /// @param transform Transform3 positions the surface in 3D global space 0084 /// @note also acts as default constructor 0085 explicit Surface(const Transform3& transform = Transform3::Identity()); 0086 0087 /// Copy constructor 0088 /// 0089 /// @note copy construction invalidates the association 0090 /// to detector element and layer 0091 /// 0092 /// @param other Source surface for copy. 0093 Surface(const Surface& other) noexcept = default; 0094 0095 /// Constructor from SurfacePlacement: Element proxy 0096 /// 0097 /// @param placement Reference to the surface placement 0098 /// @note The Surface does not take any ownership over the 0099 /// `SurfacePlacementBase` it is expected that the user 0100 /// ensures the life-time of the `SurfacePlacementBase` 0101 /// and that the `Surface` is actually owned by 0102 /// the `SurfacePlacementBase` instance 0103 explicit Surface(const SurfacePlacementBase& placement) noexcept; 0104 0105 /// Copy constructor with optional shift 0106 /// 0107 /// @note copy construction invalidates the association 0108 /// to detector element and layer 0109 /// 0110 /// @param gctx The current geometry context object, e.g. alignment 0111 /// @param other Source surface for copy 0112 /// @param shift Additional transform applied as: shift * transform 0113 explicit Surface(const GeometryContext& gctx, const Surface& other, 0114 const Transform3& shift) noexcept; 0115 0116 public: 0117 ~Surface() noexcept override; 0118 0119 /// Factory for producing memory managed instances of Surface. 0120 /// Will forward all parameters and will attempt to find a suitable 0121 /// constructor. 0122 /// @param args Constructor arguments to forward to surface creation 0123 /// @return Shared pointer to the created surface instance 0124 template <class T, typename... Args> 0125 static std::shared_ptr<T> makeShared(Args&&... args) { 0126 return std::shared_ptr<T>(new T(std::forward<Args>(args)...)); 0127 } 0128 0129 /// Retrieve a @c std::shared_ptr for this surface (non-const version) 0130 /// 0131 /// @note Will error if this was not created through the @c makeShared factory 0132 /// since it needs access to the original reference. In C++14 this is 0133 /// undefined behavior (but most likely implemented as a @c bad_weak_ptr 0134 /// exception), in C++17 it is defined as that exception. 0135 /// @note Only call this if you need shared ownership of this object. 0136 /// 0137 /// @return The shared pointer 0138 std::shared_ptr<Surface> getSharedPtr(); 0139 0140 /// Retrieve a @c std::shared_ptr for this surface (const version) 0141 /// 0142 /// @note Will error if this was not created through the @c makeShared factory 0143 /// since it needs access to the original reference. In C++14 this is 0144 /// undefined behavior, but most likely implemented as a @c bad_weak_ptr 0145 /// exception, in C++17 it is defined as that exception. 0146 /// @note Only call this if you need shared ownership of this object. 0147 /// 0148 /// @return The shared pointer 0149 std::shared_ptr<const Surface> getSharedPtr() const; 0150 0151 /// Assignment operator 0152 /// @note copy construction invalidates the association 0153 /// to detector element and layer 0154 /// 0155 /// @param other Source surface for the assignment 0156 /// @return Reference to this surface after assignment 0157 Surface& operator=(const Surface& other) noexcept = default; 0158 0159 /// Comparison (equality) operator 0160 /// The strategy for comparison is 0161 /// (a) first pointer comparison 0162 /// (b) then type comparison 0163 /// (c) then bounds comparison 0164 /// (d) then transform comparison 0165 /// 0166 /// @param other source surface for the comparison 0167 /// @return True if surfaces are equal, false otherwise 0168 bool operator==(const Surface& other) const; 0169 0170 public: 0171 /// Return method for the Surface type to avoid dynamic casts 0172 /// @return The surface type enumeration value 0173 virtual SurfaceType type() const = 0; 0174 0175 /// Return method for the surface Transform3 by reference 0176 /// In case a detector element is associated the surface transform 0177 /// is just forwarded to the detector element in order to keep the 0178 /// (mis-)alignment cache cetrally handled 0179 /// 0180 /// @param gctx The current geometry context object, e.g. alignment 0181 /// 0182 /// @return the contextual transform 0183 [[deprecated( 0184 "Please use localToGlobalTransform(const GeometryContext& gctx) " 0185 "instead")]] 0186 const Transform3& transform(const GeometryContext& gctx) const; 0187 /// Return method for the surface Transform3 by reference 0188 /// In case a detector element is associated the surface transform 0189 /// is just forwarded to the detector element in order to keep the 0190 /// (mis-)alignment cache cetrally handled 0191 /// 0192 /// @param gctx The current geometry context object, e.g. alignment 0193 /// 0194 /// @return the contextual transform 0195 const Transform3& localToGlobalTransform(const GeometryContext& gctx) const; 0196 0197 /// Return method for the surface center 0198 /// @note the center is always recalculated in order to not keep a cache 0199 /// 0200 /// @param gctx The current geometry context object, e.g. alignment 0201 /// 0202 /// @return center position by value 0203 virtual Vector3 center(const GeometryContext& gctx) const; 0204 0205 /// Return the surface normal at a given @p position and @p direction. 0206 /// This method is fully generic, and valid for all surface types. 0207 /// @note For some surface types, the @p direction is ignored, but 0208 /// it is **not safe** to pass in a zero vector! 0209 /// @param gctx The current geometry context object, e.g. alignment 0210 /// @param pos The position at which to calculate the normal 0211 /// @param direction The direction at which to calculate the normal 0212 /// @return The normal vector at the given position and direction 0213 virtual Vector3 normal(const GeometryContext& gctx, const Vector3& pos, 0214 const Vector3& direction) const = 0; 0215 0216 /// Return method for SurfaceBounds 0217 /// @return SurfaceBounds by reference 0218 virtual const SurfaceBounds& bounds() const = 0; 0219 0220 /// Return method for the associated Detector Element 0221 /// @deprecated This method is deprecated in favour of surfacePlacement() 0222 /// @return plain pointer to the DetectorElement, can be nullptr 0223 [[deprecated("Please use surfacePlacement()")]] 0224 const DetectorElementBase* associatedDetectorElement() const; 0225 0226 /// @brief Return the associated surface placement if there is any 0227 /// @return Pointer to the surface placement, can be nullptr 0228 const SurfacePlacementBase* surfacePlacement() const; 0229 0230 /// Return method for the associated Layer in which the surface is embedded 0231 /// @return Layer by plain pointer, can be nullptr 0232 const Layer* associatedLayer() const; 0233 0234 /// @brief Return the thickness of the surface in the normal direction 0235 /// @return The surface thickness 0236 double thickness() const; 0237 0238 /// Set Associated Layer 0239 /// Many surfaces can be associated to a Layer, but it might not be known yet 0240 /// during construction of the layer, this can be set afterwards 0241 /// 0242 /// @param lay the assignment Layer by reference 0243 void associateLayer(const Layer& lay); 0244 0245 /// Return method for the associated Material to this surface 0246 /// @return SurfaceMaterial as plain pointer, can be nullptr 0247 const ISurfaceMaterial* surfaceMaterial() const; 0248 0249 /// Return method for the shared pointer to the associated Material 0250 /// @return SurfaceMaterial as shared_pointer, can be nullptr 0251 const std::shared_ptr<const ISurfaceMaterial>& surfaceMaterialSharedPtr() 0252 const; 0253 0254 /// Assign a detector element 0255 /// 0256 /// @deprecated: The method is deprecated in favour of assignSurfacePlacement() 0257 /// @param detelement Detector element which is represented by this surface 0258 [[deprecated( 0259 "Please use assignSurfacePlacement(const SurfacePlacementBase& " 0260 "placement) instead")]] 0261 void assignDetectorElement(const SurfacePlacementBase& detelement); 0262 0263 /// @brief Assign a placement object which may dynamically align the surface in space 0264 /// @param placement: Placement object defining the surface's position 0265 void assignSurfacePlacement(const SurfacePlacementBase& placement); 0266 0267 /// Assign the surface material description 0268 /// 0269 /// The material is usually derived in a complicated way and loaded from 0270 /// a framework given source. As various surfaces may share the same source 0271 /// this is provided by a shared pointer 0272 /// 0273 /// @param material Material description associated to this surface 0274 void assignSurfaceMaterial(std::shared_ptr<const ISurfaceMaterial> material); 0275 0276 /// Assign whether the surface is sensitive 0277 /// @param isSensitive Boolean flag to set sensitivity 0278 /// @throw logic_error if the surface is associated to a detector element 0279 void assignIsSensitive(bool isSensitive); 0280 /// @brief Assign the thickness of the surface in the 0281 /// orthogonal dimension 0282 /// @param thick: Thickness parameter to assign (>=0) 0283 void assignThickness(double thick); 0284 0285 /// The geometric onSurface method 0286 /// 0287 /// Geometrical check whether position is on Surface 0288 /// 0289 /// @param gctx The current geometry context object, e.g. alignment 0290 /// @param position global position to be evaludated 0291 /// @param direction global momentum direction (required for line-type surfaces) 0292 /// @param boundaryTolerance BoundaryTolerance directive for this onSurface check 0293 /// @param tolerance optional tolerance within which a point is considered on surface 0294 /// 0295 /// @return boolean indication if operation was successful 0296 bool isOnSurface( 0297 const GeometryContext& gctx, const Vector3& position, 0298 const Vector3& direction, 0299 const BoundaryTolerance& boundaryTolerance = BoundaryTolerance::None(), 0300 double tolerance = s_onSurfaceTolerance) const; 0301 0302 /// Calculates the closest point on the boundary of the surface to a given 0303 /// point in local coordinates. 0304 /// @param lposition The local position to check 0305 /// @param metric The metric to use for the calculation 0306 /// @return The closest point on the boundary of the surface 0307 virtual Vector2 closestPointOnBoundary(const Vector2& lposition, 0308 const SquareMatrix2& metric) const; 0309 0310 /// Calculates the distance to the boundary of the surface from a given point 0311 /// in local coordinates. 0312 /// @param lposition The local position to check 0313 /// @return The distance to the boundary of the surface 0314 virtual double distanceToBoundary(const Vector2& lposition) const; 0315 0316 /// The insideBounds method for local positions 0317 /// 0318 /// @param lposition The local position to check 0319 /// @param boundaryTolerance BoundaryTolerance directive for this onSurface check 0320 /// @return boolean indication if operation was successful 0321 virtual bool insideBounds(const Vector2& lposition, 0322 const BoundaryTolerance& boundaryTolerance = 0323 BoundaryTolerance::None()) const; 0324 0325 /// Local to global transformation 0326 /// Generalized local to global transformation for the surface types. Since 0327 /// some surface types need the global momentum/direction to resolve sign 0328 /// ambiguity this is also provided 0329 /// 0330 /// @param gctx The current geometry context object, e.g. alignment 0331 /// @param lposition local 2D position in specialized surface frame 0332 /// @param direction global 3D momentum direction 0333 /// 0334 /// @return The global position by value 0335 virtual Vector3 localToGlobal(const GeometryContext& gctx, 0336 const Vector2& lposition, 0337 const Vector3& direction) const = 0; 0338 0339 /// Global to local transformation 0340 /// Generalized global to local transformation for the surface types. Since 0341 /// some surface types need the global momentum/direction to resolve sign 0342 /// ambiguity this is also provided 0343 /// 0344 /// @param gctx The current geometry context object, e.g. alignment 0345 /// @param position global 3D position - considered to be on surface but not 0346 /// inside bounds (check is done) 0347 /// @param direction global 3D momentum direction 0348 /// @param tolerance optional tolerance within which a point is considered 0349 /// valid on surface 0350 /// 0351 /// @return a Result<Vector2> which can be !ok() if the operation fails 0352 virtual Result<Vector2> globalToLocal( 0353 const GeometryContext& gctx, const Vector3& position, 0354 const Vector3& direction, 0355 double tolerance = s_onSurfaceTolerance) const = 0; 0356 0357 /// Return method for the reference frame 0358 /// This is the frame in which the covariance matrix is defined (specialized 0359 /// by all surfaces) 0360 /// 0361 /// @param gctx The current geometry context object, e.g. alignment 0362 /// @param position global 3D position - considered to be on surface but not 0363 /// inside bounds (check is done) 0364 /// @param direction global 3D momentum direction (optionally ignored) 0365 /// 0366 /// @return RotationMatrix3 which defines the three axes of the measurement 0367 /// frame 0368 virtual Acts::RotationMatrix3 referenceFrame(const GeometryContext& gctx, 0369 const Vector3& position, 0370 const Vector3& direction) const; 0371 0372 /// Calculate the jacobian from local to global which the surface knows best, 0373 /// hence the calculation is done here. 0374 /// 0375 /// @note In principle, the input could also be a free parameters 0376 /// vector as it could be transformed to a bound parameters. But the transform 0377 /// might fail in case the parameters is not on surface. To avoid the check 0378 /// inside this function, it takes directly the bound parameters as input 0379 /// (then the check might be done where this function is called). 0380 /// 0381 /// @todo this mixes track parameterisation and geometry 0382 /// should move to : 0383 /// "Acts/EventData/detail/coordinate_transformations.hpp" 0384 /// 0385 /// @param gctx The current geometry context object, e.g. alignment 0386 /// @param position global 3D position 0387 /// @param direction global 3D momentum direction 0388 /// 0389 /// @return Jacobian from local to global 0390 virtual BoundToFreeMatrix boundToFreeJacobian(const GeometryContext& gctx, 0391 const Vector3& position, 0392 const Vector3& direction) const; 0393 0394 /// Calculate the jacobian from global to local which the surface knows best, 0395 /// hence the calculation is done here. 0396 /// 0397 /// @note It assumes the input free parameters is on surface, hence no 0398 /// onSurface check is done inside this function. 0399 /// 0400 /// @todo this mixes track parameterisation and geometry 0401 /// should move to : 0402 /// "Acts/EventData/detail/coordinate_transformations.hpp" 0403 /// 0404 /// @param gctx The current geometry context object, e.g. alignment 0405 /// @param position global 3D position 0406 /// @param direction global 3D momentum direction 0407 /// 0408 /// @return Jacobian from global to local 0409 virtual FreeToBoundMatrix freeToBoundJacobian(const GeometryContext& gctx, 0410 const Vector3& position, 0411 const Vector3& direction) const; 0412 0413 /// Calculate the derivative of path length at the geometry constraint or 0414 /// point-of-closest-approach w.r.t. free parameters. The calculation is 0415 /// identical for all surfaces where the reference frame does not depend on 0416 /// the direction 0417 /// 0418 /// @todo this mixes track parameterisation and geometry 0419 /// should move to : 0420 /// "Acts/EventData/detail/coordinate_transformations.hpp" 0421 /// 0422 /// @param gctx The current geometry context object, e.g. alignment 0423 /// @param position global 3D position 0424 /// @param direction global 3D momentum direction 0425 /// 0426 /// @return Derivative of path length w.r.t. free parameters 0427 virtual FreeToPathMatrix freeToPathDerivative(const GeometryContext& gctx, 0428 const Vector3& position, 0429 const Vector3& direction) const; 0430 0431 /// Calculation of the path correction for incident 0432 /// 0433 /// @param gctx The current geometry context object, e.g. alignment 0434 /// @param position global 3D position 0435 /// @note The @p position is either ignored, or it is coerced to be on the surface, 0436 /// depending on the surface type. 0437 /// @param direction global 3D momentum direction 0438 /// 0439 /// @return Path correction with respect to the nominal incident. 0440 virtual double pathCorrection(const GeometryContext& gctx, 0441 const Vector3& position, 0442 const Vector3& direction) const = 0; 0443 0444 /// Straight line intersection schema from position/direction 0445 /// 0446 /// @param gctx The current geometry context object, e.g. alignment 0447 /// @param position The position to start from 0448 /// @param direction The direction at start 0449 /// @param boundaryTolerance the BoundaryTolerance 0450 /// @param tolerance the tolerance used for the intersection 0451 /// 0452 /// @return @c MultiIntersection3D intersection object 0453 virtual MultiIntersection3D intersect( 0454 const GeometryContext& gctx, const Vector3& position, 0455 const Vector3& direction, 0456 const BoundaryTolerance& boundaryTolerance = 0457 BoundaryTolerance::Infinite(), 0458 double tolerance = s_onSurfaceTolerance) const = 0; 0459 0460 /// Helper method for printing: the returned object captures the 0461 /// surface and the geometry context and will print the surface 0462 /// @param gctx The current geometry context object, e.g. alignment 0463 /// @return The wrapper object for printing 0464 GeometryContextOstreamWrapper<Surface> toStream( 0465 const GeometryContext& gctx) const { 0466 return {*this, gctx}; 0467 } 0468 0469 /// Output into a std::string 0470 /// 0471 /// @param gctx The current geometry context object, e.g. alignment 0472 /// @return String representation of the surface 0473 std::string toString(const GeometryContext& gctx) const; 0474 0475 /// Return properly formatted class name 0476 /// @return The surface class name as a string 0477 virtual std::string name() const = 0; 0478 0479 /// @brief Returns whether the Surface is sensitive 0480 /// @return True if the surface is sensitive 0481 bool isSensitive() const; 0482 /// @brief Returns whether the Surface is alignable 0483 /// @return True if the surface is alignable 0484 bool isAlignable() const; 0485 0486 /// Return a Polyhedron for surface objects 0487 /// 0488 /// @param gctx The current geometry context object, e.g. alignment 0489 /// @param quarterSegments The number of segemtns to approximate a 0.5*pi sector, 0490 /// which represents a quarter of the full circle 0491 /// 0492 /// @note In order to symmetrize the code between sectoral and closed cylinders 0493 /// in case of closed cylinders, both (-pi, pi) are given as separate vertices 0494 /// 0495 /// @note An internal surface transform can invalidate the extrema 0496 /// in the transformed space 0497 /// 0498 /// @return A list of vertices and a face/facett description of it 0499 virtual Polyhedron polyhedronRepresentation( 0500 const GeometryContext& gctx, unsigned int quarterSegments = 2u) const = 0; 0501 0502 /// The derivative of bound track parameters w.r.t. alignment 0503 /// parameters of its reference surface (i.e. local frame origin in 0504 /// global 3D Cartesian coordinates and its rotation represented with 0505 /// extrinsic Euler angles) 0506 /// 0507 /// @param gctx The current geometry context object, e.g. alignment 0508 /// change of alignment parameters 0509 /// @param position global 3D position 0510 /// @param direction global 3D momentum direction 0511 /// @param pathDerivative is the derivative of free parameters w.r.t. path 0512 /// length 0513 /// 0514 /// @return Derivative of bound track parameters w.r.t. local frame 0515 /// alignment parameters 0516 AlignmentToBoundMatrix alignmentToBoundDerivative( 0517 const GeometryContext& gctx, const Vector3& position, 0518 const Vector3& direction, const FreeVector& pathDerivative) const; 0519 0520 /// Calculate the derivative of path length at the geometry constraint or 0521 /// point-of-closest-approach w.r.t. alignment parameters of the surface (i.e. 0522 /// local frame origin in global 3D Cartesian coordinates and its rotation 0523 /// represented with extrinsic Euler angles) 0524 /// 0525 /// @note Re-implementation is needed for surface whose intersection with 0526 /// track is not its local xy plane, e.g. LineSurface, CylinderSurface and 0527 /// ConeSurface 0528 /// 0529 /// @param gctx The current geometry context object, e.g. alignment 0530 /// @param position global 3D position 0531 /// @param direction global 3D momentum direction 0532 /// 0533 /// @return Derivative of path length w.r.t. the alignment parameters 0534 virtual AlignmentToPathMatrix alignmentToPathDerivative( 0535 const GeometryContext& gctx, const Vector3& position, 0536 const Vector3& direction) const; 0537 0538 /// Calculate the derivative of bound track parameters local position w.r.t. 0539 /// position in local 3D Cartesian coordinates 0540 /// 0541 /// @param gctx The current geometry context object, e.g. alignment 0542 /// @param position The position of the parameters in global 0543 /// 0544 /// @return Derivative of bound local position w.r.t. position in local 3D 0545 /// cartesian coordinates 0546 virtual Matrix<2, 3> localCartesianToBoundLocalDerivative( 0547 const GeometryContext& gctx, const Vector3& position) const = 0; 0548 0549 /// Visualize the surface for debugging and inspection 0550 /// @param helper Visualization helper for 3D rendering 0551 /// @param gctx Geometry context for coordinate transformations 0552 /// @param viewConfig Visual configuration (color, style, etc.) 0553 void visualize(IVisualization3D& helper, const GeometryContext& gctx, 0554 const ViewConfig& viewConfig = s_viewSurface) const; 0555 0556 protected: 0557 /// Output Method for std::ostream, to be overloaded by child classes 0558 /// 0559 /// @param gctx The current geometry context object, e.g. alignment 0560 /// @param sl is the ostream to be dumped into 0561 /// @return Reference to the output stream for chaining 0562 virtual std::ostream& toStreamImpl(const GeometryContext& gctx, 0563 std::ostream& sl) const; 0564 0565 /// Transform3 definition that positions 0566 /// (translation, rotation) the surface in global space 0567 CloneablePtr<const Transform3> m_transform{}; 0568 0569 private: 0570 /// Pointer to the a SurfacePlacement 0571 const SurfacePlacementBase* m_placement{nullptr}; 0572 0573 /// The associated layer Layer - layer in which the Surface is be embedded, 0574 /// nullptr if not associated 0575 const Layer* m_associatedLayer{nullptr}; 0576 0577 /// Possibility to attach a material description 0578 std::shared_ptr<const ISurfaceMaterial> m_surfaceMaterial; 0579 0580 /// Flag to indicate whether the surface is sensitive 0581 bool m_isSensitive{false}; 0582 0583 /// @brief Thickness of the surface in the normal direction 0584 double m_thickness{0.}; 0585 /// Calculate the derivative of bound track parameters w.r.t. 0586 /// alignment parameters of its reference surface (i.e. origin in global 3D 0587 /// Cartesian coordinates and its rotation represented with extrinsic Euler 0588 /// angles) without any path correction 0589 /// 0590 /// @note This function should be used together with alignment to path 0591 /// derivative to get the full alignment to bound derivatives 0592 /// 0593 /// @param gctx The current geometry context object, e.g. alignment 0594 /// @param position global 3D position 0595 /// @param direction global 3D momentum direction 0596 /// 0597 /// @return Derivative of bound track parameters w.r.t. local frame alignment 0598 /// parameters without path correction 0599 AlignmentToBoundMatrix alignmentToBoundDerivativeWithoutCorrection( 0600 const GeometryContext& gctx, const Vector3& position, 0601 const Vector3& direction) const; 0602 }; 0603 0604 } // namespace Acts
| [ Source navigation ] | [ Diff markup ] | [ Identifier search ] | [ general search ] |
|
This page was automatically generated by the 2.3.7 LXR engine. The LXR team |
|