ActsPlugins/Detray/DetrayPayloadConverter.hpp

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/Material/BinnedSurfaceMaterial.hpp"
0013 #include "Acts/Material/GridSurfaceMaterial.hpp"
0014 #include "Acts/Material/HomogeneousSurfaceMaterial.hpp"
0015 #include "Acts/Material/ProtoSurfaceMaterial.hpp"
0016 #include "Acts/Navigation/CylinderNavigationPolicy.hpp"
0017 #include "Acts/Navigation/INavigationPolicy.hpp"
0018 #include "Acts/Navigation/MultiLayerNavigationPolicy.hpp"
0019 #include "Acts/Navigation/MultiNavigationPolicy.hpp"
0020 #include "Acts/Navigation/SurfaceArrayNavigationPolicy.hpp"
0021 #include "Acts/Navigation/TryAllNavigationPolicy.hpp"
0022 #include "Acts/Utilities/Logger.hpp"
0023 #include "Acts/Utilities/TypeDispatcher.hpp"
0024
0025 #include <map>
0026 #include <memory>
0027
0028 /// @cond
0029 namespace detray {
0030
0031 using dindex = unsigned int;
0032
0033 namespace io {
0034
0035 struct detector_payload;
0036 struct transform_payload;
0037 struct mask_payload;
0038 struct surface_payload;
0039 struct volume_payload;
0040 struct material_slab_payload;
0041 struct material_volume_payload;
0042 struct detector_homogeneous_material_payload;
0043
0044 template <typename, typename>
0045 struct grid_payload;
0046 enum class material_id : unsigned int;
0047
0048 template <typename, typename>
0049 struct detector_grids_payload;
0050
0051 enum class accel_id : unsigned int;
0052
0053 }  // namespace io
0054 }  // namespace detray
0055 /// @endcond
0056
0057 namespace Acts {
0058 class GeometryContext;
0059 class TrackingGeometry;
0060 class SurfaceBounds;
0061 class Surface;
0062 class Portal;
0063 class TrackingVolume;
0064 class PortalLinkBase;
0065 class MaterialSlab;
0066 class ISurfaceMaterial;
0067 }  // namespace Acts
0068
0069 namespace ActsPlugins {
0070
0071 /// @ingroup detray_plugin
0072 class DetrayPayloadConverter {
0073  public:
0074   using DetraySurfaceMaterial =
0075       std::variant<detray::io::grid_payload<detray::io::material_slab_payload,
0076                                             detray::io::material_id>,
0077                    detray::io::material_slab_payload>;
0078
0079   using DetraySurfaceGrid =
0080       detray::io::grid_payload<std::size_t, detray::io::accel_id>;
0081
0082   /// Function type for looking up surface indices in detray conversion
0083   using SurfaceLookupFunction =
0084       std::function<std::size_t(const Acts::Surface*)>;
0085
0086   static std::optional<DetraySurfaceMaterial> convertHomogeneousSurfaceMaterial(
0087       const Acts::HomogeneousSurfaceMaterial& material);
0088
0089   static std::optional<DetraySurfaceMaterial> convertGridSurfaceMaterial(
0090       const Acts::IGridSurfaceMaterialBase& material);
0091
0092   static std::optional<DetraySurfaceMaterial> convertBinnedSurfaceMaterial(
0093       const Acts::BinnedSurfaceMaterial& material);
0094
0095   static std::optional<DetraySurfaceMaterial>
0096   convertProtoSurfaceMaterialBinUtility(
0097       const Acts::ProtoSurfaceMaterialT<Acts::BinUtility>& material);
0098
0099   static std::optional<DetraySurfaceMaterial>
0100   convertProtoSurfaceMaterialProtoAxes(
0101       const Acts::ProtoSurfaceMaterialT<std::vector<Acts::DirectedProtoAxis>>&
0102           material);
0103
0104   static std::optional<DetraySurfaceGrid> convertSurfaceArray(
0105       const Acts::SurfaceArrayNavigationPolicy& policy,
0106       const Acts::GeometryContext& gctx,
0107       const SurfaceLookupFunction& surfaceLookup, const Acts::Logger& logger);
0108
0109   static std::optional<DetraySurfaceGrid> convertTryAllNavigationPolicy(
0110       const Acts::TryAllNavigationPolicy& policy,
0111       const Acts::GeometryContext& gctx,
0112       const SurfaceLookupFunction& surfaceLookup, const Acts::Logger& logger);
0113
0114   static std::optional<DetraySurfaceGrid> convertCylinderNavigationPolicy(
0115       const Acts::CylinderNavigationPolicy& policy,
0116       const Acts::GeometryContext& gctx,
0117       const SurfaceLookupFunction& surfaceLookup, const Acts::Logger& logger);
0118
0119   static std::optional<DetraySurfaceGrid> convertMultiLayerNavigationPolicy(
0120       const Acts::Experimental::MultiLayerNavigationPolicy& policy,
0121       const Acts::GeometryContext& gctx,
0122       const SurfaceLookupFunction& surfaceLookup, const Acts::Logger& logger);
0123
0124   // This is a noop, the payload converter will actually traverse the children
0125   // via `visit`.
0126   static std::optional<DetraySurfaceGrid> convertMultiNavigationPolicy(
0127       const Acts::MultiNavigationPolicy& policy,
0128       const Acts::GeometryContext& gctx,
0129       const SurfaceLookupFunction& surfaceLookup, const Acts::Logger& logger);
0130
0131   struct Config {
0132     Config() = default;
0133
0134     Config(const Config&) = default;
0135     Config(Config&&) = default;
0136     Config& operator=(const Config&) = default;
0137     Config& operator=(Config&&) = default;
0138     enum class SensitiveStrategy {
0139       /// Checks if the sensitive component of the surface is set to check if
0140       /// it's a sensitive surface
0141       Identifier,
0142       /// Check if the surface is a sensitive surface by checking for an
0143       /// associated detector element
0144       DetectorElement
0145     };
0146     SensitiveStrategy sensitiveStrategy = SensitiveStrategy::Identifier;
0147
0148     /// Detray MUST have beampipe volume at index 0
0149     const Acts::TrackingVolume* beampipeVolume = nullptr;
0150
0151     Acts::TypeDispatcher<Acts::INavigationPolicy,
0152                          std::optional<DetraySurfaceGrid>(
0153                              const Acts::GeometryContext& gctx,
0154                              const SurfaceLookupFunction& surfaceLookup,
0155                              const Acts::Logger& logger)>
0156         convertNavigationPolicy{
0157             convertSurfaceArray, convertTryAllNavigationPolicy,
0158             convertCylinderNavigationPolicy, convertMultiLayerNavigationPolicy,
0159             convertMultiNavigationPolicy};
0160
0161     Acts::TypeDispatcher<Acts::ISurfaceMaterial,
0162                          std::optional<DetraySurfaceMaterial>()>
0163         convertSurfaceMaterial{
0164             convertHomogeneousSurfaceMaterial, convertBinnedSurfaceMaterial,
0165             convertGridSurfaceMaterial, convertProtoSurfaceMaterialProtoAxes,
0166             convertProtoSurfaceMaterialBinUtility};
0167   };
0168
0169   /// @param bounds the surface bounds to convert
0170   /// @param forPortal detray special cases the local parametrization for portals for performance reasons
0171   static detray::io::mask_payload convertMask(const Acts::SurfaceBounds& bounds,
0172                                               bool forPortal);
0173
0174   detray::io::surface_payload convertSurface(const Acts::GeometryContext& gctx,
0175                                              const Acts::Surface& surface,
0176                                              bool portal = false) const;
0177
0178   detray::io::volume_payload convertVolume(
0179       const Acts::GeometryContext& gctx,
0180       const Acts::TrackingVolume& volume) const;
0181
0182   struct Payloads {
0183     // Unique pointers used to be able to forward declare the type
0184     std::unique_ptr<detray::io::detector_payload> detector;
0185
0186     std::unique_ptr<detray::io::detector_homogeneous_material_payload>
0187         homogeneousMaterial;
0188
0189     std::unique_ptr<detray::io::detector_grids_payload<
0190         detray::io::material_slab_payload, detray::io::material_id>>
0191         materialGrids;
0192
0193     std::unique_ptr<
0194         detray::io::detector_grids_payload<std::size_t, detray::io::accel_id>>
0195         surfaceGrids;
0196
0197     std::map<detray::dindex, std::string> names;
0198   };
0199
0200   Payloads convertTrackingGeometry(
0201       const Acts::GeometryContext& gctx,
0202       const Acts::TrackingGeometry& geometry) const;
0203
0204   explicit DetrayPayloadConverter(
0205       const Config& config,
0206       std::unique_ptr<const Acts::Logger> logger = Acts::getDefaultLogger(
0207           "DetrayPayloadConverter", Acts::Logging::INFO));
0208
0209   std::pair<std::vector<detray::io::grid_payload<
0210                 detray::io::material_slab_payload, detray::io::material_id>>,
0211             detray::io::material_volume_payload>
0212   convertMaterial(const Acts::TrackingVolume& volume,
0213
0214                   const std::unordered_map<const Acts::Surface*, std::size_t>&
0215                       surfaceIndices,
0216                   detray::io::volume_payload& volPayload) const;
0217
0218  private:
0219   void handlePortalLink(
0220       const Acts::GeometryContext& gctx, const Acts::TrackingVolume& volume,
0221       detray::io::volume_payload& volPayload,
0222       const std ::function<std::size_t(const Acts::TrackingVolume*)>&
0223           volumeLookup,
0224       std::unordered_map<const Acts::Surface*, std::size_t>& surfaceIndices,
0225       const Acts::PortalLinkBase& link) const;
0226
0227   void makeEndOfWorld(
0228       const Acts::GeometryContext& gctx, detray::io::volume_payload& volPayload,
0229       std::unordered_map<const Acts::Surface*, std::size_t>& surfaceIndices,
0230       const Acts::Surface& surface) const;
0231
0232   void handlePortal(
0233       const Acts::GeometryContext& gctx, const Acts::TrackingVolume& volume,
0234       detray::io::volume_payload& volPayload,
0235       const std::function<std::size_t(const Acts::TrackingVolume*)>&
0236           volumeLookup,
0237       std::unordered_map<const Acts::Surface*, std::size_t>& surfaceIndices,
0238       const Acts::Portal& portal) const;
0239
0240   Config m_cfg;
0241
0242   const Acts::Logger& logger() const { return *m_logger; }
0243   std::unique_ptr<const Acts::Logger> m_logger;
0244 };
0245
0246 /// @ingroup detray_plugin
0247 class DetrayUnsupportedMaterialException : public std::runtime_error {
0248  public:
0249   explicit DetrayUnsupportedMaterialException(std::string_view name);
0250 };
0251
0252 }  // namespace ActsPlugins