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