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