EIC code displayed by LXR |
|
|
|
|||
File indexing completed on 2026-04-02 07:32:05
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/Geometry/BoundarySurfaceFace.hpp" 0013 #include "Acts/Geometry/BoundarySurfaceT.hpp" 0014 #include "Acts/Geometry/GeometryContext.hpp" 0015 #include "Acts/Geometry/GeometryIdentifier.hpp" 0016 #include "Acts/Geometry/Layer.hpp" 0017 #include "Acts/Geometry/Portal.hpp" 0018 #include "Acts/Geometry/TrackingGeometryVisitor.hpp" 0019 #include "Acts/Geometry/TrackingVolumeVisitorConcept.hpp" 0020 #include "Acts/Geometry/Volume.hpp" 0021 #include "Acts/Material/IVolumeMaterial.hpp" 0022 #include "Acts/Navigation/NavigationDelegate.hpp" 0023 #include "Acts/Navigation/NavigationStream.hpp" 0024 #include "Acts/Propagator/NavigationTarget.hpp" 0025 #include "Acts/Surfaces/Surface.hpp" 0026 #include "Acts/Surfaces/SurfaceVisitorConcept.hpp" 0027 #include "Acts/Utilities/BinnedArray.hpp" 0028 #include "Acts/Utilities/Logger.hpp" 0029 #include "Acts/Utilities/TransformRange.hpp" 0030 #include "Acts/Visualization/ViewConfig.hpp" 0031 0032 #include <cstddef> 0033 #include <memory> 0034 #include <string> 0035 #include <utility> 0036 #include <vector> 0037 0038 #include <boost/container/container_fwd.hpp> 0039 0040 namespace Acts { 0041 0042 class GlueVolumesDescriptor; 0043 class VolumeBounds; 0044 template <typename object_t> 0045 struct NavigationOptions; 0046 class IMaterialDecorator; 0047 class ISurfaceMaterial; 0048 class IVolumeMaterial; 0049 class Surface; 0050 class TrackingVolume; 0051 struct GeometryIdentifierHook; 0052 class Portal; 0053 class INavigationPolicy; 0054 0055 /// Interface types of the Gen1 geometry model 0056 /// @note This interface is being replaced, and is subject to removal 0057 /// @{ 0058 0059 // master typedefs 0060 using TrackingVolumePtr = std::shared_ptr<const TrackingVolume>; 0061 using MutableTrackingVolumePtr = std::shared_ptr<TrackingVolume>; 0062 0063 /// @typedef TrackingVolumeBoundaryPtr 0064 /// Shared pointer to a constant BoundarySurfaceT of a TrackingVolume. 0065 using TrackingVolumeBoundaryPtr = 0066 std::shared_ptr<const BoundarySurfaceT<TrackingVolume>>; 0067 /// Type alias for collection of tracking volume boundaries 0068 using TrackingVolumeBoundaries = std::vector<TrackingVolumeBoundaryPtr>; 0069 0070 // possible contained 0071 using TrackingVolumeArray = BinnedArray<TrackingVolumePtr>; 0072 using TrackingVolumeVector = std::vector<TrackingVolumePtr>; 0073 using MutableTrackingVolumeVector = std::vector<MutableTrackingVolumePtr>; 0074 using LayerArray = BinnedArray<LayerPtr>; 0075 using LayerVector = std::vector<LayerPtr>; 0076 0077 /// @} 0078 0079 /// @class TrackingVolume 0080 /// 0081 /// Full Volume description used in Tracking, 0082 /// it inherits from Volume to get the geometrical structure. 0083 /// 0084 /// A TrackingVolume at navigation level can provide the (layer) material 0085 /// information / internal navigation with in 0086 /// 5 different ways: 0087 /// 0088 /// --- a) Static confinement of Layers 0089 /// --- b) detached sub volumes 0090 /// --- b) unordered (arbitrarily oriented) layers 0091 /// --- d) unordered sub volumes 0092 /// --- e) unordered layers AND unordered subvolumes 0093 /// 0094 /// The TrackingVolume can also be a simple container of other 0095 /// TrackingVolumes 0096 /// 0097 /// In addition it is capable of holding a subarray of Layers and 0098 /// TrackingVolumes. 0099 /// 0100 class TrackingVolume : public Volume { 0101 friend class TrackingGeometry; 0102 0103 public: 0104 TrackingVolume() = delete; 0105 ~TrackingVolume() override; 0106 TrackingVolume(const TrackingVolume&) = delete; 0107 TrackingVolume& operator=(const TrackingVolume&) = delete; 0108 0109 // The move constructors are declared here and defined in the .cpp file to 0110 // enable forward declarations. 0111 0112 /// Move constructor for transferring ownership of tracking volume resources. 0113 TrackingVolume(TrackingVolume&&) noexcept; 0114 /// Move assignment operator for transferring ownership of tracking volume 0115 /// resources. 0116 /// @return Reference to this TrackingVolume after move assignment 0117 TrackingVolume& operator=(TrackingVolume&&) noexcept; 0118 0119 /// Constructor for an aligned container volume container Volume 0120 /// - vacuum filled volume either as a for other tracking volumes 0121 /// 0122 /// @param placement is the volume placement object dynamically positioning 0123 /// the volume in space 0124 /// @param volbounds is the description of the volume boundaries 0125 /// @param volumeName is a string identifier 0126 TrackingVolume(VolumePlacementBase& placement, 0127 std::shared_ptr<VolumeBounds> volbounds, 0128 const std::string& volumeName = "undefined"); 0129 0130 /// Constructor for a container Volume 0131 /// - vacuum filled volume either as a for other tracking volumes 0132 /// 0133 /// @param transform is the global 3D transform to position the volume in 0134 /// space 0135 /// @param volbounds is the description of the volume boundaries 0136 /// @param volumeName is a string identifier 0137 TrackingVolume(const Transform3& transform, 0138 std::shared_ptr<VolumeBounds> volbounds, 0139 const std::string& volumeName = "undefined"); 0140 0141 /// Constructor for a full equipped Tracking Volume 0142 /// 0143 /// @param transform is the global 3D transform to position the volume in 0144 /// space 0145 /// @param volumeBounds is the description of the volume boundaries 0146 /// @param volumeMaterial is are materials of the tracking volume 0147 /// @param staticLayerArray is the confined layer array (optional) 0148 /// @param containedVolumeArray are the sub volumes if the volume is a 0149 /// container 0150 /// @param denseVolumeVector The contained dense volumes 0151 /// @param volumeName is a string identifier 0152 TrackingVolume( 0153 const Transform3& transform, std::shared_ptr<VolumeBounds> volumeBounds, 0154 std::shared_ptr<const IVolumeMaterial> volumeMaterial, 0155 std::unique_ptr<const LayerArray> staticLayerArray = nullptr, 0156 std::shared_ptr<const TrackingVolumeArray> containedVolumeArray = nullptr, 0157 MutableTrackingVolumeVector denseVolumeVector = {}, 0158 const std::string& volumeName = "undefined"); 0159 0160 /// Constructor from a regular volume 0161 /// @param volume is the volume to be converted 0162 /// @param volumeName is a string identifier 0163 explicit TrackingVolume(const Volume& volume, 0164 const std::string& volumeName = "undefined"); 0165 0166 /// Return the associated sub Volume, returns THIS if no subVolume exists 0167 /// @param gctx The current geometry context object, e.g. alignment 0168 /// @param position is the global position associated with that search 0169 /// @param tol Search position tolerance for dense volumes 0170 /// 0171 /// @return plain pointer to associated with the position 0172 const TrackingVolume* lowestTrackingVolume(const GeometryContext& gctx, 0173 const Vector3& position, 0174 const double tol = 0.) const; 0175 0176 /// @brief Visit all reachable surfaces 0177 /// 0178 /// @tparam visitor_t Type of the callable visitor 0179 /// 0180 /// @param visitor The callable. Will be called for each reachable surface 0181 /// that is found, a selection of the surfaces can be done in the visitor 0182 /// @param restrictToSensitives If true, only sensitive surfaces are visited 0183 /// 0184 /// @note If a context is needed for the visit, the vistitor has to provide 0185 /// this, e.g. as a private member 0186 template <SurfaceVisitor visitor_t> 0187 void visitSurfaces(visitor_t&& visitor, bool restrictToSensitives) const { 0188 auto sensitive = [&visitor](const Surface& surface) { 0189 if (surface.geometryId().sensitive() == 0) { 0190 return; 0191 } 0192 visitor(&surface); 0193 }; 0194 0195 if (restrictToSensitives) { 0196 apply(sensitive); 0197 } else { 0198 apply(overloaded{ 0199 sensitive, 0200 [&visitor](const Portal& portal) { visitor(&portal.surface()); }, 0201 [&visitor](const BoundarySurface& bs) { 0202 visitor(&bs.surfaceRepresentation()); 0203 }}); 0204 } 0205 } 0206 0207 /// @brief Visit all sensitive surfaces 0208 /// 0209 /// @tparam visitor_t Type of the callable visitor 0210 /// 0211 /// @param visitor The callable. Will be called for each sensitive surface 0212 /// that is found, a selection of the surfaces can be done in the visitor 0213 /// 0214 /// @note If a context is needed for the visit, the vistitor has to provide 0215 /// this, e.g. as a private member 0216 template <SurfaceVisitor visitor_t> 0217 void visitSurfaces(visitor_t&& visitor) const { 0218 visitSurfaces(std::forward<visitor_t>(visitor), true); 0219 } 0220 0221 /// @brief Visit all reachable tracking volumes 0222 /// 0223 /// @tparam visitor_t Type of the callable visitor 0224 /// 0225 /// @param visitor The callable. Will be called for each reachable volume 0226 /// that is found, a selection of the volumes can be done in the visitor 0227 /// 0228 /// @note If a context is needed for the visit, the vistitor has to provide 0229 /// this, e.g. as a private member 0230 template <TrackingVolumeVisitor visitor_t> 0231 void visitVolumes(visitor_t&& visitor) const { 0232 apply([&visitor](const TrackingVolume& volume) { visitor(&volume); }); 0233 } 0234 0235 /// @brief Apply a visitor to the tracking volume 0236 /// 0237 /// @param visitor The visitor to apply 0238 /// 0239 void apply(TrackingGeometryVisitor& visitor) const; 0240 0241 /// @brief Apply a mutable visitor to the tracking volume 0242 /// 0243 /// @param visitor The visitor to apply 0244 /// 0245 void apply(TrackingGeometryMutableVisitor& visitor); 0246 0247 /// @brief Apply an arbitrary callable as a visitor to the tracking volume 0248 /// 0249 /// @param callable The callable to apply 0250 /// 0251 /// @note The visitor can be overloaded on any of the arguments that 0252 /// the methods in @c TrackingGeometryVisitor receive. 0253 template <typename Callable> 0254 void apply(Callable&& callable) 0255 requires(detail::callableWithAnyMutable<Callable>() && 0256 !detail::callableWithAnyConst<Callable>()) 0257 { 0258 detail::TrackingGeometryLambdaMutableVisitor visitor{ 0259 std::forward<Callable>(callable)}; 0260 apply(visitor); 0261 } 0262 0263 /// @brief Apply an arbitrary callable as a visitor to the tracking volume 0264 /// 0265 /// @param callable The callable to apply 0266 /// 0267 /// @note The visitor can be overloaded on any of the arguments that 0268 /// the methods in @c TrackingGeometryMutableVisitor receive. 0269 template <typename Callable> 0270 void apply(Callable&& callable) const 0271 requires(detail::callableWithAnyConst<Callable>()) 0272 { 0273 detail::TrackingGeometryLambdaVisitor visitor{ 0274 std::forward<Callable>(callable)}; 0275 apply(visitor); 0276 } 0277 0278 /// Returns the VolumeName - for debug reason, might be depreciated later 0279 /// @return Reference to the volume name string 0280 const std::string& volumeName() const; 0281 0282 /// Set the volume name to @p volumeName 0283 /// @param volumeName is the new name of 0284 void setVolumeName(std::string_view volumeName); 0285 0286 /// Return the material of the volume 0287 /// @return Pointer to volume material or nullptr if no material assigned 0288 const IVolumeMaterial* volumeMaterial() const; 0289 0290 /// Return the material of the volume as shared pointer 0291 /// @return Shared pointer to volume material 0292 const std::shared_ptr<const IVolumeMaterial>& volumeMaterialPtr() const; 0293 0294 /// Set the volume material description 0295 /// 0296 /// The material is usually derived in a complicated way and loaded from 0297 /// a framework given source. As various volumes could potentially share the 0298 /// the same material description, it is provided as a shared object 0299 /// 0300 /// @param material Material description of this volume 0301 void assignVolumeMaterial(std::shared_ptr<const IVolumeMaterial> material); 0302 0303 /// Return the MotherVolume - if it exists 0304 /// @return Pointer to mother volume or nullptr if this is the root volume 0305 const TrackingVolume* motherVolume() const; 0306 0307 /// Return the MotherVolume - if it exists 0308 /// @return Mutable pointer to mother volume or nullptr if this is the root volume 0309 TrackingVolume* motherVolume(); 0310 0311 /// Set the MotherVolume 0312 /// 0313 /// @param mvol is the mother volume 0314 void setMotherVolume(TrackingVolume* mvol); 0315 0316 /// Type alias for mutable range of tracking volumes in container 0317 using MutableVolumeRange = 0318 detail::TransformRange<detail::Dereference, 0319 std::vector<std::unique_ptr<TrackingVolume>>>; 0320 /// Type alias for const range of tracking volumes in container 0321 using VolumeRange = detail::TransformRange< 0322 detail::ConstDereference, 0323 const std::vector<std::unique_ptr<TrackingVolume>>>; 0324 0325 /// Return all volumes registered under this tracking volume 0326 /// @return the range of volumes 0327 VolumeRange volumes() const; 0328 0329 /// Return mutable view of the registered volumes under this tracking volume 0330 /// @return the range of volumes 0331 MutableVolumeRange volumes(); 0332 0333 /// Type alias for mutable range of portals in tracking volume 0334 using MutablePortalRange = 0335 detail::TransformRange<detail::Dereference, 0336 std::vector<std::shared_ptr<Portal>>>; 0337 0338 /// Type alias for const range of portals in tracking volume 0339 using PortalRange = 0340 detail::TransformRange<detail::ConstDereference, 0341 const std::vector<std::shared_ptr<Portal>>>; 0342 0343 /// Return all portals registered under this tracking volume 0344 /// @return the range of portals 0345 PortalRange portals() const; 0346 0347 /// Return mutable view of the registered portals under this tracking volume 0348 /// @return the range of portals 0349 MutablePortalRange portals(); 0350 0351 /// Add a portal to this tracking volume 0352 /// @param portal The portal to add 0353 void addPortal(std::shared_ptr<Portal> portal); 0354 0355 /// Type alias for mutable range of surfaces in tracking volume 0356 using MutableSurfaceRange = 0357 detail::TransformRange<detail::Dereference, 0358 std::vector<std::shared_ptr<Surface>>>; 0359 /// Type alias for const range of surfaces in tracking volume 0360 using SurfaceRange = 0361 detail::TransformRange<detail::ConstDereference, 0362 const std::vector<std::shared_ptr<Surface>>>; 0363 0364 /// Return all surfaces registered under this tracking volume 0365 /// @return the range of surfaces 0366 SurfaceRange surfaces() const; 0367 0368 /// Return mutable view of the registered surfaces under this tracking volume 0369 /// @return the range of surfaces 0370 MutableSurfaceRange surfaces(); 0371 0372 /// Add a surface to this tracking volume 0373 /// @param surface The surface to add 0374 void addSurface(std::shared_ptr<Surface> surface); 0375 0376 /// Add a child volume to this tracking volume 0377 /// @param volume The volume to add 0378 /// @note The @p volume will have its mother volume assigned to @p this. 0379 /// It will throw if @p volume already has a mother volume set 0380 /// @return Reference to the added volume 0381 TrackingVolume& addVolume(std::unique_ptr<TrackingVolume> volume); 0382 0383 /// Interface of @c TrackingVolume in the Gen1 geometry model 0384 /// @note This interface is being replaced, and is subject to removal 0385 /// 0386 /// @{ 0387 0388 /// Return the associated Layer to the global position 0389 /// 0390 /// @param gctx The current geometry context object, e.g. alignment 0391 /// @param position is the associated global position 0392 /// 0393 /// @return plain pointer to layer object 0394 const Layer* associatedLayer(const GeometryContext& gctx, 0395 const Vector3& position) const; 0396 0397 /// @brief Resolves the volume into (compatible) Layers 0398 /// 0399 /// This is the method for the propagator/extrapolator 0400 /// @tparam options_t Type of navigation options object for decomposition 0401 /// 0402 /// @param gctx The current geometry context object, e.g. alignment 0403 /// @param position Position for the search 0404 /// @param direction Direction for the search 0405 /// @param options The templated navigation options 0406 /// 0407 /// @return vector of compatible intersections with layers 0408 boost::container::small_vector<NavigationTarget, 10> compatibleLayers( 0409 const GeometryContext& gctx, const Vector3& position, 0410 const Vector3& direction, const NavigationOptions<Layer>& options) const; 0411 0412 /// @brief Returns all boundary surfaces sorted by the user. 0413 /// 0414 /// @tparam options_t Type of navigation options object for decomposition 0415 /// @tparam sorter_t Type of the boundary surface sorter 0416 /// 0417 /// @param gctx The current geometry context object, e.g. alignment 0418 /// @param position The position for searching 0419 /// @param direction The direction for searching 0420 /// @param options The templated navigation options 0421 /// @param logger A @c Logger instance 0422 /// 0423 /// @return is the templated boundary intersection 0424 boost::container::small_vector<NavigationTarget, 4> compatibleBoundaries( 0425 const GeometryContext& gctx, const Vector3& position, 0426 const Vector3& direction, const NavigationOptions<Surface>& options, 0427 const Logger& logger = getDummyLogger()) const; 0428 0429 /// Return the confined static layer array - if it exists 0430 /// @return the BinnedArray of static layers if exists 0431 const LayerArray* confinedLayers() const; 0432 0433 /// Return the confined volumes of this container array - if it exists 0434 /// @return Shared pointer to array of contained tracking volumes or nullptr 0435 std::shared_ptr<const TrackingVolumeArray> confinedVolumes() const; 0436 0437 /// Return the confined dense volumes 0438 /// @return Vector of pointers to dense tracking volumes 0439 MutableTrackingVolumeVector denseVolumes() const; 0440 0441 /// Method to return the BoundarySurfaces 0442 /// @return Reference to vector of boundary surface pointers 0443 const TrackingVolumeBoundaries& boundarySurfaces() const; 0444 0445 /// Set the boundary surface material description 0446 /// 0447 /// The material is usually derived in a complicated way and loaded from 0448 /// a framework given source. As various volumes could potentially share the 0449 /// the same material description, it is provided as a shared object 0450 /// 0451 /// @param surfaceMaterial Material description of this volume 0452 /// @param bsFace Specifies which boundary surface to assign the material to 0453 void assignBoundaryMaterial( 0454 std::shared_ptr<const ISurfaceMaterial> surfaceMaterial, 0455 BoundarySurfaceFace bsFace); 0456 0457 /// Glue another tracking volume to this one 0458 /// - if common face is set the glued volumes are sharing the boundary, down 0459 /// to the last navigation volume 0460 /// 0461 /// @param gctx The current geometry context object, e.g. alignment 0462 /// @param bsfMine is the boundary face indicator where to glue 0463 /// @param neighbor is the TrackingVolume to be glued 0464 /// @param bsfNeighbor is the boundary surface of the neighbor 0465 void glueTrackingVolume(const GeometryContext& gctx, 0466 BoundarySurfaceFace bsfMine, TrackingVolume* neighbor, 0467 BoundarySurfaceFace bsfNeighbor); 0468 0469 /// Glue another tracking volume to this one 0470 /// - if common face is set the glued volumes are sharing the boundary, down 0471 /// to the last navigation volume 0472 /// 0473 /// @param gctx The current geometry context object, e.g. alignment 0474 /// @param bsfMine is the boundary face indicator where to glue 0475 /// @param neighbors are the TrackingVolumes to be glued 0476 /// @param bsfNeighbor are the boundary surface of the neighbors 0477 void glueTrackingVolumes( 0478 const GeometryContext& gctx, BoundarySurfaceFace bsfMine, 0479 const std::shared_ptr<TrackingVolumeArray>& neighbors, 0480 BoundarySurfaceFace bsfNeighbor); 0481 0482 /// Provide a new BoundarySurface from the glueing 0483 /// 0484 /// @param bsf is the boundary face indicator where to glue 0485 /// @param bs is the new boundary surface 0486 /// @param checkmaterial is a flag how to deal with material, if true: 0487 /// - if the old boundary surface had a material description 0488 /// but the new one has not, keep the current one 0489 /// - in all other cases just assign the new boundary surface 0490 void updateBoundarySurface( 0491 BoundarySurfaceFace bsf, 0492 std::shared_ptr<const BoundarySurfaceT<TrackingVolume>> bs, 0493 bool checkmaterial = true); 0494 0495 /// Register the outside glue volumes - 0496 /// ordering is in the TrackingVolume Frame: 0497 /// - negativeFaceXY 0498 /// - (faces YZ, ZY, radial faces) 0499 /// - positiveFaceXY 0500 /// 0501 /// @param gvd register a new GlueVolumeDescriptor 0502 void registerGlueVolumeDescriptor(std::unique_ptr<GlueVolumesDescriptor> gvd); 0503 0504 /// Clear boundary surfaces for this tracking volume 0505 void clearBoundarySurfaces(); 0506 0507 /// Register the outside glue volumes - 0508 /// ordering is in the TrackingVolume Frame: 0509 /// - negativeFaceXY 0510 /// - (faces YZ, ZY, radial faces) 0511 /// - positiveFaceXY 0512 /// @return Reference to the glue volumes descriptor 0513 GlueVolumesDescriptor& glueVolumesDescriptor(); 0514 0515 /// Produces a 3D visualization of this tracking volume 0516 /// @param helper The visualization helper describing the output format 0517 /// @param gctx The geometry context 0518 /// @param viewConfig The view configuration 0519 /// @param portalViewConfig View configuration for portals 0520 /// @param sensitiveViewConfig View configuration for sensitive surfaces 0521 void visualize(IVisualization3D& helper, const GeometryContext& gctx, 0522 const ViewConfig& viewConfig, 0523 const ViewConfig& portalViewConfig, 0524 const ViewConfig& sensitiveViewConfig) const; 0525 0526 /// @cond 0527 using Volume::visualize; 0528 /// @endcond 0529 0530 /// Access the navigation policy if any that is registered on this volume 0531 /// @return a pointer to the navigation policy, or nullptr if none is set 0532 const INavigationPolicy* navigationPolicy() const; 0533 0534 /// Access the navigation policy if any that is registered on this volume 0535 /// @return a pointer to the navigation policy, or nullptr if none is set 0536 INavigationPolicy* navigationPolicy(); 0537 0538 /// Register a navigation policy with this volume. The argument can not be 0539 /// nullptr. 0540 /// @param policy is the navigation policy to be registered 0541 void setNavigationPolicy(std::unique_ptr<INavigationPolicy> policy); 0542 0543 /// Populate the navigation stream with navigation candidates from this 0544 /// volume. Internally, this consults the registered navigation policy, where 0545 /// the default is a noop. 0546 /// @param gctx The current geometry context object, e.g. alignment 0547 /// @param args are the navigation arguments 0548 /// @param state is the navigation policy state 0549 /// @param stream is the navigation stream to be updated 0550 /// @param logger is the logger 0551 void initializeNavigationCandidates(const GeometryContext& gctx, 0552 const NavigationArguments& args, 0553 NavigationPolicyState& state, 0554 AppendOnlyNavigationStream& stream, 0555 const Logger& logger) const; 0556 0557 private: 0558 void connectDenseBoundarySurfaces( 0559 MutableTrackingVolumeVector& confinedDenseVolumes); 0560 0561 /// interlink the layers in this TrackingVolume 0562 void interlinkLayers(); 0563 0564 /// Create Boundary Surface 0565 void createBoundarySurfaces(); 0566 0567 /// method to synchronize the layers with potentially updated volume bounds: 0568 /// - adapts the layer dimensions to the new volumebounds + envelope 0569 /// 0570 /// @param envelope is the clearance between volume boundary and layer 0571 void synchronizeLayers(double envelope = 1.) const; 0572 0573 // the boundary surfaces 0574 std::vector<TrackingVolumeBoundaryPtr> m_boundarySurfaces; 0575 0576 ///(a) static configuration ordered by Binned arrays 0577 /// static layers 0578 std::unique_ptr<const LayerArray> m_confinedLayers = nullptr; 0579 0580 /// Array of Volumes inside the Volume when acting as container 0581 std::shared_ptr<const TrackingVolumeArray> m_confinedVolumes = nullptr; 0582 0583 /// confined dense 0584 MutableTrackingVolumeVector m_confinedDenseVolumes; 0585 0586 /// Volumes to glue Volumes from the outside 0587 std::unique_ptr<GlueVolumesDescriptor> m_glueVolumeDescriptor{nullptr}; 0588 0589 /// @} 0590 0591 /// The volume based material the TrackingVolume consists of 0592 std::shared_ptr<const IVolumeMaterial> m_volumeMaterial{nullptr}; 0593 0594 /// Remember the mother volume 0595 TrackingVolume* m_motherVolume{nullptr}; 0596 0597 /// Volume name for debug reasons & screen output 0598 std::string m_name; 0599 0600 std::vector<std::unique_ptr<TrackingVolume>> m_volumes; 0601 std::vector<std::shared_ptr<Portal>> m_portals; 0602 std::vector<std::shared_ptr<Surface>> m_surfaces; 0603 0604 std::unique_ptr<INavigationPolicy> m_navigationPolicy; 0605 0606 NavigationDelegate m_navigationDelegate{}; 0607 }; 0608 0609 } // 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 |
|