diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9dc1dccfa..4e05e2fe4 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -45,6 +45,8 @@ set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY
     "Directory for the built static libraries"
 )
 
+set(DETRAY_PYTHON_INSTALL_DIR "python/detray")
+
 # Include the Detray CMake code.
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 include(detray-functions)
@@ -67,6 +69,11 @@ set_property(
     PROPERTY STRINGS "NONE" "WARNING" "INFO" "VERBOSE" "DEBUG"
 )
 option(DETRAY_BUILD_CLI_TOOLS "Build the command line tools of Detray" OFF)
+option(
+    DETRAY_BUILD_PYTHON_BINDINGS
+    "Build python bindings for all enabled components"
+    OFF
+)
 
 # Device compilation
 
@@ -83,7 +90,6 @@ option(DETRAY_BUILD_SYCL "Build the SYCL sources included in detray" OFF)
 
 # Check if HIP is available
 option(DETRAY_BUILD_HIP "Build the HIP sources included in detray" OFF)
-
 cmake_dependent_option(
     DETRAY_BUILD_HOST
     "Build the host sources included in detray"
@@ -132,7 +138,23 @@ elseif(DETRAY_SET_LOGGING STREQUAL "DEBUG")
     set(DETRAY_LOG_LVL 3 CACHE INTERNAL "Print expert information" FORCE)
 endif()
 
-# Need test utils for the example detector generation
+#
+# Resolve build options and option dependencies
+#
+
+# Set the internal log level from user input
+set(DETRAY_LOG_LVL -1 CACHE INTERNAL "Disable logging")
+if(DETRAY_SET_LOGGING STREQUAL "WARN")
+    set(DETRAY_LOG_LVL 0 CACHE INTERNAL "Print warnings and errors" FORCE)
+elseif(DETRAY_SET_LOGGING STREQUAL "INFO")
+    set(DETRAY_LOG_LVL 1 CACHE INTERNAL "Print general information" FORCE)
+elseif(DETRAY_SET_LOGGING STREQUAL "VERBOSE")
+    set(DETRAY_LOG_LVL 2 CACHE INTERNAL "Print detailed information" FORCE)
+elseif(DETRAY_SET_LOGGING STREQUAL "DEBUG")
+    set(DETRAY_LOG_LVL 3 CACHE INTERNAL "Print expert information" FORCE)
+endif()
+
+# Need test utils in CLI tools for the example detector generation
 if(DETRAY_BUILD_CLI_TOOLS)
     set(DETRAY_BUILD_TEST_UTILS ON)
 endif()
@@ -145,12 +167,9 @@ if(${DETRAY_BUILD_CUDA} AND ${CMAKE_CUDA_STANDARD} LESS 20)
     )
 endif()
 
-if(${DETRAY_BUILD_SYCL} AND ${CMAKE_SYCL_STANDARD} LESS 20)
-    message(
-        SEND_ERROR
-        "CMAKE_SYCL_STANDARD=${CMAKE_SYCL_STANDARD}, but detray requires C++>=20"
-    )
-endif()
+#
+# Configure dependencies
+#
 
 if(${DETRAY_BUILD_HIP} AND ${CMAKE_HIP_STANDARD} LESS 20)
     message(
@@ -461,11 +480,15 @@ if(DETRAY_SETUP_COVFIE)
     endif()
 endif()
 
+#
 # Set up all of the libraries of the project.
+#
+
 add_subdirectory(core)
 add_subdirectory(detectors)
 add_subdirectory(io)
 add_subdirectory(plugins)
+add_subdirectory(python)
 
 # Test utils and validation tools can also be required standalone
 # (e.g. in ACTS detray plugin)
@@ -479,7 +502,6 @@ if(
     add_subdirectory(tests)
 endif()
 
-# Set up the tutorial(s).
 if(DETRAY_BUILD_TUTORIALS)
     add_subdirectory(tutorials)
 endif()
diff --git a/README.md b/README.md
index c53dd5b6e..2e2729fb7 100644
--- a/README.md
+++ b/README.md
@@ -62,13 +62,13 @@ The following cmake options are available and can also be specified explicitly f
 | DETRAY_SET_LOGGING  | Set log level (NONE, WARN, INFO, VERBOSE, DEBUG) | INFO |
 | DETRAY_BUILD_CUDA  | Build the CUDA sources included in detray | ON (if available) |
 | DETRAY_BUILD_SYCL  | Build the SYCL sources included in detray | OFF |
-| DETRAY_BUILD_TEST_UTILS  | Build the detray test utilities library (contains e.g. test detectors) | OFF |
-| DETRAY_BUILD_UNITTESTS  | Build the detray unit tests | OFF |
-| DETRAY_BUILD_INTEGRATIONTESTS  | Build the detray integration tests | OFF |
-| DETRAY_BUILD_ALL_TESTS  | Build the detray unit and integration tests | OFF |
-| DETRAY_BUILD_BENCHMARKS  | Build the detray benchmarks | OFF |
 | DETRAY_BUILD_CLI_TOOLS  | Build the detray command line tools | OFF |
+| DETRAY_BUILD_BENCHMARKS  | Build the detray benchmarks | OFF |
 | DETRAY_BUILD_TUTORIALS  | Build the examples of detray | OFF |
+| DETRAY_BUILD_ALL_TESTS  | Build the detray unit and integration tests | OFF |
+| DETRAY_BUILD_UNITTESTS  | Build the detray unit tests | OFF |
+| DETRAY_BUILD_INTEGRATIONTESTS  | Build the detray integration tests | OFF |
+| DETRAY_BUILD_TEST_UTILS  | Build the detray test utilities library (test detectors etc.) | OFF |
 | DETRAY_CUSTOM_SCALARTYPE | Floating point precision | float |
 | DETRAY_EIGEN_PLUGIN | Build Eigen math plugin | OFF |
 | DETRAY_FASTOR_PLUGIN | Build Fastor math plugin | OFF |
@@ -87,6 +87,10 @@ extra navigation tracing information
 - Moving a detector to device
 - Host and device track propagation
 
+In order to define a custom detector geometry type (called a detector 'metadata'), please follow the instructions in `detray/detectors/README.md`.
+
+Otherwise, the default detector metadata (`#include detray/detectors/default_metadata.hpp`) can be used in most cases to define the detector type, however, incurring increased build times and likely also increased runtime of client algorithms.
+
 ## Detector Validation
 
 Given a detray detector (and optionally also a grid and a material) json file, a number of validation test can be run from the command-line. For this, the library has to be built with the `-DDETRAY_BUILD_CLI_TOOLS=ON` option enabled. An example detector file can then be obtained using e.g.
diff --git a/core/include/detray/builders/cuboid_portal_generator.hpp b/core/include/detray/builders/cuboid_portal_generator.hpp
index 21339a057..4c19a6c7d 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 6f094e4b6..5e194d7a5 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 61803f7bc..213efefaf 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 1b8e5058f..be97c78cb 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 ce7a78cc8..cf62690cc 100644
--- a/core/include/detray/builders/homogeneous_material_factory.hpp
+++ b/core/include/detray/builders/homogeneous_material_factory.hpp
@@ -354,8 +354,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,
@@ -363,9 +364,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(
diff --git a/core/include/detray/builders/homogeneous_material_generator.hpp b/core/include/detray/builders/homogeneous_material_generator.hpp
index 5874ae3f0..401db58ee 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 ac9959871..b5a228f2c 100644
--- a/core/include/detray/builders/volume_builder.hpp
+++ b/core/include/detray/builders/volume_builder.hpp
@@ -53,7 +53,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);
     };
@@ -254,7 +254,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 42281cff6..8418644f7 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/README.md b/detectors/README.md
new file mode 100644
index 000000000..f4659ac15
--- /dev/null
+++ b/detectors/README.md
@@ -0,0 +1,34 @@
+## Generating custom Detector Metadata
+
+The detector metadata is a C++ `struct` used by the detray core library as a template parameter to gather the compile-time information on the capabilities of the detector modelling, for example:
+
+`using odd_detector_t = detray::detector<detray::odd_metadata<algebra_t>>`,
+
+with the `algebra_t` defined according to the linear algebra backend to be used, for instance the `detray::array<float>` plugin.
+
+A generic metadata type (the default metadata) exists, which comprises most of the geometry modelling capabilities detray has to offer, however, at the expense of increased build times and likely higher runtime of subsequent track reconstruction pipelines. A custom metadata can be defined by providing a python script that configures the detray metadata code generator,
+which can be invoked during the configuration stage of the cmake build:
+```shell
+cmake -S detray -B detray-build -DDETRAY_METADATA_GENERATOR=path/to/custom_metadata.py
+```
+The resulting metadata header, ready to be used in downstream projects, will be available in the `detray/detectors` folder. Example metadata generation scripts, for instance for the ACTS Open Data Detector (ODD detector mentioned above), can be found in the `detray/detectors/python/` folder. They can be invoked manually by:
+```shell
+source detray-build/python/setup.sh
+python3 detray/detectors/python/odd_metadata.py
+```
+
+### Metadata Configuration Manual
+
+Generate a metadata representation and dump the header file:
+
+```python
+from detray.detectors import metadata, metadata_generator
+
+md = metadata("detector_name")
+
+[...]
+
+metadata_generator(md)
+```
+
+Adding surface shapes for passive or sensitive detector elements or portals between detector sub-volumes:
diff --git a/detectors/include/detray/detectors/default_metadata.hpp b/detectors/include/detray/detectors/default_metadata.hpp
index aa04b025e..6bc849010 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,17 @@
 #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/cuboid3D.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/material/material.hpp"
 #include "detray/material/material_map.hpp"
 #include "detray/material/material_rod.hpp"
 #include "detray/material/material_slab.hpp"
@@ -26,427 +33,250 @@
 
 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
-    //
+    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>;
 
-    /// Homogeneous material description
-    /// @{
-    using slab = material_slab<scalar_t>;
-    using rod = material_rod<scalar_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
     template <typename container_t>
-    using cylinder2_map_t = material_map<algebra_type, cylinder2D, container_t>;
-
-    // Concentric cylindrical material grid
+    using concentric_cylinder2D_map_t =
+        material_map<algebra_type, detray::concentric_cylinder2D, container_t>;
     template <typename container_t>
-    using concentric_cylinder2_map_t =
-        material_map<algebra_type, concentric_cylinder2D, container_t>;
-
-    // Rectangular 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 rectangular_map_t =
-        material_map<algebra_type, rectangle2D, container_t>;
-
-    // Cuboid volume 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 cuboid_map_t = material_map<algebra_type, cuboid3D, container_t>;
-
-    // Cylindrical 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 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>;
-
-    // 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>;
+    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>>>;
 
-    // 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>;
+    template <typename container_t>
+    using volume_cuboid3D_grid_t =
+        spatial_grid_t<axes<detray::cuboid3D>, dindex, container_t>;
+
+    enum class accel_id : std::uint_least8_t {
+        e_surface_brute_force = 0,
+        e_surface_concentric_cylinder2D_grid = 1,
+        e_surface_ring2D_grid = 2,
+        e_surface_cylinder2D_grid = 3,
+        e_volume_cylinder3D_grid = 4,
+        e_volume_cuboid3D_grid = 5,
+        e_volume_brute_force = 6,
+        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";
-                break;
-            case geo_objects::e_volume:
-                os << "e_volume";
-                break;
-            case geo_objects::e_size:
-                // e_all has same value (2u)
-                os << "e_size/e_all";
-                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,
-    };
-
-    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";
+            case accel_id::e_surface_concentric_cylinder2D_grid:
+                os << "e_surface_concentric_cylinder2D_grid";
                 break;
-            case accel_ids::e_cylinder2_grid:
-                os << "e_cylinder2_grid";
+            case accel_id::e_surface_ring2D_grid:
+                os << "e_surface_ring2D_grid";
                 break;
-            case accel_ids::e_disc_grid:
-                os << "e_disc_grid";
+            case accel_id::e_surface_cylinder2D_grid:
+                os << "e_surface_cylinder2D_grid";
                 break;
-            case accel_ids::e_irr_cylinder2_grid:
-                os << "e_irr_cylinder2_grid";
+            case accel_id::e_volume_cylinder3D_grid:
+                os << "e_volume_cylinder3D_grid";
                 break;
-            case accel_ids::e_irr_disc_grid:
-                os << "e_irr_disc_grid";
+            case accel_id::e_volume_cuboid3D_grid:
+                os << "e_volume_cuboid3D_grid";
                 break;
-            case accel_ids::e_volume_brute_force:
+            case accel_id::e_volume_brute_force:
                 os << "e_volume_brute_force";
                 break;
-            case accel_ids::e_volume_cylinder3_grid:
-                os << "e_volume_cylinder3_grid/e_default_volume_searcher";
-                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>;
+    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>>,
+        grid_collection<volume_cuboid3D_grid_t<container_t>>,
+        brute_force_collection<dindex, container_t>>;
 
-    /// 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>>*/>;
+    enum geo_objects : std::uint_least8_t {
+        e_passive = 0u,
+        e_portal = 0u,
+        e_sensitive = 1u,
+        e_volume = 2u,
+        e_size = 3u,
+        e_all = e_size,
+    };
+
+    using object_link_type =
+        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 6f80542c9..5106844c9 100644
--- a/detectors/include/detray/detectors/itk_metadata.hpp
+++ b/detectors/include/detray/detectors/itk_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
  */
@@ -16,8 +16,12 @@
 #include "detray/geometry/mask.hpp"
 #include "detray/geometry/shapes/annulus2D.hpp"
 #include "detray/geometry/shapes/concentric_cylinder2D.hpp"
+#include "detray/geometry/shapes/cuboid3D.hpp"
+#include "detray/geometry/shapes/cylinder2D.hpp"
+#include "detray/geometry/shapes/cylinder3D.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/material/material_map.hpp"
 #include "detray/navigation/accelerators/brute_force.hpp"
@@ -25,262 +29,189 @@
 
 namespace detray {
 
-/// Assembles the detector type. This metatdata contains all available types
 template <concepts::algebra algebra_t>
 struct itk_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
-    using rectangle = mask<rectangle2D, algebra_type, nav_link>;
-    using annulus = mask<annulus2D, algebra_type, nav_link>;
-    using cylinder_portal = mask<concentric_cylinder2D, algebra_type, nav_link>;
-    using disc = mask<ring2D, 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_annulus2 = 1u,
-        e_cylinder2 = 2u,
-        e_portal_cylinder2 = 2u,
-        e_ring2 = 3u,
-        e_portal_ring2 = 3u,
+    using annulus2D_t = mask<detray::annulus2D, algebra_type, nav_link>;
+    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 cylinder2D_t = mask<detray::cylinder2D, algebra_type, nav_link>;
+
+    enum class mask_id : std::uint_least8_t {
+        e_annulus2D = 0u,
+        e_concentric_cylinder2D = 1u,
+        e_ring2D = 2u,
+        e_rectangle2D = 3u,
+        e_trapezoid2D = 4u,
+        e_cylinder2D = 5u,
     };
 
     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_annulus2D:
+                os << "e_annulus2D";
+                break;
+            case mask_id::e_concentric_cylinder2D:
+                os << "e_concentric_cylinder2D";
                 break;
-            case mask_ids::e_annulus2:
-                os << "e_annulus2";
+            case mask_id::e_ring2D:
+                os << "e_ring2D";
                 break;
-            case mask_ids::e_cylinder2:
-                os << "e_cylinder2/e_portal_cylinder2";
+            case mask_id::e_rectangle2D:
+                os << "e_rectangle2D";
                 break;
-            case mask_ids::e_ring2:
-                // e_portal_ring2 has same value (5u)
-                os << "e_ring2/e_portal_ring2";
+            case mask_id::e_trapezoid2D:
+                os << "e_trapezoid2D";
+                break;
+            case mask_id::e_cylinder2D:
+                os << "e_cylinder2D";
                 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, annulus, cylinder_portal, disc>;
-
-    //
-    // Material Description
-    //
+        regular_multi_store<mask_id, empty_context, dtuple, vector_t,
+                            annulus2D_t, concentric_cylinder2D_t, ring2D_t,
+                            rectangle2D_t, trapezoid2D_t, cylinder2D_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>;
-
-    // Concentric cylindrical material grid
+    using concentric_cylinder2D_map_t =
+        material_map<algebra_type, detray::concentric_cylinder2D, container_t>;
     template <typename container_t>
-    using concentric_cylinder2_map_t =
-        material_map<algebra_type, concentric_cylinder2D, container_t>;
-
-    /// @}
+    using ring2D_map_t =
+        material_map<algebra_type, detray::ring2D, 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,
+    enum class material_id : std::uint_least8_t {
+        e_concentric_cylinder2D_map = 0u,
+        e_ring2D_map = 1u,
         e_none = 2u,
     };
 
     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_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>>>;
-
-    //
-    // Acceleration structures
-    //
+        multi_store<material_id, empty_context, dtuple,
+                    grid_collection<concentric_cylinder2D_map_t<container_t>>,
+                    grid_collection<ring2D_map_t<container_t>>>;
 
-    /// 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>;
-
-    // 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>;
-
-    /// @}
-
-    /// 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 volume_cylinder3D_grid_t =
+        spatial_grid_t<axes<detray::cylinder3D>, dindex, container_t>;
+    template <typename container_t>
+    using volume_cuboid3D_grid_t =
+        spatial_grid_t<axes<detray::cuboid3D>, dindex, container_t>;
+
+    enum class accel_id : std::uint_least8_t {
+        e_surface_brute_force = -1u,
+        e_surface_brute_force = -1u,
+        e_surface_concentric_cylinder2D_grid = -1u,
+        e_surface_ring2D_grid = -1u,
+        e_volume_cylinder3D_grid = -1u,
+        e_volume_cuboid3D_grid = -1u,
+        e_surface_default = e_surface_brute_force,
+        e_volume_default = e_volume_cuboid3D_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_brute_force:
+                os << "e_surface_brute_force";
                 break;
-            case geo_objects::e_volume:
-                os << "e_volume";
-                break;
-            case geo_objects::e_size:
-                // e_all has same value (2u)
-                os << "e_size/e_all";
-                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_volume_cylinder3_grid = 3u,
-        e_default_volume_searcher = e_volume_cylinder3_grid,
-        e_default = e_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_id::e_surface_concentric_cylinder2D_grid:
+                os << "e_surface_concentric_cylinder2D_grid";
                 break;
-            case accel_ids::e_cylinder2_grid:
-                os << "e_cylinder2_grid";
+            case accel_id::e_surface_ring2D_grid:
+                os << "e_surface_ring2D_grid";
                 break;
-            case accel_ids::e_disc_grid:
-                os << "e_disc_grid";
+            case accel_id::e_volume_cylinder3D_grid:
+                os << "e_volume_cylinder3D_grid";
                 break;
-            case accel_ids::e_volume_cylinder3_grid:
-                os << "e_volume_cylinder3_grid/e_default_volume_searcher";
+            case accel_id::e_volume_cuboid3D_grid:
+                os << "e_volume_cuboid3D_grid";
                 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 acceleration structure
-    //
-
-    /// 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>;
+    };
 
-    /// The tuple store that hold the acceleration data structures for all
-    /// volumes. Every collection of accelerationdata structures defines its
-    /// own container and view type. Does not make use of conditions data
-    /// ( @c empty_context )
     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<volume_accelerator<container_t>>>;
+        accel_id, empty_context, dtuple,
+        typename container_t::template vector_type<surface_brute_force_t>,
+        typename container_t::template vector_type<surface_brute_force_t>,
+        grid_collection<surface_concentric_cylinder2D_grid_t<container_t>>,
+        grid_collection<surface_ring2D_grid_t<container_t>>,
+        grid_collection<volume_cylinder3D_grid_t<container_t>>,
+        grid_collection<volume_cuboid3D_grid_t<container_t>>>;
+
+    enum geo_objects : std::uint_least8_t {
+        e_passive = 0u,
+        e_portal = 0u,
+        e_sensitive = 1u,
+        e_volume = 2u,
+        e_size = 3u,
+        e_all = e_size,
+    };
+
+    using object_link_type =
+        dmulti_index<dtyped_index<accel_id, dindex>, geo_objects::e_size>;
 };
 
 }  // namespace detray
diff --git a/detectors/include/detray/detectors/odd_metadata.hpp b/detectors/include/detray/detectors/odd_metadata.hpp
index 421301e47..10e88e97b 100644
--- a/detectors/include/detray/detectors/odd_metadata.hpp
+++ b/detectors/include/detray/detectors/odd_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
  */
@@ -15,264 +15,199 @@
 #include "detray/definitions/indexing.hpp"
 #include "detray/geometry/mask.hpp"
 #include "detray/geometry/shapes/concentric_cylinder2D.hpp"
+#include "detray/geometry/shapes/cuboid3D.hpp"
+#include "detray/geometry/shapes/cylinder2D.hpp"
+#include "detray/geometry/shapes/cylinder3D.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/material/material_map.hpp"
+#include "detray/material/material_slab.hpp"
 #include "detray/navigation/accelerators/brute_force.hpp"
 #include "detray/navigation/accelerators/spatial_grid.hpp"
 
 namespace detray {
 
-/// Assembles the detector type. This metatdata contains all available types
 template <concepts::algebra algebra_t>
 struct odd_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
-    using rectangle = mask<rectangle2D, algebra_type, nav_link>;
-    using trapezoid = mask<trapezoid2D, algebra_type, nav_link>;
-    using cylinder_portal = mask<concentric_cylinder2D, algebra_type, nav_link>;
-    using disc = mask<ring2D, 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_trapezoid2 = 1u,
-        e_cylinder2 = 2u,
-        e_portal_cylinder2 = 2u,
-        e_ring2 = 3u,
-        e_portal_ring2 = 3u,
+    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 cylinder2D_t = mask<detray::cylinder2D, 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_cylinder2D = 4u,
     };
 
     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_id::e_ring2D:
+                os << "e_ring2D";
                 break;
-            case mask_ids::e_trapezoid2:
-                os << "e_trapezoid2";
+            case mask_id::e_rectangle2D:
+                os << "e_rectangle2D";
                 break;
-            case mask_ids::e_cylinder2:
-                os << "e_cylinder2/e_portal_cylinder2";
+            case mask_id::e_trapezoid2D:
+                os << "e_trapezoid2D";
                 break;
-            case mask_ids::e_ring2:
-                // e_portal_ring2 has same value (5u)
-                os << "e_ring2/e_portal_ring2";
+            case mask_id::e_cylinder2D:
+                os << "e_cylinder2D";
                 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, cylinder_portal, disc>;
-
-    //
-    // Material Description
-    //
-
-    /// Material grid types (default: closed bounds, regular binning)
-    /// @{
+        regular_multi_store<mask_id, empty_context, dtuple, vector_t,
+                            concentric_cylinder2D_t, ring2D_t, rectangle2D_t,
+                            trapezoid2D_t, cylinder2D_t>;
 
-    // Disc material grid
     template <typename container_t>
-    using disc_map_t = material_map<algebra_type, ring2D, container_t>;
-
-    // Concentric cylindrical material grid
+    using concentric_cylinder2D_map_t =
+        material_map<algebra_type, detray::concentric_cylinder2D, container_t>;
     template <typename container_t>
-    using concentric_cylinder2_map_t =
-        material_map<algebra_type, concentric_cylinder2D, 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_none = 2u,
+    using ring2D_map_t =
+        material_map<algebra_type, detray::ring2D, container_t>;
+    using material_slab_t = material_slab<scalar_t>;
+
+    enum class material_id : std::uint_least8_t {
+        e_concentric_cylinder2D_map = 0u,
+        e_ring2D_map = 1u,
+        e_material_slab = 2u,
+        e_none = 3u,
     };
 
     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_none:
+            case material_id::e_material_slab:
+                os << "e_material_slab";
+                break;
+            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>>>;
-
-    //
-    // Acceleration structures
-    //
+    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>>;
 
-    /// 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<sf_descriptor, 1>
-    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>;
-
-    // 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>;
-
-    /// @}
-
-    /// 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 volume_cylinder3D_grid_t =
+        spatial_grid_t<axes<detray::cylinder3D>, dindex, container_t>;
+    template <typename container_t>
+    using volume_cuboid3D_grid_t =
+        spatial_grid_t<axes<detray::cuboid3D>, dindex, container_t>;
+
+    enum class accel_id : std::uint_least8_t {
+        e_surface_brute_force = 0,
+        e_surface_concentric_cylinder2D_grid = 1,
+        e_surface_ring2D_grid = 2,
+        e_volume_cylinder3D_grid = 3,
+        e_volume_cuboid3D_grid = 4,
+        e_surface_default = e_surface_brute_force,
+        e_volume_default = e_volume_cuboid3D_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";
-                break;
-            case geo_objects::e_sensitive:
-                os << "e_sensitive";
-                break;
-            case geo_objects::e_volume:
-                os << "e_volume";
-                break;
-            case geo_objects::e_size:
-                // e_all has same value (2u)
-                os << "e_size/e_all";
+                                                       accel_id id) {
+        switch (id) {
+            case accel_id::e_surface_brute_force:
+                os << "e_surface_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_volume_cylinder3_grid = 3u,
-        e_default = e_brute_force,
-        e_default_volume_searcher = e_volume_cylinder3_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_id::e_surface_concentric_cylinder2D_grid:
+                os << "e_surface_concentric_cylinder2D_grid";
                 break;
-            case accel_ids::e_cylinder2_grid:
-                os << "e_cylinder2_grid";
+            case accel_id::e_surface_ring2D_grid:
+                os << "e_surface_ring2D_grid";
                 break;
-            case accel_ids::e_disc_grid:
-                os << "e_disc_grid";
+            case accel_id::e_volume_cylinder3D_grid:
+                os << "e_volume_cylinder3D_grid";
                 break;
-            case accel_ids::e_volume_cylinder3_grid:
-                os << "e_volume_cylinder3_grid/e_default_volume_searcher";
+            case accel_id::e_volume_cuboid3D_grid:
+                os << "e_volume_cuboid3D_grid";
                 break;
             default:
                 os << "invalid";
         }
         return os;
-    }
-
-    /// 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,
+        accel_id, 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<volume_accelerator<container_t>>>;
+        grid_collection<surface_concentric_cylinder2D_grid_t<container_t>>,
+        grid_collection<surface_ring2D_grid_t<container_t>>,
+        grid_collection<volume_cylinder3D_grid_t<container_t>>,
+        grid_collection<volume_cuboid3D_grid_t<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,
+    };
+
+    using object_link_type =
+        dmulti_index<dtyped_index<accel_id, dindex>, geo_objects::e_size>;
 };
 
 }  // namespace detray
diff --git a/detectors/include/detray/detectors/odd_metadata_old.hpp b/detectors/include/detray/detectors/odd_metadata_old.hpp
new file mode 100644
index 000000000..4e89a69f3
--- /dev/null
+++ b/detectors/include/detray/detectors/odd_metadata_old.hpp
@@ -0,0 +1,275 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022-2024 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/core/detail/multi_store.hpp"
+#include "detray/core/detail/single_store.hpp"
+#include "detray/definitions/algebra.hpp"
+#include "detray/definitions/containers.hpp"
+#include "detray/definitions/indexing.hpp"
+#include "detray/geometry/mask.hpp"
+#include "detray/geometry/shapes/concentric_cylinder2D.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_map.hpp"
+#include "detray/navigation/accelerators/brute_force.hpp"
+#include "detray/navigation/accelerators/spatial_grid.hpp"
+
+namespace detray {
+
+/// Assembles the detector type. This metatdata contains all available types
+template <concepts::algebra algebra_t>
+struct odd_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
+    using rectangle = mask<rectangle2D, algebra_type, nav_link>;
+    using trapezoid = mask<trapezoid2D, algebra_type, nav_link>;
+    using cylinder_portal = mask<concentric_cylinder2D, algebra_type, nav_link>;
+    using disc = mask<ring2D, 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_rectangle2D = 0u,
+        e_trapezoid2D = 1u,
+        e_concentric_cylinder2D = 2u,
+        e_ring2 = 3u,
+    };
+
+    DETRAY_HOST inline friend std::ostream& operator<<(std::ostream& os,
+                                                       mask_ids mid) {
+
+        switch (mid) {
+            case mask_ids::e_rectangle2D:
+                os << "e_rectangle2";
+                break;
+            case mask_ids::e_trapezoid2D:
+                os << "e_trapezoid2";
+                break;
+            case mask_ids::e_concentric_cylinder2D:
+                os << "e_concentric_cylinder2D";
+                break;
+            case mask_ids::e_ring2D:
+                os << "e_ring2D";
+                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, cylinder_portal, disc>;
+
+    //
+    // Material Description
+    //
+
+    /// 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>;
+
+    // Concentric cylindrical material grid
+    template <typename container_t>
+    using concentric_cylinder2_map_t =
+        material_map<algebra_type, concentric_cylinder2D, 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_cylinder2D_map = 0u,
+        e_ring2D_map = 1u,
+        e_none = 2u,
+    };
+
+    DETRAY_HOST inline friend std::ostream& operator<<(std::ostream& os,
+                                                       material_ids mid) {
+
+        switch (mid) {
+            case material_ids::e_concentric_cylinder2D_map:
+                os << "e_concentric_cylinder2D_map";
+                break;
+            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";
+                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>>>;
+
+    //
+    // 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<sf_descriptor, 1>
+    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>;
+
+    // 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>;
+
+    /// @}
+
+    /// 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
+    //
+
+    /// 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
+    };
+
+    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";
+                break;
+            case geo_objects::e_sensitive:
+                os << "e_sensitive";
+                break;
+            case geo_objects::e_volume:
+                os << "e_volume";
+                break;
+            case geo_objects::e_size:
+                // e_all has same value (2u)
+                os << "e_size/e_all";
+                break;
+            default:
+                os << "invalid";
+        }
+        return os;
+    }
+
+    /// Acceleration data structures
+    enum class accel_ids : std::uint_least8_t {
+        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_surface_brute_force:
+                os << "e_surface_brute_force";
+                break;
+            case accel_ids::e_surface_cylinder2D_grid:
+                os << "e_surface_cylinder2D_grid";
+                break;
+            case accel_ids::e_surface_ring2D_grid:
+                os << "e_surface_ring2D_grid";
+                break;
+            case accel_ids::e_volume_cylinder3D_grid:
+                os << "e_volume_cylinder3D_grid/e_volume_default";
+                break;
+            default:
+                os << "invalid";
+        }
+        return os;
+    }
+
+    /// 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<volume_accelerator<container_t>>>;
+};
+
+}  // namespace detray
diff --git a/detectors/include/detray/detectors/telescope_metadata.hpp b/detectors/include/detray/detectors/telescope_metadata.hpp
index 793b2b454..4f74d2c50 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..d715e2d91
--- /dev/null
+++ b/detectors/python/default_metadata.py
@@ -0,0 +1,84 @@
+# 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 detray
+
+from detray.detectors import metadata, metadata_generator
+from detray.detectors import Type, Algebra, Shape, Material, Accelerator
+from detray.detectors import (
+    add_silicon_tracker_defaults,
+    add_calorimeter_defaults,
+    add_telescope_detector_defaults,
+    add_wire_chamber_defaults,
+)
+
+from itk_metadata import add_itk_types
+from odd_metadata import add_odd_types
+
+import argparse
+import logging
+import sys
+
+# --------------------------------------------------------------------------
+# Generate the default metadata type (can represent all detectors)
+# --------------------------------------------------------------------------
+
+
+def __main__():
+    # Commandline options
+    parser = argparse.ArgumentParser(prog=sys.argv[0])
+    detray.detectors.add_logging_options(parser)
+    detray.detectors.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 and material map for generic 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/itk_metadata.py b/detectors/python/itk_metadata.py
new file mode 100644
index 000000000..e0f6aac99
--- /dev/null
+++ b/detectors/python/itk_metadata.py
@@ -0,0 +1,62 @@
+# 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 detray
+
+from detray.detectors import metadata, metadata_generator
+from detray.detectors import Shape
+from detray.detectors import (
+    add_logging_options,
+    parse_logging_options,
+    add_silicon_tracker_defaults,
+)
+
+import argparse
+import logging
+import sys
+
+# --------------------------------------------------------------------------
+# Generate the ITk metadata type
+# --------------------------------------------------------------------------
+
+""" Add all types needed to describe the ATLAS ITk detector """
+
+
+def add_itk_types(md: 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")
+    md.add_sensitive(Shape.ANNULUS)
+
+    # Add default types for silicon trackers (cylindrical detector shape)
+    add_silicon_tracker_defaults(metadata=md, use_mat_maps=True)
+
+    # Beampipe passive surface
+    logger.info("-> adding ITk beampipe")
+    md.add_passive(Shape.CYLINDER2D)
+
+
+def __main__():
+    # Commandline options
+    parser = argparse.ArgumentParser(prog=sys.argv[0])
+    detray.detectors.add_logging_options(parser)
+    detray.detectors.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..75d2b3dc0
--- /dev/null
+++ b/detectors/python/odd_metadata.py
@@ -0,0 +1,56 @@
+# 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 detray
+
+from detray.detectors import metadata, metadata_generator
+from detray.detectors import Shape
+from detray.detectors import add_silicon_tracker_defaults
+
+import argparse
+import logging
+import sys
+
+# --------------------------------------------------------------------------
+# Generate the Open Data Detector metadata type
+# --------------------------------------------------------------------------
+
+""" Add all types needed to describe the ACTS Open Data Detector (ODD) """
+
+
+def add_odd_types(md: metadata):
+    logger = logging.getLogger(__name__)
+    logger.info("Define types required by the ACTS Open Data Detector (ODD):")
+
+    # Add default types for silicon trackers (cylindrical detector shape)
+    add_silicon_tracker_defaults(
+        metadata=md, use_homogeneous_mat=True, use_mat_maps=True
+    )
+
+    # Beampipe passive surface
+    logger.info("-> adding ODD beampipe")
+    md.add_passive(Shape.CYLINDER2D)
+
+
+def __main__():
+    # Commandline options
+    parser = argparse.ArgumentParser(prog=sys.argv[0])
+    detray.detectors.add_logging_options(parser)
+    detray.detectors.parse_logging_options(parser.parse_args())
+
+    md = metadata("odd")
+
+    # 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..1d9ca15c8
--- /dev/null
+++ b/detectors/python/telescope_metadata.py
@@ -0,0 +1,54 @@
+# 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 detray
+
+from detray.detectors import metadata, metadata_generator
+from detray.detectors import Shape, Material
+from detray.detectors import add_telescope_detector_defaults
+
+import argparse
+import logging
+import sys
+
+# --------------------------------------------------------------------------
+# Generate the metadata type for the detray telescope test detector
+# --------------------------------------------------------------------------
+
+
+def __main__():
+    # Commandline options
+    parser = argparse.ArgumentParser(prog=sys.argv[0])
+    detray.detectors.add_logging_options(parser)
+    detray.detectors.parse_logging_options(parser.parse_args())
+
+    # Collect the types required for a telescope test detector
+    md = metadata("telescope_detector")
+
+    # Cuboid volume based detector shape
+    add_telescope_detector_defaults(md)
+
+    # Add more geometric shape types for telescope test detector
+    logger = logging.getLogger(__name__)
+    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)
+
+    # Add more material types
+    md.add_material(Material.SLAB)
+    md.add_material(Material.ROD)
+
+    # Dump the metadata to header file
+    metadata_generator(md)
+
+
+if __name__ == "__main__":
+    __main__()
diff --git a/detectors/python/wire_chamber_metadata.py b/detectors/python/wire_chamber_metadata.py
new file mode 100644
index 000000000..99d41f22a
--- /dev/null
+++ b/detectors/python/wire_chamber_metadata.py
@@ -0,0 +1,46 @@
+# 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(md: 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=md, use_homogeneous_mat=True, use_mat_maps=False)
+
+    # Beampipe passive surface
+    logger.info("-> adding wire chamber beampipe")
+    md.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 a4162a23a..7c13c3960 100644
--- a/io/include/detray/io/backend/detail/type_info.hpp
+++ b/io/include/detray/io/backend/detail/type_info.hpp
@@ -1,6 +1,6 @@
 /** Detray library, part of the ACTS project (R&D line)
  *
- * (c) 2023-2024 CERN for the benefit of the ACTS project
+ * (c) 2023-2026 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
diff --git a/io/include/detray/io/backend/homogeneous_material_reader.hpp b/io/include/detray/io/backend/homogeneous_material_reader.hpp
index a01592692..f1e095770 100644
--- a/io/include/detray/io/backend/homogeneous_material_reader.hpp
+++ b/io/include/detray/io/backend/homogeneous_material_reader.hpp
@@ -90,11 +90,11 @@ class homogeneous_material_reader {
                               << " material slabs to material factory");
             for (const auto& mat_data : mv_data.surface_mat) {
                 // Determine the material type id
-                auto mat_type{mat_id::e_slab};
+                auto mat_type{mat_id::e_material_slab};
                 if constexpr (detray::concepts::has_material_rods<detector_t>) {
                     mat_type = mat_data.type == io::material_id::slab
-                                   ? mat_id::e_slab
-                                   : mat_id::e_rod;
+                                   ? mat_id::e_material_slab
+                                   : mat_id::e_material_rod;
                 } else {
                     assert(mat_data.type == io::material_id::slab);
                 }
diff --git a/io/include/detray/io/backend/homogeneous_material_writer.hpp b/io/include/detray/io/backend/homogeneous_material_writer.hpp
index 1f4cc20f2..a9e489633 100644
--- a/io/include/detray/io/backend/homogeneous_material_writer.hpp
+++ b/io/include/detray/io/backend/homogeneous_material_writer.hpp
@@ -74,15 +74,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_id_t::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_id_t::rod);
         }
@@ -122,10 +123,11 @@ class homogeneous_material_writer {
         using algebra_t = typename detector_t::algebra_type;
 
         // 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 a47d24be1..ccfe3daaa 100644
--- a/io/include/detray/io/backend/material_map_writer.hpp
+++ b/io/include/detray/io/backend/material_map_writer.hpp
@@ -82,12 +82,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/python/CMakeLists.txt b/python/CMakeLists.txt
new file mode 100644
index 000000000..6c59c4395
--- /dev/null
+++ b/python/CMakeLists.txt
@@ -0,0 +1,58 @@
+# 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
+
+# Set up the python stall directories
+set(_python_dir "${CMAKE_BINARY_DIR}/python")
+file(MAKE_DIRECTORY ${_python_dir})
+file(MAKE_DIRECTORY ${_python_dir}/detray)
+
+# Set up the source script in the python directory
+configure_file(setup.sh.in ${_python_dir}/setup.sh @ONLY)
+install(FILES ${_python_dir}/setup.sh DESTINATION python)
+
+# Set up the init file for the detray python module
+set(_target ${_python_dir}/detray/__init__.py)
+file(
+    CREATE_LINK ${CMAKE_CURRENT_SOURCE_DIR}/detray/__init__.py ${_target}
+    SYMBOLIC
+)
+
+# Allow access to the python detectors package from the main __init__.py
+file(
+    CREATE_LINK
+        ${CMAKE_CURRENT_SOURCE_DIR}/detray/detectors
+        ${_python_dir}/detray/detectors
+    SYMBOLIC
+)
+
+install(
+    FILES ${CMAKE_CURRENT_SOURCE_DIR}/detray/python/__init__.py
+    DESTINATION ${DETRAY_PYTHON_INSTALL_DIR}
+)
+
+# Create the metadata headers
+message(STATUS "Configuring detray detector types...")
+#include(FindPythonInterp)
+
+# Generate the inbuilt metadata headers
+#for each
+#message(STATUS "Created xxx metadata")
+#execute_process(
+#   COMMAND ${PYTHON3} ${CMAKE_CURRENT_SOURCE_DIR}/my_python_script.py GET_LIST_OF_FILES
+#   RESULT_VARIABLE FILES
+#)
+#add_custom_command(
+#   OUTPUT ${FILES}
+#   COMMAND ${PYTHON3} ${CMAKE_CURRENT_SOURCE_DIR}/my_python_script.py
+#   DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/my_python_script.py
+#)
+
+# Generate the custom metadata headers
+
+# Build the python bindings
+if(DETRAY_BUILD_PYTHON_BINDINGS)
+    add_subdirectory(detray)
+endif()
diff --git a/python/detray/__init__.py b/python/detray/__init__.py
new file mode 100644
index 000000000..1cefd3ac6
--- /dev/null
+++ b/python/detray/__init__.py
@@ -0,0 +1 @@
+import detectors
diff --git a/python/detray/detectors/__init__.py b/python/detray/detectors/__init__.py
new file mode 100644
index 000000000..b340c581e
--- /dev/null
+++ b/python/detray/detectors/__init__.py
@@ -0,0 +1,4 @@
+from .impl import metadata, metadata_generator
+from .impl.definitions import *
+from .options import *
+from .utils import *
diff --git a/python/detray/detectors/impl/__init__.py b/python/detray/detectors/impl/__init__.py
new file mode 100644
index 000000000..8f4c7eb51
--- /dev/null
+++ b/python/detray/detectors/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/python/detray/detectors/impl/definitions.py b/python/detray/detectors/impl/definitions.py
new file mode 100644
index 000000000..0726747d6
--- /dev/null
+++ b/python/detray/detectors/impl/definitions.py
@@ -0,0 +1,160 @@
+# 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}
+    )
+    # Surface grid, cuboid 3D (telescope)
+    BLA = cpp_class(specifier="detray::bla")
diff --git a/python/detray/detectors/impl/metadata_generator.py b/python/detray/detectors/impl/metadata_generator.py
new file mode 100644
index 000000000..deb131d3a
--- /dev/null
+++ b/python/detray/detectors/impl/metadata_generator.py
@@ -0,0 +1,998 @@
+# 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 collections import Counter
+from datetime import datetime
+import itertools
+import logging
+import numbers
+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 at a given position
+    # in the mask store (type_id)
+    def add_portal(self, shape: Shape, type_id: int = -1):
+        self.add_shape(shape, type_id)
+        if "portal" not in self.surface_types:
+            self.surface_types.append("portal")
+
+    # Register a new geometric shape for a sensitive surface at a given position
+    # in the mask store (type_id)
+    def add_sensitive(self, shape: Shape, type_id: int = -1):
+        self.add_shape(shape, type_id)
+        if "sensitive" not in self.surface_types:
+            self.surface_types.append("sensitive")
+
+    # Register a new geometric shape for a passive surface at a given position
+    # in the mask store (type_id)
+    def add_passive(self, shape: Shape, type_id: int = -1):
+        self.add_shape(shape, type_id)
+        if "passive" not in self.surface_types:
+            self.surface_types.append("passive")
+
+    # Register a new geometric shape for the detector at a given position
+    # in the mask store (type_id)
+    def add_shape(self, shape: Shape, type_id: int):
+        if shape not in itertools.chain(*self.shapes.values()):
+            self.logger.debug(f'--> surface shape "{shape.specifier}"')
+
+            # Automatically enumerate the shape if no type ID is given
+            i = type_id if type_id >= 0 else len(self.shapes)
+            self.shapes.setdefault(i, []).append(shape)
+
+    # Register a new material type
+    def add_material(self, mat: Material, type_id: int = -1):
+        if mat not in itertools.chain(*self.materials.values()):
+            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}>"'
+                )
+
+            # Automatically enumerate the material if no type ID is given
+            i = type_id if type_id >= 0 else len(self.materials)
+            self.materials.setdefault(i, []).append(mat)
+
+    # Register a new acceleration structure for a geometric object type
+    def add_accel_struct(
+        self,
+        accel: Accelerator,
+        obj_type: str = "sensitive",
+        type_id: int = -1,
+        value_type: str = "surface",
+        is_default: bool = False,
+    ):
+        print(f"{type_id}, {value_type}")
+        # Make sure volume acceleration structures have indices as values
+        value_type = "index" if "volume" in obj_type else value_type
+        chosen = False
+        if obj_type not in self.acceleration_structs.keys():
+            self.acceleration_structs[obj_type] = [(accel, type_id, value_type)]
+            chosen = True
+        elif (accel, type_id, value_type) not in self.acceleration_structs[obj_type]:
+            chosen = True
+            self.acceleration_structs[obj_type].append((accel, type_id, value_type))
+
+        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, value_type)
+
+    # Mark an acceleration struct as default for the given object type
+    def set_default_accel_struct(
+        self,
+        accel: Accelerator,
+        obj_type: str,
+        type_id: int = -1,
+        value_type: str = "surface",
+    ):
+        # Make sure volume acceleration structures have indices as values
+        value_type = "index" if "volume" in obj_type else value_type
+
+        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,
+            value_type,
+        ) not in [(a, v) for a, i, v in self.acceleration_structs[obj_type]]:
+            # print(obj_type)
+            # print(self.acceleration_structs)
+            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, type_id, value_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/"
+    ):
+        det_name = md.det_name.replace("_detector", "")
+        filename = f"{os.path.abspath(src_dir)}/{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 itertools.chain(*shapes.values())
+        }
+
+        # 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 itertools.chain(*materials.values())
+        }
+        # 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 itertools.chain(*materials.values())
+            )
+
+        # Set of acceleration structure class names
+        accel_names = {
+            self.__name_from_specifier(a.specifier)
+            for accels in accel_structs.values()
+            for a, i, v 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, i, v in accels
+            )
+
+        # Add the corresponding includes
+        root_dir = '#include "detray'
+        shape_names.discard(None)
+        [self.__put(f'{root_dir}/geometry/shapes/{n}.hpp"\n') for n in shape_names]
+
+        [self.__put(f'{root_dir}/material/{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")
+
+        print(items)
+        print(extra_items)
+
+        self.indent = self.indent + 1
+        for i, values in itertools.chain(items.items(), extra_items.items()):
+            for v in values:
+                # Special value was passed
+                item = v[0] if isinstance(v, list) else v
+                tmp_value = v[1] if isinstance(v, list) else i
+                value = f"{i}u" if isinstance(tmp_value, numbers.Number) else tmp_value
+
+                print(value)
+                # 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, values in itertools.chain(items.items(), extra_items.items()):
+            for v in values:
+                # 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(itertools.chain(*types.values()))}>;"
+            )
+        else:
+            # The brute force searcher needs to be at the beginning of the store
+            type_list = []
+            flattened_types = [t for t in itertools.chain(*types.values())]
+
+            if "surface_brute_force_t" in flattened_types:
+                flattened_types = [
+                    t for t in flattened_types if t != "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 flattened_types:
+                flattened_types = [
+                    t for t in flattened_types if t != "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 flattened_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, type_id, 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.setdefault(type_id, []).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 type_id, shapes in md.shapes.items():
+            for shape in shapes:
+                self.__declare_mask(
+                    shape, type_id, "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, type_id, 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.setdefault(type_id, []).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 type_id, materials in md.materials.items():
+                for mat in materials:
+                    self.__declare_material(mat, type_id, "algebra_type")
+
+            self.__lines(1)
+            # Add an option for 'no material'
+            self.__declare_type_enum(
+                "material_id",
+                self.material_specifiers,
+                md.id_base,
+                {len(md.materials): ["none"]},
+            )
+            self.__lines(2)
+            self.__define_enum_stream_op(
+                "material_id", self.material_specifiers, {len(md.materials): ["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_id: int, value_type: str):
+        type_specifier = f"{self.__name_from_specifier(acc.specifier)}_t"
+
+        if type_specifier.endswith("grid_t"):
+            # First spatial grid declaration?
+            if not any(
+                sc.endswith("grid_t")
+                for sc in itertools.chain(*self.accel_specifiers.values())
+            ):
+                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"
+            entry_type = "surface_type" if value_type == "surface" else "dindex"
+
+            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}>, {entry_type}, container_t>;\n"
+            )
+
+        self.accel_specifiers.setdefault(type_id, []).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, type_id, value_type in accels:
+                if (obj_type, acc, type_id) not in unique_accel:
+                    self.__declare_accel(obj_type, acc, type_id, value_type)
+                    unique_accel.append((obj_type, acc, type_id, value_type))
+
+        # 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 geometry 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):
+
+        # Helper to determine if an accel. struct is one of the defaults
+        def is_default_accel(value_type, accel):
+            is_surface_default = (
+                value_type == "surface" and accel is md.default_surface_accel.specifier
+            )
+            is_volume_default = (
+                value_type == "index" and accel is md.default_volume_accel.specifier
+            )
+
+            return is_surface_default or is_volume_default
+
+        # Enumerate the different geometric objects and assign them to the accel
+        # link of the corresponding acceleration structure, e.g.
+        # geo_id:  value_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
+
+        print(f"Input:\n{md.acceleration_structs}\n")
+
+        accel_to_types = {}
+        for t, accels in md.acceleration_structs.items():
+            for a, i, v in accels:
+                specifier = f"{a.specifier}"
+
+                if (specifier, i, v) not in accel_to_types:
+                    accel_to_types[specifier, i, v] = set()
+
+                accel_to_types[specifier, i, v].add(t)
+
+        print(f"Accel to types:\n{accel_to_types}\n")
+
+        # If specific type IDs are required, merge the categories accordingly
+        type_id_dict = {}
+        for acc, type_id, value_type in accel_to_types.keys():
+            if type_id > -1:
+                type_id_dict.setdefault((type_id, value_type), []).append(acc)
+
+        print(f"type ID dict:\n{type_id_dict}\n")
+
+        # Find a representative for each category and merge the obj type sets
+        accel_to_types_merged = {}
+        for acc, type_id, value_type in accel_to_types.keys():
+            representative = acc
+            if (
+                not is_default_accel(value_type, acc)
+                and (type_id, value_type) in type_id_dict.keys()
+                and len(type_id_dict[type_id, value_type]) > 1
+            ):
+                tmp_repr = type_id_dict[type_id, value_type][0]
+                representative = (
+                    type_id_dict[type_id, value_type][1]
+                    if is_default_accel(value_type, tmp_repr)
+                    else tmp_repr
+                )
+
+            accel_to_types_merged.setdefault(
+                (representative, value_type, type_id), set()
+            ).update(accel_to_types[acc, type_id, value_type])
+
+        print(f"Accel to types (merged):\n{accel_to_types_merged}\n")
+
+        # Check duplicate sets (make the set hashable by converting to tuple)
+        counted_dict = Counter([tuple(v) for v in accel_to_types_merged.values()])
+        duplicates = {
+            key: value
+            for key, value in accel_to_types_merged.items()
+            if counted_dict[tuple(value)] > 1
+        }
+
+        print(f"Counted: {counted_dict}")
+        print(f"duplicates: {duplicates}")
+
+        # Get the list of keys for every duplicate
+        flipped_duplicates = {}
+        for key, value in duplicates.items():
+            flipped_duplicates.setdefault(tuple(value), []).append(key)
+
+        print(f"flipped_duplicates: {flipped_duplicates}")
+
+        # Find best representative key for the duplicates and remove the others
+        removal_keys = []
+        for obj_set, keys in flipped_duplicates.items():
+            # Keep the key with the smallest required type ID
+            type_id_counter = 10000
+            for acc, value_type, type_id in keys:
+                if is_default_accel(value_type, acc):
+                    continue
+                # Remove the non-specific type ID of "-1" in any case
+                if type_id == -1 or type_id >= type_id_counter:
+                    removal_keys.append((acc, value_type, type_id))
+                else:
+                    type_id_counter = type_id
+
+        for rk in removal_keys:
+            accel_to_types_merged.pop(rk, None)
+
+        print(f"Accel to types (deduplicated):\n{accel_to_types_merged}\n")
+
+        # Sort, in order to find the largest geo object sets
+        accel_to_types_sorted = dict(
+            sorted(
+                accel_to_types_merged.items(),
+                key=lambda item: len(item[1]),
+                reverse=True,
+            )
+        )
+
+        print(f"Accel to types (sorted):\n{accel_to_types_sorted}\n")
+
+        # 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):
+            new_link_types = [
+                l
+                for l in new_objects
+                if l not in itertools.chain(*accel_link_types.values())
+            ]
+
+            if new_link_types:
+                accel_link_types[key] = new_link_types
+
+        for (accel, value_type, type_id), obj_set in accel_to_types_sorted.items():
+            # Only add the default methods where no other accelerator is
+            # available (see below)
+            if is_default_accel(value_type, accel):
+                continue
+
+            add_link(key=type_id, new_objects=obj_set)
+
+        print(f"Final accel distinct link types:\n{accel_link_types}\n")
+
+        # Add the default link for the leftover surface and volume types
+        surface_default_list = [
+            v
+            for k, v in accel_to_types_sorted.items()
+            if "surface" in k and md.default_surface_accel.specifier in k
+        ]
+        add_link(
+            key="surface_default",
+            new_objects=itertools.chain.from_iterable(surface_default_list),
+        )
+
+        volume_default_list = [
+            v
+            for k, v in accel_to_types_sorted.items()
+            if "index" in k and md.default_volume_accel.specifier in k
+        ]
+        add_link(
+            key="volume_default",
+            new_objects=itertools.chain.from_iterable(volume_default_list),
+        )
+
+        print(f"final accel links categories: {accel_link_types}")
+
+        # 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]
+
+        print(portal_key)
+        print(portal_group)
+
+        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
+        i = 1
+        for key, link_group in accel_link_types.items():
+            if key == portal_key:
+                continue
+            for gid in link_group:
+                self.__put(f"e_{gid} = {i}u,\n")
+                i = i + 1
+
+        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
+        # print(list(itertools.chain.from_iterable(accel_link_types.values())))
+        # 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/python/detray/detectors/impl/type_helpers.py b/python/detray/detectors/impl/type_helpers.py
new file mode 100644
index 000000000..73b72bf6f
--- /dev/null
+++ b/python/detray/detectors/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/python/detray/detectors/options/__init__.py b/python/detray/detectors/options/__init__.py
new file mode 100644
index 000000000..1c354825f
--- /dev/null
+++ b/python/detray/detectors/options/__init__.py
@@ -0,0 +1 @@
+from .options import add_logging_options, parse_logging_options
diff --git a/python/detray/detectors/options/options.py b/python/detray/detectors/options/options.py
new file mode 100644
index 000000000..1bd3f4bd1
--- /dev/null
+++ b/python/detray/detectors/options/options.py
@@ -0,0 +1,62 @@
+# 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(parser):
+
+    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/python/detray/detectors/utils/__init__.py b/python/detray/detectors/utils/__init__.py
new file mode 100644
index 000000000..86bb8aa6d
--- /dev/null
+++ b/python/detray/detectors/utils/__init__.py
@@ -0,0 +1,4 @@
+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/python/detray/detectors/utils/calorimeter_defaults.py b/python/detray/detectors/utils/calorimeter_defaults.py
new file mode 100644
index 000000000..64c5f4cce
--- /dev/null
+++ b/python/detray/detectors/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(
+    md: metadata, use_mat_maps=False, use_homogeneous_mat=False
+):
+    # Don't run more than once on given metadata (prevents spurious log entries)
+    if md in add_calorimeter_defaults.clients:
+        return
+
+    add_calorimeter_defaults.clients.append(md)
+
+    logger = logging.getLogger(__name__)
+    logger.info("Define calorimeter types:")
+
+    logger.info("-> adding sensitive types")
+    md.add_sensitive(Shape.RECTANGLE)
+    md.add_sensitive(Shape.TRAPEZOID)
+
+    logger.info("-> adding portal types")
+    md.add_portal(Shape.CONCENTRIC_CYLINDER)
+    md.add_portal(Shape.RING)
+
+    # Acceleration Struct for portals and passives
+    md.add_accel_struct(Accelerator.BRUTE_FORCE, "portal", is_default=True)
+    md.add_accel_struct(Accelerator.BRUTE_FORCE, "passive")
+
+    if use_mat_maps:
+        logger.info("-> requested material map types")
+        md.add_material(Material.CYLINDER_MAP3D)
+    if use_homogeneous_mat:
+        logger.info("-> requested homogeneous material types")
+        md.add_material(Material.RAW)
+
+    # Add acceleration structures (e.g. Frustum navigation) in the future...
+
+
+add_calorimeter_defaults.clients = []
diff --git a/python/detray/detectors/utils/silicon_tracker_defaults.py b/python/detray/detectors/utils/silicon_tracker_defaults.py
new file mode 100644
index 000000000..92030ba01
--- /dev/null
+++ b/python/detray/detectors/utils/silicon_tracker_defaults.py
@@ -0,0 +1,65 @@
+# 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)
+
+    # Material 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)
+    metadata.add_accel_struct(Accelerator.CUBOID_GRID3D, "volume", is_default=True)
+
+
+add_silicon_tracker_defaults.clients = []
diff --git a/python/detray/detectors/utils/telescope_detector_defaults.py b/python/detray/detectors/utils/telescope_detector_defaults.py
new file mode 100644
index 000000000..22cfb42f5
--- /dev/null
+++ b/python/detray/detectors/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(
+    md: metadata, use_mat_maps=False, use_homogeneous_mat=False
+):
+    # Don't run more than once on given metadata (prevents spurious log entries)
+    if md in add_telescope_detector_defaults.clients:
+        return
+
+    add_telescope_detector_defaults.clients.append(md)
+
+    logger = logging.getLogger(__name__)
+    logger.info("Define telescope detector types:")
+
+    # Sensitive and portal shapes
+    md.add_sensitive(Shape.RECTANGLE)
+    md.add_portal(Shape.RECTANGLE)
+
+    # Acceleration struct for portals and passives
+    md.add_accel_struct(Accelerator.BRUTE_FORCE, "portal", is_default=True)
+    md.add_accel_struct(Accelerator.BRUTE_FORCE, "passive")
+    md.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")
+        md.add_material(Material.RECTANGLE_MAP2D)
+
+    # Sensitive material
+    if use_homogeneous_mat:
+        logger.info("-> requested homogeneous material types")
+        md.add_material(Material.SLAB)
+
+    # Acceleration struct for telescope detector volumes
+    logger.info("-> adding detector volume acceleration structure")
+    md.add_accel_struct(Accelerator.BRUTE_FORCE, "volume", is_default=True)
+
+
+add_telescope_detector_defaults.clients = []
diff --git a/python/detray/detectors/utils/wire_chamber_defaults.py b/python/detray/detectors/utils/wire_chamber_defaults.py
new file mode 100644
index 000000000..87e3357bd
--- /dev/null
+++ b/python/detray/detectors/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(
+    md: metadata, use_mat_maps=False, use_homogeneous_mat=False
+):
+    # Don't run more than once on given metadata (prevents spurious log entries)
+    if md in add_wire_chamber_defaults.clients:
+        return
+
+    add_wire_chamber_defaults.clients.append(md)
+
+    logger = logging.getLogger(__name__)
+    logger.info("Define wire chamber types:")
+
+    # Sensitive shapes
+    logger.info("-> adding sensitive types")
+    md.add_sensitive(Shape.DRIFT_CELL)
+    md.add_sensitive(Shape.STRAW_TUBE)
+
+    # Cylindrical volume portals (barrel and endcap)
+    logger.info("-> adding portal types")
+    md.add_portal(Shape.CONCENTRIC_CYLINDER)
+    md.add_portal(Shape.RING)
+
+    # Acceleration struct for portals and passives
+    md.add_accel_struct(Accelerator.BRUTE_FORCE, "portal", is_default=True)
+    md.add_accel_struct(Accelerator.BRUTE_FORCE, "passive")
+
+    # Surface acceleration structure for the wires
+    md.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
+        md.add_material(Material.CONCENTIRC_CYLINDER_MAP2D)
+        md.add_material(Material.DISC_MAP2D)
+        # Experimetal: map the all of the material above into 3D bins
+        # md.add_material(Material.CYLINDER3D)
+
+    if use_homogeneous_mat:
+        logger.info("-> requested homogeneous material types")
+        # Model the gas content
+        md.add_material(Material.RAW)
+
+    # Sensitive material
+    md.add_material(Material.ROD)
+
+    # Volume accelerator for layered cylindrical detectors
+    logger.info("-> adding detector volume acceleration structure")
+    md.add_accel_struct(Accelerator.CYLINDER_GRID3D, "volume", is_default=True)
+
+
+add_wire_chamber_defaults.clients = []
diff --git a/python/setup.sh.in b/python/setup.sh.in
new file mode 100644
index 000000000..c20fa1360
--- /dev/null
+++ b/python/setup.sh.in
@@ -0,0 +1,22 @@
+# 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
+
+# This script sets up the Detray Python package in the environment in a somewhat
+# robust way.
+
+if [ -n "$ZSH_VERSION" ]; then
+    python_dir=${0:a:h}
+elif [ -n "$BASH_VERSION" ]; then
+    python_dir=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}"  )" &> /dev/null && pwd  )
+else
+    # If the current shell is not ZSH or Bash, we can't guarantee that the
+    # script will work, so we throw an error.
+    echo "ERROR:   neither ZSH nor Bash was detected, other shells are not supported. The environment has not been modified."
+    exit 1
+fi
+
+# Make python package available
+export PYTHONPATH=$python_dir:$PYTHONPATH
diff --git a/tests/benchmarks/cpu/find_volume.cpp b/tests/benchmarks/cpu/find_volume.cpp
index ad1df14bf..a38d14544 100644
--- a/tests/benchmarks/cpu/find_volume.cpp
+++ b/tests/benchmarks/cpu/find_volume.cpp
@@ -44,8 +44,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/soa/intersectors.cpp b/tests/benchmarks/cpu/soa/intersectors.cpp
index 5915801a1..7b7cb617d 100644
--- a/tests/benchmarks/cpu/soa/intersectors.cpp
+++ b/tests/benchmarks/cpu/soa/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 85d11b328..9d73dc081 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());
 
@@ -520,7 +519,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 =
@@ -556,7 +555,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 38cd8c513..438e18cb4 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 65753ce3d..1a469341c 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 3b90d2fd6..0989e164a 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.
@@ -55,9 +55,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 ab8e5b343..a0e36d888 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 8714482a0..3a931f766 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::identifier geo_id{};
         geo_id.set_index(idx);
@@ -296,28 +296,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 82bc8727f..eb07f8273 100644
--- a/tests/integration_tests/cpu/propagator/jacobian_validation.cpp
+++ b/tests/integration_tests/cpu/propagator/jacobian_validation.cpp
@@ -339,7 +339,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) {
@@ -1667,11 +1667,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);
 
@@ -1681,11 +1681,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);
 
@@ -1791,7 +1791,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) {
@@ -1828,7 +1828,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 568e6413c..6bcc77afa 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,31 +126,30 @@ 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");
 
-    static_assert(
-        types::id<mapped_registry_t, cyl_intersector_t> == mask_id::e_cylinder2,
-        "ID for type cylinder intersector incorrect");
+    static_assert(types::id<mapped_registry_t, cyl_intersector_t> ==
+                      mask_id::e_cylinder2D,
+                  "ID for type cylinder intersector incorrect");
     static_assert(types::id<mapped_registry_t, rect_intersector_t> ==
-                      mask_id::e_rectangle2,
+                      mask_id::e_rectangle2D,
                   "ID for type rectangle intersector incorrect");
-    static_assert(types::id<mapped_registry_t, ring_intersector_t> ==
-                      mask_id::e_portal_ring2,
-                  "ID for type ring intersector incorrect");
+    static_assert(
+        types::id<mapped_registry_t, ring_intersector_t> == mask_id::e_ring2D,
+        "ID for type ring intersector incorrect");
     // From the point of view of the mapped registry, this is the same as for
     // the rectangle shape
     static_assert(types::id<mapped_registry_t, trpz_intersector_t> ==
-                      mask_id::e_rectangle2,
+                      mask_id::e_rectangle2D,
                   "ID for type trapezoid intersector incorrect");
 
     // contains
@@ -170,31 +168,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 465aa21ab..3b44d6d24 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());
@@ -236,14 +236,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 b3fbb611c..5d89ab1b2 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 689a9e9c7..1ca158750 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());
@@ -220,7 +220,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());
@@ -296,7 +296,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 f81589723..f0e59b632 100644
--- a/tests/unit_tests/cpu/geometry/tracking_volume.cpp
+++ b/tests/unit_tests/cpu/geometry/tracking_volume.cpp
@@ -35,7 +35,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,
 };
 
@@ -52,14 +52,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);
@@ -71,7 +71,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 545dae4e8..ae28f70f6 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 2bdfef640..020a3575e 100644
--- a/tests/unit_tests/cpu/navigation/intersection/intersection_kernel.cpp
+++ b/tests/unit_tests/cpu/navigation/intersection/intersection_kernel.cpp
@@ -48,15 +48,15 @@ const intersection::config intr_cfg{
     .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
@@ -118,35 +118,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);
@@ -202,19 +202,19 @@ GTEST_TEST(detray_intersection, intersection_kernel_ray) {
         vector3 global{0.f, 0.f, 0.f};
 
         const surface_t sf_desc = sfi_init[i].surface();
-        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());
         }
@@ -282,21 +282,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};
@@ -325,13 +325,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 c89bffd22..954582717 100644
--- a/tutorials/include/detray/tutorial/detector_metadata.hpp
+++ b/tutorials/include/detray/tutorial/detector_metadata.hpp
@@ -74,21 +74,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";
@@ -115,14 +115,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";
@@ -189,16 +189,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";
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 c3a1f2720..493258ca7 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) {