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