From cfeb189493503d8e28bdc117115b732c194c6293 Mon Sep 17 00:00:00 2001
From: Joana Niermann <joana.niermann@cern.ch>
Date: Fri, 13 Dec 2024 16:27:15 +0100
Subject: [PATCH] Update ITk metadata and add ODD specific metadata

---
 .../detray/builders/material_map_builder.hpp  |  31 ++-
 .../detray/detectors/default_metadata.hpp     | 232 ++++++++++--------
 .../include/detray/detectors/itk_metadata.hpp | 136 +++++-----
 .../include/detray/detectors/odd_metadata.hpp | 190 ++++++++++++++
 .../detray/detectors/telescope_metadata.hpp   |  60 +++--
 .../include/detray/detectors/toy_metadata.hpp | 126 +++++-----
 6 files changed, 524 insertions(+), 251 deletions(-)
 create mode 100644 detectors/include/detray/detectors/odd_metadata.hpp

diff --git a/core/include/detray/builders/material_map_builder.hpp b/core/include/detray/builders/material_map_builder.hpp
index b994c7e71..28bb67dee 100644
--- a/core/include/detray/builders/material_map_builder.hpp
+++ b/core/include/detray/builders/material_map_builder.hpp
@@ -246,21 +246,26 @@ struct add_sf_material_map {
             // The detector only knows the non-owning grid types
             using non_owning_t =
                 typename decltype(mat_grid)::template type<false>;
-            static_assert(materials_t::template is_defined<non_owning_t>());
 
-            // Add the material slabs to the grid
-            for (const auto& bin : bin_data) {
-                mat_grid.template populate<replace<>>(bin.local_bin_idx,
-                                                      bin.single_element);
+            // Not every mask shape might be used for material maps
+            if constexpr (materials_t::template is_defined<non_owning_t>()) {
+                // Add the material slabs to the grid
+                for (const auto& bin : bin_data) {
+                    mat_grid.template populate<replace<>>(bin.local_bin_idx,
+                                                          bin.single_element);
+                }
+
+                // Add the material grid to the detector
+                constexpr auto gid{
+                    materials_t::template get_id<non_owning_t>()};
+                mat_store.template push_back<gid>(mat_grid);
+
+                // Return the index of the new material map
+                return {gid, static_cast<dindex>(
+                                 mat_store.template size<gid>() - 1u)};
+            } else {
+                return {materials_t::id::e_none, dindex_invalid};
             }
-
-            // Add the material grid to the detector
-            constexpr auto gid{materials_t::template get_id<non_owning_t>()};
-            mat_store.template push_back<gid>(mat_grid);
-
-            // Return the index of the new material map
-            return {gid,
-                    static_cast<dindex>(mat_store.template size<gid>() - 1u)};
         } else {
             return {materials_t::id::e_none, dindex_invalid};
         }
diff --git a/detectors/include/detray/detectors/default_metadata.hpp b/detectors/include/detray/detectors/default_metadata.hpp
index 1a0f3158a..317e55c13 100644
--- a/detectors/include/detray/detectors/default_metadata.hpp
+++ b/detectors/include/detray/detectors/default_metadata.hpp
@@ -37,6 +37,15 @@ struct default_metadata {
     /// 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>;
@@ -67,9 +76,51 @@ struct default_metadata {
         mask<unbounded<line_square>, algebra_type, nav_link>;
     using unmasked_plane = mask<unmasked<>, algebra_type, nav_link>;
 
-    /// Material types
+    /// 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 = 0,
+        e_portal_rectangle2 = 0,
+        e_trapezoid2 = 1,
+        e_annulus2 = 2,
+        e_cylinder2 = 3,
+        e_portal_cylinder2 = 4,
+        e_ring2 = 5,
+        e_portal_ring2 = 5,
+        e_straw_tube = 6,
+        e_drift_cell = 7,
+        /*e_single1 = 8,
+        e_single2 = 9,
+        e_single3 = 10,
+        e_unbounded_rectangle2 = 11,
+        e_unbounded_trapezoid2 = 12,
+        e_unbounded_annulus2 = 13,
+        e_unbounded_cylinder2 = 14,
+        e_unbounded_disc2 = 15,
+        e_unbounded_line_circular2 = 16,
+        e_unbounded_cell2 = 17,
+        e_unmasked2 = 18,*/
+    };
+
+    /// How to store masks
+    template <template <typename...> class vector_t = dvector>
+    using mask_store = regular_multi_store<mask_ids, empty_context, dtuple,
+                                           vector_t, rectangle, trapezoid,
+                                           annulus, cylinder, cylinder_portal,
+                                           disc, straw_tube, drift_cell /*,
+single_1, single_2, single_3, unbounded_rectangle, unbounded_trapezoid,
+unbounded_annulus, unbounded_cylinder, unbounded_disc, unbounded_straw_tube,
+unbounded_cell, unmasked_plane*/>;
+
+    //
+    // Material Description
+    //
+
+    /// Homogeneous material description
+    /// @{
     using slab = material_slab<scalar_t>;
     using rod = material_rod<scalar_t>;
+    /// @}
 
     /// Material grid types (default: closed bounds, regular binning)
     /// @{
@@ -102,6 +153,46 @@ struct default_metadata {
 
     /// @}
 
+    /// 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 = 0u,
+        e_drift_cell_map = 5u,
+        e_straw_tube_map = 5u,
+        // Volume material
+        e_cuboid3_map = 7,
+        e_cylinder3_map = 8u,
+        // Homogeneous mapetrial
+        e_slab = 4u,
+        e_rod = 5u,
+        e_raw_material = 6u,
+        e_none = 9u,
+    };
+
+    /// 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)?
@@ -151,83 +242,19 @@ struct default_metadata {
 
     /// @}
 
-    /// 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>;
-
-    /// 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 = 0,
-        e_portal_rectangle2 = 0,
-        e_trapezoid2 = 1,
-        e_annulus2 = 2,
-        e_cylinder2 = 3,
-        e_portal_cylinder2 = 4,
-        e_ring2 = 5,
-        e_portal_ring2 = 5,
-        e_straw_tube = 6,
-        e_drift_cell = 7,
-        /*e_single1 = 8,
-        e_single2 = 9,
-        e_single3 = 10,
-        e_unbounded_rectangle2 = 11,
-        e_unbounded_trapezoid2 = 12,
-        e_unbounded_annulus2 = 13,
-        e_unbounded_cylinder2 = 14,
-        e_unbounded_disc2 = 15,
-        e_unbounded_line_circular2 = 16,
-        e_unbounded_cell2 = 17,
-        e_unmasked2 = 18,*/
-    };
-
-    /// 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*/>;
-
-    /// 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_disc2_map = 0u,
-        e_concentric_cylinder2_map = 1u,
-        e_cylinder2_map = 2u,
-        e_rectangle2_map = 3u,
-        e_trapezoid2_map = 3u,
-        e_annulus2_map = 0u,
-        e_drift_cell_map = 5u,
-        e_straw_tube_map = 5u,
-        // Volume material
-        e_cuboid3_map = 7,
-        e_cylinder3_map = 8u,
-        // Homogeneous mapetrial
-        e_slab = 4u,
-        e_rod = 5u,
-        e_raw_material = 6u,
-        e_none = 9u,
+    /// Acceleration data structures
+    enum class accel_ids : std::uint_least8_t {
+        e_brute_force = 0,     // test all surfaces in a volume (brute force)
+        e_cylinder2_grid = 1,  // e.g. barrel layers
+        e_disc_grid = 2,       // e.g. endcap layers
+        e_irr_cylinder2_grid = 3,
+        e_irr_disc_grid = 4,
+        // e_cylinder3_grid = 5,
+        // e_irr_cylinder3_grid = 6,
+        // ... e.g. frustum navigation types
+        e_default = e_brute_force,
     };
 
-    /// How to store materials
-    template <typename container_t = host_container_types>
-    using material_store = multi_store<
-        material_ids, empty_context, dtuple,
-        grid_collection<disc_map_t<container_t>>,
-        grid_collection<concentric_cylinder2_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>>>;
-
     /// How to link to the entries in the data stores
     using transform_link = typename transform_store<>::link_type;
     using mask_link = typename mask_store<>::single_link;
@@ -236,6 +263,27 @@ unbounded_cell, unmasked_plane*/>;
     using surface_type =
         surface_descriptor<mask_link, material_link, transform_link, nav_link>;
 
+    /// 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_cylinder2D_sf_grid<surface_type, container_t>>,
+                    grid_collection<
+                        irr_disc_sf_grid<surface_type, container_t>> /*,
+grid_collection<cylinder3D_sf_grid<surface_type,
+container_t>>,
+grid_collection<irr_cylinder3D_sf_grid<surface_type,
+container_t>>*/>;
+
+    //
+    // 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)
@@ -247,40 +295,14 @@ unbounded_cell, unmasked_plane*/>;
         e_all = e_size,   // i.e. the brute force method and one grid type
     };
 
-    /// Acceleration data structures
-    enum class accel_ids : std::uint_least8_t {
-        e_brute_force = 0,     // test all surfaces in a volume (brute force)
-        e_disc_grid = 1,       // e.g. endcap layers
-        e_cylinder2_grid = 2,  // e.g. barrel layers
-        e_irr_disc_grid = 3,
-        e_irr_cylinder2_grid = 4,
-        // e_cylinder3_grid = 5,
-        // e_irr_cylinder3_grid = 6,
-        // ... e.g. frustum navigation types
-        e_default = e_brute_force,
-    };
-
     /// 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>;
 
-    /// 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<disc_sf_grid<surface_type, container_t>>,
-                    grid_collection<
-                        cylinder2D_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<cylinder3D_sf_grid<surface_type,
-container_t>>,
-grid_collection<irr_cylinder3D_sf_grid<surface_type,
-container_t>>*/>;
+    //
+    // Volume acceleration structure
+    //
 
     /// Volume search grid
     template <typename container_t = host_container_types>
diff --git a/detectors/include/detray/detectors/itk_metadata.hpp b/detectors/include/detray/detectors/itk_metadata.hpp
index c79d0d73f..3f5450a1d 100644
--- a/detectors/include/detray/detectors/itk_metadata.hpp
+++ b/detectors/include/detray/detectors/itk_metadata.hpp
@@ -40,11 +40,16 @@ struct itk_metadata {
 
     /// Define the algebra type for the geometry and navigation
     using algebra_type = algebra_t;
-    using scalar_t = dscalar<algebra_type>;
 
     /// Portal link type between volumes
     using nav_link = std::uint_least16_t;
 
+    /// How to store and link transforms. The geometry context allows to resolve
+    /// the conditions data for e.g. module alignment
+    template <template <typename...> class vector_t = dvector>
+    using transform_store =
+        single_store<dtransform3D<algebra_type>, vector_t, geometry_context>;
+
     //
     // Surface Primitives
     //
@@ -52,38 +57,11 @@ struct itk_metadata {
     /// The mask types for the detector sensitive surfaces
     using annulus = mask<annulus2D, algebra_type, nav_link>;
     using rectangle = mask<rectangle2D, algebra_type, nav_link>;
+
     // Types for portals
     using cylinder_portal = mask<concentric_cylinder2D, algebra_type, nav_link>;
     using disc_portal = mask<ring2D, algebra_type, nav_link>;
 
-    //
-    // Material Description
-    //
-
-    /// The material types to be mapped onto the surfaces: Here homogeneous
-    /// material
-    using slab = material_slab<scalar_t>;
-
-    // Cylindrical material map
-    template <typename container_t>
-    using cylinder_map_t =
-        material_map<algebra_type, concentric_cylinder2D, container_t>;
-
-    // Disc material map
-    template <typename container_t>
-    using disc_map_t = material_map<algebra_type, ring2D, container_t>;
-
-    // Rectangular material map
-    template <typename container_t>
-    using rectangular_map_t =
-        material_map<algebra_type, rectangle2D, container_t>;
-
-    /// How to store and link transforms. The geometry context allows to resolve
-    /// the conditions data for e.g. module alignment
-    template <template <typename...> class vector_t = dvector>
-    using transform_store =
-        single_store<dtransform3D<algebra_type>, vector_t, geometry_context>;
-
     /// Assign the mask types to the mask tuple container entries. It may be a
     /// good idea to have the most common types in the first tuple entries, in
     /// order to minimize the depth of the 'unrolling' before a mask is found
@@ -103,14 +81,28 @@ struct itk_metadata {
         regular_multi_store<mask_ids, empty_context, dtuple, vector_t,
                             rectangle, annulus, cylinder_portal, disc_portal>;
 
+    //
+    // Material Description
+    //
+
+    /// The material types to be mapped onto the surfaces: Here homogeneous
+    /// material
+    using slab = material_slab<scalar_t>;
+
+    // Cylindrical material map
+    template <typename container_t>
+    using cylinder_map_t =
+        material_map<algebra_type, concentric_cylinder2D, container_t>;
+
+    // Disc material map
+    template <typename container_t>
+    using disc_map_t = material_map<algebra_type, ring2D, container_t>;
+
     /// Similar to the mask store, there is a material store, which
     enum class material_ids : std::uint_least8_t {
-        e_disc2_map = 0u,
-        e_annulus2_map = 0u,
-        e_concentric_cylinder2_map = 1u,
-        e_reactangle2_map = 2u,
-        e_slab = 3u,  //< keep for the EF-tracking geometry
-        e_none = 4u,
+        e_concentric_cylinder2_map = 0u,
+        e_disc2_map = 1u,
+        e_none = 2u,
     };
 
     /// How to store and link materials. The material does not make use of
@@ -118,10 +110,36 @@ struct itk_metadata {
     template <typename container_t = host_container_types>
     using material_store =
         multi_store<material_ids, empty_context, dtuple,
-                    grid_collection<disc_map_t<container_t>>,
                     grid_collection<cylinder_map_t<container_t>>,
-                    grid_collection<rectangular_map_t<container_t>>,
-                    typename container_t::template vector_type<slab>>;
+                    grid_collection<disc_map_t<container_t>>>;
+
+    //
+    // Acceleration structures
+    //
+
+    // surface grid definition: dynamic bin size
+    template <typename axes_t, typename bin_entry_t, typename container_t>
+    using surface_grid_t =
+        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>;
+
+    /// The acceleration data structures live in another tuple that needs to be
+    /// indexed correctly:
+    enum class accel_ids : std::uint_least8_t {
+        e_brute_force = 0,     // test all surfaces in a volume (brute force)
+        e_cylinder2_grid = 1,  // barrel
+        e_disc_grid = 2,       // endcap
+        e_default = e_brute_force,
+    };
 
     /// Surface descriptor type used for sensitives, passives and portals
     /// It holds the indices to the surface data in the detector data stores
@@ -133,21 +151,30 @@ struct itk_metadata {
     using surface_type =
         surface_descriptor<mask_link, material_link, transform_link, nav_link>;
 
+    /// 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>>>;
+
+    //
+    // Volume descriptors
+    //
+
     /// How to index the constituent objects in a volume
     /// If they share the same index value here, they will be added into the
     /// same acceleration data structure in every respective volume
     enum geo_objects : std::uint_least8_t {
-        e_surface = 0u,  //< This detector keeps all surfaces in the same
-        e_portal = 0u,   //  acceleration data structure (id 0)
-        e_passive = 0u,
-        e_size = 1u
-    };
-
-    /// The acceleration data structures live in another tuple that needs to be
-    /// indexed correctly:
-    enum class accel_ids : std::uint_least8_t {
-        e_brute_force = 0u,  //< test all surfaces in a volume (brute force)
-        e_default = e_brute_force,
+        e_portal = 0,
+        e_passive = 0,
+        e_sensitive = 1,
+        e_size = 2,
+        e_all = e_size,
     };
 
     /// How a volume finds its constituent objects in the detector containers
@@ -155,14 +182,9 @@ struct itk_metadata {
     using object_link_type =
         dmulti_index<dtyped_index<accel_ids, dindex>, geo_objects::e_size>;
 
-    /// 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>>;
+    //
+    // Volume acceleration structure
+    //
 
     /// Data structure that allows to find the current detector volume from a
     /// given position. Here: Uniform grid with a 3D cylindrical shape
diff --git a/detectors/include/detray/detectors/odd_metadata.hpp b/detectors/include/detray/detectors/odd_metadata.hpp
new file mode 100644
index 000000000..1767d25f7
--- /dev/null
+++ b/detectors/include/detray/detectors/odd_metadata.hpp
@@ -0,0 +1,190 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 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/detail/containers.hpp"
+#include "detray/definitions/detail/indexing.hpp"
+#include "detray/geometry/detail/surface_descriptor.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/materials/material_map.hpp"
+#include "detray/navigation/accelerators/brute_force_finder.hpp"
+#include "detray/navigation/accelerators/surface_grid.hpp"
+
+// Linear algebra types
+#include "detray/definitions/detail/algebra.hpp"
+
+namespace detray {
+
+//
+// ODD Detector
+//
+
+/// Defines a detector type that is design to contain the ODD geometry
+template <concepts::algebra algebra_t>
+struct odd_metadata {
+
+    /// Define the algebra type for the geometry and navigation
+    using algebra_type = algebra_t;
+
+    /// Portal link type between volumes
+    using nav_link = std::uint_least16_t;
+
+    /// How to store and link transforms. The geometry context allows to resolve
+    /// the conditions data for e.g. module alignment
+    template <template <typename...> class vector_t = dvector>
+    using transform_store =
+        single_store<dtransform3D<algebra_type>, vector_t, geometry_context>;
+
+    //
+    // Surface Primitives
+    //
+
+    /// The mask types for the ODD sensitive surfaces
+    using rectangle = mask<rectangle2D, nav_link>;
+    using trapezoid = mask<trapezoid2D, nav_link>;
+
+    // Types for portals
+    using cylinder_portal = mask<concentric_cylinder2D, nav_link>;
+    using disc_portal = mask<ring2D, nav_link>;
+
+    /// Assign the mask types to the mask tuple container entries.
+    enum class mask_ids : std::uint_least8_t {
+        e_rectangle2 = 0u,
+        e_trapezoid2 = 1u,
+        e_portal_cylinder2 = 2u,
+        e_portal_ring2 = 3u,
+    };
+
+    /// This is the mask collections tuple (in the detector called 'mask store')
+    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_portal>;
+
+    //
+    // Material Description
+    //
+
+    // Used for "ODD light"
+    using slab = material_slab<scalar_t>;
+
+    // Cylindrical material map
+    template <typename container_t>
+    using cylinder_map_t =
+        material_map<concentric_cylinder2D, scalar, container_t>;
+
+    // Disc material map
+    template <typename container_t>
+    using disc_map_t = material_map<ring2D, scalar, container_t>;
+
+    // Rectangular material map (material mapped to sensitive surface)
+    template <typename container_t>
+    using rectangular_map_t =
+        material_map<algebra_type, rectangle2D, container_t>;
+
+    /// Define positions of ODD material types in detector material store
+    enum class material_ids : std::uint_least8_t {
+        e_concentric_cylinder2_map = 0u,
+        e_disc2_map = 1u,
+        e_rectangle2_map = 2u,
+        e_trapezoid2_map = 2u,
+        e_slab = 3u,
+        e_none = 4u,
+    };
+
+    /// How to store and link materials. The material does not make use of
+    /// conditions data ( @c empty_context )
+    template <typename container_t = host_container_types>
+    using material_store =
+        multi_store<material_ids, empty_context, dtuple,
+                    grid_collection<cylinder_map_t<container_t>>,
+                    grid_collection<disc_map_t<container_t>>,
+                    grid_collection<rectangular_map_t<container_t>>,
+                    typename container_t::template vector_type<slab>>;
+
+    //
+    // Acceleration Structures
+    //
+
+    // Surface grid definition: dynamic bin size
+    template <typename axes_t, typename bin_entry_t, typename container_t>
+    using surface_grid_t =
+        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>;
+
+    /// The acceleration data structures live in another tuple that needs to be
+    /// indexed correctly:
+    enum class accel_ids : std::uint_least8_t {
+        e_brute_force = 0,     // test all surfaces in a volume (brute force)
+        e_disc_grid = 1,       // endcap
+        e_cylinder2_grid = 2,  // barrel
+        e_default = e_brute_force,
+    };
+
+    /// Surface descriptor type used for sensitives, passives and portals
+    using transform_link = typename transform_store<>::link_type;
+    using mask_link = typename mask_store<>::single_link;
+    using material_link = typename material_store<>::single_link;
+    using surface_type =
+        surface_descriptor<mask_link, material_link, transform_link, nav_link>;
+
+    /// The tuple store that hold the acceleration data structures for all
+    /// volumes.
+    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>>>;
+
+    //
+    // Volume descriptors
+    //
+
+    /// How to index the constituent objects in a volume
+    enum geo_objects : std::uint_least8_t {
+        e_portal = 0,
+        e_passive = 0,
+        e_sensitive = 1,
+        e_size = 2,
+        e_all = e_size,
+    };
+
+    /// How a volume finds its constituent objects in the detector containers
+    using object_link_type =
+        dmulti_index<dtyped_index<accel_ids, dindex>, geo_objects::e_size>;
+
+    //
+    // Volume acceleration structure
+    //
+
+    /// Uniform grid with a 3D cylindrical shape
+    template <typename container_t = host_container_types>
+    using volume_finder =
+        grid<axes<cylinder3D, axis::bounds::e_open, axis::irregular,
+                  axis::regular, axis::irregular>,
+             bins::single<dindex>, simple_serializer, container_t>;
+};
+
+}  // namespace detray
diff --git a/detectors/include/detray/detectors/telescope_metadata.hpp b/detectors/include/detray/detectors/telescope_metadata.hpp
index 221b197c5..95a797938 100644
--- a/detectors/include/detray/detectors/telescope_metadata.hpp
+++ b/detectors/include/detray/detectors/telescope_metadata.hpp
@@ -34,21 +34,21 @@ struct telescope_metadata {
     /// Mask to (next) volume link: next volume(s)
     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 (these types are needed for the portals, which are always
     /// there, and to resolve the wire surface material, i.e. slab vs. rod)
     using rectangle = mask<rectangle2D, algebra_type, nav_link>;
     using straw_tube = mask<line_circular, algebra_type, nav_link>;
     using drift_cell = mask<line_square, algebra_type, nav_link>;
 
-    /// Material types
-    using rod = material_rod<scalar_t>;
-    using slab = material_slab<scalar_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>;
-
     /// 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 {
@@ -83,6 +83,14 @@ struct telescope_metadata {
                             rectangle,
                             mask<mask_shape_t, algebra_type, nav_link>>>;
 
+    //
+    // Material Description
+    //
+
+    /// Material types
+    using rod = material_rod<scalar_t>;
+    using slab = material_slab<scalar_t>;
+
     /// Material type ids
     enum class material_ids : std::uint_least8_t {
         e_slab = 0u,
@@ -104,6 +112,16 @@ struct telescope_metadata {
                             container_t::template vector_type, slab,
                             material<scalar_t>>>;
 
+    //
+    // Acceleration structures
+    //
+
+    /// Acceleration data structures
+    enum class accel_ids {
+        e_brute_force = 0,  // test all surfaces in a volume (brute force)
+        e_default = e_brute_force,
+    };
+
     /// How to link to the entries in the data stores
     using transform_link = typename transform_store<>::link_type;
     using mask_link = typename mask_store<>::single_link;
@@ -112,6 +130,16 @@ struct telescope_metadata {
     using surface_type =
         surface_descriptor<mask_link, material_link, transform_link, nav_link>;
 
+    /// How to store the brute force search data structure
+    template <typename container_t = host_container_types>
+    using accelerator_store =
+        multi_store<accel_ids, empty_context, dtuple,
+                    brute_force_collection<surface_type, container_t>>;
+
+    //
+    // Volume descriptors
+    //
+
     /// No grids/other acceleration data structure, everything is brute forced
     enum geo_objects : std::uint_least8_t {
         e_portal = 0,
@@ -120,21 +148,13 @@ struct telescope_metadata {
         e_all = e_size,
     };
 
-    /// Acceleration data structures
-    enum class accel_ids {
-        e_brute_force = 0,  // test all surfaces in a volume (brute force)
-        e_default = e_brute_force,
-    };
-
     /// One link for all surfaces (in the brute force method)
     using object_link_type =
         dmulti_index<dtyped_index<accel_ids, dindex>, geo_objects::e_size>;
 
-    /// How to store the brute force search data structure
-    template <typename container_t = host_container_types>
-    using accelerator_store =
-        multi_store<accel_ids, empty_context, dtuple,
-                    brute_force_collection<surface_type, container_t>>;
+    //
+    // Volume acceleration structure
+    //
 
     /// Volume search (only one volume exists)
     template <typename container_t = host_container_types>
diff --git a/detectors/include/detray/detectors/toy_metadata.hpp b/detectors/include/detray/detectors/toy_metadata.hpp
index 1dd8afcea..c9a6cd2ab 100644
--- a/detectors/include/detray/detectors/toy_metadata.hpp
+++ b/detectors/include/detray/detectors/toy_metadata.hpp
@@ -37,14 +37,43 @@ struct toy_metadata {
     /// Mask to (next) volume link: next volume(s)
     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 = mask<cylinder2D, algebra_type, nav_link>;  // beampipe
     using cylinder_portal = mask<concentric_cylinder2D, algebra_type, nav_link>;
     using disc_portal = mask<ring2D, algebra_type, nav_link>;
 
-    /// Material types
+    /// Mask type ids
+    enum class mask_ids : std::uint_least8_t {
+        e_rectangle2 = 0,
+        e_trapezoid2 = 1,
+        e_portal_cylinder2 = 2,
+        e_portal_ring2 = 3,
+        e_cylinder2 = 2,
+    };
+
+    /// 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_portal>;
+
+    //
+    // Material Description
+    //
+
+    // Homogeneous material description
     using slab = material_slab<scalar_t>;
 
     // Cylindrical material grid
@@ -56,10 +85,25 @@ struct toy_metadata {
     template <typename container_t>
     using disc_map_t = material_map<algebra_type, ring2D, container_t>;
 
-    // Rectangular material grid
-    template <typename container_t>
-    using rectangular_map_t =
-        material_map<algebra_type, rectangle2D, container_t>;
+    /// Material type ids
+    enum class material_ids : std::uint_least8_t {
+        e_concentric_cylinder2_map = 0u,
+        e_disc2_map = 1u,
+        e_slab = 2u,
+        e_none = 3u,
+    };
+
+    /// How to store materials
+    template <typename container_t = host_container_types>
+    using material_store =
+        multi_store<material_ids, empty_context, dtuple,
+                    grid_collection<cylinder_map_t<container_t>>,
+                    grid_collection<disc_map_t<container_t>>,
+                    typename container_t::template vector_type<slab>>;
+
+    //
+    // Acceleration structures
+    //
 
     /// Surface grid types (regular, open binning)
     /// @{
@@ -81,44 +125,14 @@ struct toy_metadata {
 
     /// @}
 
-    /// 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>;
-
-    /// Mask type ids
-    enum class mask_ids : std::uint_least8_t {
-        e_rectangle2 = 0,
-        e_trapezoid2 = 1,
-        e_portal_cylinder2 = 2,
-        e_portal_ring2 = 3,
-        e_cylinder2 = 2,
-    };
-
-    /// 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_portal>;
-
-    /// Material type ids
-    enum class material_ids : std::uint_least8_t {
-        e_disc2_map = 0u,
-        e_concentric_cylinder2_map = 1u,
-        e_rectangle2_map = 2u,
-        e_slab = 3u,
-        e_none = 4u,
+    /// Acceleration data structures
+    enum class accel_ids : std::uint_least8_t {
+        e_brute_force = 0,     // test all surfaces in a volume (brute force)
+        e_cylinder2_grid = 1,  // barrel
+        e_disc_grid = 2,       // endcap
+        e_default = e_brute_force,
     };
 
-    /// How to store materials
-    template <typename container_t = host_container_types>
-    using material_store =
-        multi_store<material_ids, empty_context, dtuple,
-                    grid_collection<disc_map_t<container_t>>,
-                    grid_collection<cylinder_map_t<container_t>>,
-                    grid_collection<rectangular_map_t<container_t>>,
-                    typename container_t::template vector_type<slab>>;
-
     /// How to link to the entries in the data stores
     using transform_link = typename transform_store<>::link_type;
     using mask_link = typename mask_store<>::single_link;
@@ -127,6 +141,18 @@ struct toy_metadata {
     using surface_type =
         surface_descriptor<mask_link, material_link, transform_link, nav_link>;
 
+    /// 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<cylinder_sf_grid<surface_type, container_t>>,
+        grid_collection<disc_sf_grid<surface_type, container_t>>>;
+
+    //
+    // Volume descriptors
+    //
+
     /// Portals and passives in the brute froce search, sensitives in the grids
     enum geo_objects : std::uint_least8_t {
         e_portal = 0,
@@ -136,25 +162,13 @@ struct toy_metadata {
         e_all = e_size,
     };
 
-    /// Acceleration data structures
-    enum class accel_ids : std::uint_least8_t {
-        e_brute_force = 0,     // test all surfaces in a volume (brute force)
-        e_disc_grid = 1,       // endcap
-        e_cylinder2_grid = 2,  // barrel
-        e_default = e_brute_force,
-    };
-
     /// One link for portals/passives and one sensitive surfaces
     using object_link_type =
         dmulti_index<dtyped_index<accel_ids, dindex>, geo_objects::e_size>;
 
-    /// 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<disc_sf_grid<surface_type, container_t>>,
-        grid_collection<cylinder_sf_grid<surface_type, container_t>>>;
+    //
+    // Volume acceleration structure
+    //
 
     /// Volume search grid
     template <typename container_t = host_container_types>