diff --git a/core/include/detray/builders/cuboid_portal_generator.hpp b/core/include/detray/builders/cuboid_portal_generator.hpp
index af5895b7a..bf19db747 100644
--- a/core/include/detray/builders/cuboid_portal_generator.hpp
+++ b/core/include/detray/builders/cuboid_portal_generator.hpp
@@ -116,7 +116,7 @@ class cuboid_portal_generator final
         auto surfaces_offset{static_cast<dindex>(n_surfaces)};
 
         // Fetch the position in the mask tuple for the rectangle portals
-        constexpr auto rectangle_id{detector_t::masks::id::e_portal_rectangle2};
+        constexpr auto rectangle_id{detector_t::masks::id::e_rectangle2D};
 
         // The material will be added in a later step
         constexpr auto no_material = surface_t::material_id::e_none;
diff --git a/core/include/detray/builders/cylinder_portal_generator.hpp b/core/include/detray/builders/cylinder_portal_generator.hpp
index c7b1fe4b6..51c24ba9c 100644
--- a/core/include/detray/builders/cylinder_portal_generator.hpp
+++ b/core/include/detray/builders/cylinder_portal_generator.hpp
@@ -305,14 +305,14 @@ class cylinder_portal_generator final
 
         // Add transform and mask data
         transforms.emplace_back(ctx, tsl);
-        masks.template emplace_back<mask_id::e_portal_cylinder2>(
+        masks.template emplace_back<mask_id::e_concentric_cylinder2D>(
             empty_context{}, vol_link, r, min_z, max_z);
 
         // Add surface links
         mask_link_t mask_link{};
         const auto mask_idx{static_cast<dindex>(
-            masks.template size<mask_id::e_portal_cylinder2>() - 1u)};
-        set_mask_link(mask_link, mask_id::e_portal_cylinder2, mask_idx);
+            masks.template size<mask_id::e_concentric_cylinder2D>() - 1u)};
+        set_mask_link(mask_link, mask_id::e_concentric_cylinder2D, mask_idx);
 
         material_link_t material_link{material_id::e_none, dindex_invalid};
 
@@ -341,14 +341,14 @@ class cylinder_portal_generator final
 
         // Add transform and mask data
         transforms.emplace_back(ctx, tsl);
-        masks.template emplace_back<mask_id::e_portal_ring2>(
-            empty_context{}, vol_link, min_r, max_r);
+        masks.template emplace_back<mask_id::e_ring2D>(empty_context{},
+                                                       vol_link, min_r, max_r);
 
         // Add surface links
         mask_link_t mask_link{};
-        const auto mask_idx{static_cast<dindex>(
-            masks.template size<mask_id::e_portal_ring2>() - 1u)};
-        set_mask_link(mask_link, mask_id::e_portal_ring2, mask_idx);
+        const auto mask_idx{
+            static_cast<dindex>(masks.template size<mask_id::e_ring2D>() - 1u)};
+        set_mask_link(mask_link, mask_id::e_ring2D, mask_idx);
 
         material_link_t material_link{material_id::e_none, dindex_invalid};
 
diff --git a/core/include/detray/builders/detail/volume_connector.hpp b/core/include/detray/builders/detail/volume_connector.hpp
index 743e84e13..c54d1c7d3 100644
--- a/core/include/detray/builders/detail/volume_connector.hpp
+++ b/core/include/detray/builders/detail/volume_connector.hpp
@@ -248,8 +248,9 @@ void connect_cylindrical_volumes(
                     0., 0., volume_bounds[bound_index]};
 
                 // Get the mask context group and fill it
-                constexpr auto disc_id = detector_t::masks::id::e_portal_ring2;
-                constexpr auto slab_id = detector_t::materials::id::e_slab;
+                constexpr auto disc_id = detector_t::masks::id::e_ring2D;
+                constexpr auto slab_id =
+                    detector_t::materials::id::e_material_slab;
                 typename portal_t::mask_link mask_index = {
                     disc_id, portal_masks.template size<disc_id>()};
                 typename portal_t::material_link material_index = {
@@ -298,7 +299,8 @@ void connect_cylindrical_volumes(
                     detector_t::masks::id::e_portal_cylinder3;
                 typename portal_t::mask_link mask_index = {
                     cylinder_id, portal_masks.template size<cylinder_id>()};
-                constexpr auto slab_id = detector_t::materials::id::e_slab;
+                constexpr auto slab_id =
+                    detector_t::materials::id::e_material_slab;
 
                 for (auto &info_ : portals_info) {
                     // Add new mask to container
diff --git a/core/include/detray/builders/homogeneous_material_builder.hpp b/core/include/detray/builders/homogeneous_material_builder.hpp
index b362e50c1..d47012cee 100644
--- a/core/include/detray/builders/homogeneous_material_builder.hpp
+++ b/core/include/detray/builders/homogeneous_material_builder.hpp
@@ -97,34 +97,38 @@ class homogeneous_material_builder final : public volume_decorator<detector_t> {
         for (auto &sf : this->surfaces()) {
             DETRAY_DEBUG_HOST("-> sf=" << sf);
             DETRAY_DEBUG_HOST("  -> material_id=" << sf.material().id());
-            if (sf.material().id() == material_id::e_slab) {
-                dindex offset = material.template size<material_id::e_slab>();
+            if (sf.material().id() == material_id::e_material_slab) {
+                dindex offset =
+                    material.template size<material_id::e_material_slab>();
                 DETRAY_DEBUG_HOST("-> update material slab offset: " << offset);
                 sf.update_material(offset);
                 DETRAY_DEBUG_HOST("-> material now: " << sf.material());
             }
             if constexpr (types::contains<typename detector_t::materials,
                                           material_rod<scalar_type>>) {
-                if (sf.material().id() == material_id::e_rod) {
+                if (sf.material().id() == material_id::e_material_rod) {
                     DETRAY_DEBUG_HOST(
                         "-> update material rod offset: "
-                        << material.template size<material_id::e_rod>());
+                        << material
+                               .template size<material_id::e_material_rod>());
                     sf.update_material(
-                        material.template size<material_id::e_rod>());
+                        material.template size<material_id::e_material_rod>());
                 }
             }
         }
 
         // Add material to the detector
-        DETRAY_DEBUG_HOST("-> Appending "
-                          << m_materials.template size<material_id::e_slab>()
-                          << " slabs into detector materials");
+        DETRAY_DEBUG_HOST(
+            "-> Appending "
+            << m_materials.template size<material_id::e_material_slab>()
+            << " slabs into detector materials");
 
         if constexpr (types::contains<typename detector_t::materials,
                                       material_rod<scalar_type>>) {
-            DETRAY_DEBUG_HOST("-> Appending "
-                              << m_materials.template size<material_id::e_rod>()
-                              << " rods into detector materials");
+            DETRAY_DEBUG_HOST(
+                "-> Appending "
+                << m_materials.template size<material_id::e_material_rod>()
+                << " rods into detector materials");
         }
         det._materials.append(std::move(m_materials));
         m_materials.clear_all();
diff --git a/core/include/detray/builders/homogeneous_material_factory.hpp b/core/include/detray/builders/homogeneous_material_factory.hpp
index aec207a5e..01a6a342d 100644
--- a/core/include/detray/builders/homogeneous_material_factory.hpp
+++ b/core/include/detray/builders/homogeneous_material_factory.hpp
@@ -352,8 +352,9 @@ class homogeneous_material_factory final
             DETRAY_DEBUG_HOST("           mat=" << mat << " thickness=" << t);
 
             dindex mat_idx{0u};
-            if (m_links.at(sf_idx).first == material_id::e_slab) {
-                auto &mat_coll = materials.template get<material_id::e_slab>();
+            if (m_links.at(sf_idx).first == material_id::e_material_slab) {
+                auto &mat_coll =
+                    materials.template get<material_id::e_material_slab>();
 
                 material_slab<scalar_type> mat_slab{mat, t};
                 mat_idx = this->insert_in_container(mat_coll, mat_slab,
@@ -361,9 +362,9 @@ class homogeneous_material_factory final
             }
             if constexpr (types::contains<typename detector_t::materials,
                                           material_rod<scalar_type>>) {
-                if (m_links.at(sf_idx).first == material_id::e_rod) {
+                if (m_links.at(sf_idx).first == material_id::e_material_rod) {
                     auto &mat_coll =
-                        materials.template get<material_id::e_rod>();
+                        materials.template get<material_id::e_material_rod>();
 
                     material_rod<scalar_type> mat_rod{mat, t};
                     mat_idx = this->insert_in_container(mat_coll, mat_rod,
diff --git a/core/include/detray/builders/homogeneous_material_generator.hpp b/core/include/detray/builders/homogeneous_material_generator.hpp
index f30b8410e..5011b866b 100644
--- a/core/include/detray/builders/homogeneous_material_generator.hpp
+++ b/core/include/detray/builders/homogeneous_material_generator.hpp
@@ -198,20 +198,21 @@ class homogeneous_material_generator final
                     is_line = true;
 
                     auto &mat_coll =
-                        materials.template get<material_id::e_rod>();
+                        materials.template get<material_id::e_material_rod>();
                     mat_coll.emplace_back(*mat_ptr, m_cfg.thickness());
 
-                    mat_link = {material_id::e_rod,
+                    mat_link = {material_id::e_material_rod,
                                 static_cast<dindex>(mat_coll.size() - 1u)};
                 }
             }
 
             // For all surfaces that are not lines, generate a material slab
             if (!is_line) {
-                auto &mat_coll = materials.template get<material_id::e_slab>();
+                auto &mat_coll =
+                    materials.template get<material_id::e_material_slab>();
                 mat_coll.emplace_back(*mat_ptr, m_cfg.thickness());
 
-                mat_link = {material_id::e_slab,
+                mat_link = {material_id::e_material_slab,
                             static_cast<dindex>(mat_coll.size() - 1u)};
             }
 
diff --git a/core/include/detray/builders/volume_builder.hpp b/core/include/detray/builders/volume_builder.hpp
index 8e11798a8..3d4f43de2 100644
--- a/core/include/detray/builders/volume_builder.hpp
+++ b/core/include/detray/builders/volume_builder.hpp
@@ -52,7 +52,7 @@ class volume_builder : public volume_builder_interface<detector_t> {
         // force method that will at least contain the portals
         m_volume.template set_accel_link<
             static_cast<typename volume_type::object_id>(0)>(
-            detector_t::accel::id::e_default, 0);
+            detector_t::accel::id::e_surface_default, 0);
 
         DETRAY_VERBOSE_HOST("Created builder for volume: " << idx);
     };
@@ -253,7 +253,7 @@ class volume_builder : public volume_builder_interface<detector_t> {
         }
 
         // Place the appropriate surfaces in the brute force search method.
-        constexpr auto default_acc_id{detector_t::accel::id::e_default};
+        constexpr auto default_acc_id{detector_t::accel::id::e_surface_default};
 
         // Strip the source link from the lookup data structure
         typename detector_t::surface_container descriptors;
diff --git a/core/include/detray/core/detector.hpp b/core/include/detray/core/detector.hpp
index 93bd39e68..e12499b61 100644
--- a/core/include/detray/core/detector.hpp
+++ b/core/include/detray/core/detector.hpp
@@ -232,7 +232,7 @@ class detector {
         // TODO: Add volume accelerator builder
         volume_type v_desc{};
         v_desc.template set_accel_link<geo_obj_ids::e_volume>(
-            accel::id::e_default_volume_searcher, 0u);
+            accel::id::e_volume_default, 0u);
         tracking_volume world{*this, v_desc};
 
         dindex volume_index{0u};
@@ -248,7 +248,8 @@ class detector {
     DETRAY_HOST_DEVICE
     inline const auto &portals() const {
         // All portals are registered with the brute force search
-        return _accelerators.template get<accel::id::e_brute_force>().all();
+        return _accelerators.template get<accel::id::e_surface_brute_force>()
+            .all();
     }
 
     /// @returns the sub-volumes of the detector - const access
diff --git a/core/include/detray/utils/detector_statistics.hpp b/core/include/detray/utils/detector_statistics.hpp
index 5ec0ad08b..26e1a2bae 100644
--- a/core/include/detray/utils/detector_statistics.hpp
+++ b/core/include/detray/utils/detector_statistics.hpp
@@ -89,7 +89,7 @@ DETRAY_HOST_DEVICE inline std::size_t n_material_maps(const detector_t& det) {
 template <typename detector_t>
 DETRAY_HOST_DEVICE inline std::size_t n_material_slabs(const detector_t& det) {
     if constexpr (detray::concepts::has_material_slabs<detector_t>) {
-        constexpr auto slab_id{detector_t::materials::id::e_slab};
+        constexpr auto slab_id{detector_t::materials::id::e_material_slab};
         return det.material_store().template size<slab_id>();
     } else {
         return 0u;
@@ -100,7 +100,7 @@ DETRAY_HOST_DEVICE inline std::size_t n_material_slabs(const detector_t& det) {
 template <typename detector_t>
 DETRAY_HOST_DEVICE inline std::size_t n_material_rods(const detector_t& det) {
     if constexpr (detray::concepts::has_material_rods<detector_t>) {
-        constexpr auto rod_id{detector_t::materials::id::e_rod};
+        constexpr auto rod_id{detector_t::materials::id::e_material_rod};
         return det.material_store().template size<rod_id>();
     } else {
         return 0u;
diff --git a/detectors/include/detray/detectors/default_metadata.hpp b/detectors/include/detray/detectors/default_metadata.hpp
index 4fa3d3939..60b3567fe 100644
--- a/detectors/include/detray/detectors/default_metadata.hpp
+++ b/detectors/include/detray/detectors/default_metadata.hpp
@@ -1,6 +1,6 @@
 /** Detray library, part of the ACTS project (R&D line)
  *
- * (c) 2022-2024 CERN for the benefit of the ACTS project
+ * (c) 2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -14,10 +14,16 @@
 #include "detray/definitions/containers.hpp"
 #include "detray/definitions/indexing.hpp"
 #include "detray/geometry/mask.hpp"
-#include "detray/geometry/shapes.hpp"
-#include "detray/geometry/shapes/unbounded.hpp"
-#include "detray/geometry/shapes/unmasked.hpp"
+#include "detray/geometry/shapes/annulus2D.hpp"
+#include "detray/geometry/shapes/concentric_cylinder2D.hpp"
+#include "detray/geometry/shapes/cylinder2D.hpp"
+#include "detray/geometry/shapes/cylinder3D.hpp"
+#include "detray/geometry/shapes/line.hpp"
+#include "detray/geometry/shapes/rectangle2D.hpp"
+#include "detray/geometry/shapes/ring2D.hpp"
+#include "detray/geometry/shapes/trapezoid2D.hpp"
 #include "detray/geometry/surface_descriptor.hpp"
+#include "detray/materials/material.hpp"
 #include "detray/materials/material_map.hpp"
 #include "detray/materials/material_rod.hpp"
 #include "detray/materials/material_slab.hpp"
@@ -26,427 +32,266 @@
 
 namespace detray {
 
-/// Assembles the detector type. This metatdata contains all available types
 template <concepts::algebra algebra_t>
 struct default_metadata {
 
-    /// Define the algebra type for the geometry and navigation
     using algebra_type = algebra_t;
     using scalar_t = dscalar<algebra_type>;
 
-    /// Mask-to-(next)-volume link (potentially switchable for SoA)
     using nav_link = std::uint_least16_t;
 
-    /// How to store coordinate transform matrices
     template <template <typename...> class vector_t = dvector>
     using transform_store =
         single_store<dtransform3D<algebra_type>, vector_t, geometry_context>;
 
-    //
-    // Surface Primitives
-    //
-
-    /// Mask types
-    /// @TODO: Need to duplicate for pixel/strip measurement dimensions?
-    using rectangle = mask<rectangle2D, algebra_type, nav_link>;
-    using trapezoid = mask<trapezoid2D, algebra_type, nav_link>;
-    using annulus = mask<annulus2D, algebra_type, nav_link>;
-    using cylinder = mask<cylinder2D, algebra_type, nav_link>;
-    using cylinder_portal = mask<concentric_cylinder2D, algebra_type, nav_link>;
-    using disc = mask<ring2D, algebra_type, nav_link>;
-    using straw_tube = mask<line_circular, algebra_type, nav_link>;
-    using drift_cell = mask<line_square, algebra_type, nav_link>;
-    using single_1 = mask<single3D<1>, algebra_type, nav_link>;
-    using single_2 = mask<single3D<2>, algebra_type, nav_link>;
-    // TODO: Can single3 be used instead of cylinder portal type or remove it?
-    using single_3 = mask<single3D<3>, algebra_type, nav_link>;
-    // Debug types, e.g. telescope detector
-    using unbounded_rectangle =
-        mask<unbounded<rectangle2D>, algebra_type, nav_link>;
-    using unbounded_trapezoid =
-        mask<unbounded<trapezoid2D>, algebra_type, nav_link>;
-    using unbounded_annulus =
-        mask<unbounded<annulus2D>, algebra_type, nav_link>;
-    using unbounded_cylinder =
-        mask<unbounded<cylinder2D>, algebra_type, nav_link>;
-    using unbounded_disc = mask<unbounded<ring2D>, algebra_type, nav_link>;
-    using unbounded_straw_tube =
-        mask<unbounded<line_circular>, algebra_type, nav_link>;
-    using unbounded_drift_cell =
-        mask<unbounded<line_square>, algebra_type, nav_link>;
-    using unmasked_plane = mask<unmasked<>, algebra_type, nav_link>;
-
-    /// Give your mask types a name (needs to be consecutive and has to match
-    /// the types position in the mask store!)
-    enum class mask_ids : std::uint_least8_t {
-        e_rectangle2 = 0u,
-        e_portal_rectangle2 = 0u,
-        e_trapezoid2 = 1u,
-        e_annulus2 = 2u,
-        e_cylinder2 = 3u,
-        e_portal_cylinder2 = 4u,
-        e_ring2 = 5u,
-        e_portal_ring2 = 5u,
-        e_straw_tube = 6u,
-        e_drift_cell = 7u,
-        /*e_single1 = 8u,
-        e_single2 = 9u,
-        e_single3 = 10u,
-        e_unbounded_rectangle2 = 11u,
-        e_unbounded_trapezoid2 = 12u,
-        e_unbounded_annulus2 = 13u,
-        e_unbounded_cylinder2 = 14u,
-        e_unbounded_disc2 = 15u,
-        e_unbounded_line_circular2 = 16u,
-        e_unbounded_cell2 = 17u,
-        e_unmasked2 = 18u,*/
+    using concentric_cylinder2D_t =
+        mask<detray::concentric_cylinder2D, algebra_type, nav_link>;
+    using ring2D_t = mask<detray::ring2D, algebra_type, nav_link>;
+    using rectangle2D_t = mask<detray::rectangle2D, algebra_type, nav_link>;
+    using trapezoid2D_t = mask<detray::trapezoid2D, algebra_type, nav_link>;
+    using drift_cell_t = mask<detray::line_square, algebra_type, nav_link>;
+    using straw_tube_t = mask<detray::line_circular, algebra_type, nav_link>;
+    using cylinder2D_t = mask<detray::cylinder2D, algebra_type, nav_link>;
+    using annulus2D_t = mask<detray::annulus2D, algebra_type, nav_link>;
+
+    enum class mask_id : std::uint_least8_t {
+        e_concentric_cylinder2D = 0u,
+        e_ring2D = 1u,
+        e_rectangle2D = 2u,
+        e_trapezoid2D = 3u,
+        e_drift_cell = 4u,
+        e_straw_tube = 5u,
+        e_cylinder2D = 6u,
+        e_annulus2D = 7u,
     };
 
     DETRAY_HOST inline friend std::ostream& operator<<(std::ostream& os,
-                                                       mask_ids mid) {
-
-        switch (mid) {
-            case mask_ids::e_rectangle2:
-                // e_portal_rectangle2 has same value (0u)
-                os << "e_rectangle2/e_portal_rectangle2";
+                                                       mask_id id) {
+        switch (id) {
+            case mask_id::e_concentric_cylinder2D:
+                os << "e_concentric_cylinder2D";
                 break;
-            case mask_ids::e_trapezoid2:
-                os << "e_trapezoid2";
+            case mask_id::e_ring2D:
+                os << "e_ring2D";
                 break;
-            case mask_ids::e_annulus2:
-                os << "e_annulus2";
+            case mask_id::e_rectangle2D:
+                os << "e_rectangle2D";
                 break;
-            case mask_ids::e_cylinder2:
-                os << "e_cylinder2";
+            case mask_id::e_trapezoid2D:
+                os << "e_trapezoid2D";
                 break;
-            case mask_ids::e_portal_cylinder2:
-                os << "e_portal_cylinder2";
-                break;
-            case mask_ids::e_ring2:
-                // e_portal_ring2 has same value (5u)
-                os << "e_ring2/e_portal_ring2";
+            case mask_id::e_drift_cell:
+                os << "e_drift_cell";
                 break;
-            case mask_ids::e_straw_tube:
+            case mask_id::e_straw_tube:
                 os << "e_straw_tube";
                 break;
-            case mask_ids::e_drift_cell:
-                os << "e_drift_cell";
+            case mask_id::e_cylinder2D:
+                os << "e_cylinder2D";
+                break;
+            case mask_id::e_annulus2D:
+                os << "e_annulus2D";
                 break;
             default:
                 os << "invalid";
-        }
+        };
         return os;
-    }
+    };
 
-    /// How to store masks
     template <template <typename...> class vector_t = dvector>
-    using mask_store = regular_multi_store<mask_ids, empty_context, dtuple,
-                                           vector_t, rectangle, trapezoid,
-                                           annulus, cylinder, cylinder_portal,
-                                           disc, straw_tube, drift_cell /*,
-single_1, single_2, single_3, unbounded_rectangle, unbounded_trapezoid,
-unbounded_annulus, unbounded_cylinder, unbounded_disc, unbounded_straw_tube,
-unbounded_cell, unmasked_plane*/>;
-
-    //
-    // Material Description
-    //
-
-    /// Homogeneous material description
-    /// @{
-    using slab = material_slab<scalar_t>;
-    using rod = material_rod<scalar_t>;
-    /// @}
+    using mask_store =
+        regular_multi_store<mask_id, empty_context, dtuple, vector_t,
+                            concentric_cylinder2D_t, ring2D_t, rectangle2D_t,
+                            trapezoid2D_t, drift_cell_t, straw_tube_t,
+                            cylinder2D_t, annulus2D_t>;
 
-    /// Material grid types (default: closed bounds, regular binning)
-    /// @{
-
-    // Disc material grid
     template <typename container_t>
-    using disc_map_t = material_map<algebra_type, ring2D, container_t>;
-
-    // Cylindrical material grid
+    using concentric_cylinder2D_map_t =
+        material_map<algebra_type, detray::concentric_cylinder2D, container_t>;
     template <typename container_t>
-    using cylinder2_map_t = material_map<algebra_type, cylinder2D, container_t>;
-
-    // Concentric cylindrical material grid
+    using ring2D_map_t =
+        material_map<algebra_type, detray::ring2D, container_t>;
+    using material_slab_t = material_slab<scalar_t>;
     template <typename container_t>
-    using concentric_cylinder2_map_t =
-        material_map<algebra_type, concentric_cylinder2D, container_t>;
-
-    // Rectangular material grid
+    using cylinder3D_map_t =
+        material_map<algebra_type, detray::cylinder3D, container_t>;
+    using raw_material_t = material<scalar_t>;
     template <typename container_t>
-    using rectangular_map_t =
-        material_map<algebra_type, rectangle2D, container_t>;
-
-    // Cuboid volume material grid
+    using rectangle2D_map_t =
+        material_map<algebra_type, detray::rectangle2D, container_t>;
+    using material_rod_t = material_rod<scalar_t>;
     template <typename container_t>
-    using cuboid_map_t = material_map<algebra_type, cuboid3D, container_t>;
-
-    // Cylindrical volume material grid
-    template <typename container_t>
-    using cylinder3_map_t = material_map<algebra_type, cylinder3D, container_t>;
-
-    /// @}
-
-    /// Give your material types a name (needs to be consecutive and has to
-    /// match the types position in the mask store!)
-    enum class material_ids : std::uint_least8_t {
-        // Material texture (grid) shapes
-        e_concentric_cylinder2_map = 0u,
-        e_disc2_map = 1u,
-        e_cylinder2_map = 2u,
-        e_rectangle2_map = 3u,
-        e_trapezoid2_map = 3u,
-        e_annulus2_map = 1u,
-        e_drift_cell_map = 5u,
-        e_straw_tube_map = 5u,
-        // Volume material
-        // e_cuboid3_map = 7,
-        // e_cylinder3_map = 8u,
-        // Homogeneous material
-        e_slab = 4u,
-        e_rod = 5u,
-        e_raw_material = 6u,
-        e_none = 9u,
+    using cylinder2D_map_t =
+        material_map<algebra_type, detray::cylinder2D, container_t>;
+
+    enum class material_id : std::uint_least8_t {
+        e_concentric_cylinder2D_map = 0u,
+        e_ring2D_map = 1u,
+        e_material_slab = 2u,
+        e_cylinder3D_map = 3u,
+        e_raw_material = 4u,
+        e_rectangle2D_map = 5u,
+        e_material_rod = 6u,
+        e_cylinder2D_map = 7u,
+        e_none = 8u,
     };
 
     DETRAY_HOST inline friend std::ostream& operator<<(std::ostream& os,
-                                                       material_ids mid) {
-
-        switch (mid) {
-            case material_ids::e_concentric_cylinder2_map:
-                os << "e_concentric_cylinder2_map";
+                                                       material_id id) {
+        switch (id) {
+            case material_id::e_concentric_cylinder2D_map:
+                os << "e_concentric_cylinder2D_map";
                 break;
-            case material_ids::e_disc2_map:
-                // e_annulus2_map has same value (1u)
-                os << "e_disc2_map/e_annulus2_map";
+            case material_id::e_ring2D_map:
+                os << "e_ring2D_map";
                 break;
-            case material_ids::e_cylinder2_map:
-                os << "e_cylinder2_map";
+            case material_id::e_material_slab:
+                os << "e_material_slab";
                 break;
-            case material_ids::e_rectangle2_map:
-                // e_trapezoid2_map has same value (3u)
-                os << "e_rectangle2_map/e_trapezoid2_map";
+            case material_id::e_cylinder3D_map:
+                os << "e_cylinder3D_map";
                 break;
-            case material_ids::e_slab:
-                os << "e_slab";
+            case material_id::e_raw_material:
+                os << "e_raw_material";
                 break;
-            case material_ids::e_drift_cell_map:
-                // e_straw_tube_map and e_rod have same value (5u)
-                os << "e_drift_cell_map/e_straw_tube_map/e_rod";
+            case material_id::e_rectangle2D_map:
+                os << "e_rectangle2D_map";
                 break;
-            case material_ids::e_raw_material:
-                os << "e_raw_material";
+            case material_id::e_material_rod:
+                os << "e_material_rod";
                 break;
-            /*case material_ids::e_cuboid3_map:
-                os << "e_cuboid3_map";
+            case material_id::e_cylinder2D_map:
+                os << "e_cylinder2D_map";
                 break;
-            case material_ids::e_cylinder3_map:
-                os << "e_cylinder3_map";
-                break;*/
-            case material_ids::e_none:
+            case material_id::e_none:
                 os << "e_none";
                 break;
             default:
                 os << "invalid";
-        }
+        };
         return os;
-    }
+    };
 
-    /// How to store materials
     template <typename container_t = host_container_types>
-    using material_store = multi_store<
-        material_ids, empty_context, dtuple,
-        grid_collection<concentric_cylinder2_map_t<container_t>>,
-        grid_collection<disc_map_t<container_t>>,
-        grid_collection<cylinder2_map_t<container_t>>,
-        grid_collection<rectangular_map_t<container_t>>,
-        typename container_t::template vector_type<slab>,
-        typename container_t::template vector_type<rod>,
-        typename container_t::template vector_type<material<scalar_t>>/*,
-        grid_collection<cuboid_map_t<container_t>>,
-        grid_collection<cylinder3_map_t<container_t>>*/>;
-
-    //
-    // Acceleration structures
-    //
-
-    /// surface grid types (default boundaries: closed binning)
-    /// @TODO: Will we need the types for all grid configurations (binnning,
-    /// bin boundaries, serializers)?
-    /// @{
-
-    // surface grid definition: bin-content: darray<surface_type, 9>
-    template <typename axes_t, typename bin_entry_t, typename container_t>
-    using surface_grid_t =
-        spatial_grid<algebra_type, axes_t, bins::dynamic_array<bin_entry_t>,
-                     simple_serializer, container_t, false>;
+    using material_store =
+        multi_store<material_id, empty_context, dtuple,
+                    grid_collection<concentric_cylinder2D_map_t<container_t>>,
+                    grid_collection<ring2D_map_t<container_t>>,
+                    typename container_t::template vector_type<material_slab_t>,
+                    grid_collection<cylinder3D_map_t<container_t>>,
+                    typename container_t::template vector_type<raw_material_t>,
+                    grid_collection<rectangle2D_map_t<container_t>>,
+                    typename container_t::template vector_type<material_rod_t>,
+                    grid_collection<cylinder2D_map_t<container_t>>>;
 
-    // 2D cylindrical grid for the barrel layers
-    template <typename bin_entry_t, typename container_t>
-    using cylinder2D_sf_grid =
-        surface_grid_t<axes<concentric_cylinder2D>, bin_entry_t, container_t>;
-
-    // disc grid for the endcap layers
-    template <typename bin_entry_t, typename container_t>
-    using disc_sf_grid = surface_grid_t<axes<ring2D>, bin_entry_t, container_t>;
-
-    // 3D cylindrical grid for the entire barrel / endcaps
-    template <typename bin_entry_t, typename container_t>
-    using cylinder3D_sf_grid =
-        surface_grid_t<axes<cylinder3D>, bin_entry_t, container_t>;
-
-    // Irregular binning (hopefully not needed)
-
-    // cylindrical grid for the barrel layers
-    template <typename bin_entry_t, typename container_t>
-    using irr_cylinder2D_sf_grid =
-        surface_grid_t<axes<cylinder2D, axis::bounds::e_closed, axis::irregular,
-                            axis::irregular>,
-                       bin_entry_t, container_t>;
-
-    // disc grid for the endcap layers
-    template <typename bin_entry_t, typename container_t>
-    using irr_disc_sf_grid = surface_grid_t<
-        axes<ring2D, axis::bounds::e_closed, axis::irregular, axis::irregular>,
-        bin_entry_t, container_t>;
-
-    // 3D cylindrical grid for the entire barrel
-    template <typename bin_entry_t, typename container_t>
-    using irr_cylinder3D_sf_grid =
-        surface_grid_t<axes<cylinder3D, axis::bounds::e_closed, axis::irregular,
-                            axis::irregular, axis::irregular>,
-                       bin_entry_t, container_t>;
-
-    /// @}
-
-    /// How to link to the entries in the data stores
     using transform_link = typename transform_store<>::single_link;
     using mask_link = typename mask_store<>::range_link;
     using material_link = typename material_store<>::single_link;
-    /// Surface type used for sensitives, passives and portals
     using surface_type =
         surface_descriptor<mask_link, material_link, transform_link, nav_link>;
 
-    //
-    // Volume descriptors
-    //
+    template <typename axes_t, typename bin_entry_t, typename container_t>
+    using spatial_grid_t =
+        spatial_grid<algebra_type, axes_t, bins::dynamic_array<bin_entry_t>,
+                     simple_serializer, container_t, false>;
 
-    /// How to index the constituent objects (surfaces) in a volume
-    /// If they share the same index value here, they will be added into the
-    /// same acceleration data structure (brute force is always at 0)
-    enum geo_objects : std::uint_least8_t {
-        e_portal = 0u,     // Brute force search
-        e_passive = 0u,    // Brute force search
-        e_sensitive = 1u,  // Grid accelerated search (can be different types)
-        e_volume = 2u,     // Daughter volumes
-        e_size = 3u,     // Every volume holds two acceleration data structures
-        e_all = e_size,  // i.e. the brute force method and one grid type
+    template <typename container_t>
+    using surface_concentric_cylinder2D_grid_t =
+        spatial_grid_t<axes<detray::concentric_cylinder2D>, surface_type,
+                       container_t>;
+    template <typename container_t>
+    using surface_ring2D_grid_t =
+        spatial_grid_t<axes<detray::ring2D>, surface_type, container_t>;
+    template <typename container_t>
+    using surface_cylinder2D_grid_t =
+        spatial_grid_t<axes<detray::cylinder2D>, surface_type, container_t>;
+    template <typename container_t>
+    using volume_cylinder3D_grid_t =
+        spatial_grid_t<axes<detray::cylinder3D>, dindex, container_t>;
+
+    enum class accel_id : std::uint_least8_t {
+        e_surface_brute_force = 0u,
+        e_surface_concentric_cylinder2D_grid = 1u,
+        e_surface_ring2D_grid = 2u,
+        e_surface_cylinder2D_grid = 3u,
+        e_volume_cylinder3D_grid = 4u,
+        e_volume_brute_force = 5u,
+        e_surface_default = e_surface_brute_force,
+        e_volume_default = e_volume_cylinder3D_grid,
     };
 
     DETRAY_HOST inline friend std::ostream& operator<<(std::ostream& os,
-                                                       geo_objects gobj) {
-
-        switch (gobj) {
-            case geo_objects::e_portal:
-                // e_passive has same value (0u)
-                os << "e_portal/e_passive";
+                                                       accel_id id) {
+        switch (id) {
+            case accel_id::e_surface_brute_force:
+                os << "e_surface_brute_force";
                 break;
-            case geo_objects::e_sensitive:
-                os << "e_sensitive";
+            case accel_id::e_surface_concentric_cylinder2D_grid:
+                os << "e_surface_concentric_cylinder2D_grid";
                 break;
-            case geo_objects::e_volume:
-                os << "e_volume";
+            case accel_id::e_surface_ring2D_grid:
+                os << "e_surface_ring2D_grid";
                 break;
-            case geo_objects::e_size:
-                // e_all has same value (2u)
-                os << "e_size/e_all";
+            case accel_id::e_surface_cylinder2D_grid:
+                os << "e_surface_cylinder2D_grid";
+                break;
+            case accel_id::e_volume_cylinder3D_grid:
+                os << "e_volume_cylinder3D_grid";
+                break;
+            case accel_id::e_volume_brute_force:
+                os << "e_volume_brute_force";
                 break;
             default:
                 os << "invalid";
-        }
+        };
         return os;
-    }
+    };
 
-    /// Acceleration data structures
-    enum class accel_ids : std::uint_least8_t {
-        e_brute_force = 0u,     // test all surfaces in a volume (brute force)
-        e_cylinder2_grid = 1u,  // e.g. barrel layers
-        e_disc_grid = 2u,       // e.g. endcap layers
-        e_irr_cylinder2_grid = 3u,
-        e_irr_disc_grid = 4u,
-        e_volume_brute_force = 5u,
-        e_volume_cylinder3_grid = 6u,
-        // e_cylinder3_grid = 7u,
-        // e_irr_cylinder3_grid = 8u,
-        // ... e.g. frustum navigation types
-        e_default = e_brute_force,
-        e_default_volume_searcher = e_volume_cylinder3_grid,
+    template <typename container_t = host_container_types>
+    using accelerator_store = multi_store<
+        accel_id, empty_context, dtuple,
+        brute_force_collection<surface_type, container_t>,
+        grid_collection<surface_concentric_cylinder2D_grid_t<container_t>>,
+        grid_collection<surface_ring2D_grid_t<container_t>>,
+        grid_collection<surface_cylinder2D_grid_t<container_t>>,
+        grid_collection<volume_cylinder3D_grid_t<container_t>>,
+        brute_force_collection<dindex, container_t>>;
+
+    enum geo_objects : std::uint_least8_t {
+        e_portal = 0u,
+        e_passive = 0u,
+        e_sensitive = 1u,
+        e_volume = 2u,
+        e_size = 3u,
+        e_all = e_size,
     };
 
     DETRAY_HOST inline friend std::ostream& operator<<(std::ostream& os,
-                                                       accel_ids aid) {
-
-        switch (aid) {
-            case accel_ids::e_brute_force:
-                os << "e_brute_force/e_default";
-                break;
-            case accel_ids::e_cylinder2_grid:
-                os << "e_cylinder2_grid";
-                break;
-            case accel_ids::e_disc_grid:
-                os << "e_disc_grid";
+                                                       geo_objects id) {
+        switch (id) {
+            case geo_objects::e_sensitive:
+                os << "e_sensitive";
                 break;
-            case accel_ids::e_irr_cylinder2_grid:
-                os << "e_irr_cylinder2_grid";
+            case geo_objects::e_volume:
+                os << "e_volume";
                 break;
-            case accel_ids::e_irr_disc_grid:
-                os << "e_irr_disc_grid";
+            case geo_objects::e_portal:
+                os << "e_portal";
                 break;
-            case accel_ids::e_volume_brute_force:
-                os << "e_volume_brute_force";
+            case geo_objects::e_passive:
+                os << "e_passive";
                 break;
-            case accel_ids::e_volume_cylinder3_grid:
-                os << "e_volume_cylinder3_grid/e_default_volume_searcher";
+            case geo_objects::e_size:
+                os << "e_size";
                 break;
             default:
                 os << "invalid";
-        }
+        };
         return os;
-    }
+    };
 
-    /// How a volume links to the accelration data structures
-    /// In this case: One link for portals/passives and one sensitive surfaces
     using object_link_type =
-        dmulti_index<dtyped_index<accel_ids, dindex>, geo_objects::e_size>;
-
-    /// Volume search grid
-    template <typename container_t = host_container_types>
-    using volume_accelerator =
-        spatial_grid<algebra_type,
-                     axes<cylinder3D, axis::bounds::e_open, axis::irregular,
-                          axis::regular, axis::irregular>,
-                     bins::single<dindex>, simple_serializer, container_t,
-                     false>;
-
-    /// How to store the acceleration data structures
-    template <typename container_t = host_container_types>
-    using accelerator_store =
-        multi_store<accel_ids, empty_context, dtuple,
-                    brute_force_collection<surface_type, container_t>,
-                    grid_collection<
-                        cylinder2D_sf_grid<surface_type, container_t>>,
-                    grid_collection<disc_sf_grid<surface_type, container_t>>,
-                    grid_collection<
-                        irr_disc_sf_grid<surface_type, container_t>>,
-                    grid_collection<
-                        irr_cylinder2D_sf_grid<surface_type, container_t>>,
-                    grid_collection<volume_accelerator<container_t>> /*,
-grid_collection<cylinder3D_sf_grid<surface_type,
-container_t>>,
-grid_collection<irr_cylinder3D_sf_grid<surface_type,
-container_t>>*/>;
+        dmulti_index<dtyped_index<accel_id, dindex>, geo_objects::e_size>;
 };
 
 }  // namespace detray
diff --git a/detectors/include/detray/detectors/itk_metadata.hpp b/detectors/include/detray/detectors/itk_metadata.hpp
index 1fd966dd0..67566dfb3 100644
--- a/detectors/include/detray/detectors/itk_metadata.hpp
+++ b/detectors/include/detray/detectors/itk_metadata.hpp
@@ -54,31 +54,27 @@ struct itk_metadata {
     /// Give your mask types a name (needs to be consecutive and has to match
     /// the types position in the mask store!)
     enum class mask_ids : std::uint_least8_t {
-        e_rectangle2 = 0u,
-        e_annulus2 = 1u,
-        e_cylinder2 = 2u,
-        e_portal_cylinder2 = 2u,
-        e_ring2 = 3u,
-        e_portal_ring2 = 3u,
+        e_rectangle2D = 0u,
+        e_annulus2D = 1u,
+        e_concentric_cylinder2D = 2u,
+        e_ring2D = 3u,
     };
 
     DETRAY_HOST inline friend std::ostream& operator<<(std::ostream& os,
                                                        mask_ids mid) {
 
         switch (mid) {
-            case mask_ids::e_rectangle2:
-                // e_portal_rectangle2 has same value (0u)
-                os << "e_rectangle2/e_portal_rectangle2";
+            case mask_ids::e_rectangle2D:
+                os << "e_rectangle2D";
                 break;
-            case mask_ids::e_annulus2:
-                os << "e_annulus2";
+            case mask_ids::e_annulus2D:
+                os << "e_annulus2D";
                 break;
-            case mask_ids::e_cylinder2:
-                os << "e_cylinder2/e_portal_cylinder2";
+            case mask_ids::e_concentric_cylinder2D:
+                os << "e_concentric_cylinder2D";
                 break;
-            case mask_ids::e_ring2:
-                // e_portal_ring2 has same value (5u)
-                os << "e_ring2/e_portal_ring2";
+            case mask_ids::e_ring2D:
+                os << "e_ring2";
                 break;
             default:
                 os << "invalid";
@@ -114,8 +110,8 @@ struct itk_metadata {
     /// match the types position in the mask store!)
     enum class material_ids : std::uint_least8_t {
         // Material texture (grid) shapes
-        e_concentric_cylinder2_map = 0u,
-        e_disc2_map = 1u,
+        e_concentric_cylinder2D_map = 0u,
+        e_ring2D_map = 1u,
         e_none = 2u,
     };
 
@@ -123,12 +119,12 @@ struct itk_metadata {
                                                        material_ids mid) {
 
         switch (mid) {
-            case material_ids::e_concentric_cylinder2_map:
-                os << "e_concentric_cylinder2_map";
+            case material_ids::e_concentric_cylinder2D_map:
+                os << "e_concentric_cylinder2D_map";
                 break;
-            case material_ids::e_disc2_map:
-                // e_annulus2_map has same value (1u)
-                os << "e_disc2_map/e_annulus2_map";
+            case material_ids::e_ring2D_map:
+                // e_annulus2D_map has same value (1u)
+                os << "e_ring2D_map/e_annulus2D_map";
                 break;
             case material_ids::e_none:
                 os << "e_none";
@@ -222,29 +218,30 @@ struct itk_metadata {
 
     /// Acceleration data structures
     enum class accel_ids : std::uint_least8_t {
-        e_brute_force = 0u,     // test all surfaces in a volume (brute force)
-        e_cylinder2_grid = 1u,  // e.g. barrel layers
-        e_disc_grid = 2u,       // e.g. endcap layers
-        e_volume_cylinder3_grid = 3u,
-        e_default_volume_searcher = e_volume_cylinder3_grid,
-        e_default = e_brute_force,
+        e_surface_brute_force =
+            0u,  // test all surfaces in a volume (brute force)
+        e_surface_cylinder2D_grid = 1u,  // e.g. barrel layers
+        e_surface_ring2D_grid = 2u,      // e.g. endcap layers
+        e_volume_cylinder3D_grid = 3u,
+        e_volume_default = e_volume_cylinder3D_grid,
+        e_surface_default = e_surface_brute_force,
     };
 
     DETRAY_HOST inline friend std::ostream& operator<<(std::ostream& os,
                                                        accel_ids aid) {
 
         switch (aid) {
-            case accel_ids::e_brute_force:
-                os << "e_brute_force";
+            case accel_ids::e_surface_brute_force:
+                os << "e_surface_brute_force";
                 break;
-            case accel_ids::e_cylinder2_grid:
-                os << "e_cylinder2_grid";
+            case accel_ids::e_surface_cylinder2D_grid:
+                os << "e_surface_cylinder2D_grid";
                 break;
-            case accel_ids::e_disc_grid:
-                os << "e_disc_grid";
+            case accel_ids::e_surface_ring2D_grid:
+                os << "e_surface_ring2D_grid";
                 break;
-            case accel_ids::e_volume_cylinder3_grid:
-                os << "e_volume_cylinder3_grid/e_default_volume_searcher";
+            case accel_ids::e_volume_cylinder3D_grid:
+                os << "e_volume_cylinder3D_grid/e_volume_default";
                 break;
             default:
                 os << "invalid";
diff --git a/detectors/include/detray/detectors/odd_metadata.hpp b/detectors/include/detray/detectors/odd_metadata.hpp
index 77267df49..4e89a69f3 100644
--- a/detectors/include/detray/detectors/odd_metadata.hpp
+++ b/detectors/include/detray/detectors/odd_metadata.hpp
@@ -54,31 +54,27 @@ struct odd_metadata {
     /// Give your mask types a name (needs to be consecutive and has to match
     /// the types position in the mask store!)
     enum class mask_ids : std::uint_least8_t {
-        e_rectangle2 = 0u,
-        e_trapezoid2 = 1u,
-        e_cylinder2 = 2u,
-        e_portal_cylinder2 = 2u,
+        e_rectangle2D = 0u,
+        e_trapezoid2D = 1u,
+        e_concentric_cylinder2D = 2u,
         e_ring2 = 3u,
-        e_portal_ring2 = 3u,
     };
 
     DETRAY_HOST inline friend std::ostream& operator<<(std::ostream& os,
                                                        mask_ids mid) {
 
         switch (mid) {
-            case mask_ids::e_rectangle2:
-                // e_portal_rectangle2 has same value (0u)
-                os << "e_rectangle2/e_portal_rectangle2";
+            case mask_ids::e_rectangle2D:
+                os << "e_rectangle2";
                 break;
-            case mask_ids::e_trapezoid2:
+            case mask_ids::e_trapezoid2D:
                 os << "e_trapezoid2";
                 break;
-            case mask_ids::e_cylinder2:
-                os << "e_cylinder2/e_portal_cylinder2";
+            case mask_ids::e_concentric_cylinder2D:
+                os << "e_concentric_cylinder2D";
                 break;
-            case mask_ids::e_ring2:
-                // e_portal_ring2 has same value (5u)
-                os << "e_ring2/e_portal_ring2";
+            case mask_ids::e_ring2D:
+                os << "e_ring2D";
                 break;
             default:
                 os << "invalid";
@@ -114,8 +110,8 @@ struct odd_metadata {
     /// match the types position in the mask store!)
     enum class material_ids : std::uint_least8_t {
         // Material texture (grid) shapes
-        e_concentric_cylinder2_map = 0u,
-        e_disc2_map = 1u,
+        e_concentric_cylinder2D_map = 0u,
+        e_ring2D_map = 1u,
         e_none = 2u,
     };
 
@@ -123,12 +119,12 @@ struct odd_metadata {
                                                        material_ids mid) {
 
         switch (mid) {
-            case material_ids::e_concentric_cylinder2_map:
-                os << "e_concentric_cylinder2_map";
+            case material_ids::e_concentric_cylinder2D_map:
+                os << "e_concentric_cylinder2D_map";
                 break;
-            case material_ids::e_disc2_map:
-                // e_annulus2_map has same value (1u)
-                os << "e_disc2_map/e_annulus2_map";
+            case material_ids::e_ring2D_map:
+                // e_annulus2D_map has same value (1u)
+                os << "e_ring2D_map/e_annulus2D_map";
                 break;
             case material_ids::e_none:
                 os << "e_none";
@@ -222,29 +218,30 @@ struct odd_metadata {
 
     /// Acceleration data structures
     enum class accel_ids : std::uint_least8_t {
-        e_brute_force = 0u,     // test all surfaces in a volume (brute force)
-        e_cylinder2_grid = 1u,  // e.g. barrel layers
-        e_disc_grid = 2u,       // e.g. endcap layers
-        e_volume_cylinder3_grid = 3u,
-        e_default = e_brute_force,
-        e_default_volume_searcher = e_volume_cylinder3_grid,
+        e_surface_brute_force =
+            0u,  // test all surfaces in a volume (brute force)
+        e_surface_cylinder2D_grid = 1u,  // e.g. barrel layers
+        e_surface_ring2D_grid = 2u,      // e.g. endcap layers
+        e_volume_cylinder3D_grid = 3u,
+        e_surface_default = e_surface_brute_force,
+        e_volume_default = e_volume_cylinder3D_grid,
     };
 
     DETRAY_HOST inline friend std::ostream& operator<<(std::ostream& os,
                                                        accel_ids aid) {
 
         switch (aid) {
-            case accel_ids::e_brute_force:
-                os << "e_brute_force";
+            case accel_ids::e_surface_brute_force:
+                os << "e_surface_brute_force";
                 break;
-            case accel_ids::e_cylinder2_grid:
-                os << "e_cylinder2_grid";
+            case accel_ids::e_surface_cylinder2D_grid:
+                os << "e_surface_cylinder2D_grid";
                 break;
-            case accel_ids::e_disc_grid:
-                os << "e_disc_grid";
+            case accel_ids::e_surface_ring2D_grid:
+                os << "e_surface_ring2D_grid";
                 break;
-            case accel_ids::e_volume_cylinder3_grid:
-                os << "e_volume_cylinder3_grid/e_default_volume_searcher";
+            case accel_ids::e_volume_cylinder3D_grid:
+                os << "e_volume_cylinder3D_grid/e_volume_default";
                 break;
             default:
                 os << "invalid";
diff --git a/detectors/include/detray/detectors/telescope_metadata.hpp b/detectors/include/detray/detectors/telescope_metadata.hpp
index 65d5fbb39..60ec1cfbf 100644
--- a/detectors/include/detray/detectors/telescope_metadata.hpp
+++ b/detectors/include/detray/detectors/telescope_metadata.hpp
@@ -52,15 +52,14 @@ struct telescope_metadata {
     /// Rectangles are always needed as portals (but the yhave the same type as
     /// module rectangles). Only one additional mask shape is allowed
     enum class mask_ids : std::uint_least8_t {
-        e_rectangle2 = 0u,
-        e_portal_rectangle2 = 0u,
-        e_annulus2 = 1u,
-        e_cylinder2 = 1u,
-        e_ring2 = 1u,
-        e_trapezoid2 = 1u,
-        e_single1 = 1u,
-        e_single2 = 1u,
-        e_single3 = 1u,
+        e_rectangle2D = 0u,
+        e_annulus2D = 1u,
+        e_cylinder2D = 1u,
+        e_ring2D = 1u,
+        e_trapezoid2D = 1u,
+        e_single1D = 1u,
+        e_single2D = 1u,
+        e_single3D = 1u,
         e_straw_tube = 1u,
         e_drift_cell = 1u,
         e_unbounded_annulus2 = 1u,
@@ -77,11 +76,10 @@ struct telescope_metadata {
                                                        mask_ids mid) {
 
         switch (mid) {
-            case mask_ids::e_rectangle2:
-                // e_portal_rectangle2 has same value (0u)
-                os << "e_rectangle2/e_portal_rectangle2";
+            case mask_ids::e_rectangle2D:
+                os << "e_rectangle2";
                 break;
-            case mask_ids::e_annulus2:
+            case mask_ids::e_annulus2D:
                 // All other values are 1u, showing first alphabetically
                 os << "OTHER SHAPE";
                 break;
@@ -111,9 +109,9 @@ struct telescope_metadata {
 
     /// Material type ids
     enum class material_ids : std::uint_least8_t {
-        e_slab = 0u,
+        e_material_slab = 0u,
         e_raw_material = 1u,  //< used for homogeneous volume material
-        e_rod = 2u,
+        e_material_rod = 2u,
         e_none = 3u,
     };
 
@@ -121,14 +119,14 @@ struct telescope_metadata {
                                                        material_ids mid) {
 
         switch (mid) {
-            case material_ids::e_slab:
-                os << "e_slab";
+            case material_ids::e_material_slab:
+                os << "e_material_slab";
                 break;
             case material_ids::e_raw_material:
                 os << "e_raw_material";
                 break;
-            case material_ids::e_rod:
-                os << "e_rod";
+            case material_ids::e_material_rod:
+                os << "e_material_rod";
                 break;
             case material_ids::e_none:
                 os << "e_none";
@@ -198,23 +196,24 @@ struct telescope_metadata {
 
     /// Acceleration data structures
     enum class accel_ids {
-        e_brute_force = 0u,  // test all surfaces in a volume (brute force)
+        e_surface_brute_force =
+            0u,  // test all surfaces in a volume (brute force)
         e_volume_brute_force = 1u,
-        e_default = e_brute_force,
-        e_default_volume_searcher = e_volume_brute_force,
+        e_surface_default = e_surface_brute_force,
+        e_volume_default = e_volume_brute_force,
     };
 
     DETRAY_HOST inline friend std::ostream& operator<<(std::ostream& os,
                                                        accel_ids aid) {
 
         switch (aid) {
-            case accel_ids::e_brute_force:
-                // e_default has same value (0u)
-                os << "e_brute_force/e_default";
+            case accel_ids::e_surface_brute_force:
+                // e_surface_default has same value (0u)
+                os << "e_surface_brute_force/e_surface_default";
                 break;
             case accel_ids::e_volume_brute_force:
                 // e_default has same value (0u)
-                os << "e_volume_brute_force/e_default_volume_searcher";
+                os << "e_volume_brute_force/e_volume_default";
                 break;
             default:
                 os << "invalid";
diff --git a/detectors/include/detray/detectors/toy_metadata.hpp b/detectors/include/detray/detectors/toy_metadata.hpp
index 4da338063..40c14b2ef 100644
--- a/detectors/include/detray/detectors/toy_metadata.hpp
+++ b/detectors/include/detray/detectors/toy_metadata.hpp
@@ -42,29 +42,29 @@ struct toy_metadata {
 
     /// Mask type ids
     enum class mask_ids : std::uint_least8_t {
-        e_rectangle2 = 0u,
-        e_trapezoid2 = 1u,
-        e_portal_cylinder2 = 2u,
-        e_portal_ring2 = 3u,
-        e_cylinder2 = 2u,
+        e_rectangle2D = 0u,
+        e_trapezoid2D = 1u,
+        e_concentric_cylinder2D = 2u,
+        e_ring2D = 3u,
+        e_cylinder2D = 2u,
     };
 
     DETRAY_HOST inline friend std::ostream& operator<<(std::ostream& os,
                                                        mask_ids mid) {
 
         switch (mid) {
-            case mask_ids::e_rectangle2:
+            case mask_ids::e_rectangle2D:
                 os << "e_rectangle2";
                 break;
-            case mask_ids::e_trapezoid2:
+            case mask_ids::e_trapezoid2D:
                 os << "e_trapezoid2";
                 break;
-            case mask_ids::e_portal_cylinder2:
+            case mask_ids::e_concentric_cylinder2D:
                 // e_cylinder2 has same value (2u)
-                os << "e_portal_cylinder2/e_cylinder2";
+                os << "e_concentric_cylinder2D";
                 break;
-            case mask_ids::e_portal_ring2:
-                os << "e_portal_ring2";
+            case mask_ids::e_ring2D:
+                os << "e_ring2D";
                 break;
             default:
                 os << "invalid";
@@ -96,9 +96,9 @@ struct toy_metadata {
 
     /// Material type ids
     enum class material_ids : std::uint_least8_t {
-        e_concentric_cylinder2_map = 0u,
-        e_disc2_map = 1u,
-        e_slab = 2u,
+        e_concentric_cylinder2D_map = 0u,
+        e_ring2D_map = 1u,
+        e_material_slab = 2u,
         e_none = 3u,
     };
 
@@ -106,14 +106,14 @@ struct toy_metadata {
                                                        material_ids mid) {
 
         switch (mid) {
-            case material_ids::e_concentric_cylinder2_map:
-                os << "e_concentric_cylinder2_map";
+            case material_ids::e_concentric_cylinder2D_map:
+                os << "e_concentric_cylinder2D_map";
                 break;
-            case material_ids::e_disc2_map:
-                os << "e_disc2_map";
+            case material_ids::e_ring2D_map:
+                os << "e_ring2D_map";
                 break;
-            case material_ids::e_slab:
-                os << "e_slab";
+            case material_ids::e_material_slab:
+                os << "e_material_slab";
                 break;
             case material_ids::e_none:
                 os << "e_none";
@@ -204,30 +204,31 @@ struct toy_metadata {
 
     /// Acceleration data structures
     enum class accel_ids : std::uint_least8_t {
-        e_brute_force = 0u,     // test all surfaces in a volume (brute force)
-        e_cylinder2_grid = 1u,  // barrel
-        e_disc_grid = 2u,       // endcap
-        e_volume_cylinder3_grid = 3u,
-        e_default = e_brute_force,
-        e_default_volume_searcher = e_volume_cylinder3_grid,
+        e_surface_brute_force =
+            0u,  // test all surfaces in a volume (brute force)
+        e_surface_cylinder2D_grid = 1u,  // barrel
+        e_surface_ring2D_grid = 2u,      // endcap
+        e_volume_cylinder3D_grid = 3u,
+        e_surface_default = e_surface_brute_force,
+        e_volume_default = e_volume_cylinder3D_grid,
     };
 
     DETRAY_HOST inline friend std::ostream& operator<<(std::ostream& os,
                                                        accel_ids aid) {
 
         switch (aid) {
-            case accel_ids::e_brute_force:
-                // e_default has same value (0u)
-                os << "e_brute_force/e_default";
+            case accel_ids::e_surface_brute_force:
+                // e_surface_default has same value (0u)
+                os << "e_surface_brute_force/e_surface_default";
                 break;
-            case accel_ids::e_cylinder2_grid:
-                os << "e_cylinder2_grid";
+            case accel_ids::e_surface_cylinder2D_grid:
+                os << "e_surface_cylinder2D_grid";
                 break;
-            case accel_ids::e_disc_grid:
-                os << "e_disc_grid";
+            case accel_ids::e_surface_ring2D_grid:
+                os << "e_surface_ring2D_grid";
                 break;
-            case accel_ids::e_volume_cylinder3_grid:
-                os << "e_volume_cylinder3_grid/e_default_volume_searcher";
+            case accel_ids::e_volume_cylinder3D_grid:
+                os << "e_volume_cylinder3D_grid/e_volume_default";
                 break;
             default:
                 os << "invalid";
diff --git a/detectors/python/default_metadata.py b/detectors/python/default_metadata.py
new file mode 100644
index 000000000..2dc5ac868
--- /dev/null
+++ b/detectors/python/default_metadata.py
@@ -0,0 +1,81 @@
+# Detray library, part of the ACTS project (R&D line)
+#
+# (c) 2026 CERN for the benefit of the ACTS project
+#
+# Mozilla Public License Version 2.0
+
+from impl import metadata, metadata_generator
+from impl import Type, Algebra, Shape, Material, Accelerator
+from utils import (
+    add_logging_options,
+    parse_logging_options,
+    add_calorimeter_defaults,
+    add_silicon_tracker_defaults,
+    add_telescope_detector_defaults,
+    add_wire_chamber_defaults,
+)
+
+from itk_metadata import add_itk_types
+from odd_metadata import add_odd_types
+
+import logging
+
+# --------------------------------------------------------------------------
+# Generate the default metadata type (can represent all detectors)
+# --------------------------------------------------------------------------
+
+
+def __main__():
+    # Commandline options
+    parser = add_logging_options()
+    parse_logging_options(parser.parse_args())
+
+    logger = logging.getLogger(__name__)
+
+    # Collect the types required for a detector that can hold all detector types
+    md = metadata("default")
+
+    # Specify a particular algebra plugin (otherwise left as template param.)
+    # md.set_algebra_plugin(Algebra.ARRAY, Type.SINGLE)
+
+    # Make sure all of the defaults are added
+    add_silicon_tracker_defaults(md, use_mat_maps=True, use_homogeneous_mat=True)
+    add_calorimeter_defaults(md, use_mat_maps=True, use_homogeneous_mat=True)
+    add_telescope_detector_defaults(md, use_mat_maps=True, use_homogeneous_mat=True)
+    add_wire_chamber_defaults(md, use_mat_maps=True, use_homogeneous_mat=True)
+
+    # Make sure all detectors can be represented by this metadata
+    add_odd_types(md)
+    add_itk_types(md)
+
+    # Add an acceleration struct for general 2D cylinders
+    md.add_accel_struct(Accelerator.CYLINDER_GRID2D)
+    md.add_material(Material.CYLINDER_MAP2D)
+
+    #
+    # Add some special types (e.g. for detector R&D)
+
+    # Special surface types
+    # md.add_sensitive(Shape.UNBOUNDED)  # Always hit the surface
+    # md.add_sensitive(Shape.UNMASKED)
+
+    # Add more material types
+    # Material maps on non-concentric cylinders
+    # md.add_material(Material.CYLINDER_MAP2D)
+
+    # Add surface acceleration structures
+    # md.add_accel_struct(Accelerator.CYLINDER_GRID3D)
+    # md.add_accel_struct(Accelerator.CUBOID_GRID3D)
+
+    # Make sure a default acceleration struct is chosen that can be used in all
+    # detector types
+    logger.info("Overwrite default acceleration structures to most generic type")
+    md.set_default_accel_struct(Accelerator.BRUTE_FORCE, "portal")
+    md.set_default_accel_struct(Accelerator.CYLINDER_GRID3D, "volume")
+
+    # Dump the metadata to header file
+    metadata_generator(md)
+
+
+if __name__ == "__main__":
+    __main__()
diff --git a/detectors/python/impl/__init__.py b/detectors/python/impl/__init__.py
new file mode 100644
index 000000000..8f4c7eb51
--- /dev/null
+++ b/detectors/python/impl/__init__.py
@@ -0,0 +1,5 @@
+from .metadata_generator import (
+    metadata,
+    metadata_generator,
+)
+from .definitions import Type, Algebra, Shape, Material, Accelerator
diff --git a/detectors/python/impl/definitions.py b/detectors/python/impl/definitions.py
new file mode 100644
index 000000000..3062589e2
--- /dev/null
+++ b/detectors/python/impl/definitions.py
@@ -0,0 +1,158 @@
+# Detray library, part of the ACTS project (R&D line)
+#
+# (c) 2026 CERN for the benefit of the ACTS project
+#
+# Mozilla Public License Version 2.0
+
+# Project includes
+from .type_helpers import cpp_class
+
+# python includes
+from enum import Enum
+
+
+""" Fundamental types """
+
+
+class Type(Enum):
+    SINGLE = "float"
+    DOUBLE = "double"
+    UINT_8 = "std::uint8_t"
+    UINT_16 = "std::uint16_t"
+    UINT_32 = "std::uint32_t"
+    UINT_64 = "std::uint64_t"
+    UINT_128 = "std::uint128_t"
+    UINT_LEAST_8 = "std::uint_least8_t"
+    UINT_LEAST_16 = "std::uint_least16_t"
+    UINT_LEAST_32 = "std::uint_least32_t"
+    UINT_LEAST_64 = "std::uint_least64_t"
+    UINT_LEAST_128 = "std::uint_least128_t"
+
+    def __str__(self) -> str:
+        return self.value
+
+
+""" Available linear algebra bachends """
+
+
+class Algebra(Enum):
+    ANY = "concepts::algebra algebra_t"
+    ARRAY = "detray::array"
+    EIGEN = "detray::eigen"
+    FASTOR = "detray::fastor"
+    SMATRIX = "detray::smatrix"
+    VC_AOS = "detray::vc_aos"
+    VC_SOA = "detray::vc_soa"
+
+    def __str__(self) -> str:
+        return self.value
+
+
+""" Available geometric shape types """
+
+
+class Shape:
+    # ITk stereo annulus (r, phi)
+    ANNULUS = cpp_class(specifier="detray::annulus2D")
+    # 2D cylinder, at the origin, no rotation, single inters. sol. (r*phi, z)
+    CONCENTRIC_CYLINDER = cpp_class(specifier="detray::concentric_cylinder2D")
+    # 3D cubiod (x, y, z)
+    CUBOID = cpp_class(specifier="detray::cuboid3D")
+    # 2D cylinder (r*phi, z)
+    CYLINDER2D = cpp_class(specifier="detray::cylinder2D")
+    # 3D cylinder (r, phi, z)
+    CYLINDER3D = cpp_class(specifier="detray::cylinder3D")
+    # line, square cross sec, (+-r, z)
+    DRIFT_CELL = cpp_class(specifier="detray::line_square")
+    # line, circular cross sec, (+-r, z)
+    STRAW_TUBE = cpp_class(specifier="detray::line_circular")
+    # 2D rectangle (x, y)
+    RECTANGLE = cpp_class(specifier="detray::rectangle2D")
+    # 2D ring / disc (r, phi)
+    RING = cpp_class(specifier="detray::ring2D")
+    # 2D trapezoid (x, y)
+    TRAPEZOID = cpp_class(specifier="detray::trapezoid2D")
+    # Mask of any shape (to be added as 'param'), always 'inside'= true
+    UNBOUNDED = cpp_class(specifier="detray::unbounded")
+    # No shape
+    UNMASKED = cpp_class(specifier="detray::unmasked")
+
+
+MATERIAL_MAP_SPECIFIER = "detray::material_map"
+
+""" Available material types """
+
+
+class Material:
+    # Slab of material of given thickness
+    SLAB = cpp_class(specifier="detray::material_slab")
+    # Material with round cross sec, of given r
+    ROD = cpp_class(specifier="detray::material_rod")
+    # Raw material type, used e.g. for homogeneous volume material
+    RAW = cpp_class(specifier="detray::material")
+    # Surface material map, annulus shape 2D
+    ANNULUS_MAP2D = cpp_class(
+        specifier=MATERIAL_MAP_SPECIFIER, param={"shape": Shape.ANNULUS}
+    )
+    # Surface material map, concentric cyl.
+    CONCENTIRC_CYLINDER_MAP2D = cpp_class(
+        specifier=MATERIAL_MAP_SPECIFIER, param={"shape": Shape.CONCENTRIC_CYLINDER}
+    )
+    # Surface material map, cylindrical 2D
+    CYLINDER_MAP2D = cpp_class(
+        specifier=MATERIAL_MAP_SPECIFIER, param={"shape": Shape.CYLINDER2D}
+    )
+    # Volume material map, cylindrical 3D
+    CYLINDER_MAP3D = cpp_class(
+        specifier=MATERIAL_MAP_SPECIFIER, param={"shape": Shape.CYLINDER3D}
+    )
+    # Volume material map, cuboid 3D
+    CUBOID_MAP3D = cpp_class(
+        specifier=MATERIAL_MAP_SPECIFIER, param={"shape": Shape.CUBOID}
+    )
+    # Surface material map, rectangular 2D
+    RECTANGLE_MAP2D = cpp_class(
+        specifier=MATERIAL_MAP_SPECIFIER, param={"shape": Shape.RECTANGLE}
+    )
+    # Surface material map, disc 2D
+    DISC_MAP2D = cpp_class(
+        specifier=MATERIAL_MAP_SPECIFIER, param={"shape": Shape.RING}
+    )
+    # Surface material map, trapezoidal 2D
+    TRAPEZOID_MAP2D = cpp_class(
+        specifier=MATERIAL_MAP_SPECIFIER, param={"shape": Shape.TRAPEZOID}
+    )
+
+
+SPATIAL_GRID_SPECIFIER = "detray::spatial_grid"
+
+""" Available surface/volume acceleration structure types """
+
+
+class Accelerator:
+    # Test all registered surfaces
+    BRUTE_FORCE = cpp_class(specifier="detray::brute_force")
+    # Surface grid, cylindrical 2D (barrel)
+    CONCENTRIC_CYLINDER_GRID2D = cpp_class(
+        specifier=SPATIAL_GRID_SPECIFIER, param={"shape": Shape.CONCENTRIC_CYLINDER}
+    )
+    # Surface grid, cylindrical 2D (barrel)
+    CYLINDER_GRID2D = cpp_class(
+        specifier=SPATIAL_GRID_SPECIFIER, param={"shape": Shape.CYLINDER2D}
+    )
+    # Surface grid, cylindrical 3D (barrel)
+    CYLINDER_GRID3D = cpp_class(
+        specifier=SPATIAL_GRID_SPECIFIER, param={"shape": Shape.CYLINDER3D}
+    )
+    # Surface grid, disc (endcap)
+    DISC_GRID2D = cpp_class(
+        specifier=SPATIAL_GRID_SPECIFIER, param={"shape": Shape.RING}
+    )
+    # Surface grid, reactangular (telescope)
+    RECTANGLE_GRID2D = cpp_class(
+        specifier=SPATIAL_GRID_SPECIFIER, param={"shape": Shape.RECTANGLE}
+    )
+    # Surface grid, cuboid 3D (telescope)
+    CUBOID_GRID3D = cpp_class(
+        specifier=SPATIAL_GRID_SPECIFIER, param={"shape": Shape.CUBOID}
+    )
diff --git a/detectors/python/impl/metadata_generator.py b/detectors/python/impl/metadata_generator.py
new file mode 100644
index 000000000..c0491ee1a
--- /dev/null
+++ b/detectors/python/impl/metadata_generator.py
@@ -0,0 +1,837 @@
+# Detray library, part of the ACTS project (R&D line)
+#
+# (c) 2026 CERN for the benefit of the ACTS project
+#
+# Mozilla Public License Version 2.0
+
+# Project includes
+from .type_helpers import link
+from .definitions import (
+    Type,
+    Algebra,
+    Shape,
+    Material,
+    Accelerator,
+)
+
+# Python includes
+from datetime import datetime
+import itertools
+import logging
+import os
+from typing import Optional
+
+
+""" Class that represents the c++ metadata struct with all of its types """
+
+
+class metadata:
+
+    def __init__(
+        self,
+        detector_name,
+    ):
+        self.logger = logging.getLogger(__name__)
+        self.det_name = detector_name
+        # Custom linear algebra implementation
+        self.algebra = Algebra.ANY
+        # Only relevant, if algebra type is not 'ANY'
+        self.precision = None
+        # Base type for type ID enums
+        self.id_base = Type.UINT_LEAST_8
+        # Volume link in the masks (resolve geometry connectivity in navigation)
+        self.nav_link = link(link_type="single", data_type=Type.UINT_LEAST_16)
+        # Surface link to its mask(s) (type ID, index range)
+        self.mask_link = link(link_type="range", data_type=Type.UINT_32)
+        # Surface link to its material (type ID, index)
+        self.material_link = link(link_type="single", data_type=Type.UINT_32)
+        # Surface types: passive, portal, sensitive etc.
+        self.surface_types = []
+        # Surface shapes: rectangle, ring etc.
+        self.shapes = []
+        # Material types: slabs, material maps etc.
+        self.materials = []
+        # Set brute force finder as default for portals/passives and volumes
+        self.default_surface_accel = Accelerator.BRUTE_FORCE
+        self.default_volume_accel = Accelerator.BRUTE_FORCE
+        # Surface and volume acceleration structures
+        self.acceleration_structs = {}
+
+        self.logger.info(f'Detector: "{self.det_name}"')
+
+    # Choose an algebra-plugin
+    def set_algebra_plugin(self, plugin: Algebra, precision: Optional[Type] = None):
+        self.algebra = plugin
+
+        if self.algebra is not Algebra.ANY:
+            if precision is not Type.SINGLE or precision is not Type.DOUBLE:
+                self.logger.warning(
+                    f'Incorrect precision "{precision}" for algebra type. Using "float" instead'
+                )
+                self.precision = Type.SINGLE
+            else:
+                self.precision = precision
+            self.logger.info(f"Algebra plugin: {self.algebra}<{self.precision}>")
+        elif precision is not None:
+            self.logger.warning(
+                f'Precision "{precision}" will be ignored for generic algebra type'
+            )
+
+    # Register a new geometric shape for a portal surface
+    def add_portal(self, shape: Shape):
+        self.add_shape(shape)
+        if "portal" not in self.surface_types:
+            self.surface_types.append("portal")
+
+    # Register a new geometric shape for a sensitive surface
+    def add_sensitive(self, shape: Shape):
+        self.add_shape(shape)
+        if "sensitive" not in self.surface_types:
+            self.surface_types.append("sensitive")
+
+    # Register a new geometric shape for a passive surface
+    def add_passive(self, shape: Shape):
+        self.add_shape(shape)
+        if "passive" not in self.surface_types:
+            self.surface_types.append("passive")
+
+    # Register a new geometric shape for the detector
+    def add_shape(self, shape: Shape):
+        if shape not in self.shapes:
+            self.logger.debug(f'--> surface shape "{shape.specifier}"')
+            self.shapes.append(shape)
+
+    # Register a new material type
+    def add_material(self, mat: Material):
+        if mat not in self.materials:
+            if mat is Material.SLAB or mat is Material.ROD or mat is Material.RAW:
+                self.logger.debug(f'--> material type "{mat.specifier}"')
+            else:
+                shape_secifier = mat.param["shape"].specifier
+                self.logger.debug(
+                    f'--> material type "{mat.specifier}<{shape_secifier}>"'
+                )
+
+            self.materials.append(mat)
+
+    # Register a new acceleration structure for a geometric object type
+    def add_accel_struct(
+        self, accel: Accelerator, obj_type: str = "sensitive", is_default: bool = False
+    ):
+        chosen = False
+        if obj_type not in self.acceleration_structs.keys():
+            self.acceleration_structs[obj_type] = [accel]
+            chosen = True
+        elif accel not in self.acceleration_structs[obj_type]:
+            chosen = True
+            self.acceleration_structs[obj_type].append(accel)
+
+        if chosen:
+            shape_secifier = (
+                "" if "grid" not in accel.specifier else accel.param["shape"].specifier
+            )
+            accel_type = (
+                f"{accel.specifier}"
+                if "grid" not in accel.specifier
+                else f"{accel.specifier}<{shape_secifier}>"
+            )
+
+            self.logger.debug(f"--> accel. struct ({obj_type}): {accel_type}")
+
+        if is_default:
+            self.set_default_accel_struct(accel, obj_type)
+
+    # Mark an acceleration struct as default for the given object type
+    def set_default_accel_struct(self, accel: Accelerator, obj_type: str):
+        shape_secifier = (
+            "" if "grid" not in accel.specifier else accel.param["shape"].specifier
+        )
+        accel_type = (
+            f"{accel.specifier}"
+            if "grid" not in accel.specifier
+            else f"{accel.specifier}<{shape_secifier}>"
+        )
+
+        if obj_type == "portal":
+            self.logger.debug(
+                f"--> setting default surface accel. struct: {accel_type}"
+            )
+            self.default_surface_accel = accel
+        elif obj_type == "volume":
+            self.logger.debug(f"--> setting default volume accel. struct: {accel_type}")
+            self.default_volume_accel = accel
+        else:
+            self.logger.warning(
+                f'Cannot set default acceleration structure for geometry object type "{obj_type}"'
+            )
+
+        # Make sure the requested default exists
+        if (
+            obj_type not in self.acceleration_structs.keys()
+            or accel not in self.acceleration_structs[obj_type]
+        ):
+            self.logger.warning(
+                f"Requested default acceleration structure ({obj_type}, {accel_type}) not defined in metadata: Adding it now..."
+            )
+            self.add_accel_struct(accel, obj_type)
+
+
+""" Class that accumulates detector type data and writes a metadat header """
+
+
+class metadata_generator:
+
+    def __init__(
+        self,
+        md: metadata,
+    ):
+        # Internal state during header generation
+        self.file = None
+        self.logger = logging.getLogger(__name__)
+        self.indent = 0
+
+        # Save the type specifiers
+        self.shape_specifiers = []
+        self.material_specifiers = []
+        self.accel_specifiers = []
+
+        # Common header section
+        root_dir = '#include "detray'
+        self.__common_includes = f'#pragma once\n\n// Project include(s)\n\
+{root_dir}/core/detail/multi_store.hpp"\n\
+{root_dir}/core/detail/single_store.hpp"\n\
+{root_dir}/definitions/algebra.hpp"\n\
+{root_dir}/definitions/containers.hpp"\n\
+{root_dir}/definitions/indexing.hpp"\n\
+{root_dir}/geometry/mask.hpp"\n\
+{root_dir}/geometry/surface_descriptor.hpp"\n'
+
+        # Dump the header
+        self.__generate(md)
+
+    # Write the given metadata to file
+    def __generate(
+        self, md: metadata, src_dir="../detectors/include/detray/detectors/"
+    ):
+        filename = f"{os.path.abspath(src_dir)}/{md.det_name}_metadata.hpp"
+        self.logger.debug(f'Open "{filename}"')
+        self.file = open(filename, "w+")
+
+        self.logger.info("Generating metadata...")
+
+        # Beginning of the header (copyright, includes etc.)
+        self.__preamble(md)
+
+        # Basic typedefs
+        self.__local_typedefs(md)
+
+        # Transform store
+        self.logger.info(" -> Transforms")
+        self.__declare_transform_store()
+
+        # Mask store
+        self.logger.info(" -> Masks")
+        self.__declare_mask_store(md)
+
+        # Mask store
+        self.logger.info(" -> Material")
+        self.__declare_material_store(md)
+
+        # Surface type to be used in surface accelerator types
+        # (The volume type is automatically assembled in the detector class)
+        self.__lines(2)
+        self.__declare_surface_descriptor(md)
+
+        # Acceleration structure store
+        self.logger.info(" -> Acceleration Structures")
+        self.__declare_accel_store(md)
+
+        # Definition of geometric object types in a detector volume
+        self.__declare_geometry_objects(md)
+
+        # Finish (write header file to disk)
+        self.__finish()
+
+        self.logger.info("Done!")
+
+    # Add a string to the header file
+    def __put(self, string):
+        self.file.write(f"{self.__tabs()}{string}")
+
+    # Add empty lines
+    def __lines(self, n):
+        self.file.write("\n" * n)
+
+    # Add the current indent
+    def __tabs(self):
+        return "\t" * self.indent
+
+    # Write C++ typedef
+    def __typedef(self, name, type):
+        self.__put(f"using {name} = {type};\n")
+
+    # Write C++ template parameter list
+    def __template_list(self, params=[]):
+        return "" if not params else f"template <{','.join(params)}>"
+
+    # Get the the class name from the full type (which has namespace, template params etc.)
+    def __name_from_specifier(self, specifier):
+        # Strip template parameter list
+        tokens = specifier.split("<")
+        tp_str = tokens[0]
+
+        tokens = []
+
+        # Strip namespace
+        tokens = tp_str.split(":")
+
+        return tokens[-1]
+
+    # Beginning of the header
+    def __preamble(self, md: metadata):
+        copy_right = f"\
+/** Detray library, part of the ACTS project (R&D line)\n\
+ *\n\
+ * (c) {datetime.now().year} CERN for the benefit of the ACTS project\n\
+ *\n\
+ * Mozilla Public License Version 2.0\n\
+ */"
+        self.__put(copy_right)
+        self.__lines(2)
+        self.__add_header_includes(md.shapes, md.materials, md.acceleration_structs)
+        self.__lines(2)
+        self.__put("namespace detray {")
+        self.__lines(2)
+        # Write the C++ metatdata struct definition
+        template_params = (
+            f"{self.__template_list([str(md.algebra)])}\n"
+            if md.algebra == Algebra.ANY
+            else ""
+        )
+        struct_def = f"{template_params}struct {md.det_name}_metadata {{"
+        self.__put(struct_def)
+        self.indent = self.indent + 1
+        self.__lines(2)
+
+    # Identify the required dependencies and add the includes to the header
+    def __add_header_includes(self, shapes, materials, accel_structs):
+        # Add the common includes
+        self.__put(self.__common_includes)
+
+        # Set of shape class names
+        shape_names = {self.__name_from_specifier(s.specifier) for s in shapes}
+
+        # Correct the header name for the line surfaces
+        add_line = False
+        if "line_circular" in shape_names:
+            shape_names.remove("line_circular")
+            add_line = True
+        if "line_square" in shape_names:
+            shape_names.remove("line_square")
+            add_line = True
+
+        if add_line and "line" not in shape_names:
+            shape_names.add("line")
+
+        # Set of material class names
+        mat_names = {self.__name_from_specifier(m.specifier) for m in materials}
+        # Add shapes for material maps that have not been added, yet
+        if "material_map" in mat_names:
+            shape_names.update(
+                (
+                    self.__name_from_specifier(m.param["shape"].specifier)
+                    if m.param
+                    else None
+                )
+                for m in materials
+            )
+
+        # Set of acceleration structure class names
+        accel_names = {
+            self.__name_from_specifier(a.specifier)
+            for accels in accel_structs.values()
+            for a in accels
+        }
+        if "spatial_grid" in accel_names:
+            # Add shapes for spatial grids that have not been added, yet
+            shape_names.update(
+                (
+                    self.__name_from_specifier(a.param["shape"].specifier)
+                    if a.param
+                    else None
+                )
+                for accels in accel_structs.values()
+                for a in accels
+            )
+
+        # Add the corresponding includes
+        root_dir = '#include "detray'
+        shape_names.remove(None)
+        [self.__put(f'{root_dir}/geometry/shapes/{n}.hpp"\n') for n in shape_names]
+
+        [self.__put(f'{root_dir}/materials/{n}.hpp"\n') for n in mat_names]
+
+        [
+            self.__put(f'{root_dir}/navigation/accelerators/{n}.hpp"\n')
+            for n in accel_names
+        ]
+
+    # Add some mandatory local typedefs of the metadata class
+    def __local_typedefs(self, md: metadata):
+        self.__typedef(
+            "algebra_type",
+            (
+                "algebra_t"
+                if md.algebra == Algebra.ANY
+                else f"{md.algebra}<{md.precision}>"
+            ),
+        )
+        self.__typedef("scalar_t", "dscalar<algebra_type>")
+        self.__lines(1)
+        self.__typedef("nav_link", md.nav_link.data_type)
+
+    # Declare the transform store type
+    def __declare_transform_store(self):
+        self.__lines(1)
+        self.__put(
+            f"\
+template <template <typename...> class vector_t = dvector>\n\
+{self.__tabs()}using transform_store =\n\
+{self.__tabs()}    single_store<dtransform3D<algebra_type>, vector_t, geometry_context>;"
+        )
+
+    # Generate the IDs enums for the multi store
+    def __declare_type_enum(self, specifier, items, base_type, extra_items=[]):
+        self.__put(f"enum class {specifier} : {base_type} {{\n")
+
+        self.indent = self.indent + 1
+        for i, v in enumerate(items + extra_items):
+            # Special value was passed
+            item = v[0] if isinstance(v, list) else v
+            value = v[1] if isinstance(v, list) else f"{i}u"
+            # Remove the trailing '_t' suffix
+            sub_specifier = f"e_{item[:-2]}" if item.endswith("_t") else f"e_{item}"
+            self.__put(f"{sub_specifier} = {value},\n")
+
+        self.indent = self.indent - 1
+
+        self.__put("};")
+
+    # Add the streaming operator for an enum
+    def __define_enum_stream_op(self, specifier, items, extra_items=[]):
+        self.__put(
+            f"DETRAY_HOST inline friend std::ostream& operator<<(std::ostream& os, {specifier} id) {{\n"
+        )
+
+        self.indent = self.indent + 1
+
+        self.__put("switch (id) {\n")
+
+        self.indent = self.indent + 1
+        for i, v in enumerate(items + extra_items):
+            # Special value was passed
+            item = v[0] if isinstance(v, list) else v
+            value = v[1] if isinstance(v, list) else f"{i}u"
+            # Remove the trailing '_t' suffix
+            sub_specifier = f"e_{item[:-2]}" if item.endswith("_t") else f"e_{item}"
+
+            self.__put(f"case {specifier}::{sub_specifier}:\n")
+            self.indent = self.indent + 1
+            self.__put(f'os << "{value if isinstance(v, list) else sub_specifier}";\n')
+            self.__put("break;\n")
+            self.indent = self.indent - 1
+
+        # Add the default case
+        self.__put("default:\n")
+        self.indent = self.indent + 1
+        self.__put('os << "invalid";\n')
+        self.indent = self.indent - 1
+
+        self.indent = self.indent - 1
+
+        self.__put("};\n")
+        self.__put("return os;\n")
+
+        self.indent = self.indent - 1
+
+        self.__put("};")
+
+    # Generate the type declaration for the multi_stores
+    def __declare_multi_store(
+        self, specifier, id_name, types, context="empty_context", is_regular=True
+    ):
+        template_params = (
+            "template<typename...> class vector_t = dvector"
+            if is_regular
+            else "typename container_t = host_container_types"
+        )
+        self.__put(f"{self.__template_list([template_params])}\n")
+        self.__put(f"using {specifier} =\n")
+
+        if is_regular:
+            self.__put(
+                f"\tregular_multi_store<{id_name}, {context}, dtuple, vector_t, {','.join(types)}>;"
+            )
+        else:
+            # The brute force searcher needs to be at the beginning of the store
+            type_list = []
+            if "surface_brute_force_t" in types:
+                types.remove("surface_brute_force_t")
+                type_list.append("brute_force_collection<surface_type, container_t>")
+
+            # Have the volume acceleration structure at the end of the store
+            volume_brute_force = ""
+            if "volume_brute_force_t" in types:
+                types.remove("volume_brute_force_t")
+                volume_brute_force = "brute_force_collection<dindex, container_t>"
+
+            type_list = type_list + [
+                (
+                    f"grid_collection<{t}<container_t>>"
+                    if (t.endswith("map_t") or t.endswith("grid_t"))
+                    else f"typename container_t::template vector_type<{t}>"
+                )
+                for t in types
+            ]
+
+            if volume_brute_force:
+                type_list.append(volume_brute_force)
+
+            self.__put(
+                f"\tmulti_store<{id_name}, {context}, dtuple, {','.join(type_list)}>;"
+            )
+
+    # Declare the surface descriptor type with all links
+    def __declare_surface_descriptor(self, md: metadata):
+        self.__put("using transform_link = typename transform_store<>::single_link;\n")
+
+        link_type = (
+            "single_link" if md.mask_link.link_type == "single" else "range_link"
+        )
+        mask_link = f"typename mask_store<>::{link_type}"
+        self.__put(f"using mask_link = {mask_link};\n")
+
+        link_type = (
+            "single_link" if md.material_link.link_type == "single" else "range_link"
+        )
+        material_link = f"typename material_store<>::{link_type}"
+        self.__put(f"using material_link = {material_link};\n")
+
+        self.__put(
+            "using surface_type = surface_descriptor<mask_link, material_link, transform_link, nav_link>;"
+        )
+
+    # Write a full mask type
+    def __declare_mask(self, shape, algebra, link, shape_params={}):
+        type_specifier = f"{self.__name_from_specifier(shape.specifier)}_t"
+
+        # Distinguish line types
+        if type_specifier == "line_square_t" or type_specifier == "line_circular_t":
+            type_specifier = (
+                "drift_cell_t" if type_specifier == "line_square_t" else "straw_tube_t"
+            )
+
+        self.shape_specifiers.append(type_specifier)
+
+        # Prepate extra template parameters
+        params = [str(v).lower() for v in shape_params.values()]
+        template_params = "" if not shape_params else f"<{','.join(params)}>"
+
+        self.__put(
+            f"using {type_specifier} = mask<{shape.specifier}{template_params}, {algebra}, {link}>;\n"
+        )
+
+    # Declare the mask types and mask store for the detector
+    def __declare_mask_store(self, md: metadata):
+        # Mask types
+        assert md.shapes, "Define at least one geometric shape"
+        self.__lines(2)
+        for shape in md.shapes:
+            self.__declare_mask(shape, "algebra_type", "nav_link", shape.param)
+
+        self.__lines(1)
+        self.__declare_type_enum("mask_id", self.shape_specifiers, md.id_base)
+        self.__lines(2)
+        self.__define_enum_stream_op("mask_id", self.shape_specifiers)
+        self.__lines(2)
+
+        # Mask Store
+        self.__declare_multi_store("mask_store", "mask_id", self.shape_specifiers)
+
+    # Write a full material type
+    def __declare_material(self, mat, algebra):
+        type_specifier = f"{self.__name_from_specifier(mat.specifier)}_t"
+
+        if mat is Material.SLAB:
+            self.__put(f"using {type_specifier} = material_slab<scalar_t>;\n")
+        elif mat is Material.ROD:
+            self.__put(f"using {type_specifier} = material_rod<scalar_t>;\n")
+        elif mat is Material.RAW:
+            type_specifier = "raw_material_t"
+            self.__put(f"using {type_specifier} = material<scalar_t>;\n")
+        else:
+            shape_specifier = mat.param["shape"].specifier
+            shape_type = self.__name_from_specifier(shape_specifier)
+            type_specifier = f"{shape_type}_map_t"
+            template_list = "template <typename container_t>\n"
+            self.__put(
+                f"{template_list}{self.__tabs()}using {type_specifier} = material_map<{algebra}, {shape_specifier}, container_t>;\n"
+            )
+
+        self.material_specifiers.append(type_specifier)
+
+    # Declare the material types and material store for the detector
+    def __declare_material_store(self, md: metadata):
+        # Material types
+        if md.materials:
+            self.__lines(2)
+            for mat in md.materials:
+                self.__declare_material(mat, "algebra_type")
+
+            self.__lines(1)
+            # Add an option for 'no material'
+            self.__declare_type_enum(
+                "material_id", self.material_specifiers, md.id_base, ["none"]
+            )
+            self.__lines(2)
+            self.__define_enum_stream_op(
+                "material_id", self.material_specifiers, ["none"]
+            )
+        self.__lines(2)
+
+        # Material Store
+        self.__declare_multi_store(
+            "material_store", "material_id", self.material_specifiers, is_regular=False
+        )
+
+    # Write a full acceleration structure type
+    def __declare_accel(self, obj_type, acc):
+        type_specifier = f"{self.__name_from_specifier(acc.specifier)}_t"
+
+        # Surface descriptor or volume index as value type?
+        value_type = "dindex" if "volume" in obj_type else "surface_type"
+
+        if type_specifier.endswith("grid_t"):
+            # First spatial grid declaration?
+            if not any(sc.endswith("grid_t") for sc in self.accel_specifiers):
+                template_list = "template <typename axes_t, typename bin_entry_t, typename container_t>\n"
+                self.__put(
+                    f"{template_list}{self.__tabs()}using spatial_grid_t = spatial_grid<algebra_type, axes_t,bins::dynamic_array<bin_entry_t>, simple_serializer, container_t, false>;"
+                )
+                self.__lines(2)
+
+            shape_specifier = acc.param["shape"].specifier
+            type_specifier = f"{self.__name_from_specifier(shape_specifier)}_grid_t"
+
+            template_list = "template <typename container_t>\n"
+            self.__put(
+                f"{template_list}{self.__tabs()}using {obj_type}_{type_specifier} = spatial_grid_t<axes<{shape_specifier}>, {value_type}, container_t>;\n"
+            )
+
+        self.accel_specifiers.append(f"{obj_type}_{type_specifier}")
+
+    # Declare the accleration structure types and accel store for the detector
+    def __declare_accel_store(self, md: metadata):
+        # Acceleration Structures
+        assert (
+            len(md.acceleration_structs) > 2
+        ), "Define at least one default surface(portal) and one default volume acceleration structure"
+
+        assert (
+            "portal" in md.acceleration_structs.keys()
+        ), "Define at least one portal acceleration structure"
+
+        assert (
+            "volume" in md.acceleration_structs.keys()
+        ), "Define at least one volume acceleration structure"
+
+        if not md.acceleration_structs:
+            return
+
+        self.__lines(2)
+        # Make sure an acceleration struct is declared only once,
+        # even if it is used for multiple surface types
+        unique_accel = []
+        for geo_obj, accels in md.acceleration_structs.items():
+            obj_type = "volume" if "volume" in geo_obj else "surface"
+            for acc in accels:
+                if (obj_type, acc) not in unique_accel:
+                    self.__declare_accel(obj_type, acc)
+                    unique_accel.append((obj_type, acc))
+
+        # Add options for the default acceleration structs
+        self.__lines(1)
+
+        # Set enum item for default surface acceleration structure
+        surface_default = ""
+        if "grid" in md.default_surface_accel.specifier:
+            shape_specifier = md.default_surface_accel.param["shape"].specifier
+            surface_default = (
+                f"e_surface_{self.__name_from_specifier(shape_specifier)}_grid"
+            )
+        else:
+            surface_default = f"e_surface_{self.__name_from_specifier(md.default_surface_accel.specifier)}"
+
+        # Set enum item for default volume acceleration structure
+        volume_default = ""
+        if "grid" in md.default_volume_accel.specifier:
+            shape_specifier = md.default_volume_accel.param["shape"].specifier
+            volume_default = (
+                f"e_volume_{self.__name_from_specifier(shape_specifier)}_grid"
+            )
+        else:
+            volume_default = f"e_volume_{self.__name_from_specifier(md.default_volume_accel.specifier)}"
+
+        extra_items = [
+            ["surface_default", surface_default],
+            ["volume_default", volume_default],
+        ]
+        self.__declare_type_enum(
+            "accel_id",
+            self.accel_specifiers,
+            md.id_base,
+            extra_items=extra_items,
+        )
+
+        self.__lines(2)
+        self.__define_enum_stream_op(
+            "accel_id",
+            self.accel_specifiers,
+        )
+
+        # Accelerator Store
+        self.__lines(2)
+        self.__declare_multi_store(
+            "accelerator_store", "accel_id", self.accel_specifiers, is_regular=False
+        )
+
+    # Declare the geo,etry object types (e.g. passive, portal, sensitive)
+    # that are distinguishable to the volume: use enum values to link a
+    # geometry object type category to the corresponding accel. struct
+    def __declare_geometry_objects(self, md: metadata):
+        # Enumerate the different geometric objects and assign them to the accel
+        # link of the corresponding acceleration structure, e.g.
+        # geo_id:  obj_type:        accel_link [accel_id, accel_idx]
+        # ---------------------------------------------------------------------
+        # 0:       portal/passive:  [brute_force, 0] <- two in one accel. struct
+        # 1:       sensitive:       [disk_grid, 14]  <- distinct accel. struct
+        # 2:       volume:          [brute_force, 2] <- distinct accel. struct
+
+        # Find which geometric objects go together into which accel. struct
+        accel_to_types = {}
+        for t, accels in md.acceleration_structs.items():
+            # Suface and volume acceleration have different entry points
+            obj_type = "volume" if "volume" in t else "surface"
+
+            for a in accels:
+                specifier = f"{a.specifier}"
+
+                if (specifier, obj_type) not in accel_to_types:
+                    accel_to_types[specifier, obj_type] = set()
+
+                accel_to_types[specifier, obj_type].add(t)
+
+        # Sort, in order to find the largest geo object sets
+        accel_to_types_sorted = dict(
+            sorted(accel_to_types.items(), key=lambda item: len(item[1]), reverse=True)
+        )
+
+        # Link slot to geometry object types
+        accel_link_types = {}
+
+        # Add a new link slot, if there are previously unknown object types
+        def add_link(key, new_objects):
+            flattened_values = list(
+                itertools.chain.from_iterable(accel_link_types.values())
+            )
+
+            new_link_types = [l for l in new_objects if l not in flattened_values]
+            if new_link_types:
+                accel_link_types[key] = new_link_types
+
+        for (accel, obj_type), obj_set in accel_to_types_sorted.items():
+            # Only add the default methods where no other accelerator is
+            # available (see below)
+            is_surface_default = (
+                obj_type == "surface" and accel is md.default_surface_accel.specifier
+            )
+            is_volume_default = (
+                obj_type == "volume" and accel is md.default_volume_accel.specifier
+            )
+            if is_surface_default or is_volume_default:
+                continue
+
+            add_link(key=len(accel_link_types), new_objects=obj_set)
+
+        # Add the default link for the leftover surface and volume types
+        add_link(
+            key="surface_default",
+            new_objects=accel_to_types_sorted[
+                md.default_surface_accel.specifier, "surface"
+            ],
+        )
+
+        add_link(
+            key="volume_default",
+            new_objects=accel_to_types_sorted[
+                md.default_volume_accel.specifier, "volume"
+            ],
+        )
+
+        # Write the id enum for the types of distinct geometric objects
+        self.__lines(2)
+        self.__put(f"enum geo_objects : {md.id_base} {{\n")
+
+        self.indent = self.indent + 1
+
+        # The surface accelerator that contains the portals has to be in slot 0:
+        (portal_key, portal_group) = [
+            (k, v) for (k, v) in accel_link_types.items() if "portal" in v
+        ][0]
+
+        if not portal_group:
+            self.logger.error(
+                "No acceleration structure link define for portal surfaces!"
+            )
+            return
+
+        for gid in portal_group:
+            self.__put(f"e_{gid} = 0u,\n")
+
+        # Loop over the other link groups and enumerate them
+        for i, (key, link_group) in enumerate(accel_link_types.items()):
+            if key == portal_key:
+                continue
+            for gid in link_group:
+                # Observe the offset for the portal group link
+                self.__put(f"e_{gid} = {i + 1}u,\n")
+
+        self.__put(f"e_size = {len(accel_link_types)}u,\n")
+        self.__put("e_all = e_size,\n")
+
+        self.indent = self.indent - 1
+
+        self.__put("};")
+
+        # Add streaming operator for geo_objects enum
+        self.__lines(2)
+        self.__define_enum_stream_op(
+            "geo_objects",
+            list(itertools.chain.from_iterable(accel_link_types.values())),
+            extra_items=[["size", "e_size"]],
+        )
+
+        # Add the surface acceleration struct link to the volume descriptor
+        self.__lines(2)
+        self.__put(
+            "using object_link_type = dmulti_index<dtyped_index<accel_id, dindex>, geo_objects::e_size>;"
+        )
+
+    # Close the header file
+    def __finish(self):
+        self.__lines(1)
+        self.indent = self.indent - 1
+        self.__put("};\n\n} // namespace detray")
+        self.file.close()
+
+        self.logger.debug("Wrote file to disk")
diff --git a/detectors/python/impl/type_helpers.py b/detectors/python/impl/type_helpers.py
new file mode 100644
index 000000000..73b72bf6f
--- /dev/null
+++ b/detectors/python/impl/type_helpers.py
@@ -0,0 +1,18 @@
+# Detray library, part of the ACTS project (R&D line)
+#
+# (c) 2026 CERN for the benefit of the ACTS project
+#
+# Mozilla Public License Version 2.0
+
+# python includes
+from collections import namedtuple
+
+""" The type can be 'single' (index) or 'range' (index range) """
+link = namedtuple(
+    "link",
+    "link_type data_type",
+    defaults=["single", None],
+)
+
+""" A detray class with a name and its include path """
+cpp_class = namedtuple("cpp_class", "specifier path param", defaults=["", "", {}])
diff --git a/detectors/python/itk_metadata.py b/detectors/python/itk_metadata.py
new file mode 100644
index 000000000..ca09243c3
--- /dev/null
+++ b/detectors/python/itk_metadata.py
@@ -0,0 +1,57 @@
+# Detray library, part of the ACTS project (R&D line)
+#
+# (c) 2026 CERN for the benefit of the ACTS project
+#
+# Mozilla Public License Version 2.0
+
+from impl import metadata, metadata_generator
+from impl import Shape
+from utils import (
+    add_logging_options,
+    parse_logging_options,
+    add_silicon_tracker_defaults,
+)
+
+import logging
+
+# --------------------------------------------------------------------------
+# Generate the ITk metadata type
+# --------------------------------------------------------------------------
+
+""" Add all types needed to describe the ATLAS ITk detector """
+
+
+def add_itk_types(metadata: metadata):
+    logger = logging.getLogger(__name__)
+    logger.info("Define types required by the ATLAS Inner Tracker (ITk):")
+
+    # Strip stereo annulus shape
+    logger.info("-> adding ITk strip detecor custom shape")
+    metadata.add_sensitive(Shape.ANNULUS)
+
+    # Add default types for silicon trackers (cylindrical detector shape)
+    add_silicon_tracker_defaults(metadata=metadata, use_mat_maps=True)
+
+    # Beampipe passive surface
+    logger.info("-> adding ITk beampipe")
+    metadata.add_passive(Shape.CYLINDER2D)
+
+
+def __main__():
+    # Commandline options
+    parser = add_logging_options()
+    parse_logging_options(parser.parse_args())
+
+    md = metadata("itk")
+
+    # Specify a particular algebra plugin (otherwise left as template param.)
+    # md.set_algebra_plugin(Algebra.ARRAY, Type.SINGLE)
+
+    add_itk_types(md)
+
+    # Dump the metadata to header file
+    metadata_generator(md)
+
+
+if __name__ == "__main__":
+    __main__()
diff --git a/detectors/python/odd_metadata.py b/detectors/python/odd_metadata.py
new file mode 100644
index 000000000..b83e0b429
--- /dev/null
+++ b/detectors/python/odd_metadata.py
@@ -0,0 +1,55 @@
+# Detray library, part of the ACTS project (R&D line)
+#
+# (c) 2026 CERN for the benefit of the ACTS project
+#
+# Mozilla Public License Version 2.0
+
+from impl import metadata, metadata_generator
+from impl import Shape
+from utils import (
+    add_logging_options,
+    parse_logging_options,
+    add_silicon_tracker_defaults,
+)
+
+import logging
+
+# --------------------------------------------------------------------------
+# Generate the Open Data Detector metadata type
+# --------------------------------------------------------------------------
+
+""" Add all types needed to describe the ACTS Open Data Detector (ODD) """
+
+
+def add_odd_types(metadata: metadata):
+    logger = logging.getLogger(__name__)
+    logger.info("Define types required by the ACTS Open Data Detector (ODD):")
+
+    # Beampipe passive surface
+    logger.info("-> adding ODD beampipe")
+    metadata.add_passive(Shape.CYLINDER2D)
+
+    # Add default types for silicon trackers (cylindrical detector shape)
+    add_silicon_tracker_defaults(
+        metadata=metadata, use_homogeneous_mat=False, use_mat_maps=True
+    )
+
+
+def __main__():
+    # Commandline options
+    parser = add_logging_options()
+    parse_logging_options(parser.parse_args())
+
+    md = metadata("open_data_detector")
+
+    # Specify a particular algebra plugin (otherwise left as template param.)
+    # md.set_algebra_plugin(Algebra.ARRAY, Type.SINGLE)
+
+    add_odd_types(md)
+
+    # Dump the metadata to header file
+    metadata_generator(md)
+
+
+if __name__ == "__main__":
+    __main__()
diff --git a/detectors/python/telescope_metadata.py b/detectors/python/telescope_metadata.py
new file mode 100644
index 000000000..5db17a17b
--- /dev/null
+++ b/detectors/python/telescope_metadata.py
@@ -0,0 +1,53 @@
+# Detray library, part of the ACTS project (R&D line)
+#
+# (c) 2026 CERN for the benefit of the ACTS project
+#
+# Mozilla Public License Version 2.0
+
+from impl import metadata, metadata_generator
+from impl import Shape, Material
+from utils import (
+    add_logging_options,
+    parse_logging_options,
+    add_telescope_detector_defaults,
+)
+
+import logging
+
+# --------------------------------------------------------------------------
+# Generate the metadata type for the detray telescope test detector
+# --------------------------------------------------------------------------
+
+
+def __main__():
+    # Commandline options
+    parser = add_logging_options()
+    parse_logging_options(parser.parse_args())
+    logger = logging.getLogger(__name__)
+
+    # Collect the types required for a telescope test detector
+    md = metadata("telescope_test_detector")
+
+    # Cuboid volume based detector shape
+    add_telescope_detector_defaults(md)
+
+    # Add more geometric shape types for telescope test detector
+    logger.info("-> adding additional telescope sensitive types")
+    md.add_sensitive(Shape.ANNULUS)
+    md.add_sensitive(Shape.CONCENTRIC_CYLINDER)
+    md.add_sensitive(Shape.CYLINDER2D)
+    md.add_sensitive(Shape.RING)
+    md.add_sensitive(Shape.TRAPEZOID)
+    md.add_sensitive(Shape.DRIFT_CELL)
+    md.add_sensitive(Shape.STRAW_TUBE)
+    md.add_sensitive(Shape.UNBOUNDED)  # Always hit the surface
+
+    # Add more material types
+    md.add_material(Material.ROD)
+
+    # Dump the metadata to header file
+    metadata_generator(md)
+
+
+if __name__ == "__main__":
+    __main__()
diff --git a/detectors/python/utils/__init__.py b/detectors/python/utils/__init__.py
new file mode 100644
index 000000000..c9b0c1107
--- /dev/null
+++ b/detectors/python/utils/__init__.py
@@ -0,0 +1,5 @@
+from .options import add_logging_options, parse_logging_options
+from .calorimeter_defaults import add_calorimeter_defaults
+from .silicon_tracker_defaults import add_silicon_tracker_defaults
+from .telescope_detector_defaults import add_telescope_detector_defaults
+from .wire_chamber_defaults import add_wire_chamber_defaults
diff --git a/detectors/python/utils/calorimeter_defaults.py b/detectors/python/utils/calorimeter_defaults.py
new file mode 100644
index 000000000..0abecb4ec
--- /dev/null
+++ b/detectors/python/utils/calorimeter_defaults.py
@@ -0,0 +1,53 @@
+# Detray library, part of the ACTS project (R&D line)
+#
+# (c) 2026 CERN for the benefit of the ACTS project
+#
+# Mozilla Public License Version 2.0
+
+# --------------------------------------------------------------------------
+# Function that will add types commonly needed for calorimeters
+# --------------------------------------------------------------------------
+
+from impl import metadata
+from impl import Shape, Material, Accelerator
+
+import logging
+
+""" Types that are typically needed for calorimeters """
+
+
+def add_calorimeter_defaults(
+    metadata: metadata, use_mat_maps=False, use_homogeneous_mat=False
+):
+    # Don't run more than once on given metadata (prevents spurious log entries)
+    if metadata in add_calorimeter_defaults.clients:
+        return
+
+    add_calorimeter_defaults.clients.append(metadata)
+
+    logger = logging.getLogger(__name__)
+    logger.info("Define calorimeter types:")
+
+    logger.info("-> adding sensitive types")
+    metadata.add_sensitive(Shape.RECTANGLE)
+    metadata.add_sensitive(Shape.TRAPEZOID)
+
+    logger.info("-> adding portal types")
+    metadata.add_portal(Shape.CONCENTRIC_CYLINDER)
+    metadata.add_portal(Shape.RING)
+
+    # Acceleration Struct for portals and passives
+    metadata.add_accel_struct(Accelerator.BRUTE_FORCE, "portal", is_default=True)
+    metadata.add_accel_struct(Accelerator.BRUTE_FORCE, "passive")
+
+    if use_mat_maps:
+        logger.info("-> requested material map types")
+        metadata.add_material(Material.CYLINDER_MAP3D)
+    if use_homogeneous_mat:
+        logger.info("-> requested homogeneous material types")
+        metadata.add_material(Material.RAW)
+
+    # Add acceleration structures (e.g. Frustum navigation) in the future...
+
+
+add_calorimeter_defaults.clients = []
diff --git a/detectors/python/utils/options.py b/detectors/python/utils/options.py
new file mode 100644
index 000000000..3aae51253
--- /dev/null
+++ b/detectors/python/utils/options.py
@@ -0,0 +1,64 @@
+# Detray library, part of the ACTS project (R&D line)
+#
+# (c) 2026 CERN for the benefit of the ACTS project
+#
+# Mozilla Public License Version 2.0
+
+import argparse
+import logging
+import os
+import sys
+from datetime import datetime
+
+# ------------------------------------------------------------------------------
+# Options parsing
+# ------------------------------------------------------------------------------
+
+""" Parent parser that contains logging options """
+
+
+def add_logging_options(prog_name=sys.argv[0]):
+
+    parser = argparse.ArgumentParser(prog=prog_name)
+
+    parser.add_argument(
+        "-v",
+        "--info",
+        action="store_const",
+        dest="loglevel",
+        const=logging.INFO,
+        help=("increase log level (INFO)"),
+    )
+    parser.add_argument(
+        "-vv",
+        "--debug",
+        action="store_const",
+        dest="loglevel",
+        const=logging.DEBUG,
+        help=("increase log level (DEBUG)"),
+    )
+
+    return parser
+
+
+""" Parse logging options from commandline and set up logging service"""
+
+
+def parse_logging_options(args, prog_name=sys.argv[0]):
+    # Configure log level
+    log_level = logging.WARNING
+    if args.loglevel:
+        log_level = args.loglevel
+
+    # Write log to terminal
+    logging.basicConfig(
+        format=("%(levelname)s (%(module)s): %(message)s"), level=log_level
+    )
+
+    print(
+        "\ndetray - "
+        + str(datetime.now().strftime("%d/%m/%Y %H:%M"))
+        + ': Running detector type generator "'
+        + os.path.basename(prog_name)
+        + '"\n'
+    )
diff --git a/detectors/python/utils/silicon_tracker_defaults.py b/detectors/python/utils/silicon_tracker_defaults.py
new file mode 100644
index 000000000..f33e14f25
--- /dev/null
+++ b/detectors/python/utils/silicon_tracker_defaults.py
@@ -0,0 +1,64 @@
+# Detray library, part of the ACTS project (R&D line)
+#
+# (c) 2026 CERN for the benefit of the ACTS project
+#
+# Mozilla Public License Version 2.0
+
+# --------------------------------------------------------------------------
+# Function that will add types commonly needed for silicon trackers
+# --------------------------------------------------------------------------
+
+from impl import metadata
+from impl import Shape, Material, Accelerator
+
+import logging
+
+""" Types that are typically needed for silicon tracker detectors """
+
+
+def add_silicon_tracker_defaults(
+    metadata: metadata, use_mat_maps=False, use_homogeneous_mat=False
+):
+    # Don't run more than once on given metadata (prevents spurious log entries)
+    if metadata in add_silicon_tracker_defaults.clients:
+        return
+
+    add_silicon_tracker_defaults.clients.append(metadata)
+
+    logger = logging.getLogger(__name__)
+    logger.info("Define silicon tracker types:")
+
+    # Cylindrical volume portals (barrel and endcap)
+    logger.info("-> adding portal types")
+    metadata.add_portal(Shape.CONCENTRIC_CYLINDER)
+    metadata.add_portal(Shape.RING)
+
+    # Acceleration struct for portals and passives
+    metadata.add_accel_struct(Accelerator.BRUTE_FORCE, "portal", is_default=True)
+    metadata.add_accel_struct(Accelerator.BRUTE_FORCE, "passive")
+
+    # Barrel Detector
+    logger.info("-> adding barrel section types")
+    metadata.add_sensitive(Shape.RECTANGLE)
+    metadata.add_accel_struct(Accelerator.CONCENTRIC_CYLINDER_GRID2D, "sensitive")
+    if use_mat_maps:
+        metadata.add_material(Material.CONCENTIRC_CYLINDER_MAP2D)
+
+    # Endcap Detector
+    logger.info("-> adding endcap section types")
+    metadata.add_sensitive(Shape.TRAPEZOID)
+    metadata.add_accel_struct(Accelerator.DISC_GRID2D, "sensitive")
+    if use_mat_maps:
+        metadata.add_material(Material.DISC_MAP2D)
+
+    # Slabs can be used for both barrel and endcap surface shapes
+    if use_homogeneous_mat:
+        logger.info("-> requested homogeneous material types")
+        metadata.add_material(Material.SLAB)
+
+    # Volume accelerator for layered cylindrical detectors
+    logger.info("-> adding detector volume acceleration structure")
+    metadata.add_accel_struct(Accelerator.CYLINDER_GRID3D, "volume", is_default=True)
+
+
+add_silicon_tracker_defaults.clients = []
diff --git a/detectors/python/utils/telescope_detector_defaults.py b/detectors/python/utils/telescope_detector_defaults.py
new file mode 100644
index 000000000..e435e36ce
--- /dev/null
+++ b/detectors/python/utils/telescope_detector_defaults.py
@@ -0,0 +1,55 @@
+# Detray library, part of the ACTS project (R&D line)
+#
+# (c) 2026 CERN for the benefit of the ACTS project
+#
+# Mozilla Public License Version 2.0
+
+# --------------------------------------------------------------------------
+# Function that will add types commonly needed for telescope detectors
+# --------------------------------------------------------------------------
+
+from impl import metadata
+from impl import Shape, Material, Accelerator
+
+import logging
+
+""" Types that are typically needed for telescope detectors """
+
+
+def add_telescope_detector_defaults(
+    metadata: metadata, use_mat_maps=False, use_homogeneous_mat=False
+):
+    # Don't run more than once on given metadata (prevents spurious log entries)
+    if metadata in add_telescope_detector_defaults.clients:
+        return
+
+    add_telescope_detector_defaults.clients.append(metadata)
+
+    logger = logging.getLogger(__name__)
+    logger.info("Define telescope detector types:")
+
+    # Sensitive and portal shapes
+    metadata.add_sensitive(Shape.RECTANGLE)
+    metadata.add_portal(Shape.RECTANGLE)
+
+    # Acceleration struct for portals and passives
+    metadata.add_accel_struct(Accelerator.BRUTE_FORCE, "portal", is_default=True)
+    metadata.add_accel_struct(Accelerator.BRUTE_FORCE, "passive")
+    metadata.add_accel_struct(Accelerator.BRUTE_FORCE, "sensitive")
+
+    # Map the material for the support structures onto the portals
+    if use_mat_maps:
+        logger.info("-> requested material map types")
+        metadata.add_material(Material.RECTANGLE_MAP2D)
+
+    # Sensitive material
+    if use_homogeneous_mat:
+        logger.info("-> requested homogeneous material types")
+        metadata.add_material(Material.SLAB)
+
+    # Acceleration struct for telescope detector volumes
+    logger.info("-> adding detector volume acceleration structure")
+    metadata.add_accel_struct(Accelerator.BRUTE_FORCE, "volume", is_default=True)
+
+
+add_telescope_detector_defaults.clients = []
diff --git a/detectors/python/utils/wire_chamber_defaults.py b/detectors/python/utils/wire_chamber_defaults.py
new file mode 100644
index 000000000..d8de2747e
--- /dev/null
+++ b/detectors/python/utils/wire_chamber_defaults.py
@@ -0,0 +1,69 @@
+# Detray library, part of the ACTS project (R&D line)
+#
+# (c) 2026 CERN for the benefit of the ACTS project
+#
+# Mozilla Public License Version 2.0
+
+# --------------------------------------------------------------------------
+# Function that will add types commonly needed for wire chamber detectors
+# --------------------------------------------------------------------------
+
+from impl import metadata
+from impl import Shape, Material, Accelerator
+
+import logging
+
+""" Types that are typically needed for wirechamber-like detectors """
+
+
+def add_wire_chamber_defaults(
+    metadata: metadata, use_mat_maps=False, use_homogeneous_mat=False
+):
+    # Don't run more than once on given metadata (prevents spurious log entries)
+    if metadata in add_wire_chamber_defaults.clients:
+        return
+
+    add_wire_chamber_defaults.clients.append(metadata)
+
+    logger = logging.getLogger(__name__)
+    logger.info("Define wire chamber types:")
+
+    # Sensitive shapes
+    logger.info("-> adding sensitive types")
+    metadata.add_sensitive(Shape.DRIFT_CELL)
+    metadata.add_sensitive(Shape.STRAW_TUBE)
+
+    # Cylindrical volume portals (barrel and endcap)
+    logger.info("-> adding portal types")
+    metadata.add_portal(Shape.CONCENTRIC_CYLINDER)
+    metadata.add_portal(Shape.RING)
+
+    # Acceleration struct for portals and passives
+    metadata.add_accel_struct(Accelerator.BRUTE_FORCE, "portal", is_default=True)
+    metadata.add_accel_struct(Accelerator.BRUTE_FORCE, "passive")
+
+    # Surface acceleration structure for the wires
+    metadata.add_accel_struct(Accelerator.CONCENTRIC_CYLINDER_GRID2D, "sensitive")
+
+    if use_mat_maps:
+        logger.info("-> requested material map types")
+        # Map the material for the support structures
+        metadata.add_material(Material.CONCENTIRC_CYLINDER_MAP2D)
+        metadata.add_material(Material.DISC_MAP2D)
+        # Experimetal: map the all of the material above into 3D bins
+        # metadata.add_material(Material.CYLINDER3D)
+
+    if use_homogeneous_mat:
+        logger.info("-> requested homogeneous material types")
+        # Model the gas content
+        metadata.add_material(Material.RAW)
+
+    # Sensitive material
+    metadata.add_material(Material.ROD)
+
+    # Volume accelerator for layered cylindrical detectors
+    logger.info("-> adding detector volume acceleration structure")
+    metadata.add_accel_struct(Accelerator.CYLINDER_GRID3D, "volume", is_default=True)
+
+
+add_wire_chamber_defaults.clients = []
diff --git a/detectors/python/wire_chamber_metadata.py b/detectors/python/wire_chamber_metadata.py
new file mode 100644
index 000000000..b77b85b94
--- /dev/null
+++ b/detectors/python/wire_chamber_metadata.py
@@ -0,0 +1,48 @@
+# Detray library, part of the ACTS project (R&D line)
+#
+# (c) 2026 CERN for the benefit of the ACTS project
+#
+# Mozilla Public License Version 2.0
+
+from impl import metadata, metadata_generator
+from impl import Shape
+from utils import add_logging_options, parse_logging_options, add_wire_chamber_defaults
+
+import logging
+
+# --------------------------------------------------------------------------
+# Generate the wire chamber metadata type
+# --------------------------------------------------------------------------
+
+""" Add all types needed to describe the wire chamber test detector """
+
+
+def add_wire_chamber_types(metadata: metadata):
+    logger = logging.getLogger(__name__)
+    logger.info("Define types required by the wire chamber detector:")
+
+    # Add default types for wire chambers
+    add_wire_chamber_defaults(
+        metadata=metadata, use_homogeneous_mat=True, use_mat_maps=False
+    )
+
+    # Beampipe passive surface
+    logger.info("-> adding wire chamber beampipe")
+    metadata.add_passive(Shape.CYLINDER2D)
+
+
+def __main__():
+    # Commandline options
+    parser = add_logging_options()
+    parse_logging_options(parser.parse_args())
+
+    md = metadata("wire_chamber_test_detector")
+
+    add_wire_chamber_types(md)
+
+    # Dump the metadata to header file
+    metadata_generator(md)
+
+
+if __name__ == "__main__":
+    __main__()
diff --git a/io/include/detray/io/backend/detail/type_info.hpp b/io/include/detray/io/backend/detail/type_info.hpp
index 01de0c6e7..021a2686e 100644
--- a/io/include/detray/io/backend/detail/type_info.hpp
+++ b/io/include/detray/io/backend/detail/type_info.hpp
@@ -153,8 +153,8 @@ template <typename detector_t>
                                   std::uint_least16_t>>)
 struct mask_info<io::shape_id::annulus2, detector_t> {
     using type = annulus2D;
-    static constexpr
-        typename detector_t::masks::id value{detector_t::masks::id::e_annulus2};
+    static constexpr typename detector_t::masks::id value{
+        detector_t::masks::id::e_annulus2D};
 };
 
 /// Check for a 2D cylinder shape
@@ -165,7 +165,7 @@ template <typename detector_t>
 struct mask_info<io::shape_id::cylinder2, detector_t> {
     using type = cylinder2D;
     static constexpr typename detector_t::masks::id value{
-        detector_t::masks::id::e_cylinder2};
+        detector_t::masks::id::e_cylinder2D};
 };
 
 /// Check for a 2D cylinder portal shape
@@ -177,7 +177,7 @@ template <typename detector_t>
 struct mask_info<io::shape_id::portal_cylinder2, detector_t> {
     using type = concentric_cylinder2D;
     static constexpr typename detector_t::masks::id value{
-        detector_t::masks::id::e_portal_cylinder2};
+        detector_t::masks::id::e_concentric_cylinder2D};
 };
 
 /// Check for a cell wire line shape
@@ -213,7 +213,7 @@ template <typename detector_t>
 struct mask_info<io::shape_id::rectangle2, detector_t> {
     using type = rectangle2D;
     static constexpr typename detector_t::masks::id value{
-        detector_t::masks::id::e_rectangle2};
+        detector_t::masks::id::e_rectangle2D};
 };
 
 /// Check for a ring/disc shape
@@ -223,8 +223,8 @@ template <typename detector_t>
                                   std::uint_least16_t>>)
 struct mask_info<io::shape_id::ring2, detector_t> {
     using type = ring2D;
-    static constexpr typename detector_t::masks::id value{
-        detector_t::masks::id::e_portal_ring2};
+    static constexpr
+        typename detector_t::masks::id value{detector_t::masks::id::e_ring2D};
 };
 
 /// Check for a single masked value (1st value is checked)
@@ -236,7 +236,7 @@ template <typename detector_t>
 struct mask_info<io::shape_id::single1, detector_t> {
     using type = single3D<0>;
     static constexpr
-        typename detector_t::masks::id value{detector_t::masks::id::e_single1};
+        typename detector_t::masks::id value{detector_t::masks::id::e_single1D};
 };
 
 /// Check for a single masked value (2nd value is checked)
@@ -248,7 +248,7 @@ template <typename detector_t>
 struct mask_info<io::shape_id::single2, detector_t> {
     using type = single3D<1>;
     static constexpr
-        typename detector_t::masks::id value{detector_t::masks::id::e_single2};
+        typename detector_t::masks::id value{detector_t::masks::id::e_single2D};
 };
 
 /// Check for a single masked value (3rd value is checked)
@@ -260,7 +260,7 @@ template <typename detector_t>
 struct mask_info<io::shape_id::single3, detector_t> {
     using type = single3D<2>;
     static constexpr
-        typename detector_t::masks::id value{detector_t::masks::id::e_single3};
+        typename detector_t::masks::id value{detector_t::masks::id::e_single3D};
 };
 
 /// Check for a trapezoid shape
@@ -272,7 +272,7 @@ template <typename detector_t>
 struct mask_info<io::shape_id::trapezoid2, detector_t> {
     using type = trapezoid2D;
     static constexpr typename detector_t::masks::id value{
-        detector_t::masks::id::e_trapezoid2};
+        detector_t::masks::id::e_trapezoid2D};
 };
 /// @}
 
@@ -296,7 +296,7 @@ template <typename detector_t>
 struct mat_map_info<io::material_id::ring2_map, detector_t> {
     using type = material_map<typename detector_t::algebra_type, ring2D>;
     static constexpr typename detector_t::materials::id value{
-        detector_t::materials::id::e_disc2_map};
+        detector_t::materials::id::e_ring2D_map};
 };
 
 /// Check for a 2D cartesian material map
@@ -307,7 +307,7 @@ template <typename detector_t>
 struct mat_map_info<io::material_id::rectangle2_map, detector_t> {
     using type = material_map<typename detector_t::algebra_type, rectangle2D>;
     static constexpr typename detector_t::materials::id value{
-        detector_t::materials::id::e_rectangle2_map};
+        detector_t::materials::id::e_rectangle2D_map};
 };
 
 /// Check for a 3D cuboid volume material map
@@ -318,7 +318,7 @@ template <typename detector_t>
 struct mat_map_info<io::material_id::cuboid3_map, detector_t> {
     using type = material_map<typename detector_t::algebra_type, cuboid3D>;
     static constexpr typename detector_t::materials::id value{
-        detector_t::materials::id::e_cuboid3_map};
+        detector_t::materials::id::e_cuboid3D_map};
 };
 
 /// Check for a 2D cylindrical material map
@@ -329,7 +329,7 @@ template <typename detector_t>
 struct mat_map_info<io::material_id::cylinder2_map, detector_t> {
     using type = material_map<typename detector_t::algebra_type, cylinder2D>;
     static constexpr typename detector_t::materials::id value{
-        detector_t::materials::id::e_cylinder2_map};
+        detector_t::materials::id::e_cylinder2D_map};
 };
 
 /// Check for a 2D concentric cylindrical material map
@@ -341,7 +341,7 @@ struct mat_map_info<io::material_id::concentric_cylinder2_map, detector_t> {
     using type =
         material_map<typename detector_t::algebra_type, concentric_cylinder2D>;
     static constexpr typename detector_t::materials::id value{
-        detector_t::materials::id::e_concentric_cylinder2_map};
+        detector_t::materials::id::e_concentric_cylinder2D_map};
 };
 
 /// Check for a 3D cylindrical volume material map
@@ -352,7 +352,7 @@ template <typename detector_t>
 struct mat_map_info<io::material_id::cylinder3_map, detector_t> {
     using type = material_map<typename detector_t::algebra_type, cylinder3D>;
     static constexpr typename detector_t::materials::id value{
-        detector_t::materials::id::e_cylinder3_map};
+        detector_t::materials::id::e_cylinder3D_map};
 };
 /// @}
 
diff --git a/io/include/detray/io/backend/homogeneous_material_reader.hpp b/io/include/detray/io/backend/homogeneous_material_reader.hpp
index 3196b54f8..5ba515a34 100644
--- a/io/include/detray/io/backend/homogeneous_material_reader.hpp
+++ b/io/include/detray/io/backend/homogeneous_material_reader.hpp
@@ -98,8 +98,9 @@ class homogeneous_material_reader {
 
                 DETRAY_DEBUG_HOST("-> Surface link is: " << sf_link);
 
-                mat_factory->add_material(
-                    mat_id::e_slab, from_payload<scalar_t>(slab_data), sf_link);
+                mat_factory->add_material(mat_id::e_material_slab,
+                                          from_payload<scalar_t>(slab_data),
+                                          sf_link);
             }
             if constexpr (detray::concepts::has_material_rods<detector_t>) {
                 DETRAY_DEBUG_HOST(
@@ -116,8 +117,8 @@ class homogeneous_material_reader {
                                 : detray::detail::invalid_value<std::size_t>()};
 
                         mat_factory->add_material(
-                            mat_id::e_rod, from_payload<scalar_t>(rod_data),
-                            sf_link);
+                            mat_id::e_material_rod,
+                            from_payload<scalar_t>(rod_data), sf_link);
                     }
                 } else {
                     DETRAY_DEBUG_HOST(
diff --git a/io/include/detray/io/backend/homogeneous_material_writer.hpp b/io/include/detray/io/backend/homogeneous_material_writer.hpp
index 9a96682fe..3bbafe85e 100644
--- a/io/include/detray/io/backend/homogeneous_material_writer.hpp
+++ b/io/include/detray/io/backend/homogeneous_material_writer.hpp
@@ -72,15 +72,16 @@ class homogeneous_material_writer {
         header_data.sub_header.emplace();
         auto& mat_sub_header = header_data.sub_header.value();
         if constexpr (detray::concepts::has_material_slabs<detector_t>) {
-            mat_sub_header.n_slabs =
-                materials.template size<detector_t::materials::id::e_slab>();
+            mat_sub_header.n_slabs = materials.template size<
+                detector_t::materials::id::e_material_slab>();
             mat_sub_header.n_slab_surfaces =
                 count_surface_with_material_type(material_type::slab);
         }
         mat_sub_header.n_rods = 0u;
         if constexpr (detray::concepts::has_material_rods<detector_t>) {
             mat_sub_header.n_rods =
-                materials.template size<detector_t::materials::id::e_rod>();
+                materials
+                    .template size<detector_t::materials::id::e_material_rod>();
             mat_sub_header.n_rod_surfaces =
                 count_surface_with_material_type(material_type::rod);
         }
@@ -119,10 +120,11 @@ class homogeneous_material_writer {
         using mat_id = typename detector_t::materials::id;
 
         // If this reader is called, the detector has at least material slabs
-        if (det.material_store().template empty<mat_id::e_slab>()) {
+        if (det.material_store().template empty<mat_id::e_material_slab>()) {
             // Check for material rods that are present in e.g. wire chambers
             if constexpr (detray::concepts::has_material_rods<detector_t>) {
-                if (det.material_store().template empty<mat_id::e_rod>()) {
+                if (det.material_store()
+                        .template empty<mat_id::e_material_rod>()) {
                     return mv_data;
                 }
             } else {
diff --git a/io/include/detray/io/backend/material_map_writer.hpp b/io/include/detray/io/backend/material_map_writer.hpp
index cf35690b5..1533ff660 100644
--- a/io/include/detray/io/backend/material_map_writer.hpp
+++ b/io/include/detray/io/backend/material_map_writer.hpp
@@ -81,12 +81,14 @@ class material_map_writer : public detail::grid_writer {
                 // Do not attempt to convert homogeneous material
                 if constexpr (detray::concepts::has_material_slabs<
                                   detector_t>) {
-                    if (mat_link.id() == detector_t::materials::id::e_slab) {
+                    if (mat_link.id() ==
+                        detector_t::materials::id::e_material_slab) {
                         continue;
                     }
                 }
                 if constexpr (detray::concepts::has_material_rods<detector_t>) {
-                    if (mat_link.id() == detector_t::materials::id::e_rod) {
+                    if (mat_link.id() ==
+                        detector_t::materials::id::e_material_rod) {
                         continue;
                     }
                 }
diff --git a/tests/benchmarks/cpu/find_volume.cpp b/tests/benchmarks/cpu/find_volume.cpp
index 55ff3236c..237488dda 100644
--- a/tests/benchmarks/cpu/find_volume.cpp
+++ b/tests/benchmarks/cpu/find_volume.cpp
@@ -42,8 +42,7 @@ void BM_FIND_VOLUMES(benchmark::State &state) {
 
     static const unsigned int itest = 10000u;
 
-    constexpr auto vol_grid_idx{
-        decltype(d)::accel::id::e_default_volume_searcher};
+    constexpr auto vol_grid_idx{decltype(d)::accel::id::e_volume_default};
     auto volume_grid = d.accelerator_store().template get<vol_grid_idx>()[0];
 
     const auto &axis_r = volume_grid.get_axis<axis::label::e_r>();
diff --git a/tests/benchmarks/cpu/intersect_surfaces.cpp b/tests/benchmarks/cpu/intersect_surfaces.cpp
index 393da7ed2..a11076278 100644
--- a/tests/benchmarks/cpu/intersect_surfaces.cpp
+++ b/tests/benchmarks/cpu/intersect_surfaces.cpp
@@ -84,13 +84,13 @@ BENCHMARK(BM_INTERSECT_PLANES)
 namespace {
 
 enum class mask_ids : unsigned int {
-    e_rectangle2 = 0,
-    e_cylinder2 = 1,
+    e_rectangle2D = 0,
+    e_cylinder2D = 1,
     e_conc_cylinder3 = 2,
 };
 
 enum class material_ids : unsigned int {
-    e_slab = 0,
+    e_material_slab = 0,
 };
 
 }  // namespace
@@ -116,8 +116,8 @@ void BM_INTERSECT_CYLINDERS(benchmark::State &state) {
 
     benchmarks::transform3 trf{};
 
-    mask_link_t mask_link{mask_ids::e_cylinder2, 0};
-    material_link_t material_link{material_ids::e_slab, 0};
+    mask_link_t mask_link{mask_ids::e_cylinder2D, 0};
+    material_link_t material_link{material_ids::e_material_slab, 0};
     surface_desc_t sf_desc(0u, mask_link, material_link, 0u,
                            surface_id::e_sensitive);
 
@@ -173,8 +173,8 @@ void BM_INTERSECT_PORTAL_CYLINDERS(benchmark::State &state) {
 
     benchmarks::transform3 trf{};
 
-    mask_link_t mask_link{mask_ids::e_cylinder2, 0u};
-    material_link_t material_link{material_ids::e_slab, 0u};
+    mask_link_t mask_link{mask_ids::e_cylinder2D, 0u};
+    material_link_t material_link{material_ids::e_material_slab, 0u};
     surface_desc_t sf_desc(0u, mask_link, material_link, 0u,
                            surface_id::e_sensitive);
 
diff --git a/tests/benchmarks/cpu/intersectors.cpp b/tests/benchmarks/cpu/intersectors.cpp
index 07315fa32..95a70c4aa 100644
--- a/tests/benchmarks/cpu/intersectors.cpp
+++ b/tests/benchmarks/cpu/intersectors.cpp
@@ -58,13 +58,13 @@ using ray_t = detail::ray<algebra_s>;
 namespace {
 
 enum class mask_ids : unsigned int {
-    e_rectangle2 = 0,
-    e_cylinder2 = 1,
+    e_rectangle2D = 0,
+    e_cylinder2D = 1,
     e_conc_cylinder3 = 2,
 };
 
 enum class material_ids : unsigned int {
-    e_slab = 0,
+    e_material_slab = 0,
 };
 
 // Helper type definitions.
@@ -256,7 +256,7 @@ void BM_INTERSECT_CYLINDERS_AOS(benchmark::State& state) {
     transform3_t trf{};
 
     mask_link_t mask_link{mask_ids::e_conc_cylinder3, 0u};
-    material_link_t material_link{material_ids::e_slab, 0u};
+    material_link_t material_link{material_ids::e_material_slab, 0u};
     surface_desc_t cyl_desc(0u, mask_link, material_link, 0u,
                             surface_id::e_sensitive);
 
@@ -322,7 +322,7 @@ void BM_INTERSECT_CYLINDERS_SOA(benchmark::State& state) {
     transform3_t trf{};
 
     mask_link_t mask_link{mask_ids::e_conc_cylinder3, 0u};
-    material_link_t material_link{material_ids::e_slab, 0u};
+    material_link_t material_link{material_ids::e_material_slab, 0u};
     surface_desc_t cyl_desc(0u, mask_link, material_link, 0u,
                             surface_id::e_sensitive);
 
@@ -386,7 +386,7 @@ void BM_INTERSECT_CONCENTRIC_CYLINDERS_AOS(benchmark::State& state) {
     transform3_t trf{};
 
     mask_link_t mask_link{mask_ids::e_conc_cylinder3, 0u};
-    material_link_t material_link{material_ids::e_slab, 0u};
+    material_link_t material_link{material_ids::e_material_slab, 0u};
     surface_desc_t cyl_desc(0u, mask_link, material_link, 0u,
                             surface_id::e_sensitive);
 
@@ -448,7 +448,7 @@ void BM_INTERSECT_CONCENTRIC_CYLINDERS_SOA(benchmark::State& state) {
     transform3_t trf{};
 
     mask_link_t mask_link{mask_ids::e_conc_cylinder3, 0u};
-    material_link_t material_link{material_ids::e_slab, 0u};
+    material_link_t material_link{material_ids::e_material_slab, 0u};
     surface_desc_t cyl_desc(0u, mask_link, material_link, 0u,
                             surface_id::e_sensitive);
 
diff --git a/tests/include/detray/test/common/build_toy_detector.hpp b/tests/include/detray/test/common/build_toy_detector.hpp
index 6bb3e8f54..67f3eb18d 100644
--- a/tests/include/detray/test/common/build_toy_detector.hpp
+++ b/tests/include/detray/test/common/build_toy_detector.hpp
@@ -385,22 +385,21 @@ std::shared_ptr<surface_factory_interface<detector_t>> decorate_material(
 
         // Add the complete configuration for the beampipe map generation
         cfg.beampipe_material_map().map_id =
-            static_cast<dindex>(material_id::e_concentric_cylinder2_map);
-        material_map_config.set_map_config(mask_id::e_portal_cylinder2,
+            static_cast<dindex>(material_id::e_concentric_cylinder2D_map);
+        material_map_config.set_map_config(mask_id::e_concentric_cylinder2D,
                                            surface_id::e_passive,
                                            cfg.beampipe_material_map());
 
         // Add the complete configuration for disc map generation
         cfg.disc_material_map().map_id =
-            static_cast<dindex>(material_id::e_disc2_map);
-        material_map_config.set_map_config(mask_id::e_portal_ring2,
-                                           surface_id::e_portal,
-                                           cfg.disc_material_map());
+            static_cast<dindex>(material_id::e_ring2D_map);
+        material_map_config.set_map_config(
+            mask_id::e_ring2D, surface_id::e_portal, cfg.disc_material_map());
 
         // Add the complete configuration for cylinder map generation
         cfg.cyl_material_map().map_id =
-            static_cast<dindex>(material_id::e_concentric_cylinder2_map);
-        material_map_config.set_map_config(mask_id::e_portal_cylinder2,
+            static_cast<dindex>(material_id::e_concentric_cylinder2D_map);
+        material_map_config.set_map_config(mask_id::e_concentric_cylinder2D,
                                            surface_id::e_portal,
                                            cfg.cyl_material_map());
 
@@ -518,7 +517,7 @@ inline void add_cylinder_grid(
     using detector_t = typename detector_builder_t::detector_type;
     using scalar_t = dscalar<typename detector_t::algebra_type>;
 
-    constexpr auto grid_id = detector_t::accel::id::e_cylinder2_grid;
+    constexpr auto grid_id = detector_t::accel::id::e_surface_cylinder2D_grid;
     using cyl_grid_t = types::get<typename detector_t::accel, grid_id>;
 
     using grid_builder_t =
@@ -554,7 +553,7 @@ inline void add_disc_grid(
     using detector_t = typename detector_builder_t::detector_type;
     using scalar_t = dscalar<typename detector_t::algebra_type>;
 
-    constexpr auto grid_id = detector_t::accel::id::e_disc_grid;
+    constexpr auto grid_id = detector_t::accel::id::e_surface_ring2D_grid;
     using disc_grid_t = types::get<typename detector_t::accel, grid_id>;
 
     using grid_builder_t =
diff --git a/tests/include/detray/test/common/build_wire_chamber.hpp b/tests/include/detray/test/common/build_wire_chamber.hpp
index b2fc38cda..f15b6fb6a 100644
--- a/tests/include/detray/test/common/build_wire_chamber.hpp
+++ b/tests/include/detray/test/common/build_wire_chamber.hpp
@@ -168,7 +168,8 @@ inline auto build_wire_chamber(
     const scalar_t cell_size{cfg.cell_size()};
 
     // Prepare grid building
-    constexpr auto grid_id{detector_t::accel::id::e_cylinder2_grid};
+    constexpr auto grid_id{
+        detector_t::accel::id::e_surface_concentric_cylinder2D_grid};
     using cyl_grid_t = types::get<typename detector_t::accel, grid_id>;
     using loc_bin_idx_t = typename cyl_grid_t::loc_bin_index;
     static_assert(cyl_grid_t::dim == 2);
diff --git a/tests/include/detray/test/cpu/toy_detector_test.hpp b/tests/include/detray/test/cpu/toy_detector_test.hpp
index 4f28ca3ec..e585ee5de 100644
--- a/tests/include/detray/test/cpu/toy_detector_test.hpp
+++ b/tests/include/detray/test/cpu/toy_detector_test.hpp
@@ -135,35 +135,38 @@ inline bool toy_detector_test(
     constexpr auto leaving_world{detail::invalid_value<nav_link_t>()};
     constexpr auto inv_link{dindex_invalid};
     const bool has_grids =
-        (accel.template size<accel_ids::e_cylinder2_grid>() != 0u) ||
-        (accel.template size<accel_ids::e_disc_grid>() != 0u);
+        (accel.template size<accel_ids::e_surface_cylinder2D_grid>() != 0u) ||
+        (accel.template size<accel_ids::e_surface_ring2D_grid>() != 0u);
     const bool has_hom_material =
-        (materials.template size<material_ids::e_slab>() != 0);
+        (materials.template size<material_ids::e_material_slab>() != 0);
     const bool has_material_maps =
-        (materials.template size<material_ids::e_disc2_map>() != 0);
+        (materials.template size<material_ids::e_ring2D_map>() != 0);
 
     // Check number of geomtery objects
     EXPECT_EQ(volumes.size(), 22u);
     EXPECT_EQ(toy_det.surfaces().size(), 3230);
     EXPECT_EQ(transforms.size(ctx), 3252u);
-    EXPECT_EQ(masks.template size<mask_ids::e_rectangle2>(), 4u);
-    EXPECT_EQ(masks.template size<mask_ids::e_trapezoid2>(), 12u);
-    EXPECT_EQ(masks.template size<mask_ids::e_portal_cylinder2>(), 56u);
-    EXPECT_EQ(masks.template size<mask_ids::e_portal_ring2>(), 60u);
-    EXPECT_EQ(accel.template size<accel_ids::e_brute_force>(), 22u);
+    EXPECT_EQ(masks.template size<mask_ids::e_rectangle2D>(), 4u);
+    EXPECT_EQ(masks.template size<mask_ids::e_trapezoid2D>(), 12u);
+    EXPECT_EQ(masks.template size<mask_ids::e_concentric_cylinder2D>(), 56u);
+    EXPECT_EQ(masks.template size<mask_ids::e_ring2D>(), 60u);
+    EXPECT_EQ(accel.template size<accel_ids::e_surface_brute_force>(), 22u);
     if (has_grids) {
-        EXPECT_EQ(accel.template size<accel_ids::e_cylinder2_grid>(), 4);
-        EXPECT_EQ(accel.template size<accel_ids::e_disc_grid>(), 6);
+        EXPECT_EQ(accel.template size<accel_ids::e_surface_cylinder2D_grid>(),
+                  4);
+        EXPECT_EQ(accel.template size<accel_ids::e_surface_ring2D_grid>(), 6);
     }
     if (has_hom_material) {
         EXPECT_FALSE(has_material_maps);
-        EXPECT_EQ(materials.template size<material_ids::e_slab>(), 3141u);
+        EXPECT_EQ(materials.template size<material_ids::e_material_slab>(),
+                  3141u);
     } else if (has_material_maps) {
         EXPECT_FALSE(has_hom_material);
         EXPECT_EQ(
-            materials.template size<material_ids::e_concentric_cylinder2_map>(),
+            materials
+                .template size<material_ids::e_concentric_cylinder2D_map>(),
             44u);
-        EXPECT_EQ(materials.template size<material_ids::e_disc2_map>(), 42u);
+        EXPECT_EQ(materials.template size<material_ids::e_ring2D_map>(), 42u);
     }
 
     // Check the surface source links
@@ -206,7 +209,7 @@ inline bool toy_detector_test(
                                  const accel_link_t& /*accel_link*/) {
         EXPECT_EQ(vol_itr->index(), vol_index);
         EXPECT_EQ(vol_itr->template accel_link<geo_obj_ids::e_portal>().id(),
-                  accel_ids::e_brute_force);
+                  accel_ids::e_surface_brute_force);
         EXPECT_EQ(vol_itr->template accel_link<geo_obj_ids::e_portal>().index(),
                   range[0]);
     };
@@ -247,22 +250,23 @@ inline bool toy_detector_test(
                 EXPECT_EQ(sf_itr->material(), material_index);
                 if (sf_itr->material().id() != material_ids::e_none) {
                     EXPECT_EQ(
-                        materials.template get<
-                            material_ids::e_slab>()[sf_itr->material().index()],
+                        materials.template get<material_ids::e_material_slab>()
+                            [sf_itr->material().index()],
                         mat);
                 }
             } else if (has_material_maps) {
                 auto mat_link = sf_itr->material();
-                if (mat_link.id() == material_ids::e_concentric_cylinder2_map) {
+                if (mat_link.id() ==
+                    material_ids::e_concentric_cylinder2D_map) {
                     test_mat_map<scalar_t>(
                         materials.template get<
-                            material_ids::e_concentric_cylinder2_map>()
+                            material_ids::e_concentric_cylinder2D_map>()
                             [mat_link.index()],
                         true);
-                } else if (mat_link.id() == material_ids::e_disc2_map) {
+                } else if (mat_link.id() == material_ids::e_ring2D_map) {
                     test_mat_map<scalar_t>(
                         materials.template get<
-                            material_ids::e_disc2_map>()[mat_link.index()],
+                            material_ids::e_ring2D_map>()[mat_link.index()],
                         false);
                 }
             } else {
@@ -309,8 +313,8 @@ inline bool toy_detector_test(
                 if (has_hom_material) {
                     EXPECT_EQ(sf_itr->material(), material_index);
                     EXPECT_EQ(
-                        materials.template get<
-                            material_ids::e_slab>()[sf_itr->material().index()],
+                        materials.template get<material_ids::e_material_slab>()
+                            [sf_itr->material().index()],
                         mat)
                         << sf_itr->material();
                 } else if (has_material_maps &&
@@ -318,11 +322,11 @@ inline bool toy_detector_test(
                     // beampipe
                     auto mat_link = sf_itr->material();
                     EXPECT_EQ(mat_link.id(),
-                              material_ids::e_concentric_cylinder2_map);
+                              material_ids::e_concentric_cylinder2D_map);
 
                     test_mat_map<scalar_t>(
                         materials.template get<
-                            material_ids::e_concentric_cylinder2_map>()
+                            material_ids::e_concentric_cylinder2D_map>()
                             [mat_link.index()],
                         true);
                 } else {
@@ -344,42 +348,42 @@ inline bool toy_detector_test(
     /// @param accel_store the detectors acceleration data structure store
     /// @param pt_range index range of the portals in the surface lookup
     /// @param sf_range index range of the surfaces in the surface lookup
-    auto test_accel =
-        [has_grids](
-            decltype(volumes.begin())& vol_itr,
-            const typename detector_t::accelerator_container& accel_store,
-            const darray<dindex, 2>& pt_range,
-            const darray<dindex, 2>& sf_range = {0u, 0u}) {
-            // Link to the acceleration data structures the volume holds
-            const auto& link = vol_itr->accel_link();
-
-            // Test the portal search
-            const auto& bf_finder =
-                accel_store
-                    .template get<accel_ids::e_brute_force>()[link[0].index()];
-
-            // This means no grids, all surfaces are in the brute force method
-            if (!has_grids) {
-                const auto full_range = darray<dindex, 2>{
-                    sf_range[0], math::max(pt_range[1], sf_range[1])};
-                test_finder(bf_finder, vol_itr->index(), full_range);
-            } else {
-                test_finder(bf_finder, vol_itr->index(), pt_range);
-
-                // Test the module search if grids were filled
-                if (!link[1].is_invalid()) {
-                    if (link[1].id() == accel_ids::e_cylinder2_grid) {
-                        const auto& cyl_grid = accel_store.template get<
-                            accel_ids::e_cylinder2_grid>()[link[1].index()];
-                        test_finder(cyl_grid, vol_itr->index(), sf_range);
-                    } else {
-                        const auto& disc_grid = accel_store.template get<
-                            accel_ids::e_disc_grid>()[link[1].index()];
-                        test_finder(disc_grid, vol_itr->index(), sf_range);
-                    }
+    auto test_accel = [has_grids](
+                          decltype(volumes.begin())& vol_itr,
+                          const typename detector_t::accelerator_container&
+                              accel_store,
+                          const darray<dindex, 2>& pt_range,
+                          const darray<dindex, 2>& sf_range = {0u, 0u}) {
+        // Link to the acceleration data structures the volume holds
+        const auto& link = vol_itr->accel_link();
+
+        // Test the portal search
+        const auto& bf_finder = accel_store.template get<
+            accel_ids::e_surface_brute_force>()[link[0].index()];
+
+        // This means no grids, all surfaces are in the brute force method
+        if (!has_grids) {
+            const auto full_range = darray<dindex, 2>{
+                sf_range[0], math::max(pt_range[1], sf_range[1])};
+            test_finder(bf_finder, vol_itr->index(), full_range);
+        } else {
+            test_finder(bf_finder, vol_itr->index(), pt_range);
+
+            // Test the module search if grids were filled
+            if (!link[1].is_invalid()) {
+                if (link[1].id() == accel_ids::e_surface_cylinder2D_grid) {
+                    const auto& cyl_grid = accel_store.template get<
+                        accel_ids::e_surface_cylinder2D_grid>()[link[1]
+                                                                    .index()];
+                    test_finder(cyl_grid, vol_itr->index(), sf_range);
+                } else {
+                    const auto& disc_grid = accel_store.template get<
+                        accel_ids::e_surface_ring2D_grid>()[link[1].index()];
+                    test_finder(disc_grid, vol_itr->index(), sf_range);
                 }
             }
-        };
+        }
+    };
 
     //
     // beampipe
@@ -389,7 +393,7 @@ inline bool toy_detector_test(
     auto vol_itr = volumes.begin();
     EXPECT_EQ(names.at(vol_itr->index()), "beampipe_0");
     darray<dindex, 1> index = {0u};
-    accel_link_t accel_link{accel_ids::e_brute_force, 0u};
+    accel_link_t accel_link{accel_ids::e_surface_brute_force, 0u};
     check_sf_ranges(*vol_itr, {1u, 6u}, {}, {0u, 1u});
 
     // Test the links in the volumes
@@ -398,8 +402,8 @@ inline bool toy_detector_test(
     // Check links of beampipe itself
     darray<dindex, 2> range = {0u, 1u};
     test_module_links(vol_itr->index(), surfaces.begin(), range, range[0],
-                      {mask_ids::e_cylinder2, {0u, 1u}},
-                      {material_ids::e_slab, 0u}, beampipe_mat,
+                      {mask_ids::e_cylinder2D, {0u, 1u}},
+                      {material_ids::e_material_slab, 0u}, beampipe_mat,
                       {vol_itr->index()});
 
     // Check links of portals
@@ -407,34 +411,37 @@ inline bool toy_detector_test(
     range = {1u, 2u};
     test_portal_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_portal_ring2, {0u, 1u}},
+                      range, range[0], {mask_ids::e_ring2D, {0u, 1u}},
                       {material_ids::e_none, inv_link}, portal_mat,
                       {{leaving_world}});
     // cylinder portals (neg. endcap)
     range = {2u, 3u};
     test_portal_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_portal_cylinder2, {1u, 6u}},
+                      range, range[0],
+                      {mask_ids::e_concentric_cylinder2D, {1u, 6u}},
                       {material_ids::e_none, inv_link}, portal_mat,
                       {{1u, 2u, 3u, 4u, 5u, 6u}});
     // central cylinder portal
     range = {3u, 4u};
     test_portal_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_portal_cylinder2, {7u, 1u}},
+                      range, range[0],
+                      {mask_ids::e_concentric_cylinder2D, {7u, 1u}},
                       {material_ids::e_none, inv_link}, portal_mat, {{8u}});
     // right disc portal
     range = {4u, 5u};
     test_portal_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_portal_ring2, {1u, 1u}},
+                      range, range[0], {mask_ids::e_ring2D, {1u, 1u}},
                       {material_ids::e_none, inv_link}, portal_mat,
                       {{leaving_world}});
     // cylinder portals (pos. endcap)
     range = {5u, 6u};
     test_portal_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_portal_cylinder2, {8u, 6u}},
+                      range, range[0],
+                      {mask_ids::e_concentric_cylinder2D, {8u, 6u}},
                       {material_ids::e_none, inv_link}, portal_mat,
                       {{16u, 17u, 18u, 19u, 20u, 21u}});
 
@@ -450,7 +457,7 @@ inline bool toy_detector_test(
     EXPECT_EQ(names.at(vol_itr->index()), "endcap_1");
     range = {6u, 118u};
     index = {1u};
-    accel_link = {accel_ids::e_disc_grid, 0u};
+    accel_link = {accel_ids::e_surface_ring2D_grid, 0u};
     check_sf_ranges(*vol_itr, {114u, 118u}, {6u, 114u}, {});
 
     // Test the links in the volumes
@@ -461,15 +468,15 @@ inline bool toy_detector_test(
     range = {6u, 46u};
     test_module_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_trapezoid2, {0u, 1u}},
-                      {material_ids::e_slab, 1u}, pixel_mat, {vol_itr->index()},
-                      true);
+                      range, range[0], {mask_ids::e_trapezoid2D, {0u, 1u}},
+                      {material_ids::e_material_slab, 1u}, pixel_mat,
+                      {vol_itr->index()}, true);
     // One mask for the outer ring
     range = {46u, 114u};
     test_module_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_trapezoid2, {1u, 1u}},
-                      {material_ids::e_slab, 41u}, pixel_mat,
+                      range, range[0], {mask_ids::e_trapezoid2D, {1u, 1u}},
+                      {material_ids::e_material_slab, 41u}, pixel_mat,
                       {vol_itr->index()}, true);
 
     // Check links of portals
@@ -478,13 +485,13 @@ inline bool toy_detector_test(
     test_portal_links(
         vol_itr->index(),
         surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]), range,
-        range[0], {mask_ids::e_portal_cylinder2, {14u, 1u}},
+        range[0], {mask_ids::e_concentric_cylinder2D, {14u, 1u}},
         {material_ids::e_none, inv_link}, portal_mat, {{0u}, {leaving_world}});
     // disc portals
     range = {116u, 118u};
     test_portal_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_portal_ring2, {2u, 1u}},
+                      range, range[0], {mask_ids::e_ring2D, {2u, 1u}},
                       {material_ids::e_none, inv_link}, portal_mat,
                       {{4u}, {2u}});
 
@@ -500,7 +507,7 @@ inline bool toy_detector_test(
     EXPECT_EQ(names.at(vol_itr->index()), "connector_gap_2");
     range = {118u, 122u};
     index = {2u};
-    accel_link = {accel_ids::e_brute_force, 0u};
+    accel_link = {accel_ids::e_surface_brute_force, 0u};
     check_sf_ranges(*vol_itr, {118u, 122u}, {}, {});
 
     // Test the links in the volumes
@@ -511,20 +518,20 @@ inline bool toy_detector_test(
     range = {118u, 119u};
     test_portal_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_portal_ring2, {4u, 9u}},
+                      range, range[0], {mask_ids::e_ring2D, {4u, 9u}},
                       {material_ids::e_none, inv_link}, portal_mat,
                       {{7u, 8u, 9u, 10u, 11u, 12u, 13u, 14u, 15u}});
     range = {119u, 120u};
     test_portal_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_portal_ring2, {13u, 1u}},
+                      range, range[0], {mask_ids::e_ring2D, {13u, 1u}},
                       {material_ids::e_none, inv_link}, portal_mat, {{1u}});
     // cylinder portals
     range = {120u, 122u};
     test_portal_links(
         vol_itr->index(),
         surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]), range,
-        range[0], {mask_ids::e_portal_cylinder2, {16u, 1u}},
+        range[0], {mask_ids::e_concentric_cylinder2D, {16u, 1u}},
         {material_ids::e_none, inv_link}, portal_mat, {{0u}, {leaving_world}});
 
     // Check link of surfaces in surface finder
@@ -539,7 +546,7 @@ inline bool toy_detector_test(
     EXPECT_EQ(names.at(vol_itr->index()), "endcap_3");
     range = {122u, 234u};
     index = {3u};
-    accel_link = {accel_ids::e_disc_grid, 1u};
+    accel_link = {accel_ids::e_surface_ring2D_grid, 1u};
     check_sf_ranges(*vol_itr, {230u, 234u}, {122u, 230u}, {});
 
     // Test the links in the volumes
@@ -550,15 +557,15 @@ inline bool toy_detector_test(
     range = {122u, 162u};
     test_module_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_trapezoid2, {2u, 1u}},
-                      {material_ids::e_slab, 109u}, pixel_mat,
+                      range, range[0], {mask_ids::e_trapezoid2D, {2u, 1u}},
+                      {material_ids::e_material_slab, 109u}, pixel_mat,
                       {vol_itr->index()}, true);
     // One mask for the outer ring
     range = {162u, 230u};
     test_module_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_trapezoid2, {3u, 1u}},
-                      {material_ids::e_slab, 149u}, pixel_mat,
+                      range, range[0], {mask_ids::e_trapezoid2D, {3u, 1u}},
+                      {material_ids::e_material_slab, 149u}, pixel_mat,
                       {vol_itr->index()}, true);
 
     // Check links of portals
@@ -567,13 +574,13 @@ inline bool toy_detector_test(
     test_portal_links(
         vol_itr->index(),
         surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]), range,
-        range[0], {mask_ids::e_portal_cylinder2, {18u, 1u}},
+        range[0], {mask_ids::e_concentric_cylinder2D, {18u, 1u}},
         {material_ids::e_none, inv_link}, portal_mat, {{0u}, {leaving_world}});
     // disc portals
     range = {232u, 234u};
     test_portal_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_portal_ring2, {14u, 1u}},
+                      range, range[0], {mask_ids::e_ring2D, {14u, 1u}},
                       {material_ids::e_none, inv_link}, portal_mat,
                       {{6u}, {4u}});
 
@@ -589,7 +596,7 @@ inline bool toy_detector_test(
     EXPECT_EQ(names.at(vol_itr->index()), "gap_4");
     range = {234u, 238u};
     index = {4u};
-    accel_link = {accel_ids::e_brute_force, 0u};
+    accel_link = {accel_ids::e_surface_brute_force, 0u};
     check_sf_ranges(*vol_itr, {234u, 238u}, {}, {});
 
     // Test the links in the volumes
@@ -601,13 +608,13 @@ inline bool toy_detector_test(
     test_portal_links(
         vol_itr->index(),
         surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]), range,
-        range[0], {mask_ids::e_portal_cylinder2, {20u, 1u}},
+        range[0], {mask_ids::e_concentric_cylinder2D, {20u, 1u}},
         {material_ids::e_none, inv_link}, portal_mat, {{0u}, {leaving_world}});
     // disc portals
     range = {236u, 238u};
     test_portal_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_portal_ring2, {16u, 1u}},
+                      range, range[0], {mask_ids::e_ring2D, {16u, 1u}},
                       {material_ids::e_none, inv_link}, portal_mat,
                       {{3u}, {1u}});
 
@@ -623,7 +630,7 @@ inline bool toy_detector_test(
     EXPECT_EQ(names.at(vol_itr->index()), "endcap_5");
     range = {238u, 350u};
     index = {5u};
-    accel_link = {accel_ids::e_disc_grid, 2u};
+    accel_link = {accel_ids::e_surface_ring2D_grid, 2u};
     check_sf_ranges(*vol_itr, {346u, 350u}, {238u, 346u}, {});
 
     // Test the links in the volumes
@@ -634,15 +641,15 @@ inline bool toy_detector_test(
     range = {238u, 278u};
     test_module_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_trapezoid2, {4u, 1u}},
-                      {material_ids::e_slab, 217u}, pixel_mat,
+                      range, range[0], {mask_ids::e_trapezoid2D, {4u, 1u}},
+                      {material_ids::e_material_slab, 217u}, pixel_mat,
                       {vol_itr->index()}, true);
     // One mask for the outer ring
     range = {278u, 346u};
     test_module_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_trapezoid2, {5u, 1u}},
-                      {material_ids::e_slab, 257u}, pixel_mat,
+                      range, range[0], {mask_ids::e_trapezoid2D, {5u, 1u}},
+                      {material_ids::e_material_slab, 257u}, pixel_mat,
                       {vol_itr->index()}, true);
 
     // Check links of portals
@@ -651,13 +658,13 @@ inline bool toy_detector_test(
     test_portal_links(
         vol_itr->index(),
         surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]), range,
-        range[0], {mask_ids::e_portal_cylinder2, {22u, 1u}},
+        range[0], {mask_ids::e_concentric_cylinder2D, {22u, 1u}},
         {material_ids::e_none, inv_link}, portal_mat, {{0u}, {leaving_world}});
     // disc portals
     range = {348u, 350u};
     test_portal_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_portal_ring2, {18u, 1u}},
+                      range, range[0], {mask_ids::e_ring2D, {18u, 1u}},
                       {material_ids::e_none, inv_link}, portal_mat,
                       {{leaving_world}, {6u}});
 
@@ -673,7 +680,7 @@ inline bool toy_detector_test(
     EXPECT_EQ(names.at(vol_itr->index()), "gap_6");
     range = {350u, 354u};
     index = {6u};
-    accel_link = {accel_ids::e_brute_force, 0u};
+    accel_link = {accel_ids::e_surface_brute_force, 0u};
     check_sf_ranges(*vol_itr, {350u, 354u}, {}, {});
 
     // Test the links in the volumes
@@ -685,13 +692,13 @@ inline bool toy_detector_test(
     test_portal_links(
         vol_itr->index(),
         surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]), range,
-        range[0], {mask_ids::e_portal_cylinder2, {24u, 1u}},
+        range[0], {mask_ids::e_concentric_cylinder2D, {24u, 1u}},
         {material_ids::e_none, inv_link}, portal_mat, {{0u}, {leaving_world}});
     // disc portals
     range = {352u, 354u};
     test_portal_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_portal_ring2, {20u, 1u}},
+                      range, range[0], {mask_ids::e_ring2D, {20u, 1u}},
                       {material_ids::e_none, inv_link}, portal_mat,
                       {{5u}, {3u}});
 
@@ -711,7 +718,7 @@ inline bool toy_detector_test(
     EXPECT_EQ(names.at(vol_itr->index()), "barrel_7");
     range = {354u, 582u};
     index = {7u};
-    accel_link = {accel_ids::e_cylinder2_grid, 0u};
+    accel_link = {accel_ids::e_surface_cylinder2D_grid, 0u};
     check_sf_ranges(*vol_itr, {578u, 582u}, {354u, 578u}, {});
 
     // Test the links in the volumes
@@ -721,8 +728,8 @@ inline bool toy_detector_test(
     range = {354u, 578u};
     test_module_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_rectangle2, {0u, 1u}},
-                      {material_ids::e_slab, 325u}, pixel_mat,
+                      range, range[0], {mask_ids::e_rectangle2D, {0u, 1u}},
+                      {material_ids::e_material_slab, 325u}, pixel_mat,
                       {vol_itr->index()}, true);
 
     // Check links of portals
@@ -731,14 +738,14 @@ inline bool toy_detector_test(
     test_portal_links(
         vol_itr->index(),
         surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]), range,
-        range[0], {mask_ids::e_portal_cylinder2, {26u, 1u}},
+        range[0], {mask_ids::e_concentric_cylinder2D, {26u, 1u}},
         {material_ids::e_none, inv_link}, portal_mat, {{8u}, {10u}});
 
     // disc portals
     range = {580u, 582u};
     test_portal_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_portal_ring2, {22u, 1u}},
+                      range, range[0], {mask_ids::e_ring2D, {22u, 1u}},
                       {material_ids::e_none, inv_link}, portal_mat,
                       {{2u}, {17u}});
 
@@ -754,7 +761,7 @@ inline bool toy_detector_test(
     EXPECT_EQ(names.at(vol_itr->index()), "gap_8");
     range = {582u, 584u};
     index = {8u};
-    accel_link = {accel_ids::e_brute_force, 0u};
+    accel_link = {accel_ids::e_surface_brute_force, 0u};
     check_sf_ranges(*vol_itr, {582u, 586u}, {}, {});
 
     // Test the links in the volumes
@@ -766,13 +773,13 @@ inline bool toy_detector_test(
     test_portal_links(
         vol_itr->index(),
         surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]), range,
-        range[0], {mask_ids::e_portal_cylinder2, {28u, 1u}},
+        range[0], {mask_ids::e_concentric_cylinder2D, {28u, 1u}},
         {material_ids::e_none, inv_link}, portal_mat, {{0u}, {7u}});
     // disc portals
     range = {584u, 586u};
     test_portal_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_portal_ring2, {24u, 1u}},
+                      range, range[0], {mask_ids::e_ring2D, {24u, 1u}},
                       {material_ids::e_none, inv_link}, portal_mat,
                       {{2u}, {17u}});
 
@@ -788,7 +795,7 @@ inline bool toy_detector_test(
     EXPECT_EQ(names.at(vol_itr->index()), "barrel_9");
     range = {586u, 1038u};
     index = {9u};
-    accel_link = {accel_ids::e_cylinder2_grid, 1u};
+    accel_link = {accel_ids::e_surface_cylinder2D_grid, 1u};
     check_sf_ranges(*vol_itr, {1034u, 1038u}, {586u, 1034u}, {});
 
     // Test the links in the volumes
@@ -798,8 +805,8 @@ inline bool toy_detector_test(
     range = {586u, 1034u};
     test_module_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_rectangle2, {1u, 1u}},
-                      {material_ids::e_slab, 549u}, pixel_mat,
+                      range, range[0], {mask_ids::e_rectangle2D, {1u, 1u}},
+                      {material_ids::e_material_slab, 549u}, pixel_mat,
                       {vol_itr->index()}, true);
 
     // Check links of portals
@@ -808,14 +815,14 @@ inline bool toy_detector_test(
     test_portal_links(
         vol_itr->index(),
         surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]), range,
-        range[0], {mask_ids::e_portal_cylinder2, {30u, 1u}},
+        range[0], {mask_ids::e_concentric_cylinder2D, {30u, 1u}},
         {material_ids::e_none, inv_link}, portal_mat, {{10u}, {12u}});
 
     // disc portals
     range = {1036u, 1038u};
     test_portal_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_portal_ring2, {26u, 1u}},
+                      range, range[0], {mask_ids::e_ring2D, {26u, 1u}},
                       {material_ids::e_none, inv_link}, portal_mat,
                       {{2u}, {17u}});
 
@@ -831,7 +838,7 @@ inline bool toy_detector_test(
     EXPECT_EQ(names.at(vol_itr->index()), "gap_10");
     range = {1038u, 1042u};
     index = {10u};
-    accel_link = {accel_ids::e_brute_force, 0u};
+    accel_link = {accel_ids::e_surface_brute_force, 0u};
     check_sf_ranges(*vol_itr, {1038u, 1042u}, {}, {});
 
     // Test the links in the volumes
@@ -843,13 +850,13 @@ inline bool toy_detector_test(
     test_portal_links(
         vol_itr->index(),
         surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]), range,
-        range[0], {mask_ids::e_portal_cylinder2, {32u, 1u}},
+        range[0], {mask_ids::e_concentric_cylinder2D, {32u, 1u}},
         {material_ids::e_none, inv_link}, portal_mat, {{7u}, {9u}});
     // disc portals
     range = {1040u, 1042u};
     test_portal_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_portal_ring2, {28u, 1u}},
+                      range, range[0], {mask_ids::e_ring2D, {28u, 1u}},
                       {material_ids::e_none, inv_link}, portal_mat,
                       {{2u}, {17u}});
 
@@ -865,7 +872,7 @@ inline bool toy_detector_test(
     EXPECT_EQ(names.at(vol_itr->index()), "barrel_11");
     range = {1042u, 1774u};
     index = {11u};
-    accel_link = {accel_ids::e_cylinder2_grid, 2u};
+    accel_link = {accel_ids::e_surface_cylinder2D_grid, 2u};
     check_sf_ranges(*vol_itr, {1770u, 1774u}, {1042u, 1770u}, {});
 
     // Test the links in the volumes
@@ -875,8 +882,8 @@ inline bool toy_detector_test(
     range = {1042u, 1770u};
     test_module_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_rectangle2, {2u, 1u}},
-                      {material_ids::e_slab, 997u}, pixel_mat,
+                      range, range[0], {mask_ids::e_rectangle2D, {2u, 1u}},
+                      {material_ids::e_material_slab, 997u}, pixel_mat,
                       {vol_itr->index()}, true);
 
     // Check links of portals
@@ -885,14 +892,14 @@ inline bool toy_detector_test(
     test_portal_links(
         vol_itr->index(),
         surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]), range,
-        range[0], {mask_ids::e_portal_cylinder2, {34u, 1u}},
+        range[0], {mask_ids::e_concentric_cylinder2D, {34u, 1u}},
         {material_ids::e_none, inv_link}, portal_mat, {{12u}, {14u}});
 
     // disc portals
     range = {1772u, 1774u};
     test_portal_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_portal_ring2, {30u, 1u}},
+                      range, range[0], {mask_ids::e_ring2D, {30u, 1u}},
                       {material_ids::e_none, inv_link}, portal_mat,
                       {{2u}, {17u}});
 
@@ -908,7 +915,7 @@ inline bool toy_detector_test(
     EXPECT_EQ(names.at(vol_itr->index()), "gap_12");
     range = {1774u, 1778u};
     index = {12u};
-    accel_link = {accel_ids::e_brute_force, 0u};
+    accel_link = {accel_ids::e_surface_brute_force, 0u};
     check_sf_ranges(*vol_itr, {1774u, 1778u}, {}, {});
 
     // Test the links in the volumes
@@ -920,13 +927,13 @@ inline bool toy_detector_test(
     test_portal_links(
         vol_itr->index(),
         surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]), range,
-        range[0], {mask_ids::e_portal_cylinder2, {36u, 1u}},
+        range[0], {mask_ids::e_concentric_cylinder2D, {36u, 1u}},
         {material_ids::e_none, inv_link}, portal_mat, {{9u}, {11u}});
     // disc portals
     range = {1776u, 1778u};
     test_portal_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_portal_ring2, {32u, 1u}},
+                      range, range[0], {mask_ids::e_ring2D, {32u, 1u}},
                       {material_ids::e_none, inv_link}, portal_mat,
                       {{2u}, {17u}});
 
@@ -942,7 +949,7 @@ inline bool toy_detector_test(
     EXPECT_EQ(names.at(vol_itr->index()), "barrel_13");
     range = {1778u, 2874u};
     index = {13u};
-    accel_link = {accel_ids::e_cylinder2_grid, 3u};
+    accel_link = {accel_ids::e_surface_cylinder2D_grid, 3u};
     check_sf_ranges(*vol_itr, {2870u, 2874u}, {1778u, 2870u}, {});
 
     // Test the links in the volumes
@@ -952,8 +959,8 @@ inline bool toy_detector_test(
     range = {1778u, 2870u};
     test_module_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_rectangle2, {3u, 1u}},
-                      {material_ids::e_slab, 1725u}, pixel_mat,
+                      range, range[0], {mask_ids::e_rectangle2D, {3u, 1u}},
+                      {material_ids::e_material_slab, 1725u}, pixel_mat,
                       {vol_itr->index()}, true);
 
     // Check links of portals
@@ -962,14 +969,14 @@ inline bool toy_detector_test(
     test_portal_links(
         vol_itr->index(),
         surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]), range,
-        range[0], {mask_ids::e_portal_cylinder2, {38u, 1u}},
+        range[0], {mask_ids::e_concentric_cylinder2D, {38u, 1u}},
         {material_ids::e_none, inv_link}, portal_mat, {{14u}, {15u}});
 
     // disc portals
     range = {2872u, 2874u};
     test_portal_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_portal_ring2, {34u, 1u}},
+                      range, range[0], {mask_ids::e_ring2D, {34u, 1u}},
                       {material_ids::e_none, inv_link}, portal_mat,
                       {{2u}, {17u}});
 
@@ -985,7 +992,7 @@ inline bool toy_detector_test(
     EXPECT_EQ(names.at(vol_itr->index()), "gap_14");
     range = {2874u, 2878u};
     index = {14u};
-    accel_link = {accel_ids::e_brute_force, 0u};
+    accel_link = {accel_ids::e_surface_brute_force, 0u};
     check_sf_ranges(*vol_itr, {2874u, 2878u}, {}, {});
 
     // Test the links in the volumes
@@ -997,13 +1004,13 @@ inline bool toy_detector_test(
     test_portal_links(
         vol_itr->index(),
         surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]), range,
-        range[0], {mask_ids::e_portal_cylinder2, {40u, 1u}},
+        range[0], {mask_ids::e_concentric_cylinder2D, {40u, 1u}},
         {material_ids::e_none, inv_link}, portal_mat, {{11u}, {13u}});
     // disc portals
     range = {2876u, 2878u};
     test_portal_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_portal_ring2, {36u, 1u}},
+                      range, range[0], {mask_ids::e_ring2D, {36u, 1u}},
                       {material_ids::e_none, inv_link}, portal_mat,
                       {{2u}, {17u}});
 
@@ -1019,7 +1026,7 @@ inline bool toy_detector_test(
     EXPECT_EQ(names.at(vol_itr->index()), "gap_15");
     range = {2878u, 2882u};
     index = {15u};
-    accel_link = {accel_ids::e_brute_force, 0u};
+    accel_link = {accel_ids::e_surface_brute_force, 0u};
     check_sf_ranges(*vol_itr, {2878u, 2882u}, {}, {});
 
     // Test the links in the volumes
@@ -1031,13 +1038,13 @@ inline bool toy_detector_test(
     test_portal_links(
         vol_itr->index(),
         surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]), range,
-        range[0], {mask_ids::e_portal_cylinder2, {42u, 1u}},
+        range[0], {mask_ids::e_concentric_cylinder2D, {42u, 1u}},
         {material_ids::e_none, inv_link}, portal_mat, {{13u}, {leaving_world}});
     // disc portals
     range = {2880u, 2882u};
     test_portal_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_portal_ring2, {38u, 1u}},
+                      range, range[0], {mask_ids::e_ring2D, {38u, 1u}},
                       {material_ids::e_none, inv_link}, portal_mat,
                       {{2u}, {17u}});
 
@@ -1057,7 +1064,7 @@ inline bool toy_detector_test(
     EXPECT_EQ(names.at(vol_itr->index()), "endcap_16");
     range = {2882u, 2994u};
     index = {16u};
-    accel_link = {accel_ids::e_disc_grid, 0u};
+    accel_link = {accel_ids::e_surface_ring2D_grid, 0u};
     check_sf_ranges(*vol_itr, {2990u, 2994u}, {2882u, 2990u}, {});
 
     // Test the links in the volumes
@@ -1068,15 +1075,15 @@ inline bool toy_detector_test(
     range = {2882u, 2922u};
     test_module_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_trapezoid2, {6u, 1u}},
-                      {material_ids::e_slab, 2817u}, pixel_mat,
+                      range, range[0], {mask_ids::e_trapezoid2D, {6u, 1u}},
+                      {material_ids::e_material_slab, 2817u}, pixel_mat,
                       {vol_itr->index()}, true);
     // One mask for the outer ring
     range = {2922u, 2990u};
     test_module_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_trapezoid2, {7u, 1u}},
-                      {material_ids::e_slab, 2857u}, pixel_mat,
+                      range, range[0], {mask_ids::e_trapezoid2D, {7u, 1u}},
+                      {material_ids::e_material_slab, 2857u}, pixel_mat,
                       {vol_itr->index()}, true);
 
     // Check links of portals
@@ -1085,13 +1092,13 @@ inline bool toy_detector_test(
     test_portal_links(
         vol_itr->index(),
         surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]), range,
-        range[0], {mask_ids::e_portal_cylinder2, {44u, 1u}},
+        range[0], {mask_ids::e_concentric_cylinder2D, {44u, 1u}},
         {material_ids::e_none, inv_link}, portal_mat, {{0u}, {leaving_world}});
     // disc portals
     range = {2992u, 2994u};
     test_portal_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_portal_ring2, {40u, 1u}},
+                      range, range[0], {mask_ids::e_ring2D, {40u, 1u}},
                       {material_ids::e_none, inv_link}, portal_mat,
                       {{17u}, {19u}});
 
@@ -1107,7 +1114,7 @@ inline bool toy_detector_test(
     EXPECT_EQ(names.at(vol_itr->index()), "connector_gap_17");
     range = {2994u, 2998u};
     index = {17u};
-    accel_link = {accel_ids::e_brute_force, 0u};
+    accel_link = {accel_ids::e_surface_brute_force, 0u};
     check_sf_ranges(*vol_itr, {2994u, 2998u}, {}, {});
 
     // Test the links in the volumes
@@ -1118,20 +1125,20 @@ inline bool toy_detector_test(
     range = {2994u, 2995u};
     test_portal_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_portal_ring2, {42u, 9u}},
+                      range, range[0], {mask_ids::e_ring2D, {42u, 9u}},
                       {material_ids::e_none, inv_link}, portal_mat,
                       {{7u, 8u, 9u, 10u, 11u, 12u, 13u, 14u, 15u}});
     range = {2995u, 2996u};
     test_portal_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_portal_ring2, {51u, 1u}},
+                      range, range[0], {mask_ids::e_ring2D, {51u, 1u}},
                       {material_ids::e_none, inv_link}, portal_mat, {{16u}});
     // cylinder portals
     range = {2996u, 2998u};
     test_portal_links(
         vol_itr->index(),
         surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]), range,
-        range[0], {mask_ids::e_portal_cylinder2, {46u, 1u}},
+        range[0], {mask_ids::e_concentric_cylinder2D, {46u, 1u}},
         {material_ids::e_none, inv_link}, portal_mat, {{0u}, {leaving_world}});
 
     // Check link of surfaces in surface finder
@@ -1146,7 +1153,7 @@ inline bool toy_detector_test(
     EXPECT_EQ(names.at(vol_itr->index()), "endcap_18");
     range = {2998u, 3110u};
     index = {18u};
-    accel_link = {accel_ids::e_disc_grid, 3u};
+    accel_link = {accel_ids::e_surface_ring2D_grid, 3u};
     check_sf_ranges(*vol_itr, {3106u, 3110u}, {2998u, 3106u}, {});
 
     // Test the links in the volumes
@@ -1157,15 +1164,15 @@ inline bool toy_detector_test(
     range = {2998u, 3038u};
     test_module_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_trapezoid2, {8u, 1u}},
-                      {material_ids::e_slab, 2925u}, pixel_mat,
+                      range, range[0], {mask_ids::e_trapezoid2D, {8u, 1u}},
+                      {material_ids::e_material_slab, 2925u}, pixel_mat,
                       {vol_itr->index()}, true);
     // One mask for the outer ring
     range = {3038u, 3106u};
     test_module_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_trapezoid2, {9u, 1u}},
-                      {material_ids::e_slab, 2965u}, pixel_mat,
+                      range, range[0], {mask_ids::e_trapezoid2D, {9u, 1u}},
+                      {material_ids::e_material_slab, 2965u}, pixel_mat,
                       {vol_itr->index()}, true);
 
     // Check links of portals
@@ -1174,13 +1181,13 @@ inline bool toy_detector_test(
     test_portal_links(
         vol_itr->index(),
         surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]), range,
-        range[0], {mask_ids::e_portal_cylinder2, {48u, 1u}},
+        range[0], {mask_ids::e_concentric_cylinder2D, {48u, 1u}},
         {material_ids::e_none, inv_link}, portal_mat, {{0u}, {leaving_world}});
     // disc portals
     range = {3108u, 3110u};
     test_portal_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_portal_ring2, {52u, 1u}},
+                      range, range[0], {mask_ids::e_ring2D, {52u, 1u}},
                       {material_ids::e_none, inv_link}, portal_mat,
                       {{19u}, {21u}});
 
@@ -1196,7 +1203,7 @@ inline bool toy_detector_test(
     EXPECT_EQ(names.at(vol_itr->index()), "gap_19");
     range = {3110u, 3114u};
     index = {19u};
-    accel_link = {accel_ids::e_brute_force, 0u};
+    accel_link = {accel_ids::e_surface_brute_force, 0u};
     check_sf_ranges(*vol_itr, {3110u, 3114u}, {}, {});
 
     // Test the links in the volumes
@@ -1208,13 +1215,13 @@ inline bool toy_detector_test(
     test_portal_links(
         vol_itr->index(),
         surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]), range,
-        range[0], {mask_ids::e_portal_cylinder2, {50u, 1u}},
+        range[0], {mask_ids::e_concentric_cylinder2D, {50u, 1u}},
         {material_ids::e_none, inv_link}, portal_mat, {{0u}, {leaving_world}});
     // disc portals
     range = {3112u, 3114u};
     test_portal_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_portal_ring2, {54u, 1u}},
+                      range, range[0], {mask_ids::e_ring2D, {54u, 1u}},
                       {material_ids::e_none, inv_link}, portal_mat,
                       {{16u}, {18u}});
 
@@ -1230,7 +1237,7 @@ inline bool toy_detector_test(
     EXPECT_EQ(names.at(vol_itr->index()), "endcap_20");
     range = {3114u, 3226u};
     index = {20u};
-    accel_link = {accel_ids::e_disc_grid, 4u};
+    accel_link = {accel_ids::e_surface_ring2D_grid, 4u};
     check_sf_ranges(*vol_itr, {3222u, 3226u}, {3114u, 3222u}, {});
 
     // Test the links in the volumes
@@ -1241,15 +1248,15 @@ inline bool toy_detector_test(
     range = {3114u, 3154u};
     test_module_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_trapezoid2, {10u, 1u}},
-                      {material_ids::e_slab, 3033u}, pixel_mat,
+                      range, range[0], {mask_ids::e_trapezoid2D, {10u, 1u}},
+                      {material_ids::e_material_slab, 3033u}, pixel_mat,
                       {vol_itr->index()}, true);
     // One mask for the outer ring
     range = {3154u, 3222u};
     test_module_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_trapezoid2, {11u, 1u}},
-                      {material_ids::e_slab, 3073u}, pixel_mat,
+                      range, range[0], {mask_ids::e_trapezoid2D, {11u, 1u}},
+                      {material_ids::e_material_slab, 3073u}, pixel_mat,
                       {vol_itr->index()}, true);
 
     // Check links of portals
@@ -1258,13 +1265,13 @@ inline bool toy_detector_test(
     test_portal_links(
         vol_itr->index(),
         surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]), range,
-        range[0], {mask_ids::e_portal_cylinder2, {52u, 1u}},
+        range[0], {mask_ids::e_concentric_cylinder2D, {52u, 1u}},
         {material_ids::e_none, inv_link}, portal_mat, {{0u}, {leaving_world}});
     // disc portals
     range = {3224u, 3226u};
     test_portal_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_portal_ring2, {56u, 1u}},
+                      range, range[0], {mask_ids::e_ring2D, {56u, 1u}},
                       {material_ids::e_none, inv_link}, portal_mat,
                       {{21u}, {leaving_world}});
 
@@ -1280,7 +1287,7 @@ inline bool toy_detector_test(
     EXPECT_EQ(names.at(vol_itr->index()), "gap_21");
     range = {3226u, 3230u};
     index = {21u};
-    accel_link = {accel_ids::e_brute_force, 0u};
+    accel_link = {accel_ids::e_surface_brute_force, 0u};
     check_sf_ranges(*vol_itr, {3226u, 3230u}, {}, {});
 
     // Test the links in the volumes
@@ -1292,13 +1299,13 @@ inline bool toy_detector_test(
     test_portal_links(
         vol_itr->index(),
         surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]), range,
-        range[0], {mask_ids::e_portal_cylinder2, {54u, 1u}},
+        range[0], {mask_ids::e_concentric_cylinder2D, {54u, 1u}},
         {material_ids::e_none, inv_link}, portal_mat, {{0u}, {leaving_world}});
     // disc portals
     range = {3228u, 3230u};
     test_portal_links(vol_itr->index(),
                       surfaces.begin() + static_cast<std::ptrdiff_t>(range[0]),
-                      range, range[0], {mask_ids::e_portal_ring2, {58u, 1u}},
+                      range, range[0], {mask_ids::e_ring2D, {58u, 1u}},
                       {material_ids::e_none, inv_link}, portal_mat,
                       {{18u}, {20u}});
 
diff --git a/tests/include/detray/test/utils/planes_along_direction.hpp b/tests/include/detray/test/utils/planes_along_direction.hpp
index 06d87b9ff..deb6fe5bd 100644
--- a/tests/include/detray/test/utils/planes_along_direction.hpp
+++ b/tests/include/detray/test/utils/planes_along_direction.hpp
@@ -19,11 +19,11 @@
 namespace detray::test {
 
 enum class plane_mask_ids : unsigned int {
-    e_plane_rectangle2 = 0u,
+    e_plane_rectangle2D = 0u,
 };
 
 enum class plane_material_ids : unsigned int {
-    e_plane_slab = 0u,
+    e_plane_material_slab = 0u,
 };
 
 // Helper type definitions.
@@ -54,9 +54,9 @@ auto planes_along_direction(const dvector<dscalar<algebra_t>> &distances,
         vector3_t t = d * direction;
         transforms.emplace_back(t, z, x);
 
-        plane_mask_link_t mask_link{plane_mask_ids::e_plane_rectangle2, idx};
-        plane_material_link_t material_link{plane_material_ids::e_plane_slab,
-                                            0u};
+        plane_mask_link_t mask_link{plane_mask_ids::e_plane_rectangle2D, idx};
+        plane_material_link_t material_link{
+            plane_material_ids::e_plane_material_slab, 0u};
         surfaces.emplace_back(idx, std::move(mask_link),
                               std::move(material_link), 0u,
                               surface_id::e_sensitive);
diff --git a/tests/include/detray/test/utils/prefill_detector.hpp b/tests/include/detray/test/utils/prefill_detector.hpp
index 61d60ab09..57184128b 100644
--- a/tests/include/detray/test/utils/prefill_detector.hpp
+++ b/tests/include/detray/test/utils/prefill_detector.hpp
@@ -57,7 +57,7 @@ void prefill_detector(detector_t& d,
                                   transform3_t(point3_t{0.f, 0.f, 0.f}),
                                   vol_link, std::vector<scalar_t>{-3.f, 3.f}});
     rectangle_factory->add_material(
-        material_id::e_slab,
+        material_id::e_material_slab,
         {3.f * unit<scalar_t>::mm, detray::gold<scalar_t>()});
     // Surface 1
     auto annulus_factory =
@@ -68,7 +68,7 @@ void prefill_detector(detector_t& d,
         {surface_id::e_sensitive, transform3_t(point3_t{1.f, 0.f, 0.f}),
          vol_link, std::vector<scalar_t>{1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f}});
     annulus_factory->add_material(
-        material_id::e_slab,
+        material_id::e_material_slab,
         {12.f * unit<scalar_t>::mm, detray::tungsten<scalar_t>()});
 
     // Surface 2
@@ -80,7 +80,7 @@ void prefill_detector(detector_t& d,
         {surface_id::e_sensitive, transform3_t(point3_t{2.f, 0.f, 0.f}),
          vol_link, std::vector<scalar_t>{1.f, 2.f, 3.f, 1.f / 6.f}});
     trapezoid_factory->add_material(
-        material_id::e_rod,
+        material_id::e_material_rod,
         {4.f * unit<scalar_t>::mm, detray::aluminium<scalar_t>()});
 
     // Build the volume with three surfaces and homogenenous material
diff --git a/tests/integration_tests/cpu/builders/grid_builder.cpp b/tests/integration_tests/cpu/builders/grid_builder.cpp
index de0989a27..3b913ac9e 100644
--- a/tests/integration_tests/cpu/builders/grid_builder.cpp
+++ b/tests/integration_tests/cpu/builders/grid_builder.cpp
@@ -149,8 +149,8 @@ GTEST_TEST(detray_builders, decorator_grid_builder) {
 
     // only the portals are referenced through the volume
     test::toy_metadata::object_link_type sf_range{};
-    sf_range[0] = {acc_ids::e_default, 0u};
-    sf_range[1] = {acc_ids::e_cylinder2_grid, 0u};
+    sf_range[0] = {acc_ids::e_surface_default, 0u};
+    sf_range[1] = {acc_ids::e_surface_cylinder2D_grid, 0u};
 
     // toy detector makes no distinction between the surface types
     EXPECT_EQ(vol.template accel_link<geo_obj_id::e_portal>(),
@@ -162,16 +162,17 @@ GTEST_TEST(detray_builders, decorator_grid_builder) {
 
     // Only the portals should be in the detector's surface container now
     EXPECT_EQ(d.surfaces().size(), 7u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_portal_cylinder2>(), 3u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_portal_ring2>(), 0u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_cylinder2>(), 3u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_rectangle2>(), 3u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_trapezoid2>(), 1u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_concentric_cylinder2D>(),
+              3u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_ring2D>(), 0u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_cylinder2D>(), 3u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_rectangle2D>(), 3u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_trapezoid2D>(), 1u);
 
     // check the portals in the detector
     const auto& bf_finder =
         d.accelerator_store()
-            .template get<detector_t::accel::id::e_brute_force>()[0];
+            .template get<detector_t::accel::id::e_surface_brute_force>()[0];
     for (const auto& sf : bf_finder.all()) {
         EXPECT_TRUE((sf.id() == surface_id::e_portal) ||
                     (sf.id() == surface_id::e_passive));
@@ -181,7 +182,8 @@ GTEST_TEST(detray_builders, decorator_grid_builder) {
     // check the sensitive surfaces in the grid
     const auto& cyl_grid =
         d.accelerator_store()
-            .template get<detector_t::accel::id::e_cylinder2_grid>()[0];
+            .template get<
+                detector_t::accel::id::e_surface_cylinder2D_grid>()[0];
     dindex trf_idx{3u};
     for (const auto& sf : cyl_grid.all()) {
         EXPECT_TRUE(sf.is_sensitive());
diff --git a/tests/integration_tests/cpu/builders/homogeneous_material_builder.cpp b/tests/integration_tests/cpu/builders/homogeneous_material_builder.cpp
index efe0deb33..8f806b5c5 100644
--- a/tests/integration_tests/cpu/builders/homogeneous_material_builder.cpp
+++ b/tests/integration_tests/cpu/builders/homogeneous_material_builder.cpp
@@ -111,28 +111,31 @@ GTEST_TEST(detray_builders, decorator_homogeneous_material_builder) {
     auto mat_pt_cyl_factory =
         std::make_shared<mat_factory_t>(std::move(pt_cyl_factory));
     mat_pt_cyl_factory->add_material(
-        material_id::e_slab, {1.f * unit<scalar>::mm, silicon<scalar>()});
+        material_id::e_material_slab,
+        {1.f * unit<scalar>::mm, silicon<scalar>()});
     mat_pt_cyl_factory->add_material(
-        material_id::e_slab, {1.5f * unit<scalar>::mm, silicon<scalar>()});
+        material_id::e_material_slab,
+        {1.5f * unit<scalar>::mm, silicon<scalar>()});
 
     auto mat_rect_factory =
         std::make_shared<mat_factory_t>(std::move(rect_factory));
-    mat_rect_factory->add_material(material_id::e_slab,
+    mat_rect_factory->add_material(material_id::e_material_slab,
                                    {1.f * unit<scalar>::mm, silicon<scalar>()});
-    mat_rect_factory->add_material(material_id::e_slab,
+    mat_rect_factory->add_material(material_id::e_material_slab,
                                    {2.f * unit<scalar>::mm, silicon<scalar>()});
-    mat_rect_factory->add_material(material_id::e_slab,
+    mat_rect_factory->add_material(material_id::e_material_slab,
                                    {3.f * unit<scalar>::mm, silicon<scalar>()});
 
     auto mat_trpz_factory =
         std::make_shared<mat_factory_t>(std::move(trpz_factory));
-    mat_trpz_factory->add_material(material_id::e_slab,
+    mat_trpz_factory->add_material(material_id::e_material_slab,
                                    {1.f * unit<scalar>::mm, silicon<scalar>()});
 
     auto mat_cyl_factory =
         std::make_shared<mat_factory_t>(std::move(cyl_factory));
     mat_cyl_factory->add_material(
-        material_id::e_slab, {1.5f * unit<scalar>::mm, tungsten<scalar>()});
+        material_id::e_material_slab,
+        {1.5f * unit<scalar>::mm, tungsten<scalar>()});
 
     // Add surfaces and material to detector
     mat_builder.add_surfaces(mat_pt_cyl_factory, geo_ctx);
@@ -153,23 +156,26 @@ GTEST_TEST(detray_builders, decorator_homogeneous_material_builder) {
 
     EXPECT_EQ(d.surfaces().size(), 7u);
     EXPECT_EQ(d.transform_store().size(), 8u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_portal_cylinder2>(), 2u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_portal_ring2>(), 0u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_cylinder2>(), 1u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_rectangle2>(), 3u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_trapezoid2>(), 1u);
-
-    EXPECT_EQ(d.material_store().template size<material_id::e_slab>(), 7u);
-    EXPECT_EQ(d.material_store().template size<material_id::e_rod>(), 0u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_concentric_cylinder2D>(),
+              2u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_ring2D>(), 0u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_cylinder2D>(), 1u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_rectangle2D>(), 3u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_trapezoid2D>(), 1u);
+
+    EXPECT_EQ(d.material_store().template size<material_id::e_material_slab>(),
+              7u);
+    EXPECT_EQ(d.material_store().template size<material_id::e_material_rod>(),
+              0u);
 
     for (auto [idx, sf_desc] : detray::views::enumerate(d.surfaces())) {
         const auto &mat_link = sf_desc.material();
-        EXPECT_EQ(mat_link.id(), material_id::e_slab);
+        EXPECT_EQ(mat_link.id(), material_id::e_material_slab);
         EXPECT_EQ(mat_link.index(), idx);
     }
 
     for (const auto &mat_slab :
-         d.material_store().template get<material_id::e_slab>()) {
+         d.material_store().template get<material_id::e_material_slab>()) {
         EXPECT_TRUE(mat_slab.get_material() == silicon<scalar>() ||
                     mat_slab.get_material() == tungsten<scalar>());
     }
@@ -216,7 +222,7 @@ GTEST_TEST(detray_builders, detector_builder_with_material) {
     mat_sf_factory->push_back({surface_id::e_sensitive,
                                transform3(point3{0.f, 0.f, 1000.f}), vol_idx,
                                std::vector<scalar>{1.f, 3.f, 2.f, 0.25f}});
-    mat_sf_factory->add_material(material_id::e_slab,
+    mat_sf_factory->add_material(material_id::e_material_slab,
                                  {1.f * unit<scalar>::mm, silicon<scalar>()});
 
     // Add a portal box around the cuboid volume with a min distance of 'env'
@@ -229,17 +235,23 @@ GTEST_TEST(detray_builders, detector_builder_with_material) {
         std::make_shared<homogeneous_material_factory<detector_t>>(
             std::move(portal_generator));
     mat_portal_factory->add_material(
-        material_id::e_slab, {2.f * unit<scalar>::mm, silicon<scalar>()});
+        material_id::e_material_slab,
+        {2.f * unit<scalar>::mm, silicon<scalar>()});
     mat_portal_factory->add_material(
-        material_id::e_slab, {3.f * unit<scalar>::mm, silicon<scalar>()});
+        material_id::e_material_slab,
+        {3.f * unit<scalar>::mm, silicon<scalar>()});
     mat_portal_factory->add_material(
-        material_id::e_slab, {4.f * unit<scalar>::mm, silicon<scalar>()});
+        material_id::e_material_slab,
+        {4.f * unit<scalar>::mm, silicon<scalar>()});
     mat_portal_factory->add_material(
-        material_id::e_slab, {5.f * unit<scalar>::mm, silicon<scalar>()});
+        material_id::e_material_slab,
+        {5.f * unit<scalar>::mm, silicon<scalar>()});
     mat_portal_factory->add_material(
-        material_id::e_slab, {6.f * unit<scalar>::mm, silicon<scalar>()});
+        material_id::e_material_slab,
+        {6.f * unit<scalar>::mm, silicon<scalar>()});
     mat_portal_factory->add_material(
-        material_id::e_slab, {7.f * unit<scalar>::mm, silicon<scalar>()});
+        material_id::e_material_slab,
+        {7.f * unit<scalar>::mm, silicon<scalar>()});
 
     mv_builder->add_surfaces(mat_sf_factory, geo_ctx);
     mv_builder->add_surfaces(mat_portal_factory);
@@ -262,20 +274,21 @@ GTEST_TEST(detray_builders, detector_builder_with_material) {
     EXPECT_TRUE(d.transform_store().at(0u) == trf);
 
     EXPECT_EQ(d.surfaces().size(), 7u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_rectangle2>(), 3u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_trapezoid2>(), 1u);
-    EXPECT_EQ(d.material_store().template size<material_id::e_slab>(), 7u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_rectangle2D>(), 3u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_trapezoid2D>(), 1u);
+    EXPECT_EQ(d.material_store().template size<material_id::e_material_slab>(),
+              7u);
 
     // Check the material links
     for (const auto [idx, sf_desc] : detray::views::enumerate(d.surfaces())) {
-        EXPECT_EQ(sf_desc.material().id(), material_id::e_slab);
+        EXPECT_EQ(sf_desc.material().id(), material_id::e_material_slab);
         EXPECT_EQ(sf_desc.material().index(), idx);
     }
 
     // Check the material
     scalar thickness{1.f * unit<scalar>::mm};
     for (const auto &slab :
-         d.material_store().template get<material_id::e_slab>()) {
+         d.material_store().template get<material_id::e_material_slab>()) {
         EXPECT_EQ(slab.get_material(), silicon<scalar>());
         EXPECT_NEAR(slab.thickness(), thickness, tol);
         thickness += 1.f * unit<scalar>::mm;
diff --git a/tests/integration_tests/cpu/builders/material_map_builder.cpp b/tests/integration_tests/cpu/builders/material_map_builder.cpp
index 0a0ce6a60..c3aaff6e9 100644
--- a/tests/integration_tests/cpu/builders/material_map_builder.cpp
+++ b/tests/integration_tests/cpu/builders/material_map_builder.cpp
@@ -134,31 +134,31 @@ GTEST_TEST(detray_builders, decorator_material_map_builder) {
     auto mat_pt_cyl_factory =
         std::make_shared<mat_factory_t>(std::move(pt_cyl_factory));
     scalar t{1.f * unit<scalar>::mm};
-    add_material_data(mat_pt_cyl_factory, mat_id::e_concentric_cylinder2_map,
+    add_material_data(mat_pt_cyl_factory, mat_id::e_concentric_cylinder2D_map,
                       0u, t, silicon<scalar>());
-    add_material_data(mat_pt_cyl_factory, mat_id::e_concentric_cylinder2_map,
+    add_material_data(mat_pt_cyl_factory, mat_id::e_concentric_cylinder2D_map,
                       1u, t, silicon<scalar>());
 
     auto mat_rect_factory =
         std::make_shared<mat_factory_t>(std::move(rect_factory));
     t = 1.f * unit<scalar>::mm;
-    add_material_data(mat_rect_factory, mat_id::e_rectangle2_map, 2u, t,
+    add_material_data(mat_rect_factory, mat_id::e_rectangle2D_map, 2u, t,
                       tungsten<scalar>());
     // No material for surface with index 3
     t = 3.f * unit<scalar>::mm;
-    add_material_data(mat_rect_factory, mat_id::e_rectangle2_map, 4u, t,
+    add_material_data(mat_rect_factory, mat_id::e_rectangle2D_map, 4u, t,
                       tungsten<scalar>());
 
     auto mat_trpz_factory =
         std::make_shared<mat_factory_t>(std::move(trpz_factory));
     t = 1.f * unit<scalar>::mm;
-    add_material_data(mat_trpz_factory, mat_id::e_trapezoid2_map, 5u, t,
-                      tungsten<scalar>());
+    /*add_material_data(mat_trpz_factory, mat_id::e_trapezoid2D_map, 5u, t,
+                      tungsten<scalar>());*/
 
     auto mat_cyl_factory =
         std::make_shared<mat_factory_t>(std::move(cyl_factory));
     t = 1.5f * unit<scalar>::mm;
-    add_material_data(mat_cyl_factory, mat_id::e_cylinder2_map, 6u, t,
+    add_material_data(mat_cyl_factory, mat_id::e_cylinder2D_map, 6u, t,
                       gold<scalar>());
 
     // Add surfaces and material to detector
@@ -180,25 +180,30 @@ GTEST_TEST(detray_builders, decorator_material_map_builder) {
 
     EXPECT_EQ(d.surfaces().size(), 7u);
     EXPECT_EQ(d.transform_store().size(), 8u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_portal_cylinder2>(), 2u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_portal_ring2>(), 0u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_cylinder2>(), 1u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_rectangle2>(), 3u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_trapezoid2>(), 1u);
-
-    EXPECT_EQ(d.material_store().template size<mat_id::e_slab>(), 0u);
-    EXPECT_EQ(d.material_store().template size<mat_id::e_rod>(), 0u);
-    EXPECT_EQ(d.material_store().template size<mat_id::e_disc2_map>(), 0u);
-    EXPECT_EQ(d.material_store().template size<mat_id::e_annulus2_map>(), 0u);
-    EXPECT_EQ(d.material_store().template size<mat_id::e_drift_cell_map>(), 0u);
-    EXPECT_EQ(d.material_store().template size<mat_id::e_straw_tube_map>(), 0u);
-    EXPECT_EQ(d.material_store().template size<mat_id::e_cylinder2_map>(), 1u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_concentric_cylinder2D>(),
+              2u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_ring2D>(), 0u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_cylinder2D>(), 1u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_rectangle2D>(), 3u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_trapezoid2D>(), 1u);
+
+    EXPECT_EQ(d.material_store().template size<mat_id::e_material_slab>(), 0u);
+    EXPECT_EQ(d.material_store().template size<mat_id::e_material_rod>(), 0u);
+    EXPECT_EQ(d.material_store().template size<mat_id::e_ring2D_map>(), 0u);
+    // EXPECT_EQ(d.material_store().template size<mat_id::e_annulus2D_map>(),
+    // 0u); EXPECT_EQ(d.material_store().template
+    // size<mat_id::e_drift_cell_map>(), 0u);
+    // EXPECT_EQ(d.material_store().template size<mat_id::e_straw_tube_map>(),
+    // 0u);
+    EXPECT_EQ(d.material_store().template size<mat_id::e_cylinder2D_map>(), 1u);
     EXPECT_EQ(
-        d.material_store().template size<mat_id::e_concentric_cylinder2_map>(),
+        d.material_store().template size<mat_id::e_concentric_cylinder2D_map>(),
         2u);
     // Rectangle and trapezoid surfaces have the same grid geometry
-    EXPECT_EQ(d.material_store().template size<mat_id::e_rectangle2_map>(), 3u);
-    EXPECT_EQ(d.material_store().template size<mat_id::e_trapezoid2_map>(), 3u);
+    EXPECT_EQ(d.material_store().template size<mat_id::e_rectangle2D_map>(),
+              3u);
+    // EXPECT_EQ(d.material_store().template size<mat_id::e_trapezoid2D_map>(),
+    //           3u);
 
     // Check the material links
     std::size_t pt_cyl_idx{0u};
@@ -207,15 +212,15 @@ GTEST_TEST(detray_builders, decorator_material_map_builder) {
     for (auto& sf_desc : d.surfaces()) {
         const auto& mat_link = sf_desc.material();
         switch (mat_link.id()) {
-            case mat_id::e_cylinder2_map: {
+            case mat_id::e_cylinder2D_map: {
                 EXPECT_EQ(mat_link.index(), cyl_idx++) << sf_desc;
                 break;
             }
-            case mat_id::e_concentric_cylinder2_map: {
+            case mat_id::e_concentric_cylinder2D_map: {
                 EXPECT_EQ(mat_link.index(), pt_cyl_idx++) << sf_desc;
                 break;
             }
-            case mat_id::e_rectangle2_map: {
+            case mat_id::e_rectangle2D_map: {
                 EXPECT_EQ(mat_link.index(), cart_idx++) << sf_desc;
                 break;
             }
@@ -236,7 +241,7 @@ GTEST_TEST(detray_builders, decorator_material_map_builder) {
     // Check the material map content
     for (auto cyl_mat_grid :
          d.material_store()
-             .template get<mat_id::e_concentric_cylinder2_map>()) {
+             .template get<mat_id::e_concentric_cylinder2D_map>()) {
 
         EXPECT_EQ(cyl_mat_grid.nbins(), 50u);
         EXPECT_EQ(cyl_mat_grid.size(), 50u);
@@ -253,7 +258,7 @@ GTEST_TEST(detray_builders, decorator_material_map_builder) {
     }
 
     for (auto cart_mat_grid :
-         d.material_store().template get<mat_id::e_rectangle2_map>()) {
+         d.material_store().template get<mat_id::e_rectangle2D_map>()) {
 
         EXPECT_EQ(cart_mat_grid.nbins(), 50u);
         EXPECT_EQ(cart_mat_grid.size(), 50u);
diff --git a/tests/integration_tests/cpu/builders/volume_builder.cpp b/tests/integration_tests/cpu/builders/volume_builder.cpp
index c1d0ad3d7..70d23e624 100644
--- a/tests/integration_tests/cpu/builders/volume_builder.cpp
+++ b/tests/integration_tests/cpu/builders/volume_builder.cpp
@@ -58,8 +58,7 @@ GTEST_TEST(detray_builders, tracking_volume_construction) {
 
     // Surface factories
     using portal_cylinder_factory =
-        surface_factory<detector_t,
-                        typename detector_t::metadata::cylinder_portal::shape>;
+        surface_factory<detector_t, concentric_cylinder2D>;
     using annulus_factory = surface_factory<detector_t, annulus2D>;
     using cylinder_factory = surface_factory<detector_t, cylinder2D>;
     using rectangle_factory = surface_factory<detector_t, rectangle2D>;
@@ -213,7 +212,7 @@ GTEST_TEST(detray_builders, tracking_volume_construction) {
     EXPECT_TRUE(d.transform_store().at(first_trf) == trf);
 
     // Check the acceleration data structure link
-    dtyped_index<accel_id, dindex> acc_link{accel_id::e_default, 1u};
+    dtyped_index<accel_id, dindex> acc_link{accel_id::e_surface_default, 1u};
     ASSERT_TRUE(vol.accel_link().size() == geo_obj_id::e_size);
     EXPECT_EQ(vol.accel_link<geo_obj_id::e_portal>(), acc_link);
     EXPECT_EQ(vol.accel_link<geo_obj_id::e_passive>(), acc_link);
@@ -222,13 +221,14 @@ GTEST_TEST(detray_builders, tracking_volume_construction) {
         detail::is_invalid_value(vol.accel_link<geo_obj_id::e_sensitive>()));
 
     EXPECT_EQ(d.portals().size(), 19u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_portal_cylinder2>(), 2u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_portal_ring2>(), 4u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_annulus2>(), 3u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_cylinder2>(), 1u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_rectangle2>(), 7u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_ring2>(), 4u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_trapezoid2>(), 2u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_concentric_cylinder2D>(),
+              2u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_ring2D>(), 4u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_annulus2D>(), 3u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_cylinder2D>(), 1u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_rectangle2D>(), 7u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_ring2D>(), 4u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_trapezoid2D>(), 2u);
 
     // check surface type and volume link
     std::vector<surface_id> sf_ids{};
@@ -267,25 +267,25 @@ GTEST_TEST(detray_builders, tracking_volume_construction) {
 
     // check surface mask links
     std::vector<typename detector_t::surface_type::mask_link> mask_links{
-        {mask_id::e_rectangle2, {0u, 1u}},
-        {mask_id::e_annulus2, {0u, 1u}},
-        {mask_id::e_trapezoid2, {0u, 1u}},
-        {mask_id::e_portal_cylinder2, {0u, 1u}},
-        {mask_id::e_portal_cylinder2, {1u, 1u}},
-        {mask_id::e_portal_ring2, {0u, 1u}},
-        {mask_id::e_portal_ring2, {1u, 1u}},
-        {mask_id::e_annulus2, {1u, 1u}},
-        {mask_id::e_annulus2, {2u, 1u}},
-        {mask_id::e_rectangle2, {1u, 1u}},
-        {mask_id::e_rectangle2, {2u, 1u}},
-        {mask_id::e_rectangle2, {3u, 1u}},
-        {mask_id::e_trapezoid2, {1u, 1u}},
-        {mask_id::e_cylinder2, {0u, 1u}},
-        {mask_id::e_ring2, {2u, 1u}},
-        {mask_id::e_ring2, {3u, 1u}},
-        {mask_id::e_rectangle2, {4u, 1u}},
-        {mask_id::e_rectangle2, {5u, 1u}},
-        {mask_id::e_rectangle2, {6u, 1u}}};
+        {mask_id::e_rectangle2D, {0u, 1u}},
+        {mask_id::e_annulus2D, {0u, 1u}},
+        {mask_id::e_trapezoid2D, {0u, 1u}},
+        {mask_id::e_concentric_cylinder2D, {0u, 1u}},
+        {mask_id::e_concentric_cylinder2D, {1u, 1u}},
+        {mask_id::e_ring2D, {0u, 1u}},
+        {mask_id::e_ring2D, {1u, 1u}},
+        {mask_id::e_annulus2D, {1u, 1u}},
+        {mask_id::e_annulus2D, {2u, 1u}},
+        {mask_id::e_rectangle2D, {1u, 1u}},
+        {mask_id::e_rectangle2D, {2u, 1u}},
+        {mask_id::e_rectangle2D, {3u, 1u}},
+        {mask_id::e_trapezoid2D, {1u, 1u}},
+        {mask_id::e_cylinder2D, {0u, 1u}},
+        {mask_id::e_ring2D, {2u, 1u}},
+        {mask_id::e_ring2D, {3u, 1u}},
+        {mask_id::e_rectangle2D, {4u, 1u}},
+        {mask_id::e_rectangle2D, {5u, 1u}},
+        {mask_id::e_rectangle2D, {6u, 1u}}};
     for (const auto [idx, m_link] : detray::views::enumerate(mask_links)) {
         geometry::barcode bcd{};
         bcd.set_index(idx);
@@ -295,28 +295,28 @@ GTEST_TEST(detray_builders, tracking_volume_construction) {
     // check mask volume links
     volume_links.clear();
     volume_links = {0u, 2u};
-    check_mask<detector_t, mask_id::e_portal_cylinder2>(d, volume_links);
+    check_mask<detector_t, mask_id::e_concentric_cylinder2D>(d, volume_links);
 
     volume_links.clear();
     volume_links = {1u};
-    check_mask<detector_t, mask_id::e_cylinder2>(d, volume_links);
+    check_mask<detector_t, mask_id::e_cylinder2D>(d, volume_links);
 
     volume_links.clear();
     volume_links = {3u, 4u, 1u, 1u};
-    check_mask<detector_t, mask_id::e_portal_ring2>(d, volume_links);
-    check_mask<detector_t, mask_id::e_ring2>(d, volume_links);
+    check_mask<detector_t, mask_id::e_ring2D>(d, volume_links);
+    check_mask<detector_t, mask_id::e_ring2D>(d, volume_links);
 
     volume_links.clear();
     volume_links = {0u, 1u, 1u};
-    check_mask<detector_t, mask_id::e_annulus2>(d, volume_links);
+    check_mask<detector_t, mask_id::e_annulus2D>(d, volume_links);
 
     volume_links.clear();
     volume_links.reserve(7u);
     volume_links.push_back(0u);
     volume_links.insert(volume_links.end(), 6u, 1u);
-    check_mask<detector_t, mask_id::e_rectangle2>(d, volume_links);
+    check_mask<detector_t, mask_id::e_rectangle2D>(d, volume_links);
 
     volume_links.clear();
     volume_links = {0u, 1u};
-    check_mask<detector_t, mask_id::e_trapezoid2>(d, volume_links);
+    check_mask<detector_t, mask_id::e_trapezoid2D>(d, volume_links);
 }
diff --git a/tests/integration_tests/cpu/propagator/jacobian_validation.cpp b/tests/integration_tests/cpu/propagator/jacobian_validation.cpp
index ab0244c8f..1458e9ddb 100644
--- a/tests/integration_tests/cpu/propagator/jacobian_validation.cpp
+++ b/tests/integration_tests/cpu/propagator/jacobian_validation.cpp
@@ -341,7 +341,7 @@ std::pair<euler_rotation<test_algebra>, std::array<scalar, 3u>> tilt_surface(
     // Helix direction
     euler.z = helix_dir;
 
-    if constexpr (mask_id == detector_t::masks::id::e_rectangle2) {
+    if constexpr (mask_id == detector_t::masks::id::e_rectangle2D) {
         // ubasis = trf.x() for bound frame
         euler.x = trf.x();
     } else if (mask_id == detector_t::masks::id::e_drift_cell) {
@@ -1675,11 +1675,11 @@ int main(int argc, char** argv) {
             build_telescope_detector<test_algebra>(host_mr, rectangle_cfg);
         const auto [euler_rect_initial, shift_rect_initial] =
             tilt_surface<decltype(rect_det),
-                         decltype(rect_det)::masks::id::e_rectangle2>(
+                         decltype(rect_det)::masks::id::e_rectangle2D>(
                 rect_det, 0u, helix_bz.dir(0.f), alphaI, 0.f, 0.f);
         const auto [euler_rect_final, shift_rect_final] =
             tilt_surface<decltype(rect_det),
-                         decltype(rect_det)::masks::id::e_rectangle2>(
+                         decltype(rect_det)::masks::id::e_rectangle2D>(
                 rect_det, 1u, helix_bz.dir(detector_length), alphaF, betaF,
                 gammaF);
 
@@ -1689,11 +1689,11 @@ int main(int argc, char** argv) {
             build_telescope_detector<test_algebra>(host_mr, rectangle_cfg);
         [[maybe_unused]] const auto [euler_rect_initial2, shift_rect_initial2] =
             tilt_surface<decltype(rect_det_w_mat),
-                         decltype(rect_det_w_mat)::masks::id::e_rectangle2>(
+                         decltype(rect_det_w_mat)::masks::id::e_rectangle2D>(
                 rect_det_w_mat, 0u, helix_bz.dir(0.f), alphaI, 0.f, 0.f);
         [[maybe_unused]] const auto [euler_rect_final2, shift_rect_final2] =
             tilt_surface<decltype(rect_det_w_mat),
-                         decltype(rect_det_w_mat)::masks::id::e_rectangle2>(
+                         decltype(rect_det_w_mat)::masks::id::e_rectangle2D>(
                 rect_det_w_mat, 1u, helix_bz.dir(detector_length), alphaF,
                 betaF, gammaF);
 
@@ -1799,7 +1799,7 @@ int main(int argc, char** argv) {
         // Get initial parameter
         const auto rect_bparam =
             get_initial_parameter<decltype(rect_det),
-                                  decltype(rect_det)::masks::id::e_rectangle2>(
+                                  decltype(rect_det)::masks::id::e_rectangle2D>(
                 rect_det, track, B_z, helix_tol);
 
         if (!skip_rect) {
@@ -1836,7 +1836,7 @@ int main(int argc, char** argv) {
                 // For helix
                 evaluate_jacobian_difference_helix<
                     decltype(rect_det),
-                    decltype(rect_det)::masks::id::e_rectangle2>(
+                    decltype(rect_det)::masks::id::e_rectangle2D>(
                     track_count, euler_angles_I, euler_angles_F, rect_det,
                     detector_length, rect_bparam, B_z, h_sizes_rect,
                     helix_rect_file, helix_tol);
diff --git a/tests/integration_tests/cpu/utils/type_registry.cpp b/tests/integration_tests/cpu/utils/type_registry.cpp
index 89533b577..dfe822e55 100644
--- a/tests/integration_tests/cpu/utils/type_registry.cpp
+++ b/tests/integration_tests/cpu/utils/type_registry.cpp
@@ -67,10 +67,10 @@ GTEST_TEST(detray_utils, mapped_type_registry) {
     EXPECT_EQ(idx_array[2u], 1u);
     EXPECT_EQ(idx_array[3u], 2u);
 
-    using rectangle_t = types::get<mask_types, mask_id::e_rectangle2>;
-    using trapezoid_t = types::get<mask_types, mask_id::e_trapezoid2>;
-    using cylinder_t = types::get<mask_types, mask_id::e_cylinder2>;
-    using disc_t = types::get<mask_types, mask_id::e_portal_ring2>;
+    using rectangle_t = types::get<mask_types, mask_id::e_rectangle2D>;
+    using trapezoid_t = types::get<mask_types, mask_id::e_trapezoid2D>;
+    using cylinder_t = types::get<mask_types, mask_id::e_cylinder2D>;
+    using disc_t = types::get<mask_types, mask_id::e_ring2D>;
 
     static_assert(types::position<mapped_registry_t, rectangle_t> == 0u);
     static_assert(types::position<mapped_registry_t, trapezoid_t> == 0u);
@@ -78,13 +78,12 @@ GTEST_TEST(detray_utils, mapped_type_registry) {
     static_assert(types::position<mapped_registry_t, disc_t> == 2u);
 
     using cyl_intersector_t =
-        types::get<mapped_registry_t, mask_id::e_cylinder2>;
+        types::get<mapped_registry_t, mask_id::e_cylinder2D>;
     using rect_intersector_t =
-        types::get<mapped_registry_t, mask_id::e_rectangle2>;
-    using ring_intersector_t =
-        types::get<mapped_registry_t, mask_id::e_portal_ring2>;
+        types::get<mapped_registry_t, mask_id::e_rectangle2D>;
+    using ring_intersector_t = types::get<mapped_registry_t, mask_id::e_ring2D>;
     using trpz_intersector_t =
-        types::get<mapped_registry_t, mask_id::e_trapezoid2>;
+        types::get<mapped_registry_t, mask_id::e_trapezoid2D>;
 
     types::print<types::list<cyl_intersector_t>>();
     std::cout << std::endl;
@@ -127,16 +126,15 @@ GTEST_TEST(detray_utils, mapped_type_registry) {
 
     // Get ID from the original types
     static_assert(
-        types::id<mapped_registry_t, cylinder_t> == mask_id::e_cylinder2,
+        types::id<mapped_registry_t, cylinder_t> == mask_id::e_cylinder2D,
         "ID for type cylinder intersector incorrect");
     static_assert(
-        types::id<mapped_registry_t, rectangle_t> == mask_id::e_rectangle2,
+        types::id<mapped_registry_t, rectangle_t> == mask_id::e_rectangle2D,
         "ID for type rectangle intersector incorrect");
+    static_assert(types::id<mapped_registry_t, disc_t> == mask_id::e_ring2D,
+                  "ID for type ring intersector incorrect");
     static_assert(
-        types::id<mapped_registry_t, disc_t> == mask_id::e_portal_ring2,
-        "ID for type ring intersector incorrect");
-    static_assert(
-        types::id<mapped_registry_t, trapezoid_t> == mask_id::e_trapezoid2,
+        types::id<mapped_registry_t, trapezoid_t> == mask_id::e_trapezoid2D,
         "ID for type trapezoid intersector incorrect");
 
     // contains
@@ -155,31 +153,31 @@ GTEST_TEST(detray_utils, mapped_type_registry) {
                   "'contains' failed for 'void' type");
 
     // Is valid
-    static_assert(mapped_registry_t::is_valid(mask_id::e_cylinder2),
+    static_assert(mapped_registry_t::is_valid(mask_id::e_cylinder2D),
                   "ID for cylinder intersector invalid");
-    static_assert(mapped_registry_t::is_valid(mask_id::e_rectangle2),
+    static_assert(mapped_registry_t::is_valid(mask_id::e_rectangle2D),
                   "ID for rectangle intersector invalid");
-    static_assert(mapped_registry_t::is_valid(mask_id::e_portal_ring2),
+    static_assert(mapped_registry_t::is_valid(mask_id::e_ring2D),
                   "ID for ring intersector invalid");
-    static_assert(mapped_registry_t::is_valid(mask_id::e_trapezoid2),
+    static_assert(mapped_registry_t::is_valid(mask_id::e_trapezoid2D),
                   "ID for trapezoid intersector invalid");
     assert(!mapped_registry_t::is_valid(5u) && "ID '5' not invalid");
 
     // Get type
     static_assert(
         std::same_as<cyl_intersector_t,
-                     types::get<mapped_registry_t, mask_id::e_cylinder2>>,
-        "Got incorrect type for 'e_cylinder2'");
+                     types::get<mapped_registry_t, mask_id::e_cylinder2D>>,
+        "Got incorrect type for 'e_cylinder2D'");
     static_assert(
         std::same_as<rect_intersector_t,
-                     types::get<mapped_registry_t, mask_id::e_rectangle2>>,
-        "Got incorrect type for 'e_rectangle2'");
+                     types::get<mapped_registry_t, mask_id::e_rectangle2D>>,
+        "Got incorrect type for 'e_rectangle2D'");
     static_assert(
         std::same_as<ring_intersector_t,
-                     types::get<mapped_registry_t, mask_id::e_portal_ring2>>,
-        "Got incorrect type for 'e_portal_ring2'");
+                     types::get<mapped_registry_t, mask_id::e_ring2D>>,
+        "Got incorrect type for 'e_ring2D'");
     static_assert(
         std::same_as<trpz_intersector_t,
-                     types::get<mapped_registry_t, mask_id::e_trapezoid2>>,
-        "Got incorrect type for 'e_trapezoid2'");
+                     types::get<mapped_registry_t, mask_id::e_trapezoid2D>>,
+        "Got incorrect type for 'e_trapezoid2D'");
 }
diff --git a/tests/integration_tests/io/io_json_detector_roundtrip.cpp b/tests/integration_tests/io/io_json_detector_roundtrip.cpp
index 9be332db9..4c0daf434 100644
--- a/tests/integration_tests/io/io_json_detector_roundtrip.cpp
+++ b/tests/integration_tests/io/io_json_detector_roundtrip.cpp
@@ -183,7 +183,7 @@ GTEST_TEST(io, json_telescope_detector_reader) {
 
     const auto& mat_store = det_io.material_store();
     const auto& slabs =
-        mat_store.get<decltype(tel_det)::materials::id::e_slab>();
+        mat_store.get<decltype(tel_det)::materials::id::e_material_slab>();
 
     EXPECT_EQ(det_io.volumes().size(), 1u);
     EXPECT_EQ(slabs.size(), positions.size());
@@ -235,14 +235,13 @@ GTEST_TEST(io, json_toy_geometry) {
     EXPECT_EQ(comp_det.volumes().size(), 22u);
     EXPECT_EQ(comp_det.surfaces().size(), 3230);
     EXPECT_EQ(comp_det.transform_store().size(), 3252);
-    EXPECT_EQ(masks.template size<mask_id::e_rectangle2>(), 2492u);
-    EXPECT_EQ(masks.template size<mask_id::e_portal_rectangle2>(), 2492u);
-    EXPECT_EQ(masks.template size<mask_id::e_trapezoid2>(), 648u);
-    EXPECT_EQ(masks.template size<mask_id::e_annulus2>(), 0u);
-    EXPECT_EQ(masks.template size<mask_id::e_cylinder2>(), 0u);
-    EXPECT_EQ(masks.template size<mask_id::e_portal_cylinder2>(), 56u);
-    EXPECT_EQ(masks.template size<mask_id::e_ring2>(), 60u);
-    EXPECT_EQ(masks.template size<mask_id::e_portal_ring2>(), 60u);
+    EXPECT_EQ(masks.template size<mask_id::e_rectangle2D>(), 2492u);
+    EXPECT_EQ(masks.template size<mask_id::e_trapezoid2D>(), 648u);
+    EXPECT_EQ(masks.template size<mask_id::e_annulus2D>(), 0u);
+    EXPECT_EQ(masks.template size<mask_id::e_cylinder2D>(), 0u);
+    EXPECT_EQ(masks.template size<mask_id::e_concentric_cylinder2D>(), 56u);
+    EXPECT_EQ(masks.template size<mask_id::e_ring2D>(), 60u);
+    EXPECT_EQ(masks.template size<mask_id::e_ring2D>(), 60u);
     EXPECT_EQ(masks.template size<mask_id::e_straw_tube>(), 0u);
     EXPECT_EQ(masks.template size<mask_id::e_drift_cell>(), 0u);
 
diff --git a/tests/unit_tests/cpu/builders/detector_builder.cpp b/tests/unit_tests/cpu/builders/detector_builder.cpp
index 4393bb9db..a770a8960 100644
--- a/tests/unit_tests/cpu/builders/detector_builder.cpp
+++ b/tests/unit_tests/cpu/builders/detector_builder.cpp
@@ -130,12 +130,13 @@ GTEST_TEST(detray_builders, detector_builder) {
     EXPECT_TRUE(d.transform_store().at(8u) == trf);
 
     EXPECT_EQ(d.surfaces().size(), 16u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_portal_cylinder2>(), 2u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_portal_ring2>(), 2u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_annulus2>(), 0u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_cylinder2>(), 0u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_concentric_cylinder2D>(),
+              2u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_ring2D>(), 2u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_annulus2D>(), 0u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_cylinder2D>(), 0u);
     // Portal rectangle masks are deduplicated
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_rectangle2>(), 3u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_ring2>(), 2u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_trapezoid2>(), 6u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_rectangle2D>(), 3u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_ring2D>(), 2u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_trapezoid2D>(), 6u);
 }
diff --git a/tests/unit_tests/cpu/builders/homogeneous_material_builder.cpp b/tests/unit_tests/cpu/builders/homogeneous_material_builder.cpp
index efa43efb2..baa361c74 100644
--- a/tests/unit_tests/cpu/builders/homogeneous_material_builder.cpp
+++ b/tests/unit_tests/cpu/builders/homogeneous_material_builder.cpp
@@ -59,8 +59,10 @@ TEST(detray_builders, homogeneous_material_factory) {
     vecmem::host_memory_resource host_mr;
     detector_t d(host_mr);
 
-    EXPECT_TRUE(d.material_store().template empty<material_id::e_slab>());
-    EXPECT_TRUE(d.material_store().template empty<material_id::e_rod>());
+    EXPECT_TRUE(
+        d.material_store().template empty<material_id::e_material_slab>());
+    EXPECT_TRUE(
+        d.material_store().template empty<material_id::e_material_rod>());
 
     EXPECT_EQ(mat_factory->size(), 0u);
     EXPECT_TRUE(mat_factory->materials().empty());
@@ -70,19 +72,19 @@ TEST(detray_builders, homogeneous_material_factory) {
     mat_factory->push_back({surface_id::e_sensitive,
                             transform3(point3{0.f, 0.f, -1.f}), 1u,
                             std::vector<scalar>{10.f, 8.f}});
-    mat_factory->add_material(material_id::e_slab,
+    mat_factory->add_material(material_id::e_material_slab,
                               {1.f * unit<scalar>::mm, silicon<scalar>()});
     mat_factory->push_back({surface_id::e_sensitive,
                             transform3(point3{0.f, 0.f, 1.f}), 1u,
                             std::vector<scalar>{20.f, 16.f}});
-    mat_factory->add_material(material_id::e_slab,
+    mat_factory->add_material(material_id::e_material_slab,
                               {10.f * unit<scalar>::mm, tungsten<scalar>()});
     // Pass the parameters for 'gold'
     mat_factory->push_back({surface_id::e_sensitive,
                             transform3(point3{0.f, 0.f, 1.f}), 1u,
                             std::vector<scalar>{20.f, 16.f}});
     mat_factory->add_material(
-        material_id::e_rod,
+        material_id::e_material_rod,
         {0.1f * unit<scalar>::mm,
          std::vector<scalar>{
              3.344f * unit<scalar>::mm, 101.6f * unit<scalar>::mm, 196.97f, 79,
diff --git a/tests/unit_tests/cpu/builders/material_map_builder.cpp b/tests/unit_tests/cpu/builders/material_map_builder.cpp
index 079f0adc4..21857c67d 100644
--- a/tests/unit_tests/cpu/builders/material_map_builder.cpp
+++ b/tests/unit_tests/cpu/builders/material_map_builder.cpp
@@ -90,14 +90,14 @@ TEST(detray_builders, material_map_factory) {
                             std::vector<scalar>{10.f, 8.f}});
 
     scalar t{1.f * unit<scalar>::mm};
-    add_material_data(mat_factory, mat_id::e_rectangle2_map, 0u, t,
+    add_material_data(mat_factory, mat_id::e_rectangle2D_map, 0u, t,
                       silicon<scalar>());
 
     mat_factory->push_back({surface_id::e_sensitive,
                             transform3(point3{0.f, 0.f, 1.f}), 1u,
                             std::vector<scalar>{20.f, 16.f}});
     t = 2.f * unit<scalar>::mm;
-    add_material_data(mat_factory, mat_id::e_rectangle2_map, 1u, t,
+    add_material_data(mat_factory, mat_id::e_rectangle2D_map, 1u, t,
                       tungsten<scalar>());
 
     // Pass the parameters for 'gold'
@@ -106,7 +106,7 @@ TEST(detray_builders, material_map_factory) {
                             std::vector<scalar>{20.f, 16.f}});
     t = 3.f * unit<scalar>::mm;
     add_material_data(
-        mat_factory, mat_id::e_rectangle2_map, 2u, t,
+        mat_factory, mat_id::e_rectangle2D_map, 2u, t,
         {3.344f * unit<scalar>::mm, 101.6f * unit<scalar>::mm, 196.97f, 79,
          19.32f * unit<scalar>::g / (1.f * unit<scalar>::cm3),
          material_state::e_solid});
diff --git a/tests/unit_tests/cpu/builders/volume_builder.cpp b/tests/unit_tests/cpu/builders/volume_builder.cpp
index ba95a15d5..8702b6269 100644
--- a/tests/unit_tests/cpu/builders/volume_builder.cpp
+++ b/tests/unit_tests/cpu/builders/volume_builder.cpp
@@ -47,8 +47,7 @@ GTEST_TEST(detray_builders, surface_factory) {
     // check portal cylinder
     //
     using portal_cylinder_factory =
-        surface_factory<detector_t,
-                        typename metadata_t::cylinder_portal::shape>;
+        surface_factory<detector_t, concentric_cylinder2D>;
 
     auto pt_cyl_factory = std::make_shared<portal_cylinder_factory>();
 
diff --git a/tests/unit_tests/cpu/core/detector.cpp b/tests/unit_tests/cpu/core/detector.cpp
index 6c8849514..7800935eb 100644
--- a/tests/unit_tests/cpu/core/detector.cpp
+++ b/tests/unit_tests/cpu/core/detector.cpp
@@ -41,32 +41,33 @@ GTEST_TEST(detray_core, detector) {
         EXPECT_TRUE(d.volumes().empty());
         EXPECT_TRUE(d.portals().empty());
         EXPECT_TRUE(d.transform_store().empty());
-        EXPECT_TRUE(d.mask_store().template empty<mask_id::e_rectangle2>());
+        EXPECT_TRUE(d.mask_store().template empty<mask_id::e_rectangle2D>());
+        EXPECT_TRUE(d.mask_store().template empty<mask_id::e_trapezoid2D>());
+        EXPECT_TRUE(d.mask_store().template empty<mask_id::e_annulus2D>());
+        EXPECT_TRUE(d.mask_store().template empty<mask_id::e_cylinder2D>());
         EXPECT_TRUE(
-            d.mask_store().template empty<mask_id::e_portal_rectangle2>());
-        EXPECT_TRUE(d.mask_store().template empty<mask_id::e_trapezoid2>());
-        EXPECT_TRUE(d.mask_store().template empty<mask_id::e_annulus2>());
-        EXPECT_TRUE(d.mask_store().template empty<mask_id::e_cylinder2>());
-        EXPECT_TRUE(
-            d.mask_store().template empty<mask_id::e_portal_cylinder2>());
-        EXPECT_TRUE(d.mask_store().template empty<mask_id::e_ring2>());
-        EXPECT_TRUE(d.mask_store().template empty<mask_id::e_portal_ring2>());
+            d.mask_store().template empty<mask_id::e_concentric_cylinder2D>());
+        EXPECT_TRUE(d.mask_store().template empty<mask_id::e_ring2D>());
+        EXPECT_TRUE(d.mask_store().template empty<mask_id::e_ring2D>());
         EXPECT_TRUE(d.mask_store().template empty<mask_id::e_straw_tube>());
         EXPECT_TRUE(d.mask_store().template empty<mask_id::e_drift_cell>());
-        EXPECT_TRUE(d.material_store().template empty<material_id::e_slab>());
-        EXPECT_TRUE(d.material_store().template empty<material_id::e_rod>());
         EXPECT_TRUE(
-            d.accelerator_store().template empty<finder_id::e_brute_force>());
+            d.material_store().template empty<material_id::e_material_slab>());
         EXPECT_TRUE(
-            d.accelerator_store().template empty<finder_id::e_disc_grid>());
+            d.material_store().template empty<material_id::e_material_rod>());
+        EXPECT_TRUE(d.accelerator_store()
+                        .template empty<finder_id::e_surface_brute_force>());
         EXPECT_TRUE(d.accelerator_store()
-                        .template empty<finder_id::e_cylinder2_grid>());
+                        .template empty<finder_id::e_surface_ring2D_grid>());
         EXPECT_TRUE(
+            d.accelerator_store()
+                .template empty<finder_id::e_surface_cylinder2D_grid>());
+        /*EXPECT_TRUE(
             d.accelerator_store().template empty<finder_id::e_irr_disc_grid>());
         EXPECT_TRUE(d.accelerator_store()
-                        .template empty<finder_id::e_irr_cylinder2_grid>());
-        EXPECT_TRUE(
-            d.accelerator_store().template empty<finder_id::e_default>());
+                        .template empty<finder_id::e_irr_cylinder2_grid>());*/
+        EXPECT_TRUE(d.accelerator_store()
+                        .template empty<finder_id::e_surface_default>());
     };
 
     // Check the empty detector object.
@@ -81,36 +82,42 @@ GTEST_TEST(detray_core, detector) {
         EXPECT_EQ(d.volumes().size(), 1u);
         EXPECT_EQ(d.portals().size(), 3u);
         EXPECT_EQ(d.transform_store().size(), 4u);
-        EXPECT_EQ(d.mask_store().template size<mask_id::e_rectangle2>(), 1u);
-        EXPECT_EQ(d.mask_store().template size<mask_id::e_portal_rectangle2>(),
-                  1u);
-        EXPECT_EQ(d.mask_store().template size<mask_id::e_trapezoid2>(), 1u);
-        EXPECT_EQ(d.mask_store().template size<mask_id::e_annulus2>(), 1u);
-        EXPECT_EQ(d.mask_store().template size<mask_id::e_cylinder2>(), 0u);
-        EXPECT_EQ(d.mask_store().template size<mask_id::e_portal_cylinder2>(),
-                  0u);
-        EXPECT_EQ(d.mask_store().template size<mask_id::e_ring2>(), 0u);
-        EXPECT_EQ(d.mask_store().template size<mask_id::e_portal_ring2>(), 0u);
+        EXPECT_EQ(d.mask_store().template size<mask_id::e_rectangle2D>(), 1u);
+        EXPECT_EQ(d.mask_store().template size<mask_id::e_rectangle2D>(), 1u);
+        EXPECT_EQ(d.mask_store().template size<mask_id::e_trapezoid2D>(), 1u);
+        EXPECT_EQ(d.mask_store().template size<mask_id::e_annulus2D>(), 1u);
+        EXPECT_EQ(d.mask_store().template size<mask_id::e_cylinder2D>(), 0u);
+        EXPECT_EQ(
+            d.mask_store().template size<mask_id::e_concentric_cylinder2D>(),
+            0u);
+        EXPECT_EQ(d.mask_store().template size<mask_id::e_ring2D>(), 0u);
+        EXPECT_EQ(d.mask_store().template size<mask_id::e_ring2D>(), 0u);
         EXPECT_EQ(d.mask_store().template size<mask_id::e_straw_tube>(), 0u);
         EXPECT_EQ(d.mask_store().template size<mask_id::e_drift_cell>(), 0u);
-        EXPECT_EQ(d.material_store().template size<material_id::e_slab>(), 2u);
-        EXPECT_EQ(d.material_store().template size<material_id::e_rod>(), 1u);
         EXPECT_EQ(
-            d.accelerator_store().template size<finder_id::e_brute_force>(),
+            d.material_store().template size<material_id::e_material_slab>(),
+            2u);
+        EXPECT_EQ(
+            d.material_store().template size<material_id::e_material_rod>(),
             1u);
-        EXPECT_EQ(d.accelerator_store().template size<finder_id::e_disc_grid>(),
+        EXPECT_EQ(d.accelerator_store()
+                      .template size<finder_id::e_surface_brute_force>(),
+                  1u);
+        EXPECT_EQ(d.accelerator_store()
+                      .template size<finder_id::e_surface_ring2D_grid>(),
                   0u);
-        EXPECT_EQ(
-            d.accelerator_store().template size<finder_id::e_cylinder2_grid>(),
-            0u);
-        EXPECT_EQ(
+        EXPECT_EQ(d.accelerator_store()
+                      .template size<finder_id::e_surface_cylinder2D_grid>(),
+                  0u);
+        /*EXPECT_EQ(
             d.accelerator_store().template size<finder_id::e_irr_disc_grid>(),
             0u);
         EXPECT_EQ(d.accelerator_store()
                       .template size<finder_id::e_irr_cylinder2_grid>(),
-                  0u);
-        EXPECT_EQ(d.accelerator_store().template size<finder_id::e_default>(),
-                  1u);
+                  0u);*/
+        EXPECT_EQ(
+            d.accelerator_store().template size<finder_id::e_surface_default>(),
+            1u);
     };
 
     // Check the filled detector object.
diff --git a/tests/unit_tests/cpu/core/mask_store.cpp b/tests/unit_tests/cpu/core/mask_store.cpp
index cd9bfe90f..a4e580ef2 100644
--- a/tests/unit_tests/cpu/core/mask_store.cpp
+++ b/tests/unit_tests/cpu/core/mask_store.cpp
@@ -29,12 +29,12 @@ GTEST_TEST(detray_core, static_mask_store) {
     using test_algebra = test::algebra;
 
     enum class mask_ids : unsigned int {
-        e_rectangle2 = 0u,
-        e_trapezoid2 = 1u,
-        e_annulus2 = 2u,
-        e_cylinder3 = 3u,
-        e_ring2 = 4u,
-        e_single3 = 5u,
+        e_rectangle2D = 0u,
+        e_trapezoid2D = 1u,
+        e_annulus2D = 2u,
+        e_cylinder3D = 3u,
+        e_ring2D = 4u,
+        e_single3D = 5u,
     };
 
     using rectangle = mask<rectangle2D, test_algebra>;
@@ -51,52 +51,54 @@ GTEST_TEST(detray_core, static_mask_store) {
 
     mask_container_t store(host_mr);
 
-    ASSERT_TRUE(store.empty<mask_ids::e_annulus2>());
-    ASSERT_TRUE(store.empty<mask_ids::e_cylinder3>());
-    ASSERT_TRUE(store.empty<mask_ids::e_rectangle2>());
-    ASSERT_TRUE(store.empty<mask_ids::e_ring2>());
-    ASSERT_TRUE(store.empty<mask_ids::e_single3>());
-    ASSERT_TRUE(store.empty<mask_ids::e_trapezoid2>());
-
-    store.emplace_back<mask_ids::e_cylinder3>(empty_context{}, 0u, 1.f, 0.5f,
-                                              2.0f);
-
-    ASSERT_TRUE(store.empty<mask_ids::e_annulus2>());
-    ASSERT_EQ(store.size<mask_ids::e_cylinder3>(), 1);
-    ASSERT_TRUE(store.empty<mask_ids::e_rectangle2>());
-    ASSERT_TRUE(store.empty<mask_ids::e_ring2>());
-    ASSERT_TRUE(store.empty<mask_ids::e_single3>());
-    ASSERT_TRUE(store.empty<mask_ids::e_trapezoid2>());
-
-    store.emplace_back<mask_ids::e_cylinder3>(empty_context{}, 0u, 1.f, 1.5f,
-                                              2.0f);
-    store.emplace_back<mask_ids::e_trapezoid2>(empty_context{}, 0u, 0.5f, 1.5f,
-                                               4.0f, 1.f / 8.f);
-    store.emplace_back<mask_ids::e_rectangle2>(empty_context{}, 0u, 1.0f, 2.0f);
-    store.emplace_back<mask_ids::e_rectangle2>(empty_context{}, 0u, 2.0f, 1.0f);
-    store.emplace_back<mask_ids::e_rectangle2>(empty_context{}, 0u, 10.0f,
-                                               100.0f);
-
-    ASSERT_TRUE(store.empty<mask_ids::e_annulus2>());
-    ASSERT_EQ(store.size<mask_ids::e_cylinder3>(), 2);
-    ASSERT_EQ(store.size<mask_ids::e_rectangle2>(), 3);
-    ASSERT_TRUE(store.empty<mask_ids::e_ring2>());
-    ASSERT_TRUE(store.empty<mask_ids::e_single3>());
-    ASSERT_EQ(store.size<mask_ids::e_trapezoid2>(), 1);
-
-    store.emplace_back<mask_ids::e_annulus2>(empty_context{}, 0u, 1.f, 2.f, 3.f,
-                                             4.f, 5.f, 6.f, 7.f);
-    store.emplace_back<mask_ids::e_ring2>(empty_context{}, 0u, 10.f, 100.f);
-    store.emplace_back<mask_ids::e_ring2>(empty_context{}, 0u, 10.f, 100.f);
-    store.emplace_back<mask_ids::e_ring2>(empty_context{}, 0u, 10.f, 100.f);
-    store.emplace_back<mask_ids::e_ring2>(empty_context{}, 0u, 10.f, 100.f);
-
-    const auto &annulus_masks = store.get<mask_ids::e_annulus2>();
-    const auto &cylinder_masks = store.get<mask_ids::e_cylinder3>();
-    const auto &rectangle_masks = store.get<mask_ids::e_rectangle2>();
-    const auto &ring_masks = store.get<mask_ids::e_ring2>();
-    const auto &single_masks = store.get<mask_ids::e_single3>();
-    const auto &trapezoid_masks = store.get<mask_ids::e_trapezoid2>();
+    ASSERT_TRUE(store.empty<mask_ids::e_annulus2D>());
+    ASSERT_TRUE(store.empty<mask_ids::e_cylinder3D>());
+    ASSERT_TRUE(store.empty<mask_ids::e_rectangle2D>());
+    ASSERT_TRUE(store.empty<mask_ids::e_ring2D>());
+    ASSERT_TRUE(store.empty<mask_ids::e_single3D>());
+    ASSERT_TRUE(store.empty<mask_ids::e_trapezoid2D>());
+
+    store.emplace_back<mask_ids::e_cylinder3D>(empty_context{}, 0u, 1.f, 0.5f,
+                                               2.0f);
+
+    ASSERT_TRUE(store.empty<mask_ids::e_annulus2D>());
+    ASSERT_EQ(store.size<mask_ids::e_cylinder3D>(), 1);
+    ASSERT_TRUE(store.empty<mask_ids::e_rectangle2D>());
+    ASSERT_TRUE(store.empty<mask_ids::e_ring2D>());
+    ASSERT_TRUE(store.empty<mask_ids::e_single3D>());
+    ASSERT_TRUE(store.empty<mask_ids::e_trapezoid2D>());
+
+    store.emplace_back<mask_ids::e_cylinder3D>(empty_context{}, 0u, 1.f, 1.5f,
+                                               2.0f);
+    store.emplace_back<mask_ids::e_trapezoid2D>(empty_context{}, 0u, 0.5f, 1.5f,
+                                                4.0f, 1.f / 8.f);
+    store.emplace_back<mask_ids::e_rectangle2D>(empty_context{}, 0u, 1.0f,
+                                                2.0f);
+    store.emplace_back<mask_ids::e_rectangle2D>(empty_context{}, 0u, 2.0f,
+                                                1.0f);
+    store.emplace_back<mask_ids::e_rectangle2D>(empty_context{}, 0u, 10.0f,
+                                                100.0f);
+
+    ASSERT_TRUE(store.empty<mask_ids::e_annulus2D>());
+    ASSERT_EQ(store.size<mask_ids::e_cylinder3D>(), 2);
+    ASSERT_EQ(store.size<mask_ids::e_rectangle2D>(), 3);
+    ASSERT_TRUE(store.empty<mask_ids::e_ring2D>());
+    ASSERT_TRUE(store.empty<mask_ids::e_single3D>());
+    ASSERT_EQ(store.size<mask_ids::e_trapezoid2D>(), 1);
+
+    store.emplace_back<mask_ids::e_annulus2D>(empty_context{}, 0u, 1.f, 2.f,
+                                              3.f, 4.f, 5.f, 6.f, 7.f);
+    store.emplace_back<mask_ids::e_ring2D>(empty_context{}, 0u, 10.f, 100.f);
+    store.emplace_back<mask_ids::e_ring2D>(empty_context{}, 0u, 10.f, 100.f);
+    store.emplace_back<mask_ids::e_ring2D>(empty_context{}, 0u, 10.f, 100.f);
+    store.emplace_back<mask_ids::e_ring2D>(empty_context{}, 0u, 10.f, 100.f);
+
+    const auto &annulus_masks = store.get<mask_ids::e_annulus2D>();
+    const auto &cylinder_masks = store.get<mask_ids::e_cylinder3D>();
+    const auto &rectangle_masks = store.get<mask_ids::e_rectangle2D>();
+    const auto &ring_masks = store.get<mask_ids::e_ring2D>();
+    const auto &single_masks = store.get<mask_ids::e_single3D>();
+    const auto &trapezoid_masks = store.get<mask_ids::e_trapezoid2D>();
 
     ASSERT_TRUE(annulus_masks.size() == 1);
     ASSERT_TRUE(cylinder_masks.size() == 2);
diff --git a/tests/unit_tests/cpu/geometry/surface.cpp b/tests/unit_tests/cpu/geometry/surface.cpp
index 3d5905391..0dff1a587 100644
--- a/tests/unit_tests/cpu/geometry/surface.cpp
+++ b/tests/unit_tests/cpu/geometry/surface.cpp
@@ -36,11 +36,11 @@ std::ostream& operator<<(std::ostream& os, mask_ids /*mid*/) {
 
 /// Define material types
 enum class material_ids : unsigned int {
-    e_slab = 0u,
+    e_material_slab = 0u,
 };
 
 std::ostream& operator<<(std::ostream& os, material_ids /*mid*/) {
-    os << "e_slab";
+    os << "e_material_slab";
     return os;
 }
 
@@ -59,7 +59,7 @@ GTEST_TEST(detray_geometry, surface_descriptor) {
     using material_link_t = dtyped_index<material_ids, dindex>;
 
     mask_link_t mask_id{mask_ids::e_unmasked, 0u};
-    material_link_t material_id{material_ids::e_slab, 0u};
+    material_link_t material_id{material_ids::e_material_slab, 0u};
 
     surface_descriptor<mask_link_t, material_link_t> desc(
         1u, mask_id, material_id, 2u, surface_id::e_sensitive);
@@ -93,7 +93,7 @@ GTEST_TEST(detray_geometry, surface_descriptor) {
     ASSERT_FALSE(desc.is_sensitive());
     ASSERT_EQ(desc.mask().id(), mask_ids::e_unmasked);
     ASSERT_EQ(desc.mask().index(), 7u);
-    ASSERT_EQ(desc.material().id(), material_ids::e_slab);
+    ASSERT_EQ(desc.material().id(), material_ids::e_material_slab);
     ASSERT_EQ(desc.material().index(), 7u);
 }
 
@@ -130,7 +130,7 @@ GTEST_TEST(detray_geometry, surface_toy_detector) {
     ASSERT_EQ(disc.volume(), 0u);
     ASSERT_EQ(disc.index(), 1u);
     ASSERT_EQ(disc.id(), surface_id::e_portal);
-    ASSERT_EQ(disc.shape_id(), detector_t::masks::id::e_portal_ring2);
+    ASSERT_EQ(disc.shape_id(), detector_t::masks::id::e_ring2D);
     ASSERT_EQ(disc.shape_name(), "ring2D");
     ASSERT_FALSE(disc.is_sensitive());
     ASSERT_FALSE(disc.is_passive());
@@ -212,7 +212,7 @@ GTEST_TEST(detray_geometry, surface_toy_detector) {
     ASSERT_EQ(rec.volume(), 9u);
     ASSERT_EQ(rec.index(), 586u);
     ASSERT_EQ(rec.id(), surface_id::e_sensitive);
-    ASSERT_EQ(rec.shape_id(), detector_t::masks::id::e_rectangle2);
+    ASSERT_EQ(rec.shape_id(), detector_t::masks::id::e_rectangle2D);
     ASSERT_TRUE(rec.is_sensitive());
     ASSERT_FALSE(rec.is_passive());
     ASSERT_FALSE(rec.is_portal());
@@ -285,7 +285,7 @@ GTEST_TEST(detray_geometry, surface_toy_detector) {
     ASSERT_EQ(cyl.volume(), 0u);
     ASSERT_EQ(cyl.index(), 3u);
     ASSERT_EQ(cyl.id(), surface_id::e_portal);
-    ASSERT_EQ(cyl.shape_id(), detector_t::masks::id::e_portal_cylinder2);
+    ASSERT_EQ(cyl.shape_id(), detector_t::masks::id::e_concentric_cylinder2D);
     ASSERT_FALSE(cyl.is_sensitive());
     ASSERT_FALSE(cyl.is_passive());
     ASSERT_TRUE(cyl.is_portal());
diff --git a/tests/unit_tests/cpu/geometry/tracking_volume.cpp b/tests/unit_tests/cpu/geometry/tracking_volume.cpp
index 22939a97c..ee684f32e 100644
--- a/tests/unit_tests/cpu/geometry/tracking_volume.cpp
+++ b/tests/unit_tests/cpu/geometry/tracking_volume.cpp
@@ -32,7 +32,7 @@ enum geo_objects : unsigned int {
 
 // surface finder ids for testing
 enum class accel_ids : unsigned int {
-    e_default = 0u,
+    e_surface_default = 0u,
     e_grid = 1u,
 };
 
@@ -49,14 +49,14 @@ GTEST_TEST(detray_geometry, volume_descriptor) {
     volume_t v1(volume_id::e_cylinder);
     v1.set_index(12345u);
     v1.template set_accel_link<geo_objects::e_portal>(
-        {accel_ids::e_default, 1u});
+        {accel_ids::e_surface_default, 1u});
     v1.template set_accel_link<geo_objects::e_sensitive>(
         {accel_ids::e_grid, 12u});
 
     ASSERT_TRUE(v1.id() == volume_id::e_cylinder);
     ASSERT_TRUE(v1.index() == 12345u);
     ASSERT_TRUE(v1.template accel_link<geo_objects::e_portal>().id() ==
-                accel_ids::e_default);
+                accel_ids::e_surface_default);
     ASSERT_TRUE(v1.template accel_link<geo_objects::e_portal>().index() == 1u);
     ASSERT_TRUE(v1.template accel_link<geo_objects::e_sensitive>().id() ==
                 accel_ids::e_grid);
@@ -68,7 +68,7 @@ GTEST_TEST(detray_geometry, volume_descriptor) {
     ASSERT_EQ(v2.id(), volume_id::e_cylinder);
     ASSERT_EQ(v2.index(), 12345u);
     ASSERT_TRUE(v2.template accel_link<geo_objects::e_portal>().id() ==
-                accel_ids::e_default);
+                accel_ids::e_surface_default);
     ASSERT_TRUE(v2.template accel_link<geo_objects::e_portal>().index() == 1u);
     ASSERT_TRUE(v2.template accel_link<geo_objects::e_sensitive>().id() ==
                 accel_ids::e_grid);
diff --git a/tests/unit_tests/cpu/navigation/intersection/intersection2D.cpp b/tests/unit_tests/cpu/navigation/intersection/intersection2D.cpp
index dbd34d5fe..6a7108932 100644
--- a/tests/unit_tests/cpu/navigation/intersection/intersection2D.cpp
+++ b/tests/unit_tests/cpu/navigation/intersection/intersection2D.cpp
@@ -33,7 +33,7 @@ enum class mask_ids : unsigned int {
 
 /// Define material types
 enum class material_ids : unsigned int {
-    e_slab = 0u,
+    e_material_slab = 0u,
 };
 
 constexpr scalar tol{std::numeric_limits<scalar>::epsilon()};
diff --git a/tests/unit_tests/cpu/navigation/intersection/intersection_kernel.cpp b/tests/unit_tests/cpu/navigation/intersection/intersection_kernel.cpp
index e16e58cf8..b4352aa3b 100644
--- a/tests/unit_tests/cpu/navigation/intersection/intersection_kernel.cpp
+++ b/tests/unit_tests/cpu/navigation/intersection/intersection_kernel.cpp
@@ -47,15 +47,15 @@ intersection::config intr_cfg{.min_mask_tolerance = 1e-3f * unit<float>::mm,
                               .overstep_tolerance = 0.f};
 
 enum class mask_ids : unsigned int {
-    e_rectangle2 = 0u,
-    e_trapezoid2 = 1u,
-    e_annulus2 = 2u,
-    e_cylinder2 = 3u,
-    e_cylinder2_portal = 4u,
+    e_rectangle2D = 0u,
+    e_trapezoid2D = 1u,
+    e_annulus2D = 2u,
+    e_cylinder2D = 3u,
+    e_concentric_cylinder2D = 4u,
 };
 
 enum class material_ids : unsigned int {
-    e_slab = 0u,
+    e_material_slab = 0u,
 };
 
 }  // anonymous namespace
@@ -117,35 +117,35 @@ GTEST_TEST(detray_intersection, intersection_kernel_ray) {
     const cylinder_t cyl{0u, 5.f, -10.f, 10.f};
     const cylinder_portal_t cyl_portal{0u, 1.f, 0.f, 1000.f};
 
-    mask_store.template push_back<mask_ids::e_rectangle2>(rect,
-                                                          empty_context{});
-    mask_store.template push_back<mask_ids::e_rectangle2>(rect,
-                                                          empty_context{});
-    mask_store.template push_back<mask_ids::e_trapezoid2>(trap,
-                                                          empty_context{});
-    mask_store.template push_back<mask_ids::e_annulus2>(annl, empty_context{});
-    mask_store.template push_back<mask_ids::e_cylinder2>(cyl, empty_context{});
-    mask_store.template push_back<mask_ids::e_cylinder2_portal>(
+    mask_store.template push_back<mask_ids::e_rectangle2D>(rect,
+                                                           empty_context{});
+    mask_store.template push_back<mask_ids::e_rectangle2D>(rect,
+                                                           empty_context{});
+    mask_store.template push_back<mask_ids::e_trapezoid2D>(trap,
+                                                           empty_context{});
+    mask_store.template push_back<mask_ids::e_annulus2D>(annl, empty_context{});
+    mask_store.template push_back<mask_ids::e_cylinder2D>(cyl, empty_context{});
+    mask_store.template push_back<mask_ids::e_concentric_cylinder2D>(
         cyl_portal, empty_context{});
 
     // The surfaces and their store
-    surface_t rectangle_surface(0u, {mask_ids::e_rectangle2, 0u},
-                                {material_ids::e_slab, 0u}, 0u,
+    surface_t rectangle_surface(0u, {mask_ids::e_rectangle2D, 0u},
+                                {material_ids::e_material_slab, 0u}, 0u,
                                 surface_id::e_sensitive);
-    surface_t trapezoid_surface(1u, {mask_ids::e_trapezoid2, 0u},
-                                {material_ids::e_slab, 1u}, 0u,
+    surface_t trapezoid_surface(1u, {mask_ids::e_trapezoid2D, 0u},
+                                {material_ids::e_material_slab, 1u}, 0u,
                                 surface_id::e_sensitive);
-    surface_t annulus_surface(2u, {mask_ids::e_annulus2, 0u},
-                              {material_ids::e_slab, 2u}, 0u,
+    surface_t annulus_surface(2u, {mask_ids::e_annulus2D, 0u},
+                              {material_ids::e_material_slab, 2u}, 0u,
                               surface_id::e_sensitive);
-    surface_t cyl_surface(3u, {mask_ids::e_cylinder2, 0u},
-                          {material_ids::e_slab, 2u}, 0u,
+    surface_t cyl_surface(3u, {mask_ids::e_cylinder2D, 0u},
+                          {material_ids::e_material_slab, 2u}, 0u,
                           surface_id::e_passive);
-    surface_t cyl_portal_surface(4u, {mask_ids::e_cylinder2_portal, 0u},
-                                 {material_ids::e_slab, 2u}, 0u,
+    surface_t cyl_portal_surface(4u, {mask_ids::e_concentric_cylinder2D, 0u},
+                                 {material_ids::e_material_slab, 2u}, 0u,
                                  surface_id::e_portal);
-    surface_t rectangle_shifted_surface(5u, {mask_ids::e_rectangle2, 1u},
-                                        {material_ids::e_slab, 0u}, 0u,
+    surface_t rectangle_shifted_surface(5u, {mask_ids::e_rectangle2D, 1u},
+                                        {material_ids::e_material_slab, 0u}, 0u,
                                         surface_id::e_sensitive);
     // Easier test debugging
     rectangle_surface.set_index(0u);
@@ -201,19 +201,19 @@ GTEST_TEST(detray_intersection, intersection_kernel_ray) {
         vector3 global{0.f, 0.f, 0.f};
 
         const surface_t sf_desc = sfi_init[i].sf_desc;
-        if (sf_desc.mask().id() == mask_ids::e_rectangle2) {
+        if (sf_desc.mask().id() == mask_ids::e_rectangle2D) {
             global = rect.to_global_frame(
                 transform_store.at(sf_desc.transform()), sfi_init[i].local());
-        } else if (sf_desc.mask().id() == mask_ids::e_trapezoid2) {
+        } else if (sf_desc.mask().id() == mask_ids::e_trapezoid2D) {
             global = trap.to_global_frame(
                 transform_store.at(sf_desc.transform()), sfi_init[i].local());
-        } else if (sf_desc.mask().id() == mask_ids::e_annulus2) {
+        } else if (sf_desc.mask().id() == mask_ids::e_annulus2D) {
             global = annl.to_global_frame(
                 transform_store.at(sf_desc.transform()), sfi_init[i].local());
-        } else if (sf_desc.mask().id() == mask_ids::e_cylinder2) {
+        } else if (sf_desc.mask().id() == mask_ids::e_cylinder2D) {
             global = cyl.to_global_frame(
                 transform_store.at(sf_desc.transform()), sfi_init[i].local());
-        } else if (sf_desc.mask().id() == mask_ids::e_cylinder2_portal) {
+        } else if (sf_desc.mask().id() == mask_ids::e_concentric_cylinder2D) {
             global = cyl_portal.to_global_frame(
                 transform_store.at(sf_desc.transform()), sfi_init[i].local());
         }
@@ -281,21 +281,21 @@ GTEST_TEST(detray_intersection, intersection_kernel_helix) {
     const rectangle_t rect{0u, 10.f, 10.f};
     const trapezoid_t trap{0u, 10.f, 20.f, 30.f, 1.f / 60.f};
     const annulus_t annl{0u, 15.f, 55.f, 0.75f, 1.95f, 0.f, 2.f, -2.f};
-    mask_store.template push_back<mask_ids::e_rectangle2>(rect,
-                                                          empty_context{});
-    mask_store.template push_back<mask_ids::e_trapezoid2>(trap,
-                                                          empty_context{});
-    mask_store.template push_back<mask_ids::e_annulus2>(annl, empty_context{});
+    mask_store.template push_back<mask_ids::e_rectangle2D>(rect,
+                                                           empty_context{});
+    mask_store.template push_back<mask_ids::e_trapezoid2D>(trap,
+                                                           empty_context{});
+    mask_store.template push_back<mask_ids::e_annulus2D>(annl, empty_context{});
 
     // The surfaces and their store
-    const surface_t rectangle_surface(0u, {mask_ids::e_rectangle2, 0u},
-                                      {material_ids::e_slab, 0u}, 0u,
+    const surface_t rectangle_surface(0u, {mask_ids::e_rectangle2D, 0u},
+                                      {material_ids::e_material_slab, 0u}, 0u,
                                       surface_id::e_sensitive);
-    const surface_t trapezoid_surface(1u, {mask_ids::e_trapezoid2, 0u},
-                                      {material_ids::e_slab, 1u}, 0u,
+    const surface_t trapezoid_surface(1u, {mask_ids::e_trapezoid2D, 0u},
+                                      {material_ids::e_material_slab, 1u}, 0u,
                                       surface_id::e_sensitive);
-    const surface_t annulus_surface(2u, {mask_ids::e_annulus2, 0u},
-                                    {material_ids::e_slab, 2u}, 0u,
+    const surface_t annulus_surface(2u, {mask_ids::e_annulus2D, 0u},
+                                    {material_ids::e_material_slab, 2u}, 0u,
                                     surface_id::e_sensitive);
     surface_container_t surfaces = {rectangle_surface, trapezoid_surface,
                                     annulus_surface};
@@ -324,13 +324,13 @@ GTEST_TEST(detray_intersection, intersection_kernel_helix) {
 
         vector3 global{0.f, 0.f, 0.f};
 
-        if (surface.mask().id() == mask_ids::e_rectangle2) {
+        if (surface.mask().id() == mask_ids::e_rectangle2D) {
             global = rect.to_global_frame(transform_store.at(0),
                                           sfi_helix[0].local());
-        } else if (surface.mask().id() == mask_ids::e_trapezoid2) {
+        } else if (surface.mask().id() == mask_ids::e_trapezoid2D) {
             global = trap.to_global_frame(transform_store.at(1),
                                           sfi_helix[0].local());
-        } else if (surface.mask().id() == mask_ids::e_annulus2) {
+        } else if (surface.mask().id() == mask_ids::e_annulus2D) {
             global = annl.to_global_frame(transform_store.at(2),
                                           sfi_helix[0].local());
         }
diff --git a/tests/unit_tests/device/cuda/detector_cuda_kernel.cu b/tests/unit_tests/device/cuda/detector_cuda_kernel.cu
index 18b8122a8..2aed812a5 100644
--- a/tests/unit_tests/device/cuda/detector_cuda_kernel.cu
+++ b/tests/unit_tests/device/cuda/detector_cuda_kernel.cu
@@ -54,19 +54,18 @@ __global__ void detector_test_kernel(
     // copy objects - masks
     auto& masks = det_device.mask_store();
     auto& rectangles =
-        masks.template get<detector_host_t::masks::id::e_rectangle2>();
+        masks.template get<detector_host_t::masks::id::e_rectangle2D>();
     for (unsigned int i = 0u; i < rectangles.size(); i++) {
         rectangles_device[i] = rectangles[i];
     }
 
-    auto& discs =
-        masks.template get<detector_host_t::masks::id::e_portal_ring2>();
+    auto& discs = masks.template get<detector_host_t::masks::id::e_ring2D>();
     for (unsigned int i = 0u; i < discs.size(); i++) {
         discs_device[i] = discs[i];
     }
 
-    auto& cylinders =
-        masks.template get<detector_host_t::masks::id::e_portal_cylinder2>();
+    auto& cylinders = masks.template get<
+        detector_host_t::masks::id::e_concentric_cylinder2D>();
     for (unsigned int i = 0u; i < cylinders.size(); i++) {
         cylinders_device[i] = cylinders[i];
     }
diff --git a/tests/unit_tests/device/cuda/detector_cuda_kernel.hpp b/tests/unit_tests/device/cuda/detector_cuda_kernel.hpp
index 339e97af7..ab6dcf6b8 100644
--- a/tests/unit_tests/device/cuda/detector_cuda_kernel.hpp
+++ b/tests/unit_tests/device/cuda/detector_cuda_kernel.hpp
@@ -27,9 +27,9 @@ using det_surface_t = typename detector_host_t::surface_type;
 using transform_t = typename detector_host_t::transform3_type;
 using mask_defs = typename detector_host_t::masks;
 
-constexpr auto rectangle_id = mask_defs::id::e_rectangle2;
-constexpr auto disc_id = mask_defs::id::e_portal_ring2;
-constexpr auto cylinder_id = mask_defs::id::e_portal_cylinder2;
+constexpr auto rectangle_id = mask_defs::id::e_rectangle2D;
+constexpr auto disc_id = mask_defs::id::e_ring2D;
+constexpr auto cylinder_id = mask_defs::id::e_concentric_cylinder2D;
 
 using rectangle_t = types::get<mask_defs, rectangle_id>;
 using disc_t = types::get<mask_defs, disc_id>;
diff --git a/tests/unit_tests/device/cuda/mask_store_cuda.cpp b/tests/unit_tests/device/cuda/mask_store_cuda.cpp
index 92117e393..5833d041a 100644
--- a/tests/unit_tests/device/cuda/mask_store_cuda.cpp
+++ b/tests/unit_tests/device/cuda/mask_store_cuda.cpp
@@ -29,30 +29,30 @@ TEST(mask_store_cuda, mask_store) {
     // Types must be sorted according to their id (here: masks/mask_identifier)
     host_store_type store(mng_mr);
 
-    ASSERT_TRUE(store.template empty<mask_ids::e_annulus2>());
-    ASSERT_TRUE(store.template empty<mask_ids::e_cylinder2>());
-    ASSERT_TRUE(store.template empty<mask_ids::e_rectangle2>());
-    ASSERT_TRUE(store.template empty<mask_ids::e_ring2>());
-    ASSERT_TRUE(store.template empty<mask_ids::e_single3>());
-    ASSERT_TRUE(store.template empty<mask_ids::e_trapezoid2>());
-
-    store.template emplace_back<mask_ids::e_rectangle2>(empty_context{}, 0u,
-                                                        1.0f, 2.0f);
-    store.template emplace_back<mask_ids::e_trapezoid2>(
+    ASSERT_TRUE(store.template empty<mask_ids::e_annulus2D>());
+    ASSERT_TRUE(store.template empty<mask_ids::e_cylinder2D>());
+    ASSERT_TRUE(store.template empty<mask_ids::e_rectangle2D>());
+    ASSERT_TRUE(store.template empty<mask_ids::e_ring2D>());
+    ASSERT_TRUE(store.template empty<mask_ids::e_single3D>());
+    ASSERT_TRUE(store.template empty<mask_ids::e_trapezoid2D>());
+
+    store.template emplace_back<mask_ids::e_rectangle2D>(empty_context{}, 0u,
+                                                         1.0f, 2.0f);
+    store.template emplace_back<mask_ids::e_trapezoid2D>(
         empty_context{}, 0u, 0.5f, 1.5f, 4.0f, 1.f / 8.f);
-    store.template emplace_back<mask_ids::e_ring2>(empty_context{}, 0u, 1.0f,
-                                                   10.0f);
-    store.template emplace_back<mask_ids::e_cylinder2>(empty_context{}, 0u, 1.f,
-                                                       0.5f, 2.0f);
-    store.template emplace_back<mask_ids::e_annulus2>(
+    store.template emplace_back<mask_ids::e_ring2D>(empty_context{}, 0u, 1.0f,
+                                                    10.0f);
+    store.template emplace_back<mask_ids::e_cylinder2D>(empty_context{}, 0u,
+                                                        1.f, 0.5f, 2.0f);
+    store.template emplace_back<mask_ids::e_annulus2D>(
         empty_context{}, 0u, 1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f);
 
-    ASSERT_FALSE(store.empty<mask_ids::e_annulus2>());
-    ASSERT_FALSE(store.empty<mask_ids::e_cylinder2>());
-    ASSERT_FALSE(store.empty<mask_ids::e_rectangle2>());
-    ASSERT_FALSE(store.empty<mask_ids::e_ring2>());
-    ASSERT_TRUE(store.empty<mask_ids::e_single3>());
-    ASSERT_FALSE(store.empty<mask_ids::e_trapezoid2>());
+    ASSERT_FALSE(store.empty<mask_ids::e_annulus2D>());
+    ASSERT_FALSE(store.empty<mask_ids::e_cylinder2D>());
+    ASSERT_FALSE(store.empty<mask_ids::e_rectangle2D>());
+    ASSERT_FALSE(store.empty<mask_ids::e_ring2D>());
+    ASSERT_TRUE(store.empty<mask_ids::e_single3D>());
+    ASSERT_FALSE(store.empty<mask_ids::e_trapezoid2D>());
 
     // Generate random points for test
     vecmem::vector<point3> input_point3(n_points, &mng_mr);
@@ -69,11 +69,11 @@ TEST(mask_store_cuda, mask_store) {
     vecmem::jagged_vector<int> output_host(5, &mng_mr);
 
     // get mask objects
-    const auto& rectangle_mask = store.get<mask_ids::e_rectangle2>()[0];
-    const auto& trapezoid_mask = store.get<mask_ids::e_trapezoid2>()[0];
-    const auto& ring_mask = store.get<mask_ids::e_ring2>()[0];
-    const auto& cylinder_mask = store.get<mask_ids::e_cylinder2>()[0];
-    const auto& annulus_mask = store.get<mask_ids::e_annulus2>()[0];
+    const auto& rectangle_mask = store.get<mask_ids::e_rectangle2D>()[0];
+    const auto& trapezoid_mask = store.get<mask_ids::e_trapezoid2D>()[0];
+    const auto& ring_mask = store.get<mask_ids::e_ring2D>()[0];
+    const auto& cylinder_mask = store.get<mask_ids::e_cylinder2D>()[0];
+    const auto& annulus_mask = store.get<mask_ids::e_annulus2D>()[0];
 
     // get host results from is_inside function
     for (unsigned int i = 0u; i < n_points; i++) {
diff --git a/tests/unit_tests/device/cuda/mask_store_cuda_kernel.cu b/tests/unit_tests/device/cuda/mask_store_cuda_kernel.cu
index fcdb1fb1b..b0509fcae 100644
--- a/tests/unit_tests/device/cuda/mask_store_cuda_kernel.cu
+++ b/tests/unit_tests/device/cuda/mask_store_cuda_kernel.cu
@@ -26,11 +26,11 @@ __global__ void mask_test_kernel(
     vecmem::device_vector<point3> input_point3(input_point3_data);
     vecmem::jagged_device_vector<int> output_device(output_data);
 
-    const auto& rectangle_mask = store.get<mask_ids::e_rectangle2>()[0];
-    const auto& trapezoid_mask = store.get<mask_ids::e_trapezoid2>()[0];
-    const auto& ring_mask = store.get<mask_ids::e_ring2>()[0];
-    const auto& cylinder_mask = store.get<mask_ids::e_cylinder2>()[0];
-    const auto& annulus_mask = store.get<mask_ids::e_annulus2>()[0];
+    const auto& rectangle_mask = store.get<mask_ids::e_rectangle2D>()[0];
+    const auto& trapezoid_mask = store.get<mask_ids::e_trapezoid2D>()[0];
+    const auto& ring_mask = store.get<mask_ids::e_ring2D>()[0];
+    const auto& cylinder_mask = store.get<mask_ids::e_cylinder2D>()[0];
+    const auto& annulus_mask = store.get<mask_ids::e_annulus2D>()[0];
 
     // get device results from is_inside function
     for (int i = 0; i < n_points; i++) {
diff --git a/tests/unit_tests/device/cuda/mask_store_cuda_kernel.hpp b/tests/unit_tests/device/cuda/mask_store_cuda_kernel.hpp
index e00957df4..bcf2ee9f5 100644
--- a/tests/unit_tests/device/cuda/mask_store_cuda_kernel.hpp
+++ b/tests/unit_tests/device/cuda/mask_store_cuda_kernel.hpp
@@ -38,12 +38,12 @@ using trapezoid = mask<trapezoid2D, test_algebra>;
 
 /// Enumerate different mask types for convenience
 enum class mask_ids : unsigned int {
-    e_rectangle2 = 0u,
-    e_trapezoid2 = 1u,
-    e_ring2 = 2u,
-    e_cylinder2 = 3u,
-    e_single3 = 4u,
-    e_annulus2 = 5u,
+    e_rectangle2D = 0u,
+    e_trapezoid2D = 1u,
+    e_ring2D = 2u,
+    e_cylinder2D = 3u,
+    e_single3D = 4u,
+    e_annulus2D = 5u,
 };
 
 using host_store_type =
diff --git a/tests/unit_tests/device/hip/detector_hip_kernel.hip b/tests/unit_tests/device/hip/detector_hip_kernel.hip
index e2fa0466d..540e1f0d2 100644
--- a/tests/unit_tests/device/hip/detector_hip_kernel.hip
+++ b/tests/unit_tests/device/hip/detector_hip_kernel.hip
@@ -54,19 +54,18 @@ __global__ void detector_test_kernel(
     // copy objects - masks
     auto& masks = det_device.mask_store();
     auto& rectangles =
-        masks.template get<detector_host_t::masks::id::e_rectangle2>();
+        masks.template get<detector_host_t::masks::id::e_rectangle2D>();
     for (unsigned int i = 0u; i < rectangles.size(); i++) {
         rectangles_device[i] = rectangles[i];
     }
 
-    auto& discs =
-        masks.template get<detector_host_t::masks::id::e_portal_ring2>();
+    auto& discs = masks.template get<detector_host_t::masks::id::e_ring2D>();
     for (unsigned int i = 0u; i < discs.size(); i++) {
         discs_device[i] = discs[i];
     }
 
-    auto& cylinders =
-        masks.template get<detector_host_t::masks::id::e_portal_cylinder2>();
+    auto& cylinders = masks.template get<
+        detector_host_t::masks::id::e_concentric_cylinder2D>();
     for (unsigned int i = 0u; i < cylinders.size(); i++) {
         cylinders_device[i] = cylinders[i];
     }
diff --git a/tests/unit_tests/device/hip/detector_hip_kernel.hpp b/tests/unit_tests/device/hip/detector_hip_kernel.hpp
index 756d3eb23..000126892 100644
--- a/tests/unit_tests/device/hip/detector_hip_kernel.hpp
+++ b/tests/unit_tests/device/hip/detector_hip_kernel.hpp
@@ -27,9 +27,9 @@ using det_surface_t = typename detector_host_t::surface_type;
 using transform_t = typename detector_host_t::transform3_type;
 using mask_defs = typename detector_host_t::masks;
 
-constexpr auto rectangle_id = mask_defs::id::e_rectangle2;
-constexpr auto disc_id = mask_defs::id::e_portal_ring2;
-constexpr auto cylinder_id = mask_defs::id::e_portal_cylinder2;
+constexpr auto rectangle_id = mask_defs::id::e_rectangle2D;
+constexpr auto disc_id = mask_defs::id::e_ring2D;
+constexpr auto cylinder_id = mask_defs::id::e_concentric_cylinder2D;
 
 using rectangle_t = types::get<mask_defs, rectangle_id>;
 using disc_t = types::get<mask_defs, disc_id>;
diff --git a/tutorials/include/detray/tutorial/detector_metadata.hpp b/tutorials/include/detray/tutorial/detector_metadata.hpp
index d1bb79e3b..b472761b1 100644
--- a/tutorials/include/detray/tutorial/detector_metadata.hpp
+++ b/tutorials/include/detray/tutorial/detector_metadata.hpp
@@ -70,21 +70,21 @@ struct my_metadata {
     /// order to minimize the depth of the 'unrolling' before a mask is found
     /// in the tuple
     enum class mask_ids : std::uint_least8_t {
-        e_square2 = 0u,
-        e_trapezoid2 = 1u,
-        e_portal_rectangle2 = 2u
+        e_square2D = 0u,
+        e_trapezoid2D = 1u,
+        e_rectangle2D = 2u
     };
 
     friend std::ostream& operator<<(std::ostream& os, const mask_ids& id) {
         switch (id) {
-            case mask_ids::e_square2:
-                os << "e_square2";
+            case mask_ids::e_square2D:
+                os << "e_square2D";
                 break;
-            case mask_ids::e_trapezoid2:
-                os << "e_trapezoid2";
+            case mask_ids::e_trapezoid2D:
+                os << "e_trapezoid2D";
                 break;
-            case mask_ids::e_portal_rectangle2:
-                os << "e_portal_rectangle2";
+            case mask_ids::e_rectangle2D:
+                os << "e_rectangle2D";
                 break;
             default:
                 os << "Unknown mask_id";
@@ -111,14 +111,14 @@ struct my_metadata {
 
     /// Similar to the mask store, there is a material store, which
     enum class material_ids : std::uint_least8_t {
-        e_slab = 0u,
+        e_material_slab = 0u,
         e_none = 1u,
     };
 
     friend std::ostream& operator<<(std::ostream& os, const material_ids& id) {
         switch (id) {
-            case material_ids::e_slab:
-                os << "e_slab";
+            case material_ids::e_material_slab:
+                os << "e_material_slab";
                 break;
             case material_ids::e_none:
                 os << "e_none";
@@ -185,16 +185,17 @@ struct my_metadata {
     /// The acceleration data structures live in another tuple that needs to
     /// indexed correctly
     enum class accel_ids : std::uint_least8_t {
-        e_brute_force = 0u,  //< test all surfaces in a volume (brute force)
-        e_volume_cylinder3_grid = 1u,
-        e_default = e_brute_force,
-        e_default_volume_searcher = e_volume_cylinder3_grid,
+        e_surface_brute_force =
+            0u,  //< test all surfaces in a volume (brute force)
+        e_volume_cylinder3D_grid = 1u,
+        e_surface_default = e_surface_brute_force,
+        e_volume_default = e_volume_cylinder3D_grid,
     };
 
     friend std::ostream& operator<<(std::ostream& os, const accel_ids& id) {
         switch (id) {
-            case accel_ids::e_brute_force:
-                os << "e_brute_force/e_default";
+            case accel_ids::e_surface_brute_force:
+                os << "e_surface_brute_force/e_surface_default";
                 break;
             default:
                 os << "Unknown accel_id";
@@ -268,7 +269,7 @@ struct mask_info<io::shape_id::square2, detector_t>
     // This mask id is defined in the metadat down below and determines the
     // position of the collection of square in the detector mask tuple (store)
     static constexpr
-        typename detector_t::masks::id value{detector_t::masks::id::e_square2};
+        typename detector_t::masks::id value{detector_t::masks::id::e_square2D};
 };*/
 
 }  // namespace detail
diff --git a/tutorials/include/detray/tutorial/square_surface_generator.hpp b/tutorials/include/detray/tutorial/square_surface_generator.hpp
index 95099e542..d7b25be7d 100644
--- a/tutorials/include/detray/tutorial/square_surface_generator.hpp
+++ b/tutorials/include/detray/tutorial/square_surface_generator.hpp
@@ -71,7 +71,7 @@ class square_surface_generator final
         using material_link_t = typename surface_t::material_link;
 
         // Position in the detector mask tuple for square surface masks
-        constexpr auto mask_id{detector_t::masks::id::e_square2};
+        constexpr auto mask_id{detector_t::masks::id::e_square2D};
         // The material will be added in a later step
         constexpr auto no_material = surface_t::material_id::e_none;
         // In case the surfaces container is prefilled with other surfaces
diff --git a/tutorials/src/device/cuda/detector_construction.cu b/tutorials/src/device/cuda/detector_construction.cu
index 789cce04f..b1fbdda4c 100644
--- a/tutorials/src/device/cuda/detector_construction.cu
+++ b/tutorials/src/device/cuda/detector_construction.cu
@@ -32,23 +32,24 @@ __global__ void print_kernel(
                        det.transform_store().at(0).translation()[1],
                        det.transform_store().at(0).translation()[2]);
     DETRAY_INFO_DEVICE("Number of rectangles: %d",
-                       det.mask_store().get<mask_id::e_rectangle2>().size());
+                       det.mask_store().get<mask_id::e_rectangle2D>().size());
     DETRAY_INFO_DEVICE("Number of trapezoids: %d",
-                       det.mask_store().get<mask_id::e_trapezoid2>().size());
+                       det.mask_store().get<mask_id::e_trapezoid2D>().size());
     DETRAY_INFO_DEVICE("Number of portal discs: %d",
-                       det.mask_store().get<mask_id::e_portal_ring2>().size());
+                       det.mask_store().get<mask_id::e_ring2D>().size());
     DETRAY_INFO_DEVICE(
         "Number of portal cylinders: %d",
-        det.mask_store().get<mask_id::e_portal_cylinder2>().size());
+        det.mask_store().get<mask_id::e_concentric_cylinder2D>().size());
     DETRAY_INFO_DEVICE(
         "Number of portal collections: %d",
-        det.accelerator_store().get<acc_id::e_brute_force>().size());
+        det.accelerator_store().get<acc_id::e_surface_brute_force>().size());
     DETRAY_INFO_DEVICE(
         "Number of disc grids: %d",
-        det.accelerator_store().get<acc_id::e_disc_grid>().size());
-    DETRAY_INFO_DEVICE(
-        "Number of cylinder grids: %d",
-        det.accelerator_store().get<acc_id::e_cylinder2_grid>().size());
+        det.accelerator_store().get<acc_id::e_surface_ring2D_grid>().size());
+    DETRAY_INFO_DEVICE("Number of cylinder grids: %d",
+                       det.accelerator_store()
+                           .get<acc_id::e_surface_cylinder2D_grid>()
+                           .size());
 }
 
 void print(typename detray::tutorial::detector_host_t::view_type det_data) {