diff --git a/core/CMakeLists.txt b/core/CMakeLists.txt
index 85dba5e918..c4b6cd25cc 100644
--- a/core/CMakeLists.txt
+++ b/core/CMakeLists.txt
@@ -56,21 +56,21 @@ detray_add_library( detray_core core
    "include/detray/intersection/line_intersector.hpp"
    "include/detray/intersection/plane_intersector.hpp"
    # masks include(s)
-   "include/detray/masks/annulus2.hpp"
-   "include/detray/masks/cylinder3.hpp"
+   "include/detray/masks/annulus2D.hpp"
+   "include/detray/masks/cuboid3D.hpp"
+   "include/detray/masks/cylinder3D.hpp"
    "include/detray/masks/line.hpp"
    "include/detray/masks/masks.hpp"
-   "include/detray/masks/masks_base.hpp"
-   "include/detray/masks/rectangle2.hpp"
-   "include/detray/masks/ring2.hpp"
-   "include/detray/masks/single3.hpp"
-   "include/detray/masks/trapezoid2.hpp"
+   "include/detray/masks/rectangle2D.hpp"
+   "include/detray/masks/ring2D.hpp"
+   "include/detray/masks/single3D.hpp"
+   "include/detray/masks/trapezoid2D.hpp"
    "include/detray/masks/unmasked.hpp"
    # materials include(s)
-   "include/detray/materials/mixture.hpp" 
+   "include/detray/materials/mixture.hpp"
    "include/detray/materials/material.hpp"
-   "include/detray/materials/material_rod.hpp"   
-   "include/detray/materials/material_slab.hpp"   
+   "include/detray/materials/material_rod.hpp"
+   "include/detray/materials/material_slab.hpp"
    "include/detray/materials/predefined_materials.hpp"
    # propagator include(s)
    "include/detray/propagator/aborters.hpp"
@@ -85,6 +85,22 @@ detray_add_library( detray_core core
    "include/detray/propagator/navigator.hpp"
    "include/detray/propagator/propagator.hpp"
    "include/detray/propagator/rk_stepper.hpp"
+   # surface finder include(s)
+   "include/detray/surface_finders/brute_force_finder.hpp"
+   "include/detray/surface_finders/grid2_finder.hpp"
+   "include/detray/surface_finders/neighborhood_kernel.hpp"
+   # surface finder include(s)
+   "include/detray/surface_finders/grid/detail/axis_binning.hpp"
+   "include/detray/surface_finders/grid/detail/axis_helpers.hpp"
+   "include/detray/surface_finders/grid/detail/axis_shape.hpp"
+   "include/detray/surface_finders/grid/detail/grid_helpers.hpp"
+   "include/detray/surface_finders/grid/detail/populator_impl.hpp"
+   "include/detray/surface_finders/grid/detail/serializer_impl.hpp"
+   "include/detray/surface_finders/grid/axis.hpp"
+   "include/detray/surface_finders/grid/grid_builder.hpp"
+   "include/detray/surface_finders/grid/grid.hpp"
+   "include/detray/surface_finders/grid/populator.hpp"
+   "include/detray/surface_finders/grid/serializer.hpp"
    # tools include(s)
    "include/detray/tools/associator.hpp"
    "include/detray/tools/bin_association.hpp"
diff --git a/core/include/detray/coordinates/cylindrical2.hpp b/core/include/detray/coordinates/cylindrical2.hpp
index 6ed134aa9b..f08f9fde49 100644
--- a/core/include/detray/coordinates/cylindrical2.hpp
+++ b/core/include/detray/coordinates/cylindrical2.hpp
@@ -16,7 +16,7 @@
 
 namespace detray {
 
-/** Local frame projection into a polar coordinate frame
+/** Local frame projection into a 2D cylindrical coordinate frame
  */
 template <typename transform3_t>
 struct cylindrical2 : public coordinate_base<cylindrical2, transform3_t> {
@@ -60,7 +60,7 @@ struct cylindrical2 : public coordinate_base<cylindrical2, transform3_t> {
     DETRAY_HOST_DEVICE inline point3 local_to_global(
         const transform3_t &trf, const mask_t &mask, const point2 &p,
         const vector3 & /*d*/) const {
-        const scalar_type r = mask.radius();
+        const scalar_type r = mask[0];
         const scalar_type phi = p[0] / r;
         const scalar_type x = r * std::cos(phi);
         const scalar_type y = r * std::sin(phi);
diff --git a/core/include/detray/core/detail/tuple_array_container.hpp b/core/include/detray/core/detail/tuple_array_container.hpp
index 548b058d88..c4f1cd5fe0 100644
--- a/core/include/detray/core/detail/tuple_array_container.hpp
+++ b/core/include/detray/core/detail/tuple_array_container.hpp
@@ -56,6 +56,8 @@ class tuple_array_container<tuple_t, array_t, id_t, std::index_sequence<Ns...>,
 
     using container_type = typename base_type::container_type;
 
+    tuple_array_container() = default;
+
     /**
      * Constructor with a vecmem memory resource. (host-side only)
      *
diff --git a/core/include/detray/core/detail/tuple_container.hpp b/core/include/detray/core/detail/tuple_container.hpp
index 6c7b7f0761..a6758e740b 100644
--- a/core/include/detray/core/detail/tuple_container.hpp
+++ b/core/include/detray/core/detail/tuple_container.hpp
@@ -82,7 +82,7 @@ class tuple_container {
      */
     template <id_t ID>
     DETRAY_HOST_DEVICE size_t size() const {
-        return detail::get<ID>(m_container).size();
+        return detail::get<to_index(ID)>(m_container).size();
     }
 
     /**
@@ -93,7 +93,7 @@ class tuple_container {
      */
     template <id_t ID>
     DETRAY_HOST_DEVICE bool empty() const {
-        return detail::get<ID>(m_container).empty();
+        return detail::get<to_index(ID)>(m_container).empty();
     }
 
     /**
@@ -104,7 +104,7 @@ class tuple_container {
      */
     template <id_t ID>
     DETRAY_HOST_DEVICE constexpr auto &group() {
-        return detail::get<ID>(m_container);
+        return detail::get<to_index(ID)>(m_container);
     }
 
     /**
@@ -115,17 +115,17 @@ class tuple_container {
      */
     template <id_t ID>
     DETRAY_HOST_DEVICE constexpr const auto &group() const {
-        return detail::get<ID>(m_container);
+        return detail::get<to_index(ID)>(m_container);
     }
 
-    /** Enforce usage id_t in the code and do some (limited)
-     *  checking.
-     *
-     * @tparam ref_idx matches to index arg to perform static checks
-     * @param index argument to be converted to valid id type
-     *
-     * @return the matching ID type.
-     */
+    /// @brief Convert index of the tuple to an id.
+    ///
+    /// The function uses unrolling, so that it can be used as a constant expr.
+    ///
+    /// @tparam ref_idx matches to index arg to perform static checks
+    /// @param index argument to be converted to valid id type
+    ///
+    /// @return the matching ID.
     template <std::size_t ref_idx = 0>
     DETRAY_HOST_DEVICE static constexpr id_t to_id(const std::size_t index) {
         if (ref_idx == index) {
@@ -133,7 +133,7 @@ class tuple_container {
             static_assert(
                 ref_idx < sizeof...(Ts),
                 "Index out of range: Please make sure that indices and type "
-                "enums match the number of types in container.");
+                "enums match the number of types in the tuple container.");
             return static_cast<id_t>(index);
         }
         if constexpr (ref_idx < sizeof...(Ts) - 1) {
@@ -143,23 +143,70 @@ class tuple_container {
         return static_cast<id_t>(sizeof...(Ts));
     }
 
-    /** Execute functor for a group with specific ID. The group is found by
-     * unrolling varidically
-     *
-     * @tparam functor_t is the functor type
-     * @tparam size_type is type for index
-     * @tparam Args is argument type for the functor
-     *
-     * @param id is the target group index
-     * @param As is the functor arguments
-     *
-     * @return the functor output
-     */
-    template <typename functor_t, typename size_type, typename... Args>
-    DETRAY_HOST_DEVICE typename functor_t::output_type execute(
-        const size_type id, Args &&... As) const {
+    /// @brief Convert an id to an index of the tuple.
+    ///
+    /// The function uses unrolling, so that it can be used as a constant expr.
+    ///
+    /// @tparam ref_idx matches to index arg to perform static checks
+    /// @param id type id that should be used to index a tuple element
+    ///
+    /// @return the matching index.
+    template <std::size_t ref_idx = 0>
+    DETRAY_HOST_DEVICE static constexpr std::size_t to_index(const id_t id) {
+        if (to_id(ref_idx) == id) {
+            // Produce a more helpful error than the usual tuple index error
+            static_assert(
+                ref_idx < sizeof...(Ts),
+                "Index out of range: This ID cannot be used to index the tuple "
+                "container.");
+            return ref_idx;
+        }
+        if constexpr (ref_idx < sizeof...(Ts) - 1) {
+            return to_index<ref_idx + 1>(id);
+        }
+        // This produces a compiler error when used in type unrolling code
+        return sizeof...(Ts);
+    }
 
-        return unroll<functor_t>(id, std::make_index_sequence<sizeof...(Ts)>{},
+    /// Calls a functor for a group with specific ID. The group is found by
+    /// unrolling varidically
+    ///
+    /// @tparam functor_t functor that will be called on the group.
+    /// @tparam Args argument types for the functor
+    ///
+    /// @param id is the target group id
+    /// @param As additional functor arguments
+    ///
+    /// @return the functor output
+    template <typename functor_t, typename... Args>
+    DETRAY_HOST_DEVICE typename functor_t::output_type call(
+        const id_t id, Args &&... As) const {
+
+        // An invalid range will be interpreted by the detray range iterator to
+        // mean the entire range. Otherwise use overload function below to
+        // specify a valid range
+        return unroll<functor_t>(id, dindex_range{0, dindex_invalid},
+                                 std::make_index_sequence<sizeof...(Ts)>{},
+                                 std::forward<Args>(As)...);
+    }
+
+    /// Calls a functor for a group with specific ID. The group is found by
+    /// unrolling varidically
+    ///
+    /// @tparam functor_t functor that will be called on the group.
+    /// @tparam link_t how to reference a group and its entries.
+    /// @tparam Args argument types for the functor
+    ///
+    /// @param link contains the group id and an index into the group
+    /// @param As additional functor arguments
+    ///
+    /// @return the functor output
+    template <typename functor_t, typename link_t, typename... Args>
+    DETRAY_HOST_DEVICE typename functor_t::output_type call(
+        const link_t link, Args &&... As) const {
+
+        return unroll<functor_t>(detail::get<0>(link), detail::get<1>(link),
+                                 std::make_index_sequence<sizeof...(Ts)>{},
                                  std::forward<Args>(As)...);
     }
 
@@ -167,26 +214,33 @@ class tuple_container {
     container_type m_container;
 
     private:
-    /** Variadic unroll function used for execute function
-     */
-    template <typename functor_t, typename size_type, typename... Args,
-              std::size_t first_id, std::size_t... remaining_ids>
+    /// Variadic unroll function used for execute function
+    ///
+    /// @tparam functor_t functor that will be called on the group (members).
+    /// @tparam index_t how to reference a member(s) in the group. Can be a
+    ///         single index/range/multiindex
+    /// @tparam Args argument types for the functor
+    /// @tparam first_idx Current index into the container tuple. Is converted
+    ///         to an id_t and tested aginst the given id.
+    /// @tparam remaining_idcs te remaining tuple indices to be tested.
+    template <typename functor_t, typename index_t, typename... Args,
+              std::size_t first_idx, std::size_t... remaining_idcs>
     DETRAY_HOST_DEVICE typename functor_t::output_type unroll(
-        const size_type id,
-        std::index_sequence<first_id, remaining_ids...> /*seq*/,
+        const id_t id, const index_t index,
+        std::index_sequence<first_idx, remaining_idcs...> /*seq*/,
         Args &&... As) const {
 
-        // Check if the first ID is matched to the target ID
-        if (id == first_id) {
-            const auto &gr = this->group<to_id(first_id)>();
+        // Check if the first tuple index is matched to the target ID
+        if (id == to_id(first_idx)) {
+            const auto &gr = this->group<to_id(first_idx)>();
 
-            return functor_t()(gr, std::forward<Args>(As)...);
+            return functor_t()(gr, index, std::forward<Args>(As)...);
         }
 
         // Check the next ID
-        if constexpr (sizeof...(remaining_ids) >= 1) {
-            return unroll<functor_t>(id,
-                                     std::index_sequence<remaining_ids...>{},
+        if constexpr (sizeof...(remaining_idcs) >= 1) {
+            return unroll<functor_t>(id, index,
+                                     std::index_sequence<remaining_idcs...>{},
                                      std::forward<Args>(As)...);
         }
 
diff --git a/core/include/detray/core/detail/tuple_vector_container.hpp b/core/include/detray/core/detail/tuple_vector_container.hpp
index df9bb98588..00254f6e27 100644
--- a/core/include/detray/core/detail/tuple_vector_container.hpp
+++ b/core/include/detray/core/detail/tuple_vector_container.hpp
@@ -37,6 +37,7 @@ class tuple_vector_container final
     using base_type = tuple_container<tuple_t, id_t, vector_t<Ts>...>;
     using base_type::base_type;
     using id_type = typename base_type::id_type;
+    using base_type::to_index;
 
     static constexpr std::size_t m_tuple_size = base_type::m_tuple_size;
 
@@ -107,7 +108,7 @@ class tuple_vector_container final
     template <id_t ID, typename... Args>
     DETRAY_HOST auto &add_value(Args &&... args) noexcept(false) {
 
-        auto &gr = detail::get<ID>(this->m_container);
+        auto &gr = detail::get<to_index(ID)>(this->m_container);
 
         return gr.emplace_back(std::forward<Args>(args)...);
     }
@@ -157,21 +158,20 @@ class tuple_vector_container final
 
     /** Append a container to the current one
      *
-     * @tparam current_id is the index to start unrolling (if th index is known,
-     *         unrolling can be started there)
+     * @tparam current_idx is the index to start unrolling
      *
      * @param other The other container
      *
      * @note in general can throw an exception
      */
-    template <std::size_t current_id = 0>
+    template <std::size_t current_idx = 0>
     DETRAY_HOST inline void append_container(
         tuple_vector_container &other) noexcept(false) {
-        auto &gr = detail::get<current_id>(other);
+        auto &gr = detail::get<current_idx>(other);
         add_vector(gr);
 
-        if constexpr (current_id < sizeof...(Ts) - 1) {
-            append_container<current_id + 1>(other);
+        if constexpr (current_idx < sizeof...(Ts) - 1) {
+            append_container<current_idx + 1>(other);
         }
     }
 };
diff --git a/core/include/detray/core/detector.hpp b/core/include/detray/core/detector.hpp
index 848bad0ca8..b07c350bd4 100644
--- a/core/include/detray/core/detector.hpp
+++ b/core/include/detray/core/detector.hpp
@@ -16,11 +16,7 @@
 #include "detray/definitions/qualifiers.hpp"
 #include "detray/geometry/surface.hpp"
 #include "detray/geometry/volume.hpp"
-#include "detray/grids/axis.hpp"
-#include "detray/grids/grid2.hpp"
-#include "detray/grids/populator.hpp"
-#include "detray/grids/serializer2.hpp"
-#include "detray/intersection/intersection.hpp"
+#include "detray/tools/bin_association.hpp"
 
 // Vecmem include(s)
 #include <vecmem/memory/memory_resource.hpp>
@@ -32,17 +28,17 @@
 
 namespace detray {
 
-/** The detector definition.
- *
- * This class is a heavy templated detector definition class, that sets the
- * interface between geometry, navigator and grid.
- *
- * @tparam metadata helper that defines collection and link types centrally
- * @tparam array_type the type of the internal array, must have STL semantics
- * @tparam tuple_type the type of the internal tuple, must have STL semantics
- * @tparam vector_type the type of the internal array, must have STL semantics
- * @tparam source_link the surface source link
- */
+/// @brief The detector definition.
+///
+/// This class is a heavily templated container aggregation, that owns all data
+/// and sets the interface between geometry, navigator and surface finder
+/// structures. Its view type is used to move the data between host and device.
+///
+/// @tparam metadata helper that defines collection and link types centrally
+/// @tparam array_t the type of the internal array, must have STL semantics
+/// @tparam tuple_t the type of the internal tuple, must have STL semantics
+/// @tparam vector_t the type of the internal array, must have STL semantics
+/// @tparam source_link the surface source link
 template <typename metadata,
           template <typename, std::size_t> class array_t = darray,
           template <typename...> class tuple_t = dtuple,
@@ -52,64 +48,70 @@ template <typename metadata,
 class detector {
 
     public:
+    /// Algebra types
     using scalar_type = scalar;
 
     using point3 = __plugin::point3<scalar_type>;
     using vector3 = __plugin::vector3<scalar_type>;
     using point2 = __plugin::point2<scalar_type>;
 
+    /// Raw container types
     template <typename T>
     using vector_type = vector_t<T>;
 
+    /// In case the detector needs to be printed
     using name_map = std::map<dindex, std::string>;
 
-    /// Forward the alignable container and context
+    /// Forward the alignable transform container (surface placements) and
+    /// the geo context (e.g. for alignment)
     using transform_container =
         typename metadata::template transform_store<vector_t>;
     using transform3 = typename transform_container::transform3;
-
     using transform_link = typename transform_container::link_type;
     using context = typename transform_container::context;
 
-    /// Forward mask types
+    /// Forward mask types that are present in this detector
     using masks = typename metadata::mask_definitions;
     using mask_container =
         typename masks::template store_type<tuple_t, vector_t>;
 
-    /// Forward material types
+    /// Forward material types that are present in this detector
     using materials = typename metadata::material_definitions;
     using material_container =
         typename materials::template store_type<tuple_t, vector_t>;
 
-    /// volume index: volume the surface belongs to
-    using volume_link = dindex;
-    using surface_type =
-        surface<masks, materials, transform_link, volume_link, source_link>;
-
+    /// Surface Finders: structures that enable neigborhood searches in the
+    /// detector geometry during navigation. Can be different in each volume
+    using sf_finders = typename metadata::template sf_finder_definitions<
+        array_t, vector_t, tuple_t, jagged_vector_t>;
+    using sf_finder_container =
+        typename sf_finders::template store_type<tuple_t, array_t>;
+
+    // TODO: Move to the following to volume builder
+
+    /// The surface takes a mask (defines the local coordinates and the surface
+    /// extent), its material, a link to an element in the transform container
+    /// to define its placement and a source link to the object it represents.
+    using surface_type = surface<masks, materials, transform_link, source_link>;
+    /// Define the different kinds of surfaces that are present in the detector
+    /// Can model the distinction between portals and sensitive surfaces
     using objects =
         typename metadata::template object_definitions<surface_type>;
     using surface_container = vector_t<surface_type>;
-    // Volume type
-    using volume_type = volume<objects, scalar_type, dindex_range, array_t>;
-
-    /// Accelerator structures
+    /// Volume type
+    using volume_type =
+        volume<objects, scalar_type, typename sf_finders::link_type, array_t>;
 
-    /// Volume finder definition
+    /// Volume finder definition: Make volume index available from track
+    /// position
     using volume_finder =
         typename metadata::template volume_finder<array_t, vector_t, tuple_t,
                                                   jagged_vector_t>;
 
-    /// Surface finder definition
-    // TODO: Move to volume builder
-    using surfaces_finder_type =
-        typename metadata::template surface_finder<array_t, vector_t, tuple_t,
-                                                   jagged_vector_t>;
-
     detector() = delete;
 
-    /** Allowed costructor
-     * @param resource memory resource for the allocation of members
-     */
+    /// Allowed costructor
+    /// @param resource memory resource for the allocation of members
     DETRAY_HOST
     detector(vecmem::memory_resource &resource)
         : _volumes(&resource),
@@ -117,14 +119,14 @@ class detector {
           _transforms(resource),
           _masks(resource),
           _materials(resource),
+          //_sf_finders(resource),
           _volume_finder(
               std::move(typename volume_finder::axis_p0_type{resource}),
               std::move(typename volume_finder::axis_p1_type{resource}),
               resource),
-          _surfaces_finder(resource),
           _resource(&resource) {}
 
-    /** Constructor with detector_data **/
+    /// Constructor with detector_data
     template <typename detector_data_type,
               std::enable_if_t<!std::is_base_of_v<vecmem::memory_resource,
                                                   detector_data_type>,
@@ -135,142 +137,147 @@ class detector {
           _transforms(det_data._transforms_data),
           _masks(det_data._masks_data),
           _materials(det_data._materials_data),
-          _volume_finder(det_data._volume_finder_view),
-          _surfaces_finder(det_data._surfaces_finder_view) {}
-
-    /** Add a new volume and retrieve a reference to it
-     *
-     * @param bounds of the volume, they are expected to be already attaching
-     * @param surfaces_finder_entry of the volume, where to entry the surface
-     * finder
-     *
-     * @return non-const reference of the new volume
-     */
+          _volume_finder(det_data._volume_finder_view) {}
+
+    /// Add a new volume and retrieve a reference to it
+    ///
+    /// @param bounds of the volume, they are expected to be already attaching
+    /// @param sf_finder_link of the volume, where to entry the surface finder
+    ///
+    /// @return non-const reference to the new volume
     DETRAY_HOST
-    volume_type &new_volume(const array_t<scalar_type, 6> &bounds,
-                            dindex surfaces_finder_entry = dindex_invalid) {
+    volume_type &new_volume(
+        const array_t<scalar, 6> &bounds,
+        typename volume_type::sf_finder_link_type sf_finder_link = {
+            sf_finders::id::e_default, dindex_invalid}) {
         volume_type &cvolume = _volumes.emplace_back(bounds);
         cvolume.set_index(_volumes.size() - 1);
-        cvolume.set_surfaces_finder(surfaces_finder_entry);
+        cvolume.set_sf_finder(sf_finder_link);
 
         return cvolume;
     }
 
-    /** @return the contained volumes of the detector - const access */
+    /// @return the sub-volumes of the detector - const access
     DETRAY_HOST_DEVICE
-    inline auto &volumes() const { return _volumes; }
+    inline auto volumes() const -> const vector_t<volume_type> & {
+        return _volumes;
+    }
 
-    /** @return the contained volumes of the detector - non-const access */
+    /// @return the sub-volumes of the detector - non-const access
     DETRAY_HOST_DEVICE
-    inline auto &volumes() { return _volumes; }
+    inline auto volumes() -> vector_t<volume_type> & { return _volumes; }
 
-    /** @return the volume by @param volume_index - const access */
+    /// @return the volume by @param volume_index - const access
     DETRAY_HOST_DEVICE
-    inline auto &volume_by_index(dindex volume_index) const {
+    inline auto volume_by_index(dindex volume_index) const
+        -> const volume_type & {
         return _volumes[volume_index];
     }
 
-    /** @return the volume by @param volume_index - non-const access */
+    /// @return the volume by @param volume_index - non-const access
     DETRAY_HOST_DEVICE
-    inline auto &volume_by_index(dindex volume_index) {
+    inline auto volume_by_index(dindex volume_index) -> volume_type & {
         return _volumes[volume_index];
     }
 
-    /** @return the volume by @param position - const access */
+    /// @return the volume by @param position - const access
     DETRAY_HOST_DEVICE
-    inline auto &volume_by_pos(const point3 &p) const {
+    inline auto volume_by_pos(const point3 &p) const -> const volume_type & {
         point2 p2 = {getter::perp(p), p[2]};
         dindex volume_index = _volume_finder.bin(p2);
         return _volumes[volume_index];
     }
 
-    /** @return all surfaces - const access */
+    /// @return all surfaces - const access
     DETRAY_HOST_DEVICE
-    inline const auto &surfaces() const { return _surfaces; }
+    inline auto surfaces() const -> const surface_container & {
+        return _surfaces;
+    }
 
-    /** @return all surfaces - non-const access */
+    /// @return all surfaces - non-const access
     DETRAY_HOST_DEVICE
-    inline auto &surfaces() { return _surfaces; }
+    inline auto surfaces() -> surface_container & { return _surfaces; }
 
-    /** @return a surface by index - const access */
+    /// @return a surface by index - const access
     DETRAY_HOST_DEVICE
-    inline const auto &surface_by_index(dindex sfidx) const {
+    inline auto surface_by_index(dindex sfidx) const -> const surface_type & {
         return _surfaces[sfidx];
     }
 
-    /** @return a surface by index - non-const access */
+    /// @return a surface by index - non-const access
     DETRAY_HOST_DEVICE
-    inline auto &surface_by_index(dindex sfidx) { return _surfaces[sfidx]; }
-
-    /** @return all surface/portal masks in the geometry - const access */
-    DETRAY_HOST_DEVICE
-    inline const auto &mask_store() const { return _masks; }
-
-    /** @return all surface/portal masks in the geometry - non-const access */
-    DETRAY_HOST_DEVICE
-    inline auto &mask_store() { return _masks; }
+    inline auto surface_by_index(dindex sfidx) -> surface_type & {
+        return _surfaces[sfidx];
+    }
 
-    /** @return all materials in the geometry - const access */
+    /// @return all surface/portal masks in the geometry - const access
     DETRAY_HOST_DEVICE
-    inline const auto &material_store() const { return _materials; }
+    inline auto mask_store() const -> const mask_container & { return _masks; }
 
-    /** @return all materials in the geometry - non-const access */
+    /// @return all surface/portal masks in the geometry - non-const access
     DETRAY_HOST_DEVICE
-    inline auto &material_store() { return _materials; }
+    inline auto mask_store() -> mask_container & { return _masks; }
 
-    /** Add pre-built mask store
-     *
-     * @param masks the conatiner for surface masks
-     */
+    /// Add pre-built mask store
+    ///
+    /// @param masks the conatiner for surface masks
     DETRAY_HOST
     inline void add_mask_store(mask_container &&msks) {
         _masks = std::move(msks);
     }
 
-    /** Get all transform in an index range from the detector
-     *
-     * @param range The range of surfaces/portals in the transform store
-     * @param ctx The context of the call
-     *
-     * @return ranged iterator to the object transforms
-     */
+    /// @return all materials in the geometry - const access
+    DETRAY_HOST_DEVICE
+    inline auto material_store() const -> const material_container & {
+        return _materials;
+    }
+
+    /// @return all materials in the geometry - non-const access
     DETRAY_HOST_DEVICE
+    inline auto material_store() -> material_container & { return _materials; }
+
+    /// Get all transform in an index range from the detector
+    ///
+    /// @param range The range of surfaces in the transform store
+    /// @param ctx The context of the call
+    ///
+    /// @return ranged iterator to the surface transforms
+    /*DETRAY_HOST_DEVICE
     inline auto transform_store(const dindex_range &range,
                                 const context &ctx = {}) const {
         return _transforms.range(range, ctx);
-    }
+    }*/
 
-    /** Get all transform in an index range from the detector - const
-     *
-     * @param ctx The context of the call
-     *
-     * @return detector transform store
-     */
+    /// Get all transform in an index range from the detector - const
+    ///
+    /// @param ctx The context of the call
+    ///
+    /// @return detector transform store
     DETRAY_HOST_DEVICE
-    inline const auto &transform_store(const context & /*ctx*/ = {}) const {
+    inline auto transform_store(const context & /*ctx*/ = {}) const
+        -> const transform_container & {
         return _transforms;
     }
 
     DETRAY_HOST_DEVICE
-    inline auto &transform_store(const context & /*ctx*/ = {}) {
+    inline auto transform_store(const context & /*ctx*/ = {})
+        -> transform_container & {
         return _transforms;
     }
 
-    /** Add pre-built transform store
-     *
-     * @param transf the constianer for surface transforms
-     */
+    /// Add pre-built transform store
+    ///
+    /// @param transf the constianer for surface transforms
     DETRAY_HOST
-    inline void add_transform_store(transform_container &&transf) {
+    inline auto add_transform_store(transform_container &&transf) -> void {
         _transforms = std::move(transf);
     }
 
-    /** Get all available data from the detector without std::tie
-     *
-     * @param ctx The context of the call
-     *
-     * @return a struct that contains references to all relevant containers.
-     */
+    /// Get all available data from the detector without std::tie
+    ///
+    /// @param ctx The context of the call
+    ///
+    /// @return a struct that contains references to all relevant containers.
     DETRAY_HOST_DEVICE
     auto data(const context & /*ctx*/ = {}) const {
         struct data_core {
@@ -282,43 +289,70 @@ class detector {
         return data_core{_volumes, _transforms, _masks, _surfaces};
     }
 
-    template <typename grid_type>
-    DETRAY_HOST inline void add_surfaces_grid(const context ctx,
-                                              volume_type &vol,
-                                              grid_type &surfaces_grid) {
-        // iterate over surfaces to fill the grid
-        for (const auto [surf_idx, surf] : enumerate(_surfaces, vol)) {
-            if (surf.get_grid_status() == true) {
-                auto sidx = surf_idx;
-
-                auto &trf =
-                    _transforms.contextual_transform(ctx, surf.transform());
-                auto tsl = trf.translation();
-
-                if (vol.get_grid_type() ==
-                    volume_type::grid_type::e_z_phi_grid) {
-
-                    point2 location{tsl[2], algebra::getter::phi(tsl)};
-                    surfaces_grid.populate(location, std::move(sidx));
-
-                } else if (vol.get_grid_type() ==
-                           volume_type::grid_type::e_r_phi_grid) {
-
-                    point2 location{algebra::getter::perp(tsl),
-                                    algebra::getter::phi(tsl)};
-                    surfaces_grid.populate(location, std::move(sidx));
-                }
+    /// Add a grid to the surface finder store of the detector
+    ///
+    /// New surface finder id can be been given explicitly. That is helpful, if
+    /// multiple sf finders have the same type in the tuple container. Otherwise
+    /// it is determined automatically.
+    ///
+    /// @param vol the volume the surface finder should be added to
+    /// @param grid the grid that should be added
+    // TODO: Provide grid builder structure separate from the detector
+    /*template <typename grid_t, typename sf_finders::id grid_id =
+                                   sf_finders::template get_id<grid_t>()>
+    DETRAY_HOST auto add_grid(volume_type &vol, grid_t &grid) -> void {
+
+        // Add surfaces grid to surfaces finder container
+        auto &grid_group = _sf_finders.template group<grid_id>();
+
+        // Find correct index for this surface finder
+        std::size_t grid_idx = 0;
+        for (unsigned int i_s = 0; i_s < grid_group.size(); i_s++) {
+            if (!grid_group.at(i_s).data().empty()) {
+                grid_idx++;
             }
         }
+        grid_group.at(grid_idx) = std::move(grid);
+        vol.set_sf_finder(grid_id, grid_idx);
+    }
 
-        // add surfaces grid into surfaces finder
-        auto n_grids = _surfaces_finder.effective_size();
-        _surfaces_finder[n_grids] = surfaces_grid;
-        vol.set_surfaces_finder(n_grids);
+    /// Fill a grid surface finder by bin association, then add it to the
+    /// detector.
+    ///
+    /// New surface finder id can be been given explicitly. That is helpful, if
+    /// multiple sf finders have the same type in the tuple container. Otherwise
+    /// it is determined automatically.
+    ///
+    /// @param ctx the geometry context
+    /// @param vol the volume the surface finder should be added to
+    /// @param grid the grid that should be added
+    // TODO: Provide grid builder structure separate from the detector
+    template <typename grid_t>
+    DETRAY_HOST auto fill_grid(const context ctx, volume_type &vol,
+                               grid_t &grid) -> void {
+
+        // Fill the volumes surfaces into the grid
+        bin_association(ctx, *this, vol, grid, {0.1, 0.1}, false);
     }
 
+    /// Detector interface to add surface finders
+    ///
+    /// @param ctx the geometry context
+    /// @param vol the volume the surface finder should be added to
+    /// @param grid the grid that should be added
+    template <typename sf_finder_t,
+              typename sf_finders::id sf_finder_id =
+                  sf_finders::template get_id<sf_finder_t>()>
+    DETRAY_HOST auto add_sf_finder(const context ctx, volume_type &vol,
+                                   sf_finder_t &sf_finder) -> void {
+
+        // For now, only implemented for grids
+        fill_grid(ctx, vol, sf_finder);
+        add_grid<sf_finder_t, sf_finder_id>(vol, sf_finder);
+    }*/
+
     /// Add a new full set of detector components (e.g. transforms or volumes)
-    ///  according to given context.
+    /// according to given context.
     ///
     /// @param ctx is the context of the call
     /// @param vol is the target volume
@@ -328,11 +362,13 @@ class detector {
     /// @param trfs_per_vol is the transform vector per volume
     ///
     /// @note can throw an exception if input data is inconsistent
-    DETRAY_HOST inline void add_objects_per_volume(
+    // TODO: Provide volume builder structure separate from the detector
+    DETRAY_HOST
+    auto add_objects_per_volume(
         const context ctx, volume_type &vol,
         surface_container &surfaces_per_vol, mask_container &masks_per_vol,
         material_container &materials_per_vol,
-        transform_container &trfs_per_vol) noexcept(false) {
+        transform_container &trfs_per_vol) noexcept(false) -> void {
 
         // Append transforms
         const auto trf_offset = _transforms.size(ctx);
@@ -340,9 +376,8 @@ class detector {
 
         // Update mask, material and transform index of surfaces
         for (auto &sf : surfaces_per_vol) {
-            _masks.template execute<mask_index_update>(sf.mask_type(), sf);
-            _materials.template execute<material_index_update>(
-                sf.material_type(), sf);
+            _masks.template call<mask_index_update>(sf.mask(), sf);
+            _materials.template call<material_index_update>(sf.material(), sf);
             sf.update_transform(trf_offset);
         }
 
@@ -364,48 +399,55 @@ class detector {
             std::max(_n_max_objects_per_volume, vol.n_objects());
     }
 
-    /** Add the volume grid - move semantics
-     *
-     * @param v_grid the volume grid to be added
-     */
+    /// Add the volume grid - move semantics
+    ///
+    /// @param v_grid the volume grid to be added
     DETRAY_HOST
-    inline void add_volume_finder(volume_finder &&v_grid) {
+    inline auto add_volume_finder(volume_finder &&v_grid) -> void {
         _volume_finder = std::move(v_grid);
     }
 
-    /** @return the volume grid - const access */
+    /// @return the volume grid - const access
     DETRAY_HOST_DEVICE
-    inline const volume_finder &volume_search_grid() const {
+    inline auto volume_search_grid() const -> const volume_finder & {
         return _volume_finder;
     }
 
+    /// @returns const access to the detector's volume search structure
     DETRAY_HOST_DEVICE
-    inline volume_finder &volume_search_grid() { return _volume_finder; }
+    inline auto volume_search_grid() -> volume_finder & {
+        return _volume_finder;
+    }
 
-    DETRAY_HOST_DEVICE
-    inline const surfaces_finder_type &get_surfaces_finder() const {
-        return _surfaces_finder;
+    /// @returns access to the surface finder container - non-const access
+    // TODO: remove once possible
+    /*DETRAY_HOST_DEVICE
+    inline auto sf_finder_store() -> sf_finder_container & {
+        return _sf_finders;
     }
 
+    /// @returns access to the surface finder container
     DETRAY_HOST_DEVICE
-    inline surfaces_finder_type &get_surfaces_finder() {
-        return _surfaces_finder;
-    }
+    inline auto sf_finder_store() const -> const sf_finder_container & {
+        return _sf_finders;
+    }*/
 
+    /// @returns the maximum number of surfaces (sensitive + portal) in all
+    /// volumes.
     DETRAY_HOST_DEVICE
-    inline dindex get_n_max_objects_per_volume() const {
+    inline auto get_n_max_objects_per_volume() const -> dindex {
         return _n_max_objects_per_volume;
     }
 
-    /** Output to string */
+    /// @param names maps a volume to its string representation.
+    /// @returns a string representation of the detector.
     DETRAY_HOST
-    const std::string to_string(const name_map &names) const {
+    auto to_string(const name_map &names) const -> std::string {
         std::stringstream ss;
 
         ss << "[>] Detector '" << names.at(0) << "' has " << _volumes.size()
            << " volumes." << std::endl;
-        // ss << "    contains  " << _surfaces_finders.size()
-        //   << " local surface finders." << std::endl;
+        ss << " local surface finders." << std::endl;
 
         for (const auto &[i, v] : enumerate(_volumes)) {
             ss << "[>>] Volume at index " << i << ": " << std::endl;
@@ -419,9 +461,13 @@ class detector {
                << v.template n_objects<objects::e_portal>() << " portals "
                << std::endl;
 
-            if (v.surfaces_finder_entry() != dindex_invalid) {
-                ss << "  sf finders idx " << v.surfaces_finder_entry()
-                   << std::endl;
+            ss << "                 " << /*_sf_finders.size(v.sf_finder_type())
+               << " surface finders " <<*/
+                std::endl;
+
+            if (v.sf_finder_index() != dindex_invalid) {
+                ss << "  sf finder id " << v.sf_finder_type()
+                   << "  sf finders idx " << v.sf_finder_index() << std::endl;
             }
 
             const auto &bounds = v.bounds();
@@ -434,40 +480,49 @@ class detector {
         return ss.str();
     }
 
-    /** @return the pointer of memoery resource */
+    /// @return the pointer of memoery resource - non-const access
+    DETRAY_HOST
+    auto resource() -> vecmem::memory_resource * { return _resource; }
+
+    /// @return the pointer of memoery resource
     DETRAY_HOST
-    auto resource() const { return _resource; }
+    auto resource() const -> const vecmem::memory_resource * {
+        return _resource;
+    }
 
     private:
-    /** Contains the geometrical relations */
+    /// Contains the detector sub-volumes.
     vector_t<volume_type> _volumes;
 
-    /** All surfaces and portals in the geometry in contiguous memory */
+    /// All surfaces (sensitive and portal) in the geometry in contiguous memory
     surface_container _surfaces;
 
-    /** Keeps all of the transform data in contiguous memory*/
+    /// Keeps all of the transform data in contiguous memory
     transform_container _transforms;
 
-    /** Surface and portal masks of the detector in contiguous memory */
+    /// Masks of all surfaces in the geometry in contiguous memory
     mask_container _masks;
 
-    /** Materials in contiguous memory */
+    /// Materials of all surfaces in the geometry in contiguous memory
     material_container _materials;
 
-    volume_finder _volume_finder;
+    /// All surface finder data structures that are used in the detector volumes
+    // sf_finder_container _sf_finders;
 
-    /* TODO: surfaces_finder needs to be refactored */
-    surfaces_finder_type _surfaces_finder;
+    /// Search structure for volumes
+    volume_finder _volume_finder;
 
+    /// The memory resource represents how and where (host, device, managed)
+    /// the memory for the detector containers is allocated
     vecmem::memory_resource *_resource = nullptr;
 
-    // maximum number of surfaces per volume for navigation kernel candidates
+    /// Maximum number of surfaces per volume. Used to estimate size of
+    /// candidates vector in the navigator. Is determined during detector
+    /// building.
     dindex _n_max_objects_per_volume = 0;
 };
 
-/** A static inplementation of detector data for device
- *
- */
+/// @brief A static inplementation of detector data for device
 template <typename detector_type>
 struct detector_data {
 
@@ -478,7 +533,7 @@ struct detector_data {
     using material_container_t = typename detector_type::material_container;
     using transform_container_t = typename detector_type::transform_container;
     using volume_finder_t = typename detector_type::volume_finder;
-    using surfaces_finder_t = typename detector_type::surfaces_finder_type;
+    // using surfaces_finder_t = typename detector_type::surfaces_finder_type;
 
     detector_data(detector_type &det)
         : _volumes_data(vecmem::get_data(det.volumes())),
@@ -487,9 +542,7 @@ struct detector_data {
           _materials_data(get_data(det.material_store())),
           _transforms_data(get_data(det.transform_store())),
           _volume_finder_data(
-              get_data(det.volume_search_grid(), *det.resource())),
-          _surfaces_finder_data(
-              get_data(det.get_surfaces_finder(), *det.resource())) {}
+              get_data(det.volume_search_grid(), *det.resource())) {}
 
     // members
     vecmem::data::vector_view<volume_t> _volumes_data;
@@ -498,11 +551,9 @@ struct detector_data {
     tuple_vector_container_data<material_container_t> _materials_data;
     static_transform_store_data<transform_container_t> _transforms_data;
     grid2_data<volume_finder_t> _volume_finder_data;
-    surfaces_finder_data<surfaces_finder_t> _surfaces_finder_data;
 };
 
-/** A static inplementation of detector view for device
- */
+/// @brief A static inplementation of detector view for device
 template <typename detector_type>
 struct detector_view {
 
@@ -513,7 +564,6 @@ struct detector_view {
     using material_container_t = typename detector_type::material_container;
     using transform_container_t = typename detector_type::transform_container;
     using volume_finder_t = typename detector_type::volume_finder;
-    using surfaces_finder_t = typename detector_type::surfaces_finder_type;
 
     detector_view(detector_data<detector_type> &det_data)
         : _volumes_data(det_data._volumes_data),
@@ -521,8 +571,7 @@ struct detector_view {
           _masks_data(det_data._masks_data),
           _materials_data(det_data._materials_data),
           _transforms_data(det_data._transforms_data),
-          _volume_finder_view(det_data._volume_finder_data),
-          _surfaces_finder_view(det_data._surfaces_finder_data) {}
+          _volume_finder_view(det_data._volume_finder_data) {}
 
     // members
     vecmem::data::vector_view<volume_t> _volumes_data;
@@ -531,19 +580,20 @@ struct detector_view {
     tuple_vector_container_data<material_container_t> _materials_data;
     static_transform_store_data<transform_container_t> _transforms_data;
     grid2_view<volume_finder_t> _volume_finder_view;
-    surfaces_finder_view<surfaces_finder_t> _surfaces_finder_view;
 };
 
-/** stand alone function for detector_data get function
- **/
-template <
-    typename detector_registry, template <typename, std::size_t> class array_t,
-    template <typename...> class tuple_t, template <typename...> class vector_t,
-    template <typename...> class jagged_vector_t, typename source_link>
-inline detector_data<detector<detector_registry, array_t, tuple_t, vector_t,
+/// stand alone function for that @returns the detector data for transfer to
+/// device.
+///
+/// @param detector the detector to be tranferred
+template <typename metadata, template <typename, std::size_t> class array_t,
+          template <typename...> class tuple_t,
+          template <typename...> class vector_t,
+          template <typename...> class jagged_vector_t, typename source_link>
+inline detector_data<detector<metadata, array_t, tuple_t, vector_t,
                               jagged_vector_t, source_link> >
-get_data(detector<detector_registry, array_t, tuple_t, vector_t,
-                  jagged_vector_t, source_link> &det) {
+get_data(detector<metadata, array_t, tuple_t, vector_t, jagged_vector_t,
+                  source_link> &det) {
     return det;
 }
 
diff --git a/core/include/detray/core/detector_kernel.hpp b/core/include/detray/core/detector_kernel.hpp
index 5018aafe8a..e3a061bc0f 100644
--- a/core/include/detray/core/detector_kernel.hpp
+++ b/core/include/detray/core/detector_kernel.hpp
@@ -16,8 +16,9 @@ namespace detray {
 struct mask_index_update {
     using output_type = bool;
 
-    template <typename group_t, typename surface_t>
+    template <typename group_t, typename index_t, typename surface_t>
     DETRAY_HOST inline output_type operator()(const group_t& group,
+                                              const index_t& /*index*/,
                                               surface_t& sf) const {
         sf.update_mask(group.size());
         return true;
@@ -28,8 +29,9 @@ struct mask_index_update {
 struct material_index_update {
     using output_type = bool;
 
-    template <typename group_t, typename surface_t>
+    template <typename group_t, typename index_t, typename surface_t>
     DETRAY_HOST inline output_type operator()(const group_t& group,
+                                              const index_t& /*index*/,
                                               surface_t& sf) const {
         sf.update_material(group.size());
         return true;
diff --git a/core/include/detray/core/type_registry.hpp b/core/include/detray/core/type_registry.hpp
index 863955a032..9f0fac72f5 100644
--- a/core/include/detray/core/type_registry.hpp
+++ b/core/include/detray/core/type_registry.hpp
@@ -8,7 +8,9 @@
 #pragma once
 
 // Project include(s)
+#include "detray/core/detail/tuple_array_container.hpp"
 #include "detray/core/detail/tuple_vector_container.hpp"
+#include "detray/definitions/detail/accessor.hpp"
 #include "detray/definitions/indexing.hpp"
 #include "detray/definitions/qualifiers.hpp"
 
@@ -18,12 +20,12 @@
 
 namespace detray {
 
-/** Base class for a type registry that allows to map indices to types and vice
- * versa.
- *
- * @tparam IDs enum that references the types (not used in base class)
- * @tparam registered_types the types that can be mapped to indices
- */
+/// Base class for a type registry that allows to map indices to types and vice
+/// versa.
+///
+/// @tparam IDs enum that references the types (not used in base class)
+/// @tparam registered_types the types that can be mapped to indices
+// TODO: Merge with tuple_container
 template <class ID, bool /*put checks on IDs type*/,
           typename... registered_types>
 class registry_base;
@@ -41,47 +43,52 @@ class registry_base<ID, false, registered_types...> {
 template <class ID, typename... registered_types>
 class registry_base<ID, true, registered_types...> {
     public:
-    /** Conventions for some basic info */
+    /// Conventions for some basic info
     enum : std::size_t {
         n_types = sizeof...(registered_types),
         e_any = sizeof...(registered_types),
         e_unknown = sizeof...(registered_types) + 1,
     };
 
-    /** Get the index for a type. Needs to be unrolled in case of thrust tuple.
-     */
+    /// Get the index for a type. Needs to be unrolled in case of thrust tuple.
     template <typename object_t>
-    DETRAY_HOST_DEVICE static constexpr unsigned int get_id() {
+    DETRAY_HOST_DEVICE static constexpr ID get_id() {
         return unroll_ids<std::remove_reference_t<object_t>,
                           registered_types...>();
     }
 
-    /** Checks whether a given types is known in the registry.*/
+    /// Get the index for a type. Use template parameter deduction.
+    template <typename object_t>
+    DETRAY_HOST_DEVICE static constexpr ID get_id(object_t& /*obj*/) {
+        return get_id<object_t>();
+    }
+
+    /// Checks whether a given types is known in the registry.
     template <typename object_t>
     DETRAY_HOST_DEVICE static constexpr bool is_defined() {
         return not(get_id<object_t>() == e_unknown);
     }
 
-    /** Checks whether a given index can be mapped to a type.*/
+    /// Checks whether a given index can be mapped to a type.
     DETRAY_HOST_DEVICE static constexpr bool is_valid(
         const std::size_t type_id) {
         return type_id < n_types;
     }
 
-    /** Extract an index and check it.*/
+    /// Extract an index and check it.
     template <typename object_t>
     struct get_index {
         static constexpr ID value = get_id<object_t>();
+        DETRAY_HOST_DEVICE
         constexpr bool operator()() noexcept { return is_valid(value); }
     };
 
-    /** Convert index to ID and do some (limited) checking.
-     *
-     * @tparam ref_idx matches to index arg to perform static checks
-     * @param index argument to be converted to valid id type
-     *
-     * @return the matching ID type.
-     */
+    /// Convert index to ID and do some (limited) checking.
+    ///
+    /// @tparam ref_idx matches to index arg to perform static checks
+    /// @param index argument to be converted to valid id type
+    ///
+    /// @return the matching ID type.
     template <std::size_t ref_idx = 0>
     DETRAY_HOST_DEVICE static constexpr ID to_id(const std::size_t index) {
         if (ref_idx == index) {
@@ -90,7 +97,7 @@ class registry_base<ID, true, registered_types...> {
                 is_valid(ref_idx),
                 "Index out of range: Please make sure that indices and type "
                 "enums match the number of types in container.");
-            return static_cast<ID>(index);
+            return static_cast<ID>(ref_idx);
         }
         if constexpr (ref_idx < sizeof...(registered_types) - 1) {
             return to_id<ref_idx + 1>(index);
@@ -99,20 +106,42 @@ class registry_base<ID, true, registered_types...> {
         return static_cast<ID>(sizeof...(registered_types));
     }
 
-    /** Return a type for an index. If the index cannot be mapped, there will be
-     * a compiler error.
-     */
+    /// Convert index to ID and do some (limited) checking.
+    ///
+    /// @tparam ref_idx matches to index arg to perform static checks
+    /// @param index argument to be converted to valid id type
+    ///
+    /// @return the matching ID type.
+    template <std::size_t ref_idx = 0>
+    DETRAY_HOST_DEVICE static constexpr std::size_t to_index(const ID id) {
+        if (to_id(ref_idx) == id) {
+            // Produce a more helpful error than the usual tuple index error
+            static_assert(
+                is_valid(ref_idx),
+                "Index out of range: Please make sure that indices and type "
+                "enums match the number of types in container.");
+            return ref_idx;
+        }
+        if constexpr (ref_idx < sizeof...(registered_types) - 1) {
+            return to_index<ref_idx + 1>(id);
+        }
+        // This produces a compiler error when used in type unrolling code
+        return sizeof...(registered_types);
+    }
+
+    /// Return a type for an index. If the index cannot be mapped, there will be
+    /// a compiler error.
     template <ID type_id, template <typename...> class tuple_t = dtuple>
     struct get_type {
         using type = std::remove_reference_t<decltype(
-            std::get<type_id>(tuple_t<registered_types...>{}))>;
+            detail::get<to_index(type_id)>(tuple_t<registered_types...>{}))>;
     };
 
     private:
     /// dummy type
     struct empty_type {};
 
-    /** Gets the position of a type in a parameter pack, without using tuples.*/
+    /// Gets the position of a type in a parameter pack, without using tuples.
     template <typename object_t, typename first_t = empty_type,
               typename... remaining_types>
     DETRAY_HOST_DEVICE static constexpr ID unroll_ids() {
@@ -121,13 +150,13 @@ class registry_base<ID, true, registered_types...> {
             return unroll_ids<object_t, remaining_types...>();
         }
         if constexpr (std::is_same_v<object_t, first_t>) {
-            return n_types - sizeof...(remaining_types) - 1;
+            return static_cast<ID>(n_types - sizeof...(remaining_types) - 1);
         }
-        return e_unknown;
+        return static_cast<ID>(e_unknown);
     }
 };
 
-/** Registry for geometric objects.*/
+/// Registry for geometric objects.
 template <typename... registered_types>
 class object_registry
     : public registry_base<unsigned int, true, registered_types...> {
@@ -162,13 +191,10 @@ class object_registry
 /// Tuple vector container registry
 template <class ID, typename... registered_types>
 class tuple_vector_registry
-    : public registry_base<
-          ID, std::is_enum_v<ID> and std::is_convertible_v<ID, unsigned int>,
-          registered_types...> {
+    : public registry_base<ID, std::is_enum_v<ID>, registered_types...> {
     public:
-    using type_registry = registry_base<
-        ID, std::is_enum_v<ID> and std::is_convertible_v<ID, unsigned int>,
-        registered_types...>;
+    using type_registry =
+        registry_base<ID, std::is_enum_v<ID>, registered_types...>;
 
     enum : std::size_t {
         n_types = type_registry::n_types,
@@ -195,14 +221,19 @@ class tuple_vector_registry
         typename type_registry::template get_type<type_id, tuple_t>;
 };
 
-/** Registry class for surface finders (e.g. grids) */
+/// Registry class for surface finders (e.g. grids)
 // TODO: Merge with mask registry
-template <typename... registered_types>
-class sf_finder_registry
-    : public registry_base<unsigned int, true, registered_types...> {
+template <class ID, typename...>
+class tuple_array_registry;
+
+/// Specialization to resolve template parameter packs
+template <class ID, std::size_t... sizes, typename... registered_types>
+class tuple_array_registry<ID, std::index_sequence<sizes...>,
+                           registered_types...>
+    : public registry_base<ID, std::is_enum_v<ID>, registered_types...> {
     public:
     using type_registry =
-        registry_base<unsigned int, true, registered_types...>;
+        registry_base<ID, std::is_enum_v<ID>, registered_types...>;
 
     enum : std::size_t {
         n_types = type_registry::n_types,
@@ -210,21 +241,22 @@ class sf_finder_registry
         e_unknown = type_registry::e_unknown,
     };
 
-    /// Surface finders
-    enum id : std::size_t {
-        e_brute_force = 0,
-        e_z_phi_grid = 1,  // barrel
-        e_r_phi_grid = 2,  // endcap
-    };
+    // Make the type IDs accessible
+    using id = ID;
 
-    using link_type = typed_index<id>;
-    using range_type = typed_index<id, dindex_range>;
+    // Cuda cannot handle ID non-types here, so leave it for now
+    template <template <typename...> class tuple_t = dtuple,
+              template <typename, std::size_t> class array_t = darray>
+    using store_type = tuple_array_container<tuple_t, array_t, ID,
+                                             std::index_sequence<sizes...>,
+                                             registered_types...>;
+    using link_type = typed_index<ID, dindex>;
+    using range_type = typed_index<ID, dindex_range>;
 
     template <typename T>
     using get_index = typename type_registry::template get_index<T>;
 
-    template <unsigned int type_id,
-              template <typename...> class tuple_t = dtuple>
+    template <ID type_id, template <typename...> class tuple_t = dtuple>
     using get_type =
         typename type_registry::template get_type<type_id, tuple_t>;
 };
diff --git a/core/include/detray/definitions/containers.hpp b/core/include/detray/definitions/containers.hpp
index 1618ca758c..57911f5db1 100644
--- a/core/include/detray/definitions/containers.hpp
+++ b/core/include/detray/definitions/containers.hpp
@@ -1,20 +1,32 @@
 /** Detray library, part of the ACTS project (R&D line)
  *
- * (c) 2020 CERN for the benefit of the ACTS project
+ * (c) 2020-2022 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
 
 #pragma once
 
+// Project include(s)
+#include "detray/definitions/qualifiers.hpp"
+#include "detray/utils/type_traits.hpp"
+
+// Vecmem include(s)
+#include <vecmem/containers/device_vector.hpp>
+#include <vecmem/containers/jagged_device_vector.hpp>
+#include <vecmem/containers/jagged_vector.hpp>
+#include <vecmem/containers/vector.hpp>
+
+// Thrust include(s)
+#include <thrust/tuple.h>
+
+// System include(s)
 #include <array>
 #include <map>
 #include <tuple>
-#include <vecmem/containers/vector.hpp>
+#include <type_traits>
 #include <vector>
 
-#include "vecmem/containers/jagged_vector.hpp"
-
 namespace detray {
 template <typename value_t, std::size_t kDIM>
 using darray = std::array<value_t, kDIM>;
@@ -31,4 +43,84 @@ using dmap = std::map<key_t, value_t>;
 template <class... types>
 using dtuple = std::tuple<types...>;
 
+/// @brief Bundle container type definitions
+template <template <typename...> class vector_t = dvector,
+          template <typename...> class tuple_t = dtuple,
+          template <typename, std::size_t> class array_t = darray,
+          template <typename...> class jagged_vector_t = djagged_vector,
+          template <typename, typename> class map_t = dmap>
+struct container_types {
+    template <typename T>
+    using vector_type = vector_t<T>;
+
+    template <class... T>
+    using tuple_type = tuple_t<T...>;
+
+    template <typename T, std::size_t kDIM>
+    using array_type = array_t<T, kDIM>;
+
+    template <typename T>
+    using jagged_vector_type = jagged_vector_t<T>;
+
+    template <typename K, typename T>
+    using map_type = map_t<K, T>;
+};
+
+/// Defining some common types
+using host_container_types = container_types<>;
+using device_container_types =
+    container_types<vecmem::device_vector, thrust::tuple, darray,
+                    vecmem::jagged_device_vector>;
+
+// Views for types that aggregate containers
+
+/// Empty view type for inheritance template resolution
+struct dbase_view {};
+
+/// Tag a vecmem view as @c dbase_view , so that it becomes recognizable in
+/// detray as a view type
+template <typename value_t, template <typename> class view_t>
+struct view_wrapper : public dbase_view {
+    /// The vecmem data view
+    view_t<value_t> m_view{};
+
+    /// Default constructor
+    view_wrapper() = default;
+
+    /// Conversion operator from a view of the same value type
+    DETRAY_HOST
+    view_wrapper(view_t<value_t>&& view) : m_view{view} {}
+};
+
+/// Container view helper that aggregates multiple views and performs
+/// compile-time checks.
+template <bool /*check value*/, typename... view_ts>
+class dmulti_view_helper {};
+
+/// In case the checks fail
+template <typename... view_ts>
+class dmulti_view_helper<false, view_ts...> {};
+
+/// General view type that aggregates vecmem based view implementations
+template <typename... view_ts>
+struct dmulti_view_helper<true, view_ts...> : public dbase_view {
+    dtuple<view_ts...> m_views;
+
+    dmulti_view_helper() = default;
+
+    /// Tie multiple views together
+    DETRAY_HOST
+    dmulti_view_helper(view_ts&&... views) { m_views = std::tie(views...); }
+};
+
+/// The detray container view exists, if all contained view types also derive
+/// from @c dbase_view.
+template <typename... view_ts>
+using dmulti_view = dmulti_view_helper<
+    std::conjunction_v<std::is_base_of<dbase_view, view_ts>...>, view_ts...>;
+
+/// Detray view for vector containers
+template <typename value_t>
+using dvector_view = view_wrapper<value_t, vecmem::data::vector_view>;
+
 }  // namespace detray
diff --git a/core/include/detray/definitions/detail/accessor.hpp b/core/include/detray/definitions/detail/accessor.hpp
index b63b6dd9de..da05d642f7 100644
--- a/core/include/detray/definitions/detail/accessor.hpp
+++ b/core/include/detray/definitions/detail/accessor.hpp
@@ -7,6 +7,7 @@
 #pragma once
 
 #if defined(__CUDACC__)
+#include <thrust/binary_search.h>
 #include <thrust/execution_policy.h>
 #include <thrust/find.h>
 #include <thrust/sort.h>
@@ -36,6 +37,24 @@ namespace vtuple = std;
 
 namespace detail {
 
+/// Extract the first type from a parameter pack.
+template <typename first_t = void, typename... other_t>
+struct first_type {
+    using type = first_t;
+};
+
+template <typename... TYPES>
+using first_t = typename first_type<TYPES...>::type;
+
+/// Extract the first value from an index pack.
+template <std::size_t first_t, std::size_t... other_t>
+struct first_idx {
+    static constexpr std::size_t value = first_t;
+};
+
+template <std::size_t... TYPES>
+inline constexpr std::size_t first_idx_v = first_idx<TYPES...>::value;
+
 namespace {
 struct empty_type {};
 
@@ -254,5 +273,27 @@ DETRAY_HOST_DEVICE auto find_if(RandomIt first, RandomIt last, Predicate comp) {
 #endif
 }
 
+/// @brief lower_bound implementation for device
+template <class ForwardIt, typename Value>
+DETRAY_HOST_DEVICE auto lower_bound(ForwardIt first, ForwardIt last,
+                                    Value value) {
+#if defined(__CUDACC__)
+    return thrust::lower_bound(thrust::seq, first, last, value);
+#elif !defined(__CUDACC__)
+    return std::lower_bound(first, last, value);
+#endif
+}
+
+/// @brief upper_bound implementation for device
+template <class ForwardIt, typename Value>
+DETRAY_HOST_DEVICE auto upper_bound(ForwardIt first, ForwardIt last,
+                                    Value value) {
+#if defined(__CUDACC__)
+    return thrust::upper_bound(thrust::seq, first, last, value);
+#elif !defined(__CUDACC__)
+    return std::upper_bound(first, last, value);
+#endif
+}
+
 }  // namespace detail
 }  // namespace detray
diff --git a/core/include/detray/definitions/indexing.hpp b/core/include/detray/definitions/indexing.hpp
index 5c92372cde..3d4f9d5226 100644
--- a/core/include/detray/definitions/indexing.hpp
+++ b/core/include/detray/definitions/indexing.hpp
@@ -1,6 +1,6 @@
 /** Detray library, part of the ACTS project (R&D line)
  *
- * (c) 2020 CERN for the benefit of the ACTS project
+ * (c) 2020-2022 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -18,24 +18,53 @@ dindex constexpr dindex_invalid = std::numeric_limits<dindex>::max();
 using dindex_range = darray<dindex, 2>;
 using dindex_sequence = dvector<dindex>;
 
-/** Small type to tie an object type and an index into a container together.
- *
- * @tparam id_type Represents the indexed type
- * @tparam intex_type The type of indexing needed for the indexed types
- * container
- */
-template <typename id_type = unsigned int, typename index_type = dindex>
+/// @brief Simple multi-index structure
+///
+/// @tparam DIM number of indices that are held by this type
+/// @tparam value_t type of indices
+template <typename value_t = dindex, std::size_t DIM = 3>
+struct dmulti_index {
+    std::array<value_t, DIM> indices{};
+
+    /// Elementwise access.
+    DETRAY_HOST_DEVICE
+    inline auto operator[](const std::size_t i) -> value_t& {
+        return indices[i];
+    }
+    DETRAY_HOST_DEVICE
+    inline auto operator[](const std::size_t i) const -> const value_t& {
+        return indices[i];
+    }
+
+    /// Equality operator @returns true if all bin indices match.
+    DETRAY_HOST_DEVICE
+    inline auto operator==(const dmulti_index<value_t, DIM>& rhs) const
+        -> bool {
+        return (indices == rhs.indices);
+    }
+};
+
+/// @brief Ties an object type and an index into a container together.
+///
+/// @tparam id_type Represents the type of object that is being indexed
+/// @tparam index_type The type of indexing needed for the indexed type's
+///         container (e.g. single index, range, multiindex)
+template <typename id_t = unsigned int, typename index_t = dindex>
 struct typed_index {
+
+    using id_type = id_t;
+    using index_type = index_t;
+
     id_type _object_id;
     index_type _index;
 
-    /** Equality operator */
+    /// Equality operator
     DETRAY_HOST_DEVICE
     bool operator==(const typed_index<id_type, index_type>& rhs) const {
         return (_object_id == rhs._object_id && _index == rhs._index);
     }
 
-    /** Arithmetic operators*/
+    /// Arithmetic operators
     DETRAY_HOST_DEVICE
     typed_index<id_type, index_type> operator+(
         const typed_index<id_type, index_type>& rhs) const {
@@ -84,7 +113,7 @@ struct typed_index {
         return *this;
     }
 
-    /** Only make the prefix operator available */
+    /// Only make the prefix operator available
     DETRAY_HOST_DEVICE
     typed_index<id_type, index_type>& operator++() {
         ++_index;
@@ -94,12 +123,13 @@ struct typed_index {
 
 namespace detail {
 
+/// Stub function to get a single index
 template <std::size_t ID>
 dindex get(dindex idx) noexcept {
     return idx;
 }
 
-/** Custom get function for the typed_index struct. Get the type. */
+/// Custom get function for the typed_index struct. Get the type.
 template <std::size_t ID, typename id_type, typename index_type,
           std::enable_if_t<ID == 0, bool> = true>
 DETRAY_HOST_DEVICE constexpr auto& get(
@@ -107,7 +137,7 @@ DETRAY_HOST_DEVICE constexpr auto& get(
     return index._object_id;
 }
 
-/** Custom get function for the typed_index struct. Get the index. */
+/// Custom get function for the typed_index struct. Get the index.
 template <std::size_t ID, typename id_type, typename index_type,
           std::enable_if_t<ID == 1, bool> = true>
 DETRAY_HOST_DEVICE constexpr auto& get(
diff --git a/core/include/detray/geometry/surface.hpp b/core/include/detray/geometry/surface.hpp
index 5d2c15e2ea..89ec9edc82 100644
--- a/core/include/detray/geometry/surface.hpp
+++ b/core/include/detray/geometry/surface.hpp
@@ -1,3 +1,4 @@
+
 /** Detray library, part of the ACTS project (R&D line)
  *
  * (c) 2020-2022 CERN for the benefit of the ACTS project
@@ -14,189 +15,197 @@
 
 namespace detray {
 
-/** Templated surface class for detector surfaces and portals
- *
- * @tparam mask_registry_t the type of the mask link representation
- * @tparam material_registry_t the type of the material link representation
- * @tparam transform_link_t the type of the transform link representation
- * @tparam volume_link_t the typ eof the volume link representation
- * @tparam source_link_t the type of the source link representation
- */
+/// Templated surface class for detector surfaces and portals.
+///
+/// @note might be holding multiple surfaces in the future
+///
+/// @tparam mask_regsitry_t the type collection of masks that can be linked
+///                         to the surface
+/// @tparam material_registry_t the type collection of material that can be
+///                             linked to the surface
+/// @tparam transform_link_t how to reference the surfaces transforms
+/// @tparam source_link_t the type of the source link representation
 template <typename mask_regsitry_t, typename material_registry_t,
-          typename transform_link_t = dindex, typename volume_link_t = dindex,
-          typename source_link_t = bool>
+          typename transform_link_t = dindex, typename source_link_t = bool>
 class surface {
 
     public:
     // Broadcast the type of links
     using transform_link = transform_link_t;
     using mask_defs = mask_regsitry_t;
+    /// might be a single mask, a range of masks or a multiindex in the future
     using mask_link = typename mask_defs::link_type;
-    // At least one mask type is present in any geometry
-    using edge_type = typename mask_defs::template get_type<mask_defs::to_id(
-        0)>::type::links_type;
+    /// Link type of the mask to a volume. At least one mask type is present in
+    /// any geometry
+    using volume_link_type =
+        typename mask_defs::template get_type<mask_defs::to_id(
+            0)>::type::links_type;
     using material_defs = material_registry_t;
     using material_link = typename material_defs::link_type;
-    using volume_link = volume_link_t;
     using source_link = source_link_t;
 
-    /** Constructor with full arguments - move semantics
-     *
-     * @param trf the transform for positioning and 3D local frame
-     * @param msk the mask/mask link for this surface
-     * @param vol the volume link for this surface
-     * @param src the source object/source link this surface is representing
-     * @param is_pt remember whether this is a portal or not
-     *
-     **/
+    /// Constructor with full arguments - move semantics
+    ///
+    /// @param trf the transform for positioning and 3D local frame
+    /// @param mask the type and index of the mask for this surface
+    /// @param material the type and index of the material for this surface
+    /// @param vol the volume this surface belongs to
+    /// @param src the source object/source link this surface is representing
+    /// @param is_portal remember whether this is a portal or not
     surface(transform_link &&trf, mask_link &&mask, material_link &&material,
-            volume_link &&vol, source_link &&src, bool is_pt)
+            dindex volume, source_link &&src, bool is_portal)
         : _trf(std::move(trf)),
           _mask(std::move(mask)),
           _material(std::move(material)),
-          _vol(std::move(vol)),
+          _volume(volume),
           _src(std::move(src)),
-          _is_portal(std::move(is_pt)) {}
-
-    /** Constructor with full arguments - copy semantics
-     *
-     * @param trf the transform for positioning and 3D local frame
-     * @param msk the mask/mask link for this surface
-     * @param vol the volume link for this surface
-     * @param src the source object/source link this surface is representing
-     * @param is_pt remember whether this is a portal or not
-     *
-     **/
-    surface(const transform_link &trf, const mask_link &mask,
-            const material_link &material, const volume_link vol,
-            const source_link &src, bool is_pt)
+          _is_portal(is_portal) {}
+
+    /// Constructor with full arguments - copy semantics
+    ///
+    /// @param trf the transform for positioning and 3D local frame
+    /// @param mask the type and index of the mask for this surface
+    /// @param material the type and index of the material for this surface
+    /// @param vol the volume this surface belongs to
+    /// @param src the source object/source link this surface is representing
+    /// @param is_portal remember whether this is a portal or not
+    surface(const transform_link trf, const mask_link &mask,
+            const material_link &material, const dindex volume,
+            const source_link &src, bool is_portal)
         : _trf(trf),
           _mask(mask),
           _material(material),
-          _vol(vol),
+          _volume(volume),
           _src(src),
-          _is_portal(is_pt) {}
+          _is_portal(is_portal) {}
 
-    // Portal vs module decision must be made explicitly
+    /// Portal vs module decision must be made explicitly
     surface() = default;
     surface(const surface &lhs) = default;
     ~surface() = default;
 
-    /** Equality operator
-     *
-     * @param rhs is the right hand side to be compared to
-     */
+    /// Equality operator
+    ///
+    /// @param rhs is the right hand side to be compared to
     DETRAY_HOST_DEVICE
-    bool operator==(const surface &rhs) const {
-        return (_trf == rhs._trf and _mask == rhs._mask and _vol == rhs._vol and
-                _src == rhs._src and _is_portal == rhs._is_portal);
+    auto operator==(const surface &rhs) const -> bool {
+        return (_trf == rhs._trf and _mask == rhs._mask and
+                _volume == rhs._volume and _src == rhs._src and
+                _is_portal == rhs._is_portal);
     }
 
-    /** Update the transform index
-     *
-     * @param offset update the position when move into new collection
-     */
+    /// Update the transform index
+    ///
+    /// @param offset update the position when move into new collection
     DETRAY_HOST
-    void update_transform(dindex offset) { _trf += offset; }
+    auto update_transform(dindex offset) -> void { _trf += offset; }
 
-    /** Access to the transform index */
+    /// Access to the transform index
     DETRAY_HOST_DEVICE
-    const transform_link &transform() { return _trf; }
+    auto transform() -> const transform_link & { return _trf; }
 
-    /** @return the transform index */
+    /// @return the transform index
     DETRAY_HOST_DEVICE
-    const transform_link &transform() const { return _trf; }
+    auto transform() const -> const transform_link & { return _trf; }
 
     /// Update the mask link
     ///
     /// @param offset update the position when move into new collection
     DETRAY_HOST
-    void update_mask(dindex offset) { _mask += offset; }
+    auto update_mask(dindex offset) -> void { _mask += offset; }
 
-    /** Access to the mask  */
+    /// Access to the mask
     DETRAY_HOST_DEVICE
-    const mask_link &mask() { return _mask; }
+    auto mask() -> const mask_link & { return _mask; }
 
-    /** @return the mask link */
+    /// @return the mask link
     DETRAY_HOST_DEVICE
-    const mask_link &mask() const { return _mask; }
+    auto mask() const -> const mask_link & { return _mask; }
 
-    /** Access to the mask id */
+    /// Access to the mask id
     DETRAY_HOST_DEVICE
-    auto mask_type() { return detail::get<0>(_mask); }
+    auto mask_type() -> typename mask_link::id_type {
+        return detail::get<0>(_mask);
+    }
 
-    /** @return the mask link */
-    DETRAY_HOST_DEVICE
-    auto mask_type() const { return detail::get<0>(_mask); }
+    /// @return the mask link
+    auto mask_type() const -> typename mask_link::id_type {
+        return detail::get<0>(_mask);
+    }
 
-    /** Access to the mask  */
+    /// Access to the mask
     DETRAY_HOST_DEVICE
-    const auto &mask_range() { return detail::get<1>(_mask); }
+    auto mask_range() -> typename mask_link::index_type & {
+        return detail::get<1>(_mask);
+    }
 
-    /** @return the mask link */
+    /// @return the mask link
     DETRAY_HOST_DEVICE
-    const auto &mask_range() const { return detail::get<1>(_mask); }
+    auto mask_range() const -> const typename mask_link::index_type & {
+        return detail::get<1>(_mask);
+    }
 
     /// Update the material link
     ///
     /// @param offset update the position when move into new collection
     DETRAY_HOST
-    void update_material(dindex offset) { _material += offset; }
+    auto update_material(dindex offset) -> void { _material += offset; }
 
     /// Access to the material
     DETRAY_HOST_DEVICE
-    const material_link &material() { return _material; }
+    auto material() -> const material_link & { return _material; }
 
     /// @return the material link
     DETRAY_HOST_DEVICE
-    const material_link &material() const { return _material; }
+    auto material() const -> const material_link & { return _material; }
 
     /// Access to the material id
     DETRAY_HOST_DEVICE
-    auto material_type() { return detail::get<0>(_material); }
+    auto material_type() -> typename material_link::id_type & {
+        return detail::get<0>(_material);
+    }
 
     /// @return the material link
     DETRAY_HOST_DEVICE
-    auto material_type() const { return detail::get<0>(_material); }
+    auto material_type() const -> const typename material_link::id_type & {
+        return detail::get<0>(_material);
+    }
 
     /// Access to the material
     DETRAY_HOST_DEVICE
-    const auto &material_range() { return detail::get<1>(_material); }
+    auto material_range() -> typename material_link::index_type & {
+        return detail::get<1>(_material);
+    }
 
     /// @return the material link
     DETRAY_HOST_DEVICE
-    const auto &material_range() const { return detail::get<1>(_material); }
+    auto material_range() const -> const typename material_link::index_type & {
+        return detail::get<1>(_material);
+    }
 
-    /** Access to the volume */
+    /// Access to the volume
     DETRAY_HOST_DEVICE
-    volume_link volume() { return _vol; }
+    auto volume() -> dindex { return _volume; }
 
-    /** @return the volume index */
+    /// @return the volume index
     DETRAY_HOST_DEVICE
-    const volume_link volume() const { return _vol; }
+    auto volume() const -> dindex { return _volume; }
 
-    /** @return the source link */
+    /// @return the source link
     DETRAY_HOST_DEVICE
-    const source_link &source() const { return _src; }
-
-    /** @return if the surface belongs to grid **/
-    auto get_grid_status() const { return _in_grid; }
-
-    /** set if the surface belongs to grid **/
-    void set_grid_status(bool status) { _in_grid = status; }
+    auto source() const -> const source_link & { return _src; }
 
-    /** Is this instance a portal in the sense of the unified_index_geometry? */
+    /// Is this instance a portal in the sense of the unified_index_geometry?
     DETRAY_HOST_DEVICE
-    bool is_portal() const { return _is_portal; }
+    auto is_portal() const -> bool { return _is_portal; }
 
     private:
-    transform_link_t _trf;
-    mask_link _mask;
-    material_link _material;
-    volume_link_t _vol;
-    source_link_t _src;
-    bool _is_portal;
-    bool _in_grid = false;
+    transform_link_t _trf{};
+    mask_link _mask{};
+    material_link _material{};
+    dindex _volume{dindex_invalid};
+    source_link_t _src{};
+    bool _is_portal = false;
 };
 
-}  // namespace detray
+}  // namespace detray
\ No newline at end of file
diff --git a/core/include/detray/geometry/volume.hpp b/core/include/detray/geometry/volume.hpp
index ee71dde932..cd06e7ea0c 100644
--- a/core/include/detray/geometry/volume.hpp
+++ b/core/include/detray/geometry/volume.hpp
@@ -1,6 +1,6 @@
 /** Detray library, part of the ACTS project (R&D line)
  *
- * (c) 2021 CERN for the benefit of the ACTS project
+ * (c) 2021-2022 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -12,91 +12,123 @@
 
 namespace detray {
 
-/** Volume class that acts as a logical container in the geometry for geometry
- *  objects, such as module surfaces or portals. The information is kept as
- *  index ranges into larger containers that are owned by the detector
- *  implementation.
- *
- * @tparam array_t the type of the internal array, must have STL semantics
- */
-template <typename object_registry_t, typename scalar_t = scalar,
-          typename range_t = dindex_range,
+/// The detray detector volume.
+///
+/// Volume class that acts as a logical container in the geometry for geometry
+/// objects, such as module surfaces or portals. The information is kept as
+/// index ranges into larger containers that are owned by the detector
+/// implementation. For every object type a different range can be set (e.g
+/// for sensitive surfaces or portals).
+///
+/// @tparam object_registry_t the type of objects contained in the volume
+/// @tparam scalar_t type of scalar used in the volume
+/// @tparam sf_finder_link_t the type of link to the volumes surfaces finder
+///         (geometry surface finder structure). The surface finder types
+///         cannot be given directly, since the containers differ between host
+///         and device. The surface finders reside in an 'unrollable
+///         container' and are called per volume in the navigator during local
+///         navigation.
+/// @tparam array_t the type of the internal array, must have STL semantics
+template <typename object_registry_t, typename scalar_t,
+          typename sf_finder_link_t = dindex,
           template <typename, std::size_t> class array_t = darray>
 class volume {
 
     public:
-    // The type of objects a volume can contain
+    /// The types of surfaces a volume can contain (modules, portals)
     using objects = object_registry_t;
-    // In case the geometry needs to be printed
+    /// ID type of a surface
+    using obj_link_type = typename objects::link_type;
+    /// How to address objects in a container. Can be a range or might become
+    /// an index if surfaces are addressed as batches
+    using obj_range_type = typename objects::range_type;
+    /// Type and index of the surface finder strucure used by this volume
+    using sf_finder_link_type = sf_finder_link_t;
+
+    /// In case the geometry needs to be printed
     using name_map = std::map<dindex, std::string>;
-    // used for sfinae
-    using volume_def = volume<object_registry_t, scalar_t, range_t, array_t>;
-
-    enum grid_type : unsigned int {
-        e_no_grid = 0,
-        e_z_phi_grid = 1,  // barrel
-        e_r_phi_grid = 2,  // endcap
-    };
+    /// Voume tag, used for sfinae
+    using volume_def = volume<objects, scalar_t, sf_finder_link_type, array_t>;
 
-    /** Default constructor**/
+    /// Default constructor
     volume() = default;
 
-    /** Contructor with bounds
-     * @param bounds of the volume
-     */
+    /// Constructor from boundary values.
+    ///
+    /// @param bounds values of volume boundaries. They depend on the volume
+    ///               shape, which is defined by its portals and are chosen in
+    ///               the detector builder
     volume(const array_t<scalar_t, 6> &bounds) : _bounds(bounds) {}
 
-    /** @return the bounds - const access */
+    /// @return the bounds - const access
     DETRAY_HOST_DEVICE
-    inline const array_t<scalar_t, 6> &bounds() const { return _bounds; }
+    auto bounds() const -> const array_t<scalar_t, 6> & { return _bounds; }
 
-    /** @return the name (add an offset for the detector name)*/
+    /// @return the name (add an offset for the detector name)
     DETRAY_HOST_DEVICE
-    inline const std::string &name(const name_map &names) const {
+    auto name(const name_map &names) const -> const std::string & {
         return names.at(_index + 1);
     }
 
-    /** @return the index */
+    /// @return the index of the volume in the detector container
     DETRAY_HOST_DEVICE
-    inline dindex index() const { return _index; }
+    auto index() const -> dindex { return _index; }
 
-    /** @param index the index */
+    /// @param index the index of the volume in the detector container
     DETRAY_HOST
-    inline void set_index(const dindex index) { _index = index; }
+    auto set_index(const dindex index) -> void { _index = index; }
 
-    /** @return the entry into the local surface finders */
-    DETRAY_HOST_DEVICE
-    inline dindex surfaces_finder_entry() const {
-        return _surfaces_finder_entry;
+    /// set surface finder during detector building
+    DETRAY_HOST
+    auto set_sf_finder(const sf_finder_link_type &link) -> void {
+        _sf_finder = link;
     }
 
-    /** @param entry the entry into the local surface finders */
+    /// set surface finder during detector building
     DETRAY_HOST
-    inline void set_surfaces_finder(const dindex entry) {
-        _surfaces_finder_entry = entry;
+    auto set_sf_finder(const typename sf_finder_link_t::id_type id,
+                       const typename sf_finder_link_t::index_type index)
+        -> void {
+        _sf_finder = {id, index};
+    }
+
+    /// @return the surface finder link associated with the volume
+    DETRAY_HOST_DEVICE
+    auto sf_finder_link() const -> const sf_finder_link_type & {
+        return _sf_finder;
+    }
+
+    /// @return the type of surface finder associated with the volume
+    DETRAY_HOST_DEVICE
+    auto sf_finder_type() const -> typename sf_finder_link_t::id_type {
+        return detail::get<0>(_sf_finder);
     }
 
-    /** @return if the volume is empty or not */
-    DETRAY_HOST_DEVICE inline bool empty() const {
-        return n_objects<objects::e_surface>() == 0;
+    /// @return the index of the surface finder associated with volume
+    DETRAY_HOST_DEVICE
+    auto sf_finder_index() const -> typename sf_finder_link_t::index_type {
+        return detail::get<1>(_sf_finder);
     }
 
-    /** @return the number of surfaces in the volume */
+    /// @return if the volume is empty or not
+    DETRAY_HOST_DEVICE
+    auto empty() const -> bool { return n_objects<objects::e_surface>() == 0; }
+
+    /// @return the number of surfaces in the volume
     template <typename objects::id range_id = objects::e_surface>
-    DETRAY_HOST_DEVICE inline auto n_objects() const {
+    DETRAY_HOST_DEVICE auto n_objects() const -> dindex {
         return n_in_range(range<range_id>());
     }
 
-    /** Set or update the index into a geometry container identified by the
-     *  range_id.
-     *
-     * @param other Surface index range
-     */
+    /// Set or update the index into a geometry container identified by the
+    /// range_id.
+    ///
+    /// @param other Surface index range
     template <typename objects::id range_id = objects::e_surface>
-    DETRAY_HOST inline void update_range(const range_t &other) {
+    DETRAY_HOST auto update_range(const obj_range_type &other) -> void {
         auto &rg = detail::get<range_id>(_ranges);
         // Range not set yet - initialize
-        constexpr range_t empty{};
+        constexpr obj_range_type empty{};
         if (rg == empty) {
             rg = other;
         } else {
@@ -106,49 +138,45 @@ class volume {
         }
     }
 
-    /** @return range of surfaces by surface type - const access */
+    /// @return range of surfaces by surface type - const access.
     template <typename object_t>
-    DETRAY_HOST_DEVICE inline constexpr const auto &range() const {
+    DETRAY_HOST_DEVICE inline constexpr auto range() const
+        -> const obj_range_type & {
         constexpr auto index = objects::template get_index<object_t>::value;
         return detail::get<index>(_ranges);
     }
 
-    /** @return range of surfaces- const access */
+    /// @return range of surfaces- const access.
     template <typename objects::id range_id = objects::e_surface>
-    DETRAY_HOST_DEVICE inline constexpr const auto &range() const {
+    DETRAY_HOST_DEVICE inline constexpr auto range() const
+        -> const obj_range_type & {
         return detail::get<range_id>(_ranges);
     }
 
-    /** @return _ranges */
-    DETRAY_HOST_DEVICE inline constexpr const auto &ranges() const {
+    /// @return all ranges in the volume.
+    DETRAY_HOST_DEVICE
+    inline constexpr auto ranges() const
+        -> const array_t<obj_range_type, objects::n_types> & {
         return _ranges;
     }
 
-    /** @return the number of elements in a given range */
+    /// @return the number of elements in a given range
     template <typename range_type>
-    DETRAY_HOST_DEVICE inline dindex n_in_range(range_type &&rg) const {
+    DETRAY_HOST_DEVICE inline auto n_in_range(range_type &&rg) const -> dindex {
         return detail::get<1>(rg) - detail::get<0>(rg);
     }
 
-    /** set grid type associated with volume */
-    void set_grid_type(grid_type val) { _grid_type = val; }
-
-    /** get grid type associated with volume */
-    auto get_grid_type() const { return _grid_type; }
-
-    /** Equality operator
-     *
-     * @param rhs is the right hand side to be compared to
-     */
+    /// Equality operator
+    ///
+    /// @param rhs is the right hand side to be compared to
     DETRAY_HOST_DEVICE
-    bool operator==(const volume &rhs) const {
+    auto operator==(const volume &rhs) const -> bool {
         return (_bounds == rhs._bounds && _index == rhs._index &&
-                _ranges == rhs._ranges &&
-                _surfaces_finder_entry == rhs._surfaces_finder_entry);
+                _ranges == rhs._ranges && _sf_finder == rhs._sf_finder);
     }
 
     private:
-    /** Bounds section, default for r, z, phi */
+    /// Bounds section, default for r, z, phi
     array_t<scalar_t, 6> _bounds = {0.,
                                     std::numeric_limits<scalar_t>::max(),
                                     -std::numeric_limits<scalar_t>::max(),
@@ -156,18 +184,15 @@ class volume {
                                     -M_PI,
                                     M_PI};
 
-    /** Volume index */
+    /// Volume index in the detector's volume container
     dindex _index = dindex_invalid;
 
-    /** Ranges in geometry containers for different objects types that belong
-     * to this volume */
-    array_t<range_t, objects::n_types> _ranges = {};
-
-    /** Index into the surface finder container */
-    dindex _surfaces_finder_entry = dindex_invalid;
+    /// Indices in geometry containers for different objects types are
+    /// contained in this volume
+    array_t<obj_range_type, objects::n_types> _ranges = {};
 
-    /** grid type associated with volume **/
-    grid_type _grid_type = e_no_grid;
+    /// Links to a specific sf_finder structure for this volume
+    sf_finder_link_type _sf_finder = {};
 };
 
 }  // namespace detray
diff --git a/core/include/detray/geometry/volume_connector.hpp b/core/include/detray/geometry/volume_connector.hpp
index ad095eee55..eeb3c3c880 100644
--- a/core/include/detray/geometry/volume_connector.hpp
+++ b/core/include/detray/geometry/volume_connector.hpp
@@ -248,7 +248,7 @@ void connect_cylindrical_volumes(
                     &portals_info,
                 dindex bound_index) -> void {
             using portal_t = typename detector_t::surface_type;
-            using edge_t = typename portal_t::edge_type;
+            using volume_link_t = typename portal_t::volume_link_type;
             // Fill in the left side portals
             if (not portals_info.empty()) {
                 // The portal transfrom is given from the left
@@ -266,9 +266,10 @@ void connect_cylindrical_volumes(
                 // Create a stub mask for every unique index
                 for (auto &info_ : portals_info) {
                     // Add new mask to container
-                    edge_t edge{std::get<1>(info_), dindex_invalid};
+                    volume_link_t volume_link{std::get<1>(info_)};
                     portal_masks.template add_value<disc_id>(
-                        std::get<0>(info_)[0], std::get<0>(info_)[1], edge);
+                        std::get<0>(info_)[0], std::get<0>(info_)[1],
+                        volume_link);
 
                     mask_index = {disc_id,
                                   portal_masks.template size<disc_id>()};
@@ -298,7 +299,7 @@ void connect_cylindrical_volumes(
                     &portals_info,
                 dindex bound_index) -> void {
             using portal_t = typename detector_t::surface_type;
-            using edge_t = typename portal_t::edge_type;
+            using volume_link_t = typename portal_t::volume_link_type;
             // Fill in the upper side portals
             if (not portals_info.empty()) {
                 // Get the mask context group and fill it
@@ -310,12 +311,12 @@ void connect_cylindrical_volumes(
 
                 for (auto &info_ : portals_info) {
                     // Add new mask to container
-                    edge_t edge{std::get<1>(info_), dindex_invalid};
+                    volume_link_t volume_link{std::get<1>(info_)};
                     const auto cylinder_range = std::get<0>(info_);
 
                     portal_masks.template add_value<cylinder_id>(
                         volume_bounds[bound_index], cylinder_range[0],
-                        cylinder_range[1], edge);
+                        cylinder_range[1], volume_link);
 
                     mask_index = {cylinder_id,
                                   portal_masks.template size<cylinder_id>()};
diff --git a/core/include/detray/geometry/volume_graph.hpp b/core/include/detray/geometry/volume_graph.hpp
index d616268190..bb61966ad4 100644
--- a/core/include/detray/geometry/volume_graph.hpp
+++ b/core/include/detray/geometry/volume_graph.hpp
@@ -158,7 +158,7 @@ class volume_graph {
     /// half edges in the @c _edges collection (detector masks).
     struct edge_collection {
         /// The link to the next volume
-        using mask_edge_t = typename detector_t::surface_type::edge_type;
+        using mask_edge_t = typename detector_t::surface_type::volume_link_type;
         /// The link to the surfaces mask
         using mask_link_t = typename detector_t::surface_type::mask_link;
 
@@ -174,6 +174,39 @@ class volume_graph {
             dindex _from, _to;
         };
 
+        /// Nested functor that fills the edges from a mask container
+        struct edges_builder {
+
+            using output_type = vector_t<edge>;
+
+            /// @brief Builds the collection of graph edges for a given
+            /// node.
+            ///
+            /// From the volume index and a mask link owned by one of the
+            /// volumes surfaces a vector of graph edges is built.
+            /// The mask container calls this functor and provides the correct
+            /// mask group from which the surface masks can be obtained from
+            /// the surfaces mask range.
+            ///
+            /// @param mask_group the group of masks in the mask container
+            ///                   of the detector
+            /// @param volume_id the index of the volume/node for which to
+            ///                  build edges
+            /// @param mask_range the range of masks in the group for which
+            ///                   to build edges
+            template <typename mask_group_t>
+            inline output_type operator()(
+                const mask_group_t &mask_group,
+                const typename mask_link_t::index_type &mask_range,
+                const dindex volume_id) {
+                vector_t<edge> edges{};
+                for (const auto &mask : range(mask_group, mask_range)) {
+                    edges.emplace_back(volume_id, mask.volume_link());
+                }
+                return edges;
+            }
+        };
+
         /// @brief Iterator that constructs graph edges from mask links on the
         /// fly
         struct iterator {
@@ -186,7 +219,10 @@ class volume_graph {
             /// surfaces
             iterator(const dindex volume_id, const mask_link_t &mask_link,
                      const edge_collection &edges) {
-                build_edges_vector(volume_id, mask_link, edges.get_container());
+
+                _edges = edges.get_container().template call<edges_builder>(
+                    mask_link, volume_id);
+
                 _itr = _edges.begin();
             }
 
@@ -221,40 +257,6 @@ class volume_graph {
                 return _itr != rhs._itr and &_edges != &rhs._edges;
             }
 
-            /// @brief BUilds the collection of graph edges for a given node.
-            ///
-            /// From the volume index, a mask link owned by one of the volumes
-            /// surfaces and the detector mask container, a vector of graph
-            /// edges is built. The mask container needs to be unrolled to find
-            /// the correct instance and therefore link to the next volume.
-            ///
-            /// @param volume_id the index of the volume/node
-            /// @param mask_link a mask link of a surface belonging to that vol.
-            /// @param masks the mask store of the detector
-            template <std::size_t current_id = 0>
-            inline void build_edges_vector(const dindex volume_id,
-                                           const mask_link_t &mask_link,
-                                           const mask_container_t &masks) {
-
-                if (detail::get<0>(mask_link) == current_id) {
-                    // Get the mask group
-                    const auto &mask_group =
-                        masks.template group<mask_container_t::to_id(
-                            current_id)>();
-                    const auto mask_range = detail::get<1>(mask_link);
-                    for (const auto &mask : range(mask_group, mask_range)) {
-                        _edges.emplace_back(volume_id, mask.volume_link());
-                    }
-                }
-
-                // Next mask type
-                using mask_defs = typename detector_t::surface_type::mask_defs;
-                if constexpr (current_id < mask_defs::n_types - 1) {
-                    return build_edges_vector<current_id + 1>(volume_id,
-                                                              mask_link, masks);
-                }
-            }
-
             /// Iterator over the edges vector
             edge_iter _itr;
             /// Vector of graph edges, constructed on the fly in the iterator
diff --git a/core/include/detray/grids/axis.hpp b/core/include/detray/grids/axis.hpp
index 9949edd96a..cdfd89b887 100644
--- a/core/include/detray/grids/axis.hpp
+++ b/core/include/detray/grids/axis.hpp
@@ -43,14 +43,14 @@ struct regular {
     /** Defualt constructor for dummy axis **/
     DETRAY_HOST_DEVICE
     regular()
-        : n_bins(invalid_value<dindex>()),
+        : n_bins(detail::invalid_value<dindex>()),
           min(0.),
           max(static_cast<scalar>(n_bins)) {}
 
     /** Constructor with vecmem memory resource **/
     DETRAY_HOST
     regular(vecmem::memory_resource & /*resource*/)
-        : n_bins(invalid_value<dindex>()),
+        : n_bins(detail::invalid_value<dindex>()),
           min(0.),
           max(static_cast<scalar>(n_bins)) {}
 
@@ -225,14 +225,14 @@ struct circular {
     /** Defualt constructor for dummy axis **/
     DETRAY_HOST_DEVICE
     circular()
-        : n_bins(invalid_value<dindex>()),
+        : n_bins(detail::invalid_value<dindex>()),
           min(0.),
           max(static_cast<scalar>(n_bins)) {}
 
     /** Constructor with vecmem memory resource **/
     DETRAY_HOST
     circular(vecmem::memory_resource & /*resource*/)
-        : n_bins(invalid_value<dindex>()),
+        : n_bins(detail::invalid_value<dindex>()),
           min(0.),
           max(static_cast<scalar>(n_bins)) {}
 
@@ -432,7 +432,7 @@ struct irregular {
     /** Defualt constructor for dummy axis **/
     DETRAY_HOST_DEVICE
     irregular()
-        : n_bins(invalid_value<dindex>()),
+        : n_bins(detail::invalid_value<dindex>()),
           min(0.),
           max(static_cast<scalar>(n_bins)),
           boundaries({}) {}
@@ -440,7 +440,7 @@ struct irregular {
     /** Constructor with vecmem memory resource **/
     DETRAY_HOST
     irregular(vecmem::memory_resource &resource)
-        : n_bins(invalid_value<dindex>()),
+        : n_bins(detail::invalid_value<dindex>()),
           min(0.),
           max(static_cast<scalar>(n_bins)),
           boundaries(&resource) {}
@@ -628,7 +628,7 @@ struct axis_data<axis_t, scalar_t,
     /// Construct a const data object from a non-const one
     template <
         typename other_scalar_t,
-        std::enable_if_t<details::is_same_nc<scalar_t, other_scalar_t>::value,
+        std::enable_if_t<detail::is_same_nc<scalar_t, other_scalar_t>::value,
                          bool> = true>
     DETRAY_HOST_DEVICE axis_data(
         const axis_data<axis_t, other_scalar_t, void> &parent)
@@ -654,7 +654,7 @@ struct axis_data<axis_t, scalar_t,
     /// Construct a const data object from a non-const one
     template <
         typename other_scalar_t,
-        std::enable_if_t<details::is_same_nc<scalar_t, other_scalar_t>::value,
+        std::enable_if_t<detail::is_same_nc<scalar_t, other_scalar_t>::value,
                          bool> = true>
     DETRAY_HOST_DEVICE axis_data(
         const axis_data<axis_t, other_scalar_t, void> &parent)
diff --git a/core/include/detray/grids/grid2.hpp b/core/include/detray/grids/grid2.hpp
index 902defae57..4d781309f1 100644
--- a/core/include/detray/grids/grid2.hpp
+++ b/core/include/detray/grids/grid2.hpp
@@ -20,7 +20,7 @@ namespace detray {
 /** A two-dimensional grid for object storage
  *
  * @tparam populator_t  is a prescription what to do when a bin gets
- *pupulated, it broadcasts also the value type
+ * populated, it broadcasts also the value type
  * @tparam tparam axis_p0_t the type of the first axis
  * @tparam tparam axis_p1_t the type of the second axis
  * @tparam serialzier_t  type of the serializer to the storage represenations
@@ -60,11 +60,11 @@ class grid2 {
     static constexpr array_t<dindex, 2> hermit1 = {0u, 0u};
     static constexpr neighborhood<dindex> hermit2 = {hermit1, hermit1};
 
-    grid2() = delete;
+    grid2() = default;
 
     DETRAY_HOST
     grid2(vecmem::memory_resource &mr,
-          const bare_value m_invalid = invalid_value<bare_value>())
+          const bare_value m_invalid = detail::invalid_value<bare_value>())
         : _axis_p0(mr),
           _axis_p1(mr),
           _data_serialized(&mr),
@@ -79,7 +79,7 @@ class grid2 {
     DETRAY_HOST
     grid2(const axis_p0_type &axis_p0, const axis_p1_type &axis_p1,
           vecmem::memory_resource &mr,
-          const bare_value m_invalid = invalid_value<bare_value>())
+          const bare_value m_invalid = detail::invalid_value<bare_value>())
         : _axis_p0(axis_p0, mr),
           _axis_p1(axis_p1, mr),
           _data_serialized(&mr),
@@ -97,7 +97,7 @@ class grid2 {
     DETRAY_HOST
     grid2(axis_p0_type &&axis_p0, axis_p1_type &&axis_p1,
           vecmem::memory_resource &mr,
-          const bare_value m_invalid = invalid_value<bare_value>())
+          const bare_value m_invalid = detail::invalid_value<bare_value>())
         : _axis_p0(std::move(axis_p0), mr),
           _axis_p1(std::move(axis_p1), mr),
           _data_serialized(&mr),
@@ -115,7 +115,7 @@ class grid2 {
                   bool> = true>
     DETRAY_HOST_DEVICE grid2(
         const grid_view_t &grid_data,
-        const bare_value m_invalid = invalid_value<bare_value>())
+        const bare_value m_invalid = detail::invalid_value<bare_value>())
         : _axis_p0(grid_data._axis_p0_view),
           _axis_p1(grid_data._axis_p1_view),
           _data_serialized(grid_data._data_view),
@@ -229,6 +229,15 @@ class grid2 {
             _axis_p0, _axis_p1, _axis_p0.bin(p2[0]), _axis_p1.bin(p2[1]))];
     }
 
+    /// Stub function until the zone call is working correctly
+    template <typename detector_t, typename track_t>
+    DETRAY_HOST_DEVICE dindex_range
+    search(const detector_t & /*det*/,
+           const typename detector_t::volume_type &volume,
+           const track_t & /*track*/) const {
+        return volume.range();
+    }
+
     /** Return a zone around a single bin, either with binned or scalar
      *neighborhood
      *
diff --git a/core/include/detray/grids/populator.hpp b/core/include/detray/grids/populator.hpp
index 3ddacb0032..f1c5ec6704 100644
--- a/core/include/detray/grids/populator.hpp
+++ b/core/include/detray/grids/populator.hpp
@@ -39,7 +39,7 @@ template <template <typename...> class vector_t = dvector,
           typename value_t = dindex, bool kSORT = false, unsigned int kDIM = 1>
 struct replace_populator {
     DETRAY_HOST_DEVICE
-    replace_populator(const value_t invalid = invalid_value<value_t>())
+    replace_populator(const value_t invalid = detail::invalid_value<value_t>())
         : m_invalid(invalid) {}
 
     value_t m_invalid;
@@ -113,7 +113,7 @@ template <template <typename...> class vector_t = dvector,
           typename value_t = dindex, bool kSORT = false, unsigned int kDIM = 1>
 struct complete_populator {
     DETRAY_HOST_DEVICE
-    complete_populator(const value_t invalid = invalid_value<value_t>())
+    complete_populator(const value_t invalid = detail::invalid_value<value_t>())
         : m_invalid(invalid) {}
 
     value_t m_invalid;
@@ -207,7 +207,7 @@ template <template <typename...> class vector_t = dvector,
           typename value_t = dindex, bool kSORT = false, unsigned int kDIM = 1>
 struct attach_populator {
     DETRAY_HOST_DEVICE
-    attach_populator(const value_t invalid = invalid_value<value_t>())
+    attach_populator(const value_t invalid = detail::invalid_value<value_t>())
         : m_invalid(invalid) {}
 
     value_t m_invalid;
@@ -277,4 +277,4 @@ struct attach_populator {
     store_value init() const { return {}; }
 };
 
-}  // namespace detray
+}  // namespace detray
\ No newline at end of file
diff --git a/core/include/detray/intersection/concentric_cylinder_intersector.hpp b/core/include/detray/intersection/concentric_cylinder_intersector.hpp
index 3d7249c7fa..ea5a64be79 100644
--- a/core/include/detray/intersection/concentric_cylinder_intersector.hpp
+++ b/core/include/detray/intersection/concentric_cylinder_intersector.hpp
@@ -8,6 +8,7 @@
 #pragma once
 
 // Project include(s)
+#include "detray/coordinates/cylindrical2.hpp"
 #include "detray/definitions/qualifiers.hpp"
 #include "detray/intersection/detail/trajectories.hpp"
 #include "detray/intersection/intersection.hpp"
@@ -48,18 +49,19 @@ struct concentric_cylinder_intersector {
      *
      * @return the intersection
      */
-    template <typename mask_t>
+    template <
+        typename mask_t,
+        std::enable_if_t<std::is_same_v<typename mask_t::measurement_frame_type,
+                                        cylindrical2<transform3_t>>,
+                         bool> = true>
     DETRAY_HOST_DEVICE inline output_type operator()(
         const ray_type &ray, const mask_t &mask, const transform3_t & /*trf*/,
-        const scalar_type /*mask_tolerance*/ = 0,
+        const scalar_type mask_tolerance = 0.,
         const scalar_type overstep_tolerance = 0.) const {
 
         output_type ret;
 
-        using local_frame = typename mask_t::local_type;
-
         const scalar_type r{mask[0]};
-
         // Two points on the line, thes are in the cylinder frame
         const point3 &ro = ray.pos();
         const vector3 &rd = ray.dir();
@@ -107,12 +109,23 @@ struct concentric_cylinder_intersector {
                 is.path = t01[cindex];
 
                 is.p2 = point2{r * getter::phi(is.p3), is.p3[2]};
-                is.status = mask.template is_inside<local_frame>(is.p3);
-                const scalar_type rdir{
-                    getter::perp(is.p3 + scalar_type{0.1} * rd)};
-                is.direction = rdir > r ? intersection::direction::e_along
-                                        : intersection::direction::e_opposite;
+                // In this case, the point has to be in cylinder3 coordinates
+                // for the r-check
+                if constexpr (mask_t::shape::check_radius) {
+                    point3 loc3D = {r, getter::phi(is.p3), is.p3[2]};
+                    is.status = mask.is_inside(is.p3, mask_tolerance);
+                } else {
+                    is.status = mask.is_inside(is.p2, mask_tolerance);
+                }
+                is.direction = vector::dot(is.p3, rd) > scalar_type{0.}
+                                   ? intersection::direction::e_along
+                                   : intersection::direction::e_opposite;
                 is.link = mask.volume_link();
+
+                // Get incidence angle
+                const scalar_type phi{is.p2[0] / mask[mask_t::shape::e_r]};
+                const vector3 normal = {std::cos(phi), std::sin(phi), 0};
+                is.cos_incidence_angle = vector::dot(rd, normal);
             }
         }
         return ret;
diff --git a/core/include/detray/intersection/cylinder_intersector.hpp b/core/include/detray/intersection/cylinder_intersector.hpp
index 280066556f..8bea487a01 100644
--- a/core/include/detray/intersection/cylinder_intersector.hpp
+++ b/core/include/detray/intersection/cylinder_intersector.hpp
@@ -8,6 +8,7 @@
 #pragma once
 
 // Project include(s)
+#include "detray/coordinates/cylindrical2.hpp"
 #include "detray/definitions/qualifiers.hpp"
 #include "detray/intersection/detail/trajectories.hpp"
 #include "detray/intersection/intersection.hpp"
@@ -26,6 +27,7 @@ struct cylinder_intersector {
 
     /// Transformation matching this struct
     using scalar_type = typename transform3_t::scalar_type;
+    using point2 = typename transform3_t::point2;
     using point3 = typename transform3_t::point3;
     using vector3 = typename transform3_t::vector3;
     using ray_type = detail::ray<transform3_t>;
@@ -45,7 +47,11 @@ struct cylinder_intersector {
      *
      * @return the intersection
      */
-    template <typename mask_t>
+    template <
+        typename mask_t,
+        std::enable_if_t<std::is_same_v<typename mask_t::measurement_frame_type,
+                                        cylindrical2<transform3_t>>,
+                         bool> = true>
     DETRAY_HOST_DEVICE inline output_type operator()(
         const ray_type &ray, const mask_t &mask, const transform3_t &trf,
         const scalar_type mask_tolerance = 0,
@@ -53,8 +59,6 @@ struct cylinder_intersector {
 
         output_type ret;
 
-        using local_frame = typename mask_t::local_type;
-
         const scalar_type r{mask[0]};
         const auto &m = trf.matrix();
         const vector3 sz = getter::vector<3>(m, 0, 2);
@@ -65,10 +69,10 @@ struct cylinder_intersector {
 
         const vector3 pc_cross_sz = vector::cross(ro - sc, sz);
         const vector3 rd_cross_sz = vector::cross(rd, sz);
-        const scalar_type a = vector::dot(rd_cross_sz, rd_cross_sz);
-        const scalar_type b =
-            scalar_type{2.} * vector::dot(rd_cross_sz, pc_cross_sz);
-        const scalar_type c = vector::dot(pc_cross_sz, pc_cross_sz) - (r * r);
+        const scalar_type a{vector::dot(rd_cross_sz, rd_cross_sz)};
+        const scalar_type b{scalar_type{2.} *
+                            vector::dot(rd_cross_sz, pc_cross_sz)};
+        const scalar_type c{vector::dot(pc_cross_sz, pc_cross_sz) - (r * r)};
 
         quadratic_equation<scalar_type> qe = {a, b, c};
         auto qe_solution = qe();
@@ -82,19 +86,23 @@ struct cylinder_intersector {
                 intersection_type &is = ret[0];
                 is.path = t;
                 is.p3 = ro + is.path * rd;
-                constexpr local_frame local_converter{};
-                is.p2 = local_converter.global_to_local(trf, is.p3, rd);
-                const auto local3 = trf.point_to_local(is.p3);
-                is.status = mask.template is_inside<local_frame>(
-                    local3, mask_tolerance);
-                const scalar_type rdr =
-                    getter::perp(local3 + scalar_type{0.1} * rd);
-                is.direction = rdr > r ? intersection::direction::e_along
-                                       : intersection::direction::e_opposite;
+                // In this case, the point has to be in cylinder3 coordinates
+                // for the r-check
+                if constexpr (mask_t::shape::check_radius) {
+                    auto loc3D = mask.to_local_frame(trf, is.p3);
+                    is.status = mask.is_inside(loc3D, mask_tolerance);
+                    is.p2 = {loc3D[0] * loc3D[1], loc3D[2]};
+                } else {
+                    is.p2 = mask.to_local_frame(trf, is.p3);
+                    is.status = mask.is_inside(is.p2, mask_tolerance);
+                }
+                is.direction = vector::dot(is.p3, rd) > scalar_type{0.}
+                                   ? intersection::direction::e_along
+                                   : intersection::direction::e_opposite;
                 is.link = mask.volume_link();
 
                 // Get incidence angle
-                const scalar_type phi = algebra::getter::phi(local3);
+                const scalar_type phi{is.p2[0] / mask[mask_t::shape::e_r]};
                 const vector3 normal = {std::cos(phi), std::sin(phi), 0};
                 is.cos_incidence_angle = vector::dot(rd, normal);
             }
diff --git a/core/include/detray/intersection/intersection_kernel.hpp b/core/include/detray/intersection/intersection_kernel.hpp
index 5152be72bb..22406932b1 100644
--- a/core/include/detray/intersection/intersection_kernel.hpp
+++ b/core/include/detray/intersection/intersection_kernel.hpp
@@ -37,17 +37,18 @@ struct intersection_initialize {
      *
      * @return the number of valid intersections
      */
-    template <typename mask_group_t, typename is_container_t, typename traj_t,
-              typename surface_t, typename transform_container_t>
+    template <typename mask_group_t, typename mask_range_t,
+              typename is_container_t, typename traj_t, typename surface_t,
+              typename transform_container_t>
     DETRAY_HOST_DEVICE inline output_type operator()(
-        const mask_group_t &mask_group, is_container_t &is_container,
-        const traj_t &traj, const surface_t &surface,
+        const mask_group_t &mask_group, const mask_range_t &mask_range,
+        is_container_t &is_container, const traj_t &traj,
+        const surface_t &surface,
         const transform_container_t &contextual_transforms,
         const scalar mask_tolerance = 0.) const {
 
         int count = 0;
 
-        const auto &mask_range = surface.mask_range();
         const auto &ctf = contextual_transforms[surface.transform()];
 
         // Run over the masks belonged to the surface
@@ -90,6 +91,8 @@ struct intersection_update {
      * @tparam transform_container_t is the input transform store type
      *
      * @param mask_group is the input mask group
+     * @param mask_range is the range of masks in the group that belong to the
+     *                   surface
      * @param traj is the input trajectory
      * @param surface is the input surface
      * @param contextual_transforms is the input transform container
@@ -97,18 +100,17 @@ struct intersection_update {
      *
      * @return the intersection
      */
-    template <typename mask_group_t, typename traj_t, typename surface_t,
-              typename transform_container_t>
+    template <typename mask_group_t, typename mask_range_t, typename traj_t,
+              typename surface_t, typename transform_container_t>
     DETRAY_HOST_DEVICE inline output_type operator()(
-        const mask_group_t &mask_group, const traj_t &traj,
-        const surface_t &surface,
+        const mask_group_t &mask_group, const mask_range_t &mask_range,
+        const traj_t &traj, const surface_t &surface,
         const transform_container_t &contextual_transforms,
         const scalar mask_tolerance = 0.) const {
 
-        const auto &mask_range = surface.mask_range();
         const auto &ctf = contextual_transforms[surface.transform()];
 
-        // Run over the masks belonged to the surface
+        // Run over the masks belonging to the surface
         for (const auto &mask : range(mask_group, mask_range)) {
 
             auto sfi = std::move(mask.intersector()(
diff --git a/core/include/detray/intersection/line_intersector.hpp b/core/include/detray/intersection/line_intersector.hpp
index dc258baefa..3db0c15d48 100644
--- a/core/include/detray/intersection/line_intersector.hpp
+++ b/core/include/detray/intersection/line_intersector.hpp
@@ -8,6 +8,7 @@
 #pragma once
 
 // Project include(s)
+#include "detray/coordinates/line2.hpp"
 #include "detray/definitions/qualifiers.hpp"
 #include "detray/intersection/detail/trajectories.hpp"
 #include "detray/intersection/intersection.hpp"
@@ -33,8 +34,7 @@ struct line_intersector {
 
     /** Operator function to find intersections between ray and line mask
      *
-     * @tparam mask_t is the input mask type
-     * @tparam transform_t is the input transform type
+     * @tparam mask_t is the input mask type (must be a line mask)
      *
      * @param ray is the input ray trajectory
      * @param mask is the input mask
@@ -44,7 +44,11 @@ struct line_intersector {
      *
      * @return the intersection
      */
-    template <typename mask_t>
+    template <
+        typename mask_t,
+        std::enable_if_t<std::is_same_v<typename mask_t::measurement_frame_type,
+                                        line2<transform3_t>>,
+                         bool> = true>
     DETRAY_HOST_DEVICE inline output_type operator()(
         const ray_type &ray, const mask_t &mask, const transform3_t &trf,
         const scalar_type mask_tolerance = 0,
@@ -65,9 +69,9 @@ struct line_intersector {
         const point3 _p = ray.pos();
 
         // Projection of line to track direction
-        const scalar zd = vector::dot(_z, _d);
+        const scalar_type zd{vector::dot(_z, _d)};
 
-        const scalar_type denom = scalar_type{1.} - (zd * zd);
+        const scalar_type denom{scalar_type{1.} - (zd * zd)};
 
         // Case for wire is parallel to track
         if (denom < scalar_type{1e-5}) {
@@ -78,18 +82,18 @@ struct line_intersector {
         const vector3 t2l = _t - _p;
 
         // t2l projection on line direction
-        const scalar_type t2l_on_line = vector::dot(t2l, _z);
+        const scalar_type t2l_on_line{vector::dot(t2l, _z)};
 
         // t2l projection on track direction
-        const scalar_type t2l_on_track = vector::dot(t2l, _d);
+        const scalar_type t2l_on_track{vector::dot(t2l, _d)};
 
         // path length to the point of closest approach on the track
-        const scalar_type A =
-            scalar_type{1.} / denom * (t2l_on_track - t2l_on_line * zd);
+        const scalar_type A{scalar_type{1.} / denom *
+                            (t2l_on_track - t2l_on_line * zd)};
 
         // distance to the point of closest approarch on the
         // line from line center
-        const scalar_type B = zd * A - t2l_on_line;
+        const scalar_type B{zd * A - t2l_on_line};
 
         // point of closest approach on the track
         const vector3 m = _p + _d * A;
@@ -98,27 +102,37 @@ struct line_intersector {
         is.path = A;
         is.p3 = m;
 
-        // global to local transform in cartesian coordinate
-        auto loc = trf.point_to_local(is.p3);
-
-        // assign the sign depending on the position w.r.t line surface
-        // Right: -1
-        // Left: 1
-        const auto r = vector::cross(_z, _d);
-        const scalar_type sign = vector::dot(r, t2l) > 0. ? -1. : 1.;
-
-        is.p2[0] = sign * getter::perp(loc);
+        // For the radial cross section, the calculation does not need to be
+        // repeated
+        if constexpr (mask_t::shape::square_cross_sect) {
+            // This is cartesian3 for square cross section
+            auto loc3D = mask.to_local_frame(trf, is.p3);
+            is.status = mask.is_inside(loc3D, mask_tolerance);
+
+            // Determine the measurement point from the local point
+
+            // assign the sign depending on the position w.r.t line surface
+            // Right: -1
+            // Left: 1
+            const auto r = vector::cross(_z, _d);
+            const scalar_type sign{vector::dot(r, t2l) > scalar_type{0.}
+                                       ? scalar_type{-1.}
+                                       : scalar_type{1.}};
+
+            is.p2[0] = sign * getter::perp(loc3D);
+        } else {
+            is.p2 = mask.to_local_frame(trf, is.p3, _d);
+            is.status = mask.is_inside(is.p2, mask_tolerance);
+        }
         is.p2[1] = B;
 
-        is.status = mask.is_inside(loc, mask_tolerance);
-
         is.direction = is.path > overstep_tolerance
                            ? intersection::direction::e_along
                            : intersection::direction::e_opposite;
         is.link = mask.volume_link();
 
         // Get incidence angle
-        is.cos_incidence_angle = std::abs(vector::dot(_d, _z));
+        is.cos_incidence_angle = std::abs(zd);
 
         return ret;
     }
diff --git a/core/include/detray/intersection/plane_intersector.hpp b/core/include/detray/intersection/plane_intersector.hpp
index 409bf082d5..23d0ccffce 100644
--- a/core/include/detray/intersection/plane_intersector.hpp
+++ b/core/include/detray/intersection/plane_intersector.hpp
@@ -25,6 +25,7 @@ struct plane_intersector {
 
     /// Transformation matching this struct
     using scalar_type = typename transform3_t::scalar_type;
+    using point2 = typename transform3_t::point2;
     using point3 = typename transform3_t::point3;
     using vector3 = typename transform3_t::vector3;
     using ray_type = detail::ray<transform3_t>;
@@ -44,7 +45,10 @@ struct plane_intersector {
      *
      * @return the intersection
      */
-    template <typename mask_t>
+    template <
+        typename mask_t,
+        std::enable_if_t<std::is_same_v<typename mask_t::loc_point_t, point2>,
+                         bool> = true>
     DETRAY_HOST_DEVICE inline output_type operator()(
         const ray_type &ray, const mask_t &mask, const transform3_t &trf,
         const scalar_type mask_tolerance = 0,
@@ -52,8 +56,6 @@ struct plane_intersector {
 
         output_type ret;
 
-        using local_frame = typename mask_t::local_type;
-
         // Retrieve the surface normal & translation (context resolved)
         const auto &sm = trf.matrix();
         const vector3 sn = getter::vector<3>(sm, 0, 2);
@@ -67,10 +69,8 @@ struct plane_intersector {
             intersection_type &is = ret[0];
             is.path = vector::dot(sn, st - ro) / denom;
             is.p3 = ro + is.path * rd;
-            constexpr local_frame local_converter{};
-            is.p2 = local_converter.global_to_local(trf, is.p3, ray.dir());
-            is.status =
-                mask.template is_inside<local_frame>(is.p2, mask_tolerance);
+            is.p2 = mask.to_local_frame(trf, is.p3, ray.dir());
+            is.status = mask.is_inside(is.p2, mask_tolerance);
             is.direction = is.path > overstep_tolerance
                                ? intersection::direction::e_along
                                : intersection::direction::e_opposite;
diff --git a/core/include/detray/masks/annulus2.hpp b/core/include/detray/masks/annulus2.hpp
deleted file mode 100644
index 725254bc02..0000000000
--- a/core/include/detray/masks/annulus2.hpp
+++ /dev/null
@@ -1,172 +0,0 @@
-/** Detray library, part of the ACTS project (R&D line)
- *
- * (c) 2020-2022 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#pragma once
-
-// Project include(s).
-#include "detray/coordinates/coordinates.hpp"
-#include "detray/definitions/qualifiers.hpp"
-#include "detray/intersection/intersection.hpp"
-#include "detray/intersection/plane_intersector.hpp"
-#include "detray/masks/mask_base.hpp"
-
-// System include(s).
-#include <climits>
-#include <cmath>
-#include <sstream>
-#include <string>
-
-namespace detray {
-/** This is a 2-dimensional mask for the annulus geometry that is
- *  e.g. used for the itk strip endcaps.
- *
- * @tparam intersector_type is a struct used for intersecting this cylinder
- * @tparam local_type is the default local type for this mask
- * @tparam links_type is an object where the mask can link to
- * @tparam kMaskContext is a unique mask identifier in a certain context
- *
- * It is defined by the two radii _values[0] and  _values[1] in the polar
- * coordinate system of and endcap strip module, as well as the two phi
- * boundaries, _values[2] and _values[3], that are only easily definable in
- * the local strips system (relative to the average Phi along the
- * strips r coordinate). Using a conversion between the two coordinate
- * systems, these boundaries can be checked with a tolerance in r (t[0] and
- * t[1]), as well as phi (t[3] and t[3]).
- * Due to the local polar coordinate system of the strips needing a
- * different origin from the discs polar one, three additional conversion
- * parameters are included (_values[4], values[5], _values[6]).
- * Here, the first two are the origin shift in xy, while _values[6] is the
- * average Phi angle mentioned above.
- *
- * @note  While the mask_context can change depending on the typed container
- * structure the mask_identifier is a const expression that determines the
- * mask type once for all.
- *
- **/
-
-template <typename transform3_t = __plugin::transform3<scalar>,
-          template <class> typename intersector_t = plane_intersector,
-          template <class> typename local_t = polar2, typename links_t = dindex,
-          template <typename, std::size_t> class array_t = darray>
-class annulus2 final : public mask_base<transform3_t, intersector_t, local_t,
-                                        links_t, array_t, 7> {
-    public:
-    using base_type =
-        mask_base<transform3_t, intersector_t, local_t, links_t, array_t, 7>;
-    using base_type::base_type;
-    using mask_values = typename base_type::mask_values;
-    using links_type = typename base_type::links_type;
-    using local_type = typename base_type::local_type;
-    using intersector_type = typename base_type::intersector_type;
-    using point2 = typename transform3_t::point2;
-
-    /* Default constructor */
-    annulus2()
-        : base_type({0., std::numeric_limits<scalar>::infinity(),
-                     -std::numeric_limits<scalar>::infinity(),
-                     std::numeric_limits<scalar>::infinity(), 0., 0., 0.},
-                    {}) {}
-
-    /** Construction from boundary values
-     *
-     * @param r_low lower r boundary
-     * @param r_high upper r boundary
-     * @param phi_low lower phi boundary
-     * @param phi_high upper phi boundary
-     * @param shift_x origin shift loc0
-     * @param shift_y origin shift loc1
-     * @param avg_phi average phi value
-     */
-    DETRAY_HOST_DEVICE annulus2(scalar r_low, scalar r_high, scalar phi_low,
-                                scalar phi_high, scalar shift_x, scalar shift_y,
-                                scalar avg_phi, links_type links)
-        : base_type(
-              {r_low, r_high, phi_low, phi_high, shift_x, shift_y, avg_phi},
-              links) {}
-
-    /** Mask operation
-     *
-     * @tparam inside_local_t is the local type for checking, needs to be
-     * specificed
-     *
-     * @param p the point to be checked in local polar coord
-     * @param t is the tolerance in (r, phi)
-     *
-     * @return an intersection status e_inside / e_outside
-     **/
-    template <typename inside_local_t>
-    DETRAY_HOST_DEVICE intersection::status is_inside(
-        const point2 &p,
-        const scalar t = std::numeric_limits<scalar>::epsilon()) const {
-        // The two quantities to check: r^2 in module system, phi in strips
-        // system
-
-        // In cartesian coordinates go to modules system by shifting origin
-        if constexpr (std::is_same_v<inside_local_t,
-                                     cartesian2<transform3_t>>) {
-            // Calculate radial coordinate in module system:
-            scalar x_mod = p[0] - this->_values[4];
-            scalar y_mod = p[1] - this->_values[5];
-            scalar r_mod2 = x_mod * x_mod + y_mod * y_mod;
-
-            // apply tolerances
-            scalar minR_tol = this->_values[0] - t;
-            scalar maxR_tol = this->_values[1] + t;
-
-            if (r_mod2 < minR_tol * minR_tol or r_mod2 > maxR_tol * maxR_tol)
-                return intersection::status::e_outside;
-
-            scalar phi_strp = getter::phi(p) - this->_values[6];
-            // Check phi boundaries, which are well def. in local frame
-            return (phi_strp >= this->_values[2] - t and
-                    phi_strp <= this->_values[3] + t)
-                       ? intersection::status::e_inside
-                       : intersection::status::e_outside;
-        }
-        // polar strip coordinates given
-        else {
-            // For a point p in local polar coordinates, rotate by avr phi
-            scalar phi_strp = p[1] - this->_values[6];
-
-            // Check phi boundaries, which are well def. in local frame
-            if (phi_strp < this->_values[2] - t ||
-                phi_strp > this->_values[3] + t)
-                return intersection::status::e_outside;
-
-            // Now go to module frame to check r boundaries. Use the origin
-            // shift in polar coordinates for that
-            point2 shift_xy = {-1 * this->_values[4], -1 * this->_values[5]};
-            scalar shift_r = getter::perp(shift_xy);
-            scalar shift_phi = getter::phi(shift_xy);
-
-            scalar r_mod2 = shift_r * shift_r + p[0] * p[0] +
-                            2 * shift_r * p[0] * std::cos(phi_strp - shift_phi);
-
-            // Apply tolerances
-            scalar minR_tol = this->_values[0] - t;
-            scalar maxR_tol = this->_values[1] + t;
-
-            return (r_mod2 >= minR_tol * minR_tol and
-                    r_mod2 <= maxR_tol * maxR_tol)
-                       ? intersection::status::e_inside
-                       : intersection::status::e_outside;
-        }
-    }
-
-    /// Transform to a string for output debugging
-    DETRAY_HOST
-    std::string to_string() const {
-        std::stringstream ss;
-        ss << "annulus2";
-        for (const auto &v : this->_values) {
-            ss << ", " << v;
-        }
-        return ss.str();
-    }
-};
-
-}  // namespace detray
diff --git a/core/include/detray/masks/annulus2D.hpp b/core/include/detray/masks/annulus2D.hpp
new file mode 100644
index 0000000000..abb1a9401c
--- /dev/null
+++ b/core/include/detray/masks/annulus2D.hpp
@@ -0,0 +1,173 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2020-2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/coordinates/polar2.hpp"
+#include "detray/definitions/qualifiers.hpp"
+#include "detray/intersection/plane_intersector.hpp"
+#include "detray/surface_finders/grid/detail/axis_binning.hpp"
+#include "detray/surface_finders/grid/detail/axis_shape.hpp"
+
+// System include(s)
+#include <cmath>
+#include <limits>
+#include <string>
+#include <tuple>
+
+namespace detray {
+
+/// @brief Geometrical shape of a stereo annulus that is used for the itk
+/// strip endcaps.
+///
+/// @tparam intersector_t defines how to intersect the underlying surface
+///         geometry
+///
+/// The stereo annulus is defined in two different(!) polar coordinate systems
+/// that differ by an origin shift. The boundaries are the inner and outer
+/// radius (bounds[0] and bounds[1]) in the polar coordinate system of an
+/// endcap strip disc (called disc system in the following) that is centered on
+/// the beam axis, as well as the two phi boundaries that are defined in the
+/// system that is shifted into the focal point of the strips on a given module
+/// (called focal system in the following). The mask phi boundaries (bounds[2]
+/// and bounds[3]) are defined relative to the average phi position of the
+/// strips in the focal system. Using a conversion between the two coordinate
+/// systems, these boundaries can be checked with a tolerance in r (tol[0]), as
+/// well as in phi (tol[1]).
+/// Due to the focal polar coordinate system of the strips needing a
+/// different origin from the discs polar system, three additional conversion
+/// parameters are included (bounds[4], bounds[5], bounds[6]).
+/// The first two are the origin shift in x and y respectively, while
+/// bounds[6] is the average Phi angle mentioned above.
+template <template <typename> class intersector_t = plane_intersector>
+class annulus2D {
+    public:
+    /// The name for this shape
+    inline static const std::string name = "(stereo) annulus2D";
+
+    /// Names for the mask boundary values
+    enum boundaries : std::size_t {
+        e_min_r = 0,
+        e_max_r = 1,
+        e_min_phi_rel = 2,
+        e_max_phi_rel = 3,
+        e_shift_x = 4,
+        e_shift_y = 5,
+        e_average_phi = 6,
+        e_size = 7,
+    };
+
+    /// Local coordinate frame (both for disc and focal system ?)
+    template <typename algebra_t>
+    using local_frame_type = polar2<algebra_t>;
+    /// Local point type (2D)
+    template <typename algebra_t>
+    using loc_point_type = typename local_frame_type<algebra_t>::point2;
+
+    /// Measurement frame. @todo switch to focal system?
+    template <typename algebra_t>
+    using measurement_frame_type = polar2<algebra_t>;
+    /// Local measurement point (2D)
+    template <typename algebra_t>
+    using measurement_point_type =
+        typename measurement_frame_type<algebra_t>::point2;
+
+    /// Underlying surface geometry: planar
+    template <typename algebra_t>
+    using intersector_type = intersector_t<algebra_t>;
+
+    /// Behaviour of the two local axes (linear in r, circular in phi)
+    template <
+        n_axis::shape e_s = n_axis::shape::e_open,
+        template <typename, typename> class binning_loc0 = n_axis::regular,
+        template <typename, typename> class binning_loc1 = n_axis::regular>
+    struct axes {
+        static constexpr n_axis::label axis_loc0 = n_axis::label::e_r;
+        static constexpr n_axis::label axis_loc1 = n_axis::label::e_phi;
+
+        using types = std::tuple<n_axis::shape_t<e_s, axis_loc0>,
+                                 n_axis::circular<axis_loc1>>;
+
+        /// Local coordinate frame (both for disc and focal system ?)
+        template <typename algebra_t>
+        using coordinate_type = local_frame_type<algebra_t>;
+
+        template <typename C, typename S>
+        using binning = std::tuple<binning_loc0<C, S>, binning_loc1<C, S>>;
+    };
+
+    /// Given a local polar point given in the disc frame, @returns the
+    /// correponding point in the focal frame
+    /*DETRAY_HOST_DEVICE
+    template<typename scalar_t>
+    static inline constexpr loc_point_type<scalar_t> to_focal_frame(
+        const loc_point_type<scalar_t> & pc_mod_point) {
+        return {};
+    }
+
+    /// Given a local polar point given in the focal frame, @returns the
+    /// correponding point in the disc frame
+    DETRAY_HOST_DEVICE
+    template<typename scalar_t>
+    static inline constexpr loc_point_type<scalar_t> to_disc_frame(
+        const loc_point_type<scalar_t> & pc_strp_point) {
+        return {};
+    }*/
+
+    /// @brief Check boundary values for a local point.
+    ///
+    /// @note the point is expected to be given in local coordinates by the
+    /// caller. For the conversion from global cartesian coordinates, the
+    /// nested @c shape struct can be used. For this mask, the local point must
+    /// be given in the focal (strips) system.
+    ///
+    /// @param bounds the boundary values for this shape
+    /// @param loc_p the point to be checked in the local coordinate system
+    /// @param tol dynamic tolerance determined by caller
+    ///
+    /// @return true if the local point lies within the given boundaries.
+    template <template <typename, std::size_t> class bounds_t,
+              typename scalar_t, std::size_t kDIM, typename point_t,
+              typename std::enable_if_t<kDIM == e_size, bool> = true>
+    DETRAY_HOST_DEVICE inline bool check_boundaries(
+        const bounds_t<scalar_t, kDIM> &bounds, const point_t &loc_p,
+        const scalar_t tol = std::numeric_limits<scalar_t>::epsilon()) const {
+
+        // The two quantities to check: r^2 in disc system, phi in focal system:
+
+        // Rotate by avr phi into the focal system
+        const scalar_t phi_strp{loc_p[1] - bounds[e_average_phi]};
+
+        // Check phi boundaries, which are well def. in focal frame
+        if ((phi_strp < bounds[e_min_phi_rel] - tol) or
+            (phi_strp > bounds[e_max_phi_rel] + tol)) {
+            return false;
+        }
+
+        // Now go to module frame to check r boundaries. Use the origin
+        // shift in polar coordinates for that
+        // TODO: Put shift in r-phi into the bounds?
+        const point_t shift_xy = {scalar_t{-1} * bounds[e_shift_x],
+                                  scalar_t{-1} * bounds[e_shift_y]};
+        const scalar_t shift_r{getter::perp(shift_xy)};
+        const scalar_t shift_phi{getter::phi(shift_xy)};
+
+        const scalar_t r_mod2{shift_r * shift_r + loc_p[0] * loc_p[0] +
+                              scalar_t{2} * shift_r * loc_p[0] *
+                                  std::cos(phi_strp - shift_phi)};
+
+        // Apply tolerances
+        const scalar_t minR_tol{bounds[e_min_r] - tol};
+        const scalar_t maxR_tol{bounds[e_max_r] + tol};
+
+        return ((r_mod2 >= minR_tol * minR_tol) and
+                (r_mod2 <= maxR_tol * maxR_tol));
+    }
+};
+
+}  // namespace detray
diff --git a/core/include/detray/masks/cuboid3D.hpp b/core/include/detray/masks/cuboid3D.hpp
new file mode 100644
index 0000000000..6e0008822e
--- /dev/null
+++ b/core/include/detray/masks/cuboid3D.hpp
@@ -0,0 +1,108 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2020-2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/coordinates/cartesian3.hpp"
+#include "detray/definitions/qualifiers.hpp"
+#include "detray/intersection/plane_intersector.hpp"
+#include "detray/surface_finders/grid/detail/axis_binning.hpp"
+#include "detray/surface_finders/grid/detail/axis_shape.hpp"
+
+// System include(s)
+#include <cmath>
+#include <limits>
+#include <string>
+#include <tuple>
+
+namespace detray {
+
+/// @brief Geometrical shape of a full 3D cuboid.
+///
+/// It is defined by the 3 half length and checks whether a point is somewhere
+/// inside the cuboid.
+class cuboid3D {
+    public:
+    /// The name for this shape
+    inline static const std::string name = "cuboid3D";
+
+    enum boundaries : std::size_t {
+        e_half_x = 0,
+        e_half_y = 1,
+        e_half_z = 2,
+        e_size = 3,
+    };
+
+    /// Local coordinate frame for boundary checks
+    template <typename algebra_t>
+    using local_frame_type = cartesian3<algebra_t>;
+    /// Local point type (3D)
+    template <typename algebra_t>
+    using loc_point_type = typename local_frame_type<algebra_t>::point3;
+
+    /// Measurement frame
+    template <typename algebra_t>
+    using measurement_frame_type = local_frame_type<algebra_t>;
+    /// Local measurement point (2D)
+    template <typename algebra_t>
+    using measurement_point_type = loc_point_type<algebra_t>;
+
+    /// Underlying surface geometry: not a surface
+    template <typename algebra_t>
+    using intersector_type = void;
+
+    /// Behaviour of the three local axes (linear in x, linear in y,
+    /// linear in z)
+    template <
+        n_axis::shape e_s = n_axis::shape::e_open,
+        template <typename, typename> class binning_loc0 = n_axis::regular,
+        template <typename, typename> class binning_loc1 = n_axis::regular,
+        template <typename, typename> class binning_loc2 = n_axis::regular>
+    struct axes {
+        static constexpr n_axis::label axis_loc0 = n_axis::label::e_x;
+        static constexpr n_axis::label axis_loc1 = n_axis::label::e_y;
+        static constexpr n_axis::label axis_loc2 = n_axis::label::e_z;
+
+        /// How to convert into the local axis system and back
+        template <typename algebra_t>
+        using coordinate_type = local_frame_type<algebra_t>;
+
+        using types = std::tuple<n_axis::shape_t<e_s, axis_loc0>,
+                                 n_axis::shape_t<e_s, axis_loc1>,
+                                 n_axis::shape_t<e_s, axis_loc2>>;
+
+        template <typename C, typename S>
+        using binning = std::tuple<binning_loc0<C, S>, binning_loc1<C, S>,
+                                   binning_loc2<C, S>>;
+    };
+
+    /// @brief Check boundary values for a local point.
+    ///
+    /// @note the point is expected to be given in local coordinates by the
+    /// caller. For the conversion from global cartesian coordinates, the
+    /// nested @c shape struct can be used. The point is assumed to be in
+    /// the a cartesian 3D frame.
+    ///
+    /// @param bounds the boundary values for this shape
+    /// @param loc_p the point to be checked in the local coordinate system
+    /// @param tol dynamic tolerance determined by caller
+    ///
+    /// @return true if the local point lies within the given boundaries.
+    template <template <typename, std::size_t> class bounds_t,
+              typename scalar_t, std::size_t kDIM, typename point_t,
+              typename std::enable_if_t<kDIM == e_size, bool> = true>
+    DETRAY_HOST_DEVICE inline bool check_boundaries(
+        const bounds_t<scalar_t, kDIM> &bounds, const point_t &loc_p,
+        const scalar_t tol = std::numeric_limits<scalar_t>::epsilon()) const {
+        return (std::abs(loc_p[0]) <= bounds[e_half_x] + tol and
+                std::abs(loc_p[1]) <= bounds[e_half_y] + tol and
+                std::abs(loc_p[2]) <= bounds[e_half_z] + tol);
+    }
+};
+
+}  // namespace detray
diff --git a/core/include/detray/masks/cylinder2D.hpp b/core/include/detray/masks/cylinder2D.hpp
new file mode 100644
index 0000000000..dcd8770342
--- /dev/null
+++ b/core/include/detray/masks/cylinder2D.hpp
@@ -0,0 +1,127 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2020-2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/coordinates/cylindrical2.hpp"
+#include "detray/coordinates/cylindrical3.hpp"
+#include "detray/definitions/qualifiers.hpp"
+#include "detray/intersection/cylinder_intersector.hpp"
+#include "detray/surface_finders/grid/detail/axis_binning.hpp"
+#include "detray/surface_finders/grid/detail/axis_shape.hpp"
+
+// System include(s)
+#include <cmath>
+#include <limits>
+#include <string>
+#include <tuple>
+
+namespace detray {
+
+/// @brief Geometrical shape of a 2D cylinder.
+///
+/// @tparam kRadialCheck is a boolean to steer whether the radius compatibility
+///         needs to be checked (changes local coordinate system def.)
+/// @tparam intersector_t defines how to intersect the underlying surface
+///         geometry
+///
+/// It is defined by r and the two half lengths rel to the coordinate center.
+template <bool kRadialCheck = false,
+          template <typename> class intersector_t = cylinder_intersector>
+class cylinder2D {
+    public:
+    /// The name for this shape
+    inline static const std::string name = "cylinder2D";
+
+    /// Check the radial position in boundary check
+    static constexpr bool check_radius = kRadialCheck;
+
+    enum boundaries : std::size_t {
+        e_r = 0,
+        e_n_half_z = 1,
+        e_p_half_z = 2,
+        e_size = 3,
+    };
+
+    /// Local coordinate frame for boundary checks
+    template <typename algebra_t>
+    using local_frame_type =
+        std::conditional_t<kRadialCheck, cylindrical3<algebra_t>,
+                           cylindrical2<algebra_t>>;
+    /// Local point type for boundary checks (2D or 3D)
+    template <typename algebra_t>
+    using loc_point_type =
+        std::conditional_t<kRadialCheck,
+                           typename local_frame_type<algebra_t>::point3,
+                           typename local_frame_type<algebra_t>::point2>;
+
+    /// Measurement frame
+    template <typename algebra_t>
+    using measurement_frame_type = cylindrical2<algebra_t>;
+    /// Local measurement point (2D)
+    template <typename algebra_t>
+    using measurement_point_type =
+        typename measurement_frame_type<algebra_t>::point2;
+
+    /// Underlying surface geometry: cylindrical
+    template <typename algebra_t>
+    using intersector_type = intersector_t<algebra_t>;
+
+    /// Behaviour of the two local axes (circular in r_phi, linear in z)
+    template <
+        n_axis::shape e_s = n_axis::shape::e_open,
+        template <typename, typename> class binning_loc0 = n_axis::regular,
+        template <typename, typename> class binning_loc1 = n_axis::regular>
+    struct axes {
+        static constexpr n_axis::label axis_loc0 = n_axis::label::e_rphi;
+        static constexpr n_axis::label axis_loc1 = n_axis::label::e_cyl_z;
+
+        using types = std::tuple<n_axis::circular<axis_loc0>,
+                                 n_axis::shape_t<e_s, axis_loc1>>;
+
+        /// How to convert into the local axis system and back
+        template <typename algebra_t>
+        using coordinate_type = cylindrical2<algebra_t>;
+
+        template <typename C, typename S>
+        using binning = std::tuple<binning_loc0<C, S>, binning_loc1<C, S>>;
+    };
+
+    /// @brief Check boundary values for a local point.
+    ///
+    /// @note the point is expected to be given in local coordinates by the
+    /// caller. For the conversion from global cartesian coordinates, the
+    /// nested @c shape struct can be used. The point is assumed to be in
+    /// the cylinder 2D frame (r * phi, z).
+    ///
+    /// @tparam is_rad_check whether the radial bound should be checked in this
+    /// call.
+    ///
+    /// @param bounds the boundary values for this shape
+    /// @param loc_p the point to be checked in the local coordinate system
+    /// @param tol dynamic tolerance determined by caller
+    ///
+    /// @return true if the local point lies within the given boundaries.
+    template <template <typename, std::size_t> class bounds_t,
+              typename scalar_t, std::size_t kDIM, typename point_t,
+              typename std::enable_if_t<kDIM == e_size, bool> = true>
+    DETRAY_HOST_DEVICE inline bool check_boundaries(
+        const bounds_t<scalar_t, kDIM> &bounds, const point_t &loc_p,
+        const scalar_t tol = std::numeric_limits<scalar_t>::epsilon()) const {
+        if constexpr (kRadialCheck) {
+            return (loc_p[0] <= bounds[e_r] + tol and
+                    bounds[e_n_half_z] - tol <= loc_p[2] and
+                    loc_p[2] <= bounds[e_p_half_z] + tol);
+        } else {
+            return (bounds[e_n_half_z] - tol <= loc_p[1] and
+                    loc_p[1] <= bounds[e_p_half_z] + tol);
+        }
+    }
+};
+
+}  // namespace detray
diff --git a/core/include/detray/masks/cylinder3.hpp b/core/include/detray/masks/cylinder3.hpp
deleted file mode 100644
index d223a6bef2..0000000000
--- a/core/include/detray/masks/cylinder3.hpp
+++ /dev/null
@@ -1,113 +0,0 @@
-/** Detray library, part of the ACTS project (R&D line)
- *
- * (c) 2020-2022 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#pragma once
-
-// Project include(s)
-#include "detray/coordinates/coordinates.hpp"
-#include "detray/definitions/qualifiers.hpp"
-#include "detray/intersection/cylinder_intersector.hpp"
-#include "detray/intersection/intersection.hpp"
-#include "detray/masks/mask_base.hpp"
-
-// System include(s)
-#include <climits>
-#include <cmath>
-#include <sstream>
-#include <string>
-
-namespace detray {
-/** This is a simple mask for a full cylinder
- *
- * @tparam kRadialCheck is a boolean to steer wheter the radius compatibility
- *needs to be checked
- * @tparam intersector_t is a struct used for intersecting this cylinder
- * @tparam links_type is an object where the mask can link to
- * @tparam kMaskContext is a unique mask identifier in a certain context
- *
- * It is defined by r and the half length.
- *
- * @note  While the mask_context can change depending on the typed container
- * structure the mask_identifier is a const expression that determines the
- * mask type once for all.
- *
- **/
-template <typename transform3_t = __plugin::transform3<scalar>,
-          template <class> typename intersector_t = cylinder_intersector,
-          template <class> typename local_t = cylindrical2,
-          typename links_t = dindex, bool kRadialCheck = false,
-          template <typename, std::size_t> class array_t = darray>
-class cylinder3 final : public mask_base<transform3_t, intersector_t, local_t,
-                                         links_t, array_t, 3> {
-    public:
-    using base_type =
-        mask_base<transform3_t, intersector_t, local_t, links_t, array_t, 3>;
-    using base_type::base_type;
-    using mask_values = typename base_type::mask_values;
-    using links_type = typename base_type::links_type;
-    using local_type = typename base_type::local_type;
-    using intersector_type = typename base_type::intersector_type;
-    using point3 = typename transform3_t::point3;
-
-    /* Default constructor */
-    cylinder3()
-        : base_type({std::numeric_limits<scalar>::infinity(),
-                     -std::numeric_limits<scalar>::infinity(),
-                     std::numeric_limits<scalar>::infinity()},
-                    {}) {}
-
-    /** Construction from boundary values
-     *
-     * @param r radius
-     * @param half_length_1 half_length
-     * @param half_length_2 half length
-     */
-    DETRAY_HOST_DEVICE
-    cylinder3(scalar r, scalar half_length_1, scalar half_length_2,
-              links_type links)
-        : base_type({r, half_length_1, half_length_2}, links) {}
-
-    /** Mask operation
-     *
-     * @tparam inside_local_type::point3 is the deduced type of the point to be
-     *checked w.r.t. to the mask bounds, it's assumed to be within the cylinder
-     *3D frame
-     *
-     * @param p the point to be checked
-     * @param t is the tolerance tuple in (radius, z)
-     *
-     * @return an intersection status e_inside / e_outside
-     **/
-    template <typename inside_local_t, bool is_rad_check = kRadialCheck>
-    DETRAY_HOST_DEVICE intersection::status is_inside(
-        const point3 &p,
-        const scalar t = std::numeric_limits<scalar>::epsilon()) const {
-        if constexpr (is_rad_check) {
-            scalar r = getter::perp(p);
-            if (std::abs(r - this->_values[0]) >=
-                t + 5 * std::numeric_limits<scalar>::epsilon()) {
-                return intersection::status::e_missed;
-            }
-        }
-        return (this->_values[1] - t <= p[2] and p[2] <= this->_values[2] + t)
-                   ? intersection::status::e_inside
-                   : intersection::status::e_outside;
-    }
-
-    /** Transform to a string for output debugging */
-    DETRAY_HOST
-    std::string to_string() const {
-        std::stringstream ss;
-        ss << "cylinder3";
-        for (const auto &v : this->_values) {
-            ss << ", " << v;
-        }
-        return ss.str();
-    }
-};
-
-}  // namespace detray
diff --git a/core/include/detray/masks/cylinder3D.hpp b/core/include/detray/masks/cylinder3D.hpp
new file mode 100644
index 0000000000..37bb67effc
--- /dev/null
+++ b/core/include/detray/masks/cylinder3D.hpp
@@ -0,0 +1,107 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2020-2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/coordinates/cylindrical3.hpp"
+#include "detray/definitions/qualifiers.hpp"
+#include "detray/intersection/cylinder_intersector.hpp"
+#include "detray/surface_finders/grid/detail/axis_binning.hpp"
+#include "detray/surface_finders/grid/detail/axis_shape.hpp"
+
+// System include(s)
+#include <cmath>
+#include <limits>
+#include <string>
+#include <tuple>
+
+namespace detray {
+
+/// @brief Geometrical shape of a full 3D cylinder.
+///
+/// It is defined by r and the two half lengths rel to the coordinate center.
+class cylinder3D {
+    public:
+    /// The name for this shape
+    inline static const std::string name = "cylinder3D";
+
+    enum boundaries : std::size_t {
+        e_r = 0,
+        e_n_half_z = 1,
+        e_p_half_z = 2,
+        e_size = 3,
+    };
+
+    /// Local coordinate frame for boundary checks
+    template <typename algebra_t>
+    using local_frame_type = cylindrical3<algebra_t>;
+    /// Local point type (3D)
+    template <typename algebra_t>
+    using loc_point_type = typename local_frame_type<algebra_t>::point3;
+
+    /// Measurement frame
+    template <typename algebra_t>
+    using measurement_frame_type = local_frame_type<algebra_t>;
+    /// Local measurement point (2D)
+    template <typename algebra_t>
+    using measurement_point_type = loc_point_type<algebra_t>;
+
+    /// Underlying surface geometry: not a surface.
+    template <typename algebra_t>
+    using intersector_type = void;
+
+    /// Behaviour of the three local axes (linear in r, circular in phi,
+    /// linear in z)
+    template <
+        n_axis::shape e_s = n_axis::shape::e_open,
+        template <typename, typename> class binning_loc0 = n_axis::regular,
+        template <typename, typename> class binning_loc1 = n_axis::regular,
+        template <typename, typename> class binning_loc2 = n_axis::regular>
+    struct axes {
+        static constexpr n_axis::label axis_loc0 = n_axis::label::e_r;
+        static constexpr n_axis::label axis_loc1 = n_axis::label::e_phi;
+        static constexpr n_axis::label axis_loc2 = n_axis::label::e_z;
+
+        using types = std::tuple<n_axis::shape_t<e_s, axis_loc0>,
+                                 n_axis::circular<axis_loc1>,
+                                 n_axis::shape_t<e_s, axis_loc2>>;
+
+        /// How to convert into the local axis system and back
+        template <typename algebra_t>
+        using coordinate_type = local_frame_type<algebra_t>;
+
+        template <typename C, typename S>
+        using binning = std::tuple<binning_loc0<C, S>, binning_loc1<C, S>,
+                                   binning_loc2<C, S>>;
+    };
+
+    /// @brief Check boundary values for a local point.
+    ///
+    /// @note the point is expected to be given in local coordinates by the
+    /// caller. For the conversion from global cartesian coordinates, the
+    /// nested @c shape struct can be used. The point is assumed to be in
+    /// the cylinder 3D frame.
+    ///
+    /// @param bounds the boundary values for this shape
+    /// @param loc_p the point to be checked in the local coordinate system
+    /// @param tol dynamic tolerance determined by caller
+    ///
+    /// @return true if the local point lies within the given boundaries.
+    template <template <typename, std::size_t> class bounds_t,
+              typename scalar_t, std::size_t kDIM, typename point_t,
+              typename std::enable_if_t<kDIM == e_size, bool> = true>
+    DETRAY_HOST_DEVICE inline bool check_boundaries(
+        const bounds_t<scalar_t, kDIM> &bounds, const point_t &loc_p,
+        const scalar_t tol = std::numeric_limits<scalar_t>::epsilon()) const {
+        return (loc_p[0] <= bounds[e_r] + tol and
+                bounds[e_n_half_z] - tol <= loc_p[2] and
+                loc_p[2] <= bounds[e_p_half_z] + tol);
+    }
+};
+
+}  // namespace detray
diff --git a/core/include/detray/masks/line.hpp b/core/include/detray/masks/line.hpp
index 616b1c9b6a..89117a2110 100644
--- a/core/include/detray/masks/line.hpp
+++ b/core/include/detray/masks/line.hpp
@@ -8,101 +8,132 @@
 #pragma once
 
 // Project include(s).
-#include "detray/coordinates/coordinates.hpp"
+#include "detray/coordinates/cartesian3.hpp"
+#include "detray/coordinates/line2.hpp"
 #include "detray/definitions/qualifiers.hpp"
-#include "detray/intersection/intersection.hpp"
 #include "detray/intersection/line_intersector.hpp"
-#include "detray/masks/mask_base.hpp"
+#include "detray/surface_finders/grid/detail/axis_binning.hpp"
+#include "detray/surface_finders/grid/detail/axis_shape.hpp"
 
-// System include(s).
-#include <climits>
+// System include(s)
 #include <cmath>
+#include <limits>
+#include <tuple>
 #include <type_traits>
 
 namespace detray {
 
-/** This is a simple mask for a line defined with a line length and its scope
- *
- **/
-template <typename transform3_t = __plugin::transform3<scalar>,
-          template <class> typename intersector_t = line_intersector,
-          template <class> typename local_t = cartesian2,
-          typename links_t = dindex, bool kSquareScope = false,
-          template <typename, std::size_t> class array_t = darray>
-class line final : public mask_base<transform3_t, intersector_t, local_t,
-                                    links_t, array_t, 2> {
+/// @brief Geometrical shape of a line surface.
+///
+/// @tparam kSquareCrossSect determines whether the line has a cricular or
+///         square cross section. This also changes the local coord. frame.
+/// @tparam intersector_t defines how to intersect the underlying surface
+///         geometry
+///
+/// The line can either have a circular or a square cross section. In the first
+/// case bounds[0] refers to the radius, while in the second case it is the
+/// half length of the square. The second boundary bounds[1] is the half length
+/// in z.
+template <bool kSquareCrossSect = false,
+          template <typename> class intersector_t = line_intersector>
+class line {
     public:
-    using base_type =
-        mask_base<transform3_t, intersector_t, local_t, links_t, array_t, 2>;
-    using base_type::base_type;
-    using mask_values = typename base_type::mask_values;
-    using links_type = typename base_type::links_type;
-    using local_type = typename base_type::local_type;
-    using intersector_type = typename base_type::intersector_type;
-    using point2 = typename transform3_t::point2;
-    using point3 = typename transform3_t::point3;
-
-    static constexpr bool square_scope = kSquareScope;
-
-    /* Default constructor */
-    line() : base_type({0, std::numeric_limits<scalar>::infinity()}, {}) {}
-
-    /** Construction from boundary values
-     *
-     * @param half_cell_size is the half length of transverse cell of line
-     * detector
-     * @param half_length is the half length of line
-     */
-    DETRAY_HOST_DEVICE
-    line(scalar half_cell_size, scalar half_length, links_type links)
-        : base_type({half_cell_size, half_length}, links) {}
-
-    /** Mask operation
-     *
-     * @tparam inside_local_t is the local type for inside checking
-     *
-     * @param p is the intersection point in local cartesian coordinate
-     * @param t is the tolerance in r
-     *
-     * @return an intersection status e_inside / e_outside
-     **/
-    DETRAY_HOST_DEVICE intersection::status is_inside(
-        const point3 &p,
-        const scalar t = std::numeric_limits<scalar>::epsilon()) const {
-
-        // For square cross section, we check if (1) the x and y of transverse
-        // position is less than the half cell size and (2) the distance to the
-        // point of closest approach on line from the line center is less than
-        // the half line length
-        if constexpr (square_scope) {
-            return std::abs(p[0]) <= this->_values[0] + t &&
-                           std::abs(p[1]) <= this->_values[0] + t &&
-                           std::abs(p[2]) <= this->_values[1] + t
-                       ? intersection::status::e_inside
-                       : intersection::status::e_outside;
-
-            // For circular cross section, we check if (1) the radial distance
-            // is within the scope and (2) the distance to the point of closest
-            // approach on line from the line center is less than the half line
-            // length
-        } else {
-            return (getter::perp(p) <= this->_values[0] + t &&
-                    std::abs(p[2]) <= this->_values[1] + t)
+    /// The name for this shape
+    inline static const std::string name = "line";
 
-                       ? intersection::status::e_inside
-                       : intersection::status::e_outside;
-        }
-    }
+    /// Geometrical cross section of the line
+    static constexpr bool square_cross_sect = kSquareCrossSect;
+
+    enum boundaries : std::size_t {
+        e_cross_section = 0,
+        e_half_z = 1,
+        e_size = 2
+    };
+
+    /// Local coordinate frame for boundary checks
+    template <typename algebra_t>
+    using local_frame_type =
+        std::conditional_t<kSquareCrossSect, cartesian3<algebra_t>,
+                           line2<algebra_t>>;
+    /// Local point type for boundary checks (2D or 3D)
+    template <typename algebra_t>
+    using loc_point_type =
+        std::conditional_t<kSquareCrossSect,
+                           typename local_frame_type<algebra_t>::point3,
+                           typename local_frame_type<algebra_t>::point2>;
+
+    /// Measurement frame
+    template <typename algebra_t>
+    using measurement_frame_type = line2<algebra_t>;
+    /// Measurement point type (2D)
+    template <typename algebra_t>
+    using measurement_point_type =
+        typename measurement_frame_type<algebra_t>::point2;
+
+    /// Underlying surface geometry: planar
+    template <typename algebra_t>
+    using intersector_type = intersector_t<algebra_t>;
 
-    /** Transform to a string for output debugging */
-    DETRAY_HOST
-    std::string to_string() const {
-        std::stringstream ss;
-        ss << "line";
-        for (const auto &v : this->_values) {
-            ss << ", " << v;
+    /// Behaviour of the two local axes (linear in r/x, linear in z)
+    template <
+        n_axis::shape e_s = n_axis::shape::e_open,
+        template <typename, typename> class binning_loc0 = n_axis::regular,
+        template <typename, typename> class binning_loc1 = n_axis::regular>
+    struct axes {
+        static constexpr n_axis::label axis_loc0 = n_axis::label::e_r;
+        static constexpr n_axis::label axis_loc1 = n_axis::label::e_z;
+
+        using types = std::tuple<n_axis::shape_t<e_s, axis_loc0>,
+                                 n_axis::shape_t<e_s, axis_loc1>>;
+
+        /// How to convert into the local axis system and back
+        template <typename algebra_t>
+        using coordinate_type = line2<algebra_t>;
+
+        template <typename C, typename S>
+        using binning = std::tuple<binning_loc0<C, S>, binning_loc1<C, S>>;
+    };
+
+    /// @brief Check boundary values for a local point.
+    ///
+    /// @note the point is expected to be given in local coordinates by the
+    /// caller. For the conversion from global cartesian coordinates, the
+    /// nested @c shape struct can be used. In case of the line intersector
+    /// this is the point of closest approach to the line.
+    ///
+    /// @tparam point_t the local point dimension can be 2 for a circular
+    ///         cross section (local cylinder) or 3 for a square cross
+    ///         section (local 3D cartesian).
+    ///
+    /// @param bounds the boundary values for this shape
+    /// @param loc_p the point to be checked in the local coordinate system
+    /// @param tol dynamic tolerance determined by caller
+    ///
+    /// @return true if the local point lies within the given boundaries.
+    template <template <typename, std::size_t> class bounds_t,
+              typename scalar_t, std::size_t kDIM, typename point_t,
+              typename std::enable_if_t<kDIM == 2, bool> = true>
+    DETRAY_HOST_DEVICE inline bool check_boundaries(
+        const bounds_t<scalar_t, kDIM> &bounds, const point_t &loc_p,
+        const scalar_t tol = std::numeric_limits<scalar_t>::epsilon()) const {
+
+        // For square cross section, we check if (1) x and y of the local cart.
+        // point is less than the half cell size and (2) the distance to the
+        // point of closest approach on thw line from the line center is less
+        // than the half line length
+        if constexpr (square_cross_sect) {
+            return (std::abs(loc_p[0]) <= bounds[e_cross_section] + tol &&
+                    std::abs(loc_p[1]) <= bounds[e_cross_section] + tol &&
+                    std::abs(loc_p[2]) <= bounds[e_half_z] + tol);
+
+            // For a circular cross section, we check if (1) the radial distance
+            // is within the scope and (2) the distance to the point of closest
+            // approach on the line from the line center is less than the line
+            // half length
+        } else {
+            return (loc_p[0] <= bounds[e_cross_section] + tol &&
+                    std::abs(loc_p[1]) <= bounds[e_half_z] + tol);
         }
-        return ss.str();
     }
 };
 
diff --git a/core/include/detray/masks/mask_base.hpp b/core/include/detray/masks/mask_base.hpp
deleted file mode 100644
index 018238e036..0000000000
--- a/core/include/detray/masks/mask_base.hpp
+++ /dev/null
@@ -1,113 +0,0 @@
-/** Detray library, part of the ACTS project (R&D line)
- *
- * (c) 2022 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#pragma once
-
-// Project include(s)
-#include "detray/definitions/detail/accessor.hpp"
-#include "detray/definitions/qualifiers.hpp"
-
-namespace detray {
-
-template <typename transform3_t, template <class> typename intersector_t,
-          template <class> typename local_t, typename links_t,
-          template <typename, std::size_t> class array_t, std::size_t kDIM>
-class mask_base {
-    public:
-    using intersector_type = intersector_t<transform3_t>;
-    using local_type = local_t<transform3_t>;
-    using links_type = links_t;
-
-    template <typename T, std::size_t I>
-    using array_type = array_t<T, I>;
-    using mask_values = array_type<scalar, kDIM>;
-
-    /* Default constructor */
-    mask_base() = default;
-
-    DETRAY_HOST_DEVICE
-    mask_base(const mask_values& val, const links_type& links)
-        : _values(val), _links(links) {}
-
-    DETRAY_HOST_DEVICE
-    mask_base& operator=(const mask_values& rhs) {
-        this->_values = rhs;
-        return (*this);
-    }
-
-    /** Equality operator from an array, convenience function
-     *
-     * @param rhs is the rectangle to be compared with
-     *
-     * checks identity within epsilon and @return s a boolean*
-     **/
-    DETRAY_HOST_DEVICE
-    bool operator==(const mask_values& rhs) { return (_values == rhs); }
-
-    /** Equality operator
-     *
-     * @param rhs is the rectangle to be compared with
-     *
-     * checks identity within epsilon and @return s a boolean*
-     **/
-    DETRAY_HOST_DEVICE
-    bool operator==(const mask_base& rhs) {
-        return (_values == rhs._values && _links == rhs._links);
-    }
-
-    /** Access operator - non-const
-     * @return the reference to the member variable
-     */
-    DETRAY_HOST_DEVICE
-    scalar& operator[](std::size_t value_index) { return _values[value_index]; }
-
-    /** Access operator - const
-     * @return a copy of the member variable
-     */
-    DETRAY_HOST_DEVICE
-    scalar operator[](std::size_t value_index) const {
-        return _values[value_index];
-    }
-
-    /** Return the values */
-    DETRAY_HOST_DEVICE
-    const mask_values& values() const { return _values; }
-
-    /// Return an associated intersector type
-    DETRAY_HOST_DEVICE
-    intersector_type intersector() const { return intersector_type{}; };
-
-    /// Return the local frame type
-    DETRAY_HOST_DEVICE
-    constexpr local_type local() const { return local_type{}; }
-
-    /// @return the links - const reference
-    DETRAY_HOST_DEVICE
-    const links_type& links() const { return _links; }
-
-    /// @return the volume link - const reference
-    DETRAY_HOST_DEVICE
-    auto volume_link() const { return detail::get<0>(_links); }
-
-    /// @return the volume link - non-const access
-    DETRAY_HOST_DEVICE
-    auto volume_link() { return detail::get<0>(_links); }
-
-    /// @return the surface finder link - const reference
-    DETRAY_HOST_DEVICE
-    auto finder_link() const { return detail::get<1>(_links); }
-
-    /// @return the surface finder link - non-const access
-    DETRAY_HOST_DEVICE
-    auto finder_link() { return detail::get<1>(_links); }
-
-    protected:
-    mask_values _values;
-    links_type _links;
-};
-
-}  // namespace detray
\ No newline at end of file
diff --git a/core/include/detray/masks/masks.hpp b/core/include/detray/masks/masks.hpp
index 4facdd043a..9603b7af6c 100644
--- a/core/include/detray/masks/masks.hpp
+++ b/core/include/detray/masks/masks.hpp
@@ -7,11 +7,170 @@
 
 #pragma once
 
-#include "detray/masks/annulus2.hpp"
-#include "detray/masks/cylinder3.hpp"
+// Project include(s)
+#include "detray/definitions/detail/accessor.hpp"
+#include "detray/definitions/qualifiers.hpp"
+#include "detray/intersection/intersection.hpp"
+#include "detray/masks/annulus2D.hpp"
+#include "detray/masks/cuboid3D.hpp"
+#include "detray/masks/cylinder2D.hpp"
+#include "detray/masks/cylinder3D.hpp"
 #include "detray/masks/line.hpp"
-#include "detray/masks/rectangle2.hpp"
-#include "detray/masks/ring2.hpp"
-#include "detray/masks/single3.hpp"
-#include "detray/masks/trapezoid2.hpp"
-#include "detray/masks/unmasked.hpp"
\ No newline at end of file
+#include "detray/masks/rectangle2D.hpp"
+#include "detray/masks/ring2D.hpp"
+#include "detray/masks/single3D.hpp"
+#include "detray/masks/trapezoid2D.hpp"
+#include "detray/masks/unmasked.hpp"
+
+// System include(s)
+#include <sstream>
+
+namespace detray {
+
+/// @brief Mask a region on a surface and link it to a volume.
+///
+/// The class uses a lightweight 'shape' that defines the local geometry of a
+/// surface (local coordinates/axes, the intersection algorithm, as well as how
+/// to check boundaries on that surface). A simple example for such a surface
+/// shape implementation is @c rectangle2D .
+/// This class can then be instantiated as a concrete mask that holds the
+/// boundary values, as well as the link to a particular volume, which is
+/// needed during geometry navigation.
+///
+/// @tparam shape_t underlying geometrical shape of the mask, rectangle etc
+/// @tparam links_t the type of link into the volume container
+///                 (e.g. single index vs range)
+template <typename shape_t, typename links_t = dindex,
+          typename algebra_t = __plugin::transform3<detray::scalar>,
+          template <typename, std::size_t> class array_t = darray>
+class mask {
+    public:
+    using shape = shape_t;
+    using links_type = links_t;
+    using scalar_type = typename algebra_t::scalar_type;
+    using mask_values = array_t<scalar_type, shape::boundaries::e_size>;
+    using local_frame_type =
+        typename shape::template local_frame_type<algebra_t>;
+    using measurement_frame_type =
+        typename shape::template measurement_frame_type<algebra_t>;
+    // Linear algebra types
+    using loc_point_t = typename shape::template loc_point_type<algebra_t>;
+    using point3_t = typename algebra_t::point3;
+
+    /// Default constructor
+    constexpr mask() = default;
+
+    template <typename... Args>
+    DETRAY_HOST_DEVICE explicit mask(const links_type& link, Args&&... args)
+        : _values({{std::forward<Args>(args)...}}), _volume_link(link) {}
+
+    /// Assignment operator from an array, convenience function
+    ///
+    /// @param rhs is the right hand side object
+    DETRAY_HOST
+    auto operator=(const mask_values& rhs)
+        -> mask<shape_t, links_t, algebra_t, array_t>& {
+        _values = rhs;
+        return (*this);
+    }
+
+    /// Equality operator
+    ///
+    /// @param rhs is the mask to be compared
+    ///
+    /// checks identity within epsilon and @returns a boolean if the values and
+    /// links are equal.
+    DETRAY_HOST_DEVICE
+    bool operator==(
+        const mask<shape_t, links_t, algebra_t, array_t>& rhs) const {
+        return (_values == rhs._values && _volume_link == rhs._volume_link);
+    }
+
+    /// Access operator - non-const
+    ///
+    /// @returns the reference to the member variable
+    DETRAY_HOST_DEVICE
+    constexpr auto operator[](const std::size_t value_index) -> scalar_type& {
+        return _values[value_index];
+    }
+
+    /// Access operator - const
+    ///
+    /// @returns a copy of the member variable
+    DETRAY_HOST_DEVICE
+    constexpr auto operator[](const std::size_t value_index) const
+        -> scalar_type {
+        return _values[value_index];
+    }
+
+    /// @returns the boundary values
+    DETRAY_HOST_DEVICE
+    inline constexpr auto get_shape() const -> const shape& { return _shape; }
+
+    /// @returns the functor that projects a global cartesian point onto
+    /// the local geometric coordinate system.
+    template <typename transform3_t>
+    DETRAY_HOST_DEVICE inline auto to_local_frame(
+        const transform3_t& trf, const point3_t& glob_p,
+        const point3_t& glob_dir = {}) const -> loc_point_t {
+        return local_frame_type{}.global_to_local(trf, glob_p, glob_dir);
+    }
+
+    /// @returns the intersection functor for the underlying surface geometry.
+    DETRAY_HOST_DEVICE
+    inline constexpr auto intersector() const ->
+        typename shape::template intersector_type<algebra_t> {
+        return {};
+    }
+
+    /// @brief Mask this shape onto a surface.
+    ///
+    /// @note the point is expected to be given in global cartesian coordinates
+    /// by the caller. For the projection from global to local coordinates, the
+    /// shape type is used.
+    ///
+    /// @param loc_p the point to be checked in the local polar focal system
+    /// @param tol dynamic tolerance determined by caller
+    ///
+    /// @return an intersection status e_inside / e_outside
+    DETRAY_HOST_DEVICE
+    inline auto is_inside(
+        const loc_point_t& loc_p,
+        const scalar_type t = std::numeric_limits<scalar_type>::epsilon()) const
+        -> intersection::status {
+
+        return _shape.check_boundaries(_values, loc_p, t)
+                   ? intersection::status::e_inside
+                   : intersection::status::e_outside;
+    }
+
+    /// @returns the boundary values
+    DETRAY_HOST_DEVICE
+    auto values() const -> const mask_values& { return _values; }
+
+    /// @returns the volume link - const reference
+    DETRAY_HOST_DEVICE
+    auto volume_link() const -> const links_type& { return _volume_link; }
+
+    /// @returns the volume link - non-const access
+    DETRAY_HOST_DEVICE
+    auto volume_link() -> links_type& { return _volume_link; }
+
+    /// @returns a string representation of the mask
+    DETRAY_HOST
+    auto to_string() const -> std::string {
+        std::stringstream ss;
+        ss << shape::name;
+        for (const auto& v : _values) {
+            ss << ", " << v;
+        }
+        return ss.str();
+    }
+
+    private:
+    shape _shape;
+    mask_values _values;
+    links_type _volume_link;
+};
+
+}  // namespace detray
\ No newline at end of file
diff --git a/core/include/detray/masks/rectangle2.hpp b/core/include/detray/masks/rectangle2.hpp
deleted file mode 100644
index 3df451c96b..0000000000
--- a/core/include/detray/masks/rectangle2.hpp
+++ /dev/null
@@ -1,104 +0,0 @@
-/** Detray library, part of the ACTS project (R&D line)
- *
- * (c) 2020-2022 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#pragma once
-
-// Project include(s).
-#include "detray/coordinates/coordinates.hpp"
-#include "detray/definitions/qualifiers.hpp"
-#include "detray/intersection/intersection.hpp"
-#include "detray/intersection/plane_intersector.hpp"
-#include "detray/masks/mask_base.hpp"
-
-// System include(s).
-#include <climits>
-#include <cmath>
-#include <sstream>
-#include <string>
-
-namespace detray {
-
-/** This is a simple 2-dimensional mask for a regular rectangle
- *
- * @tparam intersector_t is a struct used for intersecting this cylinder
- * @tparam local_type is the default local frame definition type
- * @tparam links_type is an object where the mask can link to
- * @tparam kMaskContext is a unique mask identifier in a certain context
- *
- * It is defined by half length in local0 coordinates _values[0] and _values[1],
- * and can be checked with a tolerance in t[0] and t[1].
- *
- * @note  While the mask_context can change depending on the typed container
- * structure the mask_identifier is a const expression that determines the
- * mask type once for all.
- *
- **/
-
-template <typename transform3_t = __plugin::transform3<scalar>,
-          template <class> typename intersector_t = plane_intersector,
-          template <class> typename local_t = cartesian2,
-          typename links_t = dindex,
-          template <typename, std::size_t> class array_t = darray>
-class rectangle2 final : public mask_base<transform3_t, intersector_t, local_t,
-                                          links_t, array_t, 2> {
-    public:
-    using base_type =
-        mask_base<transform3_t, intersector_t, local_t, links_t, array_t, 2>;
-    using base_type::base_type;
-    using mask_values = typename base_type::mask_values;
-    using links_type = typename base_type::links_type;
-    using local_type = typename base_type::local_type;
-    using intersector_type = typename base_type::intersector_type;
-    using point2 = typename transform3_t::point2;
-
-    /* Default constructor */
-    rectangle2()
-        : base_type({std::numeric_limits<scalar>::infinity(),
-                     std::numeric_limits<scalar>::infinity()},
-                    {}) {}
-
-    /** Construction from boundary values
-     *
-     * @param half_length_0 half length in loc0
-     * @param half_length_1 half length in loc1
-     */
-    DETRAY_HOST_DEVICE
-    rectangle2(scalar half_length_0, scalar half_length_1, links_type links)
-        : base_type({half_length_0, half_length_1}, links) {}
-
-    /** Mask operation
-     *
-     * @tparam inside_local_t is the local type for inside checking
-     *
-     * @param p the point to be checked
-     * @param t is the tolerance tuple in (l0, l1)
-     *
-     * @return an intersection status e_inside / e_outside
-     **/
-    template <typename inside_local_t>
-    DETRAY_HOST_DEVICE intersection::status is_inside(
-        const point2 &p,
-        const scalar t = std::numeric_limits<scalar>::epsilon()) const {
-        return (std::abs(p[0]) <= this->_values[0] + t and
-                std::abs(p[1]) <= this->_values[1] + t)
-                   ? intersection::status::e_inside
-                   : intersection::status::e_outside;
-    }
-
-    /** Transform to a string for output debugging */
-    DETRAY_HOST
-    std::string to_string() const {
-        std::stringstream ss;
-        ss << "rectangle2";
-        for (const auto &v : this->_values) {
-            ss << ", " << v;
-        }
-        return ss.str();
-    }
-};
-
-}  // namespace detray
diff --git a/core/include/detray/masks/rectangle2D.hpp b/core/include/detray/masks/rectangle2D.hpp
new file mode 100644
index 0000000000..797a3cd606
--- /dev/null
+++ b/core/include/detray/masks/rectangle2D.hpp
@@ -0,0 +1,103 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2020-2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/coordinates/cartesian2.hpp"
+#include "detray/definitions/qualifiers.hpp"
+#include "detray/intersection/plane_intersector.hpp"
+#include "detray/surface_finders/grid/detail/axis_binning.hpp"
+#include "detray/surface_finders/grid/detail/axis_shape.hpp"
+
+// System include(s)
+#include <cmath>
+#include <limits>
+#include <string>
+#include <tuple>
+
+namespace detray {
+
+/// @brief Geometrical shape of a rectangle2D.
+///
+/// @tparam intersector_t defines how to intersect the underlying surface
+///         geometry
+///
+/// It is defined by half length in local0 coordinates bounds[0] and bounds[1]
+template <template <typename> class intersector_t = plane_intersector>
+class rectangle2D {
+    public:
+    /// The name for this shape
+    inline static const std::string name = "rectangle2D";
+
+    enum boundaries : std::size_t {
+        e_half_x = 0,
+        e_half_y = 1,
+        e_size = 2,
+    };
+
+    /// Local coordinate frame for boundary checks
+    template <typename algebra_t>
+    using local_frame_type = cartesian2<algebra_t>;
+    /// Local point type (2D)
+    template <typename algebra_t>
+    using loc_point_type = typename local_frame_type<algebra_t>::point2;
+
+    /// Measurement frame
+    template <typename algebra_t>
+    using measurement_frame_type = local_frame_type<algebra_t>;
+    /// Local measurement point (2D)
+    template <typename algebra_t>
+    using measurement_point_type = loc_point_type<algebra_t>;
+
+    /// Underlying surface geometry: planar
+    template <typename algebra_t>
+    using intersector_type = intersector_t<algebra_t>;
+
+    /// Behaviour of the two local axes (linear in x, y)
+    template <
+        n_axis::shape e_s = n_axis::shape::e_open,
+        template <typename, typename> class binning_loc0 = n_axis::regular,
+        template <typename, typename> class binning_loc1 = n_axis::regular>
+    struct axes {
+        static constexpr n_axis::label axis_loc0 = n_axis::label::e_x;
+        static constexpr n_axis::label axis_loc1 = n_axis::label::e_y;
+
+        /// How to convert into the local axis system and back
+        template <typename algebra_t>
+        using coordinate_type = local_frame_type<algebra_t>;
+
+        using types = std::tuple<n_axis::shape_t<e_s, axis_loc0>,
+                                 n_axis::shape_t<e_s, axis_loc1>>;
+
+        template <typename C, typename S>
+        using binning = std::tuple<binning_loc0<C, S>, binning_loc1<C, S>>;
+    };
+
+    /// @brief Check boundary values for a local point.
+    ///
+    /// @note the point is expected to be given in local coordinates by the
+    /// caller. For the conversion from global cartesian coordinates, the
+    /// nested @c shape struct can be used.
+    ///
+    /// @param bounds the boundary values for this shape
+    /// @param loc_p the point to be checked in the local coordinate system
+    /// @param tol dynamic tolerance determined by caller
+    ///
+    /// @return true if the local point lies within the given boundaries.
+    template <template <typename, std::size_t> class bounds_t,
+              typename scalar_t, std::size_t kDIM, typename point_t,
+              typename std::enable_if_t<kDIM == e_size, bool> = true>
+    DETRAY_HOST_DEVICE inline bool check_boundaries(
+        const bounds_t<scalar_t, kDIM> &bounds, const point_t &loc_p,
+        const scalar_t tol = std::numeric_limits<scalar_t>::epsilon()) const {
+        return (std::abs(loc_p[0]) <= bounds[e_half_x] + tol and
+                std::abs(loc_p[1]) <= bounds[e_half_y] + tol);
+    }
+};
+
+}  // namespace detray
diff --git a/core/include/detray/masks/ring2.hpp b/core/include/detray/masks/ring2.hpp
deleted file mode 100644
index 422ce7f206..0000000000
--- a/core/include/detray/masks/ring2.hpp
+++ /dev/null
@@ -1,106 +0,0 @@
-/** Detray library, part of the ACTS project (R&D line)
- *
- * (c) 2020-2022 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#pragma once
-
-// Project include(s)
-#include "detray/coordinates/coordinates.hpp"
-#include "detray/definitions/qualifiers.hpp"
-#include "detray/intersection/intersection.hpp"
-#include "detray/intersection/plane_intersector.hpp"
-#include "detray/masks/mask_base.hpp"
-
-// System include(s)
-#include <climits>
-#include <cmath>
-#include <sstream>
-#include <string>
-
-namespace detray {
-/** This is a simple 2-dimensional mask for a closed ring
- *
- * @tparam intersector_t is a struct used for intersecting this cylinder
- * @tparam local_type is the default local frame type
- * @tparam links_type is an object where the mask can link to
- * @tparam kMaskContext is a unique mask identifier in a certain context
- *
- * It is defined by the two radii _values[0] and  _values[1],
- * and can be checked with a tolerance in t[0] and t[1].
- *
- * @note  While the mask_context can change depending on the typed container
- * structure the mask_identifier is a const expression that determines the
- * mask type once for all.
- *
- **/
-template <typename transform3_t = __plugin::transform3<scalar>,
-          template <class> typename intersector_t = plane_intersector,
-          template <class> typename local_t = cartesian2,
-          typename links_t = dindex,
-          template <typename, std::size_t> class array_t = darray>
-class ring2 final : public mask_base<transform3_t, intersector_t, local_t,
-                                     links_t, array_t, 2> {
-    public:
-    using base_type =
-        mask_base<transform3_t, intersector_t, local_t, links_t, array_t, 2>;
-    using base_type::base_type;
-    using mask_values = typename base_type::mask_values;
-    using links_type = typename base_type::links_type;
-    using local_type = typename base_type::local_type;
-    using intersector_type = typename base_type::intersector_type;
-    using point2 = typename transform3_t::point2;
-
-    /* Default constructor */
-    ring2() : base_type({0., std::numeric_limits<scalar>::infinity()}, {}) {}
-
-    /** Construction from boundary values
-     *
-     * @param r_low lower radial bound
-     * @param r_high upper radial bound
-     */
-    DETRAY_HOST_DEVICE
-    ring2(scalar r_low, scalar r_high, links_type links)
-        : base_type({r_low, r_high}, links) {}
-
-    /** Mask operation
-     *
-     * @tparam inside_local_t is the local type for inside checking
-     *
-     * @param p the point to be checked
-     * @param t is the tolerance in r
-     *
-     * @return an intersection status e_inside / e_outside
-     **/
-    template <typename inside_local_t>
-    DETRAY_HOST_DEVICE intersection::status is_inside(
-        const point2 &p,
-        const scalar t = std::numeric_limits<scalar>::epsilon()) const {
-        if constexpr (std::is_same_v<inside_local_t,
-                                     cartesian2<transform3_t>>) {
-            scalar r = getter::perp(p);
-            return (r + t >= this->_values[0] and r <= this->_values[1] + t)
-                       ? intersection::status::e_inside
-                       : intersection::status::e_outside;
-        }
-
-        return (p[0] + t >= this->_values[0] and p[0] <= this->_values[1] + t)
-                   ? intersection::status::e_inside
-                   : intersection::status::e_outside;
-    }
-
-    /** Transform to a string for output debugging */
-    DETRAY_HOST
-    std::string to_string() const {
-        std::stringstream ss;
-        ss << "ring2";
-        for (const auto &v : this->_values) {
-            ss << ", " << v;
-        }
-        return ss.str();
-    }
-};
-
-}  // namespace detray
diff --git a/core/include/detray/masks/ring2D.hpp b/core/include/detray/masks/ring2D.hpp
new file mode 100644
index 0000000000..a70a327b8e
--- /dev/null
+++ b/core/include/detray/masks/ring2D.hpp
@@ -0,0 +1,105 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2020-2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/coordinates/polar2.hpp"
+#include "detray/definitions/qualifiers.hpp"
+#include "detray/intersection/plane_intersector.hpp"
+#include "detray/surface_finders/grid/detail/axis_binning.hpp"
+#include "detray/surface_finders/grid/detail/axis_shape.hpp"
+
+// System include(s)
+#include <cmath>
+#include <limits>
+#include <string>
+#include <tuple>
+
+namespace detray {
+
+/// @brief Geometrical shape of a closed ring.
+///
+/// @tparam intersector_t defines how to intersect the underlying surface
+///         geometry
+///
+/// It is defined by the two radii bounds[0] and bounds[1],
+/// and can be checked with a tolerance in t[0] and t[1].
+template <template <typename> class intersector_t = plane_intersector>
+class ring2D {
+    public:
+    /// The name for this shape
+    inline static const std::string name = "ring2D";
+
+    enum boundaries : std::size_t {
+        e_inner_r = 0,
+        e_outer_r = 1,
+        e_size = 2,
+    };
+
+    /// Local coordinate frame for boundary checks
+    template <typename algebra_t>
+    using local_frame_type = polar2<algebra_t>;
+    /// Local point type (2D)
+    template <typename algebra_t>
+    using loc_point_type = typename local_frame_type<algebra_t>::point2;
+
+    /// Measurement frame
+    template <typename algebra_t>
+    using measurement_frame_type = local_frame_type<algebra_t>;
+    /// Local measurement point (2D)
+    template <typename algebra_t>
+    using measurement_point_type = loc_point_type<algebra_t>;
+
+    /// Underlying surface geometry: planar
+    template <typename algebra_t>
+    using intersector_type = intersector_t<algebra_t>;
+
+    /// Behaviour of the two local axes (linear in r, circular in phi)
+    template <
+        n_axis::shape e_s = n_axis::shape::e_open,
+        template <typename, typename> class binning_loc0 = n_axis::regular,
+        template <typename, typename> class binning_loc1 = n_axis::regular>
+    struct axes {
+        static constexpr n_axis::label axis_loc0 = n_axis::label::e_r;
+        static constexpr n_axis::label axis_loc1 = n_axis::label::e_phi;
+
+        /// How to convert into the local axis system and back
+        template <typename algebra_t>
+        using coordinate_type = local_frame_type<algebra_t>;
+
+        using types = std::tuple<n_axis::shape_t<e_s, axis_loc0>,
+                                 n_axis::circular<axis_loc1>>;
+
+        template <typename C, typename S>
+        using binning = std::tuple<binning_loc0<C, S>, binning_loc1<C, S>>;
+    };
+
+    /// @brief Check boundary values for a local point.
+    ///
+    /// @note the point is expected to be given in local coordinates by the
+    /// caller. For the conversion from global cartesian coordinates, the
+    /// nested @c shape struct can be used.
+    ///
+    /// @param bounds the boundary values for this shape
+    /// @param loc_p the point to be checked in the local coordinate system
+    /// @param tol dynamic tolerance determined by caller
+    ///
+    /// @return true if the local point lies within the given boundaries.
+    template <template <typename, std::size_t> class bounds_t,
+              typename scalar_t, std::size_t kDIM, typename point_t,
+              typename std::enable_if_t<kDIM == e_size, bool> = true>
+    DETRAY_HOST_DEVICE inline bool check_boundaries(
+        const bounds_t<scalar_t, kDIM> &bounds, const point_t &loc_p,
+        const scalar_t tol = std::numeric_limits<scalar_t>::epsilon()) const {
+
+        return (loc_p[0] + tol >= bounds[e_inner_r] and
+                loc_p[0] <= bounds[e_outer_r] + tol);
+    }
+};
+
+}  // namespace detray
diff --git a/core/include/detray/masks/single3.hpp b/core/include/detray/masks/single3.hpp
deleted file mode 100644
index 6818011432..0000000000
--- a/core/include/detray/masks/single3.hpp
+++ /dev/null
@@ -1,93 +0,0 @@
-/** Detray library, part of the ACTS project (R&D line)
- *
- * (c) 2020-2022 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#pragma once
-
-// Project include(s)
-#include "detray/coordinates/coordinates.hpp"
-#include "detray/definitions/qualifiers.hpp"
-#include "detray/intersection/intersection.hpp"
-#include "detray/intersection/plane_intersector.hpp"
-#include "detray/masks/mask_base.hpp"
-
-// System include(s)
-#include <climits>
-#include <cmath>
-#include <sstream>
-#include <string>
-
-namespace detray {
-/** This is a simple mask for single parameter bound mask
- *
- * @tparam kCheckIndex is the index of the position on which the mask is applied
- * @tparam intersector_t is a struct used for intersecting this cylinder
- * @tparam local_type is the default local frame definition type
- * @tparam links_type is an object where the mask can link to
- * @tparam kMaskContext is a unique mask identifier in a certain context
- *
- * @note  While the mask_context can change depending on the typed container
- * structure the mask_identifier is a const expression that determines the
- * mask type once for all.
- *
- **/
-template <unsigned int kCheckIndex,
-          typename transform3_t = __plugin::transform3<scalar>,
-          template <class> typename intersector_t = plane_intersector,
-          template <class> typename local_t = cartesian2,
-          typename links_t = dindex,
-          template <typename, std::size_t> class array_t = darray>
-class single3 final : public mask_base<transform3_t, intersector_t, local_t,
-                                       links_t, array_t, 2> {
-    public:
-    using base_type =
-        mask_base<transform3_t, intersector_t, local_t, links_t, array_t, 2>;
-    using base_type::base_type;
-    using mask_values = typename base_type::mask_values;
-    using links_type = typename base_type::links_type;
-    using local_type = typename base_type::local_type;
-    using intersector_type = typename base_type::intersector_type;
-    using point3 = typename transform3_t::point3;
-
-    /* Default constructor */
-    single3() : base_type({std::numeric_limits<scalar>::infinity()}, {}) {}
-
-    /** Construction from boundary values **/
-    DETRAY_HOST_DEVICE
-    single3(scalar x, scalar y, links_type links) : base_type({x, y}, links) {}
-
-    /** Mask operation
-     *
-     * @tparam inside_local_type is the global type for checking (ignored)
-     *
-     * @param p the point to be checked
-     * @param t is the tolerance of the single parameter
-     *
-     * @return an intersection status e_inside / e_outside
-     **/
-    template <typename inside_local_t>
-    DETRAY_HOST_DEVICE intersection::status is_inside(
-        const point3 &p,
-        const scalar t = std::numeric_limits<scalar>::epsilon()) const {
-        return (this->_values[0] - t <= p[kCheckIndex] and
-                p[kCheckIndex] <= this->_values[1] + t)
-                   ? intersection::status::e_inside
-                   : intersection::status::e_outside;
-    }
-
-    /** Transform to a string for output debugging */
-    DETRAY_HOST
-    std::string to_string() const {
-        std::stringstream ss;
-        ss << "single3";
-        for (const auto &v : this->_values) {
-            ss << ", " << v;
-        }
-        return ss.str();
-    }
-};
-
-}  // namespace detray
diff --git a/core/include/detray/masks/single3D.hpp b/core/include/detray/masks/single3D.hpp
new file mode 100644
index 0000000000..7b8a0aedef
--- /dev/null
+++ b/core/include/detray/masks/single3D.hpp
@@ -0,0 +1,102 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2020-2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/coordinates/cartesian2.hpp"
+#include "detray/definitions/qualifiers.hpp"
+#include "detray/intersection/plane_intersector.hpp"
+#include "detray/surface_finders/grid/detail/axis_binning.hpp"
+#include "detray/surface_finders/grid/detail/axis_shape.hpp"
+
+// System include(s)
+#include <cmath>
+#include <limits>
+#include <string>
+#include <tuple>
+
+namespace detray {
+
+/// @brief Underlying geometry for a single parameter bound mask
+///
+/// @tparam kCheckIndex is the index of the local point on which the mask is
+///         applied
+/// @tparam intersector_t defines how to intersect the underlying surface
+///         geometry
+template <unsigned int kCheckIndex = 0,
+          template <typename> class intersector_t = plane_intersector>
+class single3D {
+    public:
+    /// The name for this shape
+    inline static const std::string name = "single3D";
+
+    enum boundaries : std::size_t {
+        e_lower = 0,
+        e_upper = 1,
+        e_size = 2,
+    };
+
+    /// Local coordinate frame for boundary checks
+    template <typename algebra_t>
+    using local_frame_type = cartesian3<algebra_t>;
+    /// Local point type (3D)
+    template <typename algebra_t>
+    using loc_point_type = typename local_frame_type<algebra_t>::point3;
+
+    /// Measurement frame
+    template <typename algebra_t>
+    using measurement_frame_type = local_frame_type<algebra_t>;
+    /// Local measurement point (2D)
+    template <typename algebra_t>
+    using measurement_point_type = loc_point_type<algebra_t>;
+
+    /// Underlying surface geometry: planar
+    template <typename algebra_t>
+    using intersector_type = intersector_t<algebra_t>;
+
+    /// Behaviour of the two local axes (linear in single coordinate x, y or z)
+    template <n_axis::shape e_s = n_axis::shape::e_open,
+              template <typename, typename> class binning_loc0 =
+                  n_axis::regular>
+    struct axes {
+        static constexpr n_axis::label axis_loc0 =
+            static_cast<n_axis::label>(kCheckIndex);
+
+        /// How to convert into the local axis system and back
+        template <typename algebra_t>
+        using coordinate_type = local_frame_type<algebra_t>;
+
+        using types = std::tuple<n_axis::shape_t<e_s, axis_loc0>>;
+
+        template <typename C, typename S>
+        using binning = std::tuple<binning_loc0<C, S>>;
+    };
+
+    /// @brief Check boundary values for a local point.
+    ///
+    /// @note the point is expected to be given in local coordinates by the
+    /// caller. For the conversion from global cartesian coordinates, the
+    /// nested @c shape struct can be used.
+    ///
+    /// @param bounds the boundary values for this shape
+    /// @param loc_p the point to be checked in the local coordinate system
+    /// @param tol dynamic tolerance determined by caller
+    ///
+    /// @return true if the local point lies within the given boundaries.
+    template <template <typename, std::size_t> class bounds_t,
+              typename scalar_t, std::size_t kDIM, typename point_t,
+              typename std::enable_if_t<kDIM == e_size, bool> = true>
+    DETRAY_HOST_DEVICE inline bool check_boundaries(
+        const bounds_t<scalar_t, kDIM> &bounds, const point_t &loc_p,
+        const scalar_t tol = std::numeric_limits<scalar_t>::epsilon()) const {
+        return (bounds[e_lower] - tol <= loc_p[kCheckIndex] and
+                loc_p[kCheckIndex] <= bounds[e_upper] + tol);
+    }
+};
+
+}  // namespace detray
diff --git a/core/include/detray/masks/trapezoid2.hpp b/core/include/detray/masks/trapezoid2.hpp
deleted file mode 100644
index 9c44e14aea..0000000000
--- a/core/include/detray/masks/trapezoid2.hpp
+++ /dev/null
@@ -1,113 +0,0 @@
-/** Detray library, part of the ACTS project (R&D line)
- *
- * (c) 2020-2022 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#pragma once
-
-// Project include(s)
-#include "detray/coordinates/coordinates.hpp"
-#include "detray/definitions/qualifiers.hpp"
-#include "detray/intersection/intersection.hpp"
-#include "detray/intersection/plane_intersector.hpp"
-#include "detray/masks/mask_base.hpp"
-
-// System include(s)
-#include <climits>
-#include <cmath>
-#include <sstream>
-#include <string>
-
-namespace detray {
-/** This is a simple 2-dimensional mask for a regular trapezoid
- *
- * @tparam intersector_t is a struct used for intersecting this cylinder
- * @tparam local_type is the default local frame definition type
- * @tparam links_type is an object where the mask can link to
- * @tparam kMaskContext is a unique mask identifier in a certain context
- *
- * It is defined by half lengths in local0 coordinate _values[0] and _values[1]
- * at -/+ half length in the local1 coordinate _values[2]. _values[3] contains
- * the precomputed value of 1 / (2 * _values[2]), which avoids
- * excessive floating point divisions.
- *
- * @note  While the mask_context can change depending on the typed container
- * structure the mask_identifier is a const expression that determines the
- * mask type once for all.
- *
- **/
-template <typename transform3_t = __plugin::transform3<scalar>,
-          template <class> typename intersector_t = plane_intersector,
-          template <class> typename local_t = cartesian2,
-          typename links_t = dindex,
-          template <typename, std::size_t> class array_t = darray>
-class trapezoid2 final : public mask_base<transform3_t, intersector_t, local_t,
-                                          links_t, array_t, 4> {
-    public:
-    using base_type =
-        mask_base<transform3_t, intersector_t, local_t, links_t, array_t, 4>;
-    using base_type::base_type;
-    using mask_values = typename base_type::mask_values;
-    using links_type = typename base_type::links_type;
-    using local_type = typename base_type::local_type;
-    using intersector_type = typename base_type::intersector_type;
-    using point2 = typename transform3_t::point2;
-
-    /* Default constructor */
-    trapezoid2()
-        : base_type({std::numeric_limits<scalar>::infinity(),
-                     std::numeric_limits<scalar>::infinity(),
-                     std::numeric_limits<scalar>::infinity(),
-                     std::numeric_limits<scalar>::infinity()},
-                    {}) {}
-
-    /** Construction from boundary values
-     *
-     * @param half_length_0 first half length in loc0
-     * @param half_length_1 second half length in loc0
-     * @param half_length_2 half length in loc1
-     */
-    DETRAY_HOST_DEVICE
-    trapezoid2(scalar half_length_0, scalar half_length_1, scalar half_length_2,
-               links_type links)
-        : base_type({half_length_0, half_length_1, half_length_2,
-                     static_cast<scalar>(1. / (2. * half_length_2))},
-                    links) {}
-
-    /** Mask operation
-     *
-     * @tparam inside_local_t is the type of the local frame (ignored here)
-     *
-     * @param p the point to be checked
-     * @param t us the tolerance tuple (l0,l1)
-     *
-     * @return an intersection status e_inside / e_outside
-     **/
-    template <typename inside_local_t>
-    DETRAY_HOST_DEVICE intersection::status is_inside(
-        const point2 &p,
-        const scalar t = std::numeric_limits<scalar>::epsilon()) const {
-        scalar rel_y = (this->_values[2] + p[1]) * this->_values[3];
-        return (std::abs(p[0]) <=
-                    this->_values[0] +
-                        rel_y * (this->_values[1] - this->_values[0]) + t and
-                std::abs(p[1]) <= this->_values[2] + t)
-                   ? intersection::status::e_inside
-                   : intersection::status::e_outside;
-    }
-
-    /** Transform to a string for output debugging */
-    DETRAY_HOST
-    std::string to_string() const {
-        std::stringstream ss;
-        ss << "trapezoid2";
-        for (const auto &v : this->_values) {
-            ss << ", " << v;
-        }
-        return ss.str();
-    }
-};
-
-}  // namespace detray
diff --git a/core/include/detray/masks/trapezoid2D.hpp b/core/include/detray/masks/trapezoid2D.hpp
new file mode 100644
index 0000000000..6649a3326c
--- /dev/null
+++ b/core/include/detray/masks/trapezoid2D.hpp
@@ -0,0 +1,113 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2020-2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/coordinates/cartesian2.hpp"
+#include "detray/definitions/qualifiers.hpp"
+#include "detray/intersection/plane_intersector.hpp"
+#include "detray/surface_finders/grid/detail/axis_binning.hpp"
+#include "detray/surface_finders/grid/detail/axis_shape.hpp"
+
+// System include(s)
+#include <cmath>
+#include <limits>
+#include <string>
+#include <tuple>
+
+namespace detray {
+
+/// @brief Geometrical shape of a trapezoid2D.
+///
+/// @tparam intersector_t defines how to intersect the underlying surface
+///         geometry
+///
+/// It is defined by half lengths in local0 coordinate bounds[0] and bounds[1]
+/// at -/+ half length in the local1 coordinate bounds[2]. bounds[3] contains
+/// the precomputed value of 1 / (2 * bounds[2]), which avoids
+/// excessive floating point divisions.
+template <template <typename> class intersector_t = plane_intersector>
+class trapezoid2D {
+    public:
+    /// The name for this shape
+    inline static const std::string name = "trapezoid2D";
+
+    enum boundaries : std::size_t {
+        e_half_length_0 = 0,
+        e_half_length_1 = 1,
+        e_half_length_2 = 2,
+        e_divisor = 3,  // 1 / (2 * bounds[e_half_length_2])
+        e_size = 4,
+    };
+
+    /// Local coordinate frame for boundary checks
+    template <typename algebra_t>
+    using local_frame_type = cartesian2<algebra_t>;
+    /// Local point type (2D)
+    template <typename algebra_t>
+    using loc_point_type = typename local_frame_type<algebra_t>::point2;
+
+    /// Measurement frame
+    template <typename algebra_t>
+    using measurement_frame_type = local_frame_type<algebra_t>;
+    /// Local measurement point (2D)
+    template <typename algebra_t>
+    using measurement_point_type = loc_point_type<algebra_t>;
+
+    /// Underlying surface geometry: planar
+    template <typename algebra_t>
+    using intersector_type = intersector_t<algebra_t>;
+
+    /// Behaviour of the two local axes (linear in x, y)
+    template <
+        n_axis::shape e_s = n_axis::shape::e_open,
+        template <typename, typename> class binning_loc0 = n_axis::regular,
+        template <typename, typename> class binning_loc1 = n_axis::regular>
+    struct axes {
+        static constexpr n_axis::label axis_loc0 = n_axis::label::e_x;
+        static constexpr n_axis::label axis_loc1 = n_axis::label::e_y;
+
+        /// How to convert into the local axis system and back
+        template <typename algebra_t>
+        using coordinate_type = local_frame_type<algebra_t>;
+
+        using types = std::tuple<n_axis::shape_t<e_s, axis_loc0>,
+                                 n_axis::shape_t<e_s, axis_loc1>>;
+
+        template <typename C, typename S>
+        using binning = std::tuple<binning_loc0<C, S>, binning_loc1<C, S>>;
+    };
+
+    /// @brief Check boundary values for a local point.
+    ///
+    /// @note the point is expected to be given in local coordinates by the
+    /// caller. For the conversion from global cartesian coordinates, the
+    /// nested @c shape struct can be used.
+    ///
+    /// @param bounds the boundary values for this shape
+    /// @param loc_p the point to be checked in the local coordinate system
+    /// @param tol dynamic tolerance determined by caller
+    ///
+    /// @return true if the local point lies within the given boundaries.
+    template <template <typename, std::size_t> class bounds_t,
+              typename scalar_t, std::size_t kDIM, typename point_t,
+              typename std::enable_if_t<kDIM == e_size, bool> = true>
+    DETRAY_HOST_DEVICE inline bool check_boundaries(
+        const bounds_t<scalar_t, kDIM> &bounds, const point_t &loc_p,
+        const scalar_t tol = std::numeric_limits<scalar_t>::epsilon()) const {
+        scalar_t rel_y =
+            (bounds[e_half_length_2] + loc_p[1]) * bounds[e_divisor];
+        return (std::abs(loc_p[0]) <= bounds[e_half_length_0] +
+                                          rel_y * (bounds[e_half_length_1] -
+                                                   bounds[e_half_length_0]) +
+                                          tol and
+                std::abs(loc_p[1]) <= bounds[e_half_length_2] + tol);
+    }
+};
+
+}  // namespace detray
diff --git a/core/include/detray/masks/unmasked.hpp b/core/include/detray/masks/unmasked.hpp
index 7484b10523..9f1fc64b52 100644
--- a/core/include/detray/masks/unmasked.hpp
+++ b/core/include/detray/masks/unmasked.hpp
@@ -8,57 +8,76 @@
 #pragma once
 
 // Project include(s)
-#include "detray/coordinates/coordinates.hpp"
-#include "detray/intersection/intersection.hpp"
+#include "detray/coordinates/cartesian2.hpp"
 #include "detray/intersection/plane_intersector.hpp"
-#include "detray/masks/mask_base.hpp"
+#include "detray/surface_finders/grid/detail/axis_binning.hpp"
+#include "detray/surface_finders/grid/detail/axis_shape.hpp"
 
 // System include(s)
 #include <string>
+#include <tuple>
 
 namespace detray {
 
-template <typename transform3_t = __plugin::transform3<scalar>,
-          template <class> typename intersector_t = plane_intersector,
-          template <class> typename local_t = cartesian2,
-          typename links_t = dindex,
-          template <typename, std::size_t> class array_t = darray>
-class unmasked final : public mask_base<transform3_t, intersector_t, local_t,
-                                        links_t, array_t, 1> {
+/// @brief Flat shape without boundaries.
+class unmasked {
     public:
-    using base_type =
-        mask_base<transform3_t, intersector_t, local_t, links_t, array_t, 1>;
-    using base_type::base_type;
-    using mask_values = typename base_type::mask_values;
-    using links_type = typename base_type::links_type;
-    using local_type = typename base_type::local_type;
-    using intersector_type = typename base_type::intersector_type;
-    using point2 = __plugin::point2<scalar>;
+    /// The name for this shape
+    inline static const std::string name = "unmasked";
 
-    /* Default constructor */
-    unmasked() = default;
+    enum boundaries : std::size_t { e_size = 1 };
 
-    /** Construction from voume link */
-    DETRAY_HOST_DEVICE
-    unmasked(links_type links) : base_type({0}, links) {}
+    /// Local coordinate frame for boundary checks
+    template <typename algebra_t>
+    using local_frame_type = cartesian2<algebra_t>;
+    /// Local point type (2D)
+    template <typename algebra_t>
+    using loc_point_type = typename local_frame_type<algebra_t>::point2;
 
-    /** Mask operation
-     *
-     * @tparam point_type is the type of the point to be checked w.r.t. to
-     * the mask bounds
-     *
-     * the parameters are ignored
-     *
-     * @return true
-     **/
-    template <typename inside_local_t>
-    DETRAY_HOST_DEVICE inline intersection::status is_inside(
-        const point2& /*ignored*/, const scalar /*ignored*/) const {
-        return intersection::status::e_inside;
-    }
+    /// Measurement frame
+    template <typename algebra_t>
+    using measurement_frame_type = local_frame_type<algebra_t>;
+    /// Local measurement point (2D)
+    template <typename algebra_t>
+    using measurement_point_type = loc_point_type<algebra_t>;
+
+    /// Underlying surface geometry: planar
+    template <typename algebra_t>
+    using intersector_type = plane_intersector<algebra_t>;
+
+    /// Behaviour of the two local axes (linear in x, y)
+    template <
+        n_axis::shape e_s = n_axis::shape::e_open,
+        template <typename, typename> class binning_loc0 = n_axis::regular,
+        template <typename, typename> class binning_loc1 = n_axis::regular>
+    struct axes {
+        static constexpr n_axis::label axis_loc0 = n_axis::label::e_x;
+        static constexpr n_axis::label axis_loc1 = n_axis::label::e_y;
+
+        /// How to convert into the local axis system and back
+        template <typename algebra_t>
+        using coordinate_type = local_frame_type<algebra_t>;
 
-    /** Transform to a string for output debugging */
-    std::string to_string() const { return "unmasked"; }
+        using types = std::tuple<n_axis::shape_t<e_s, axis_loc0>,
+                                 n_axis::shape_t<e_s, axis_loc1>>;
+
+        template <typename C, typename S>
+        using binning = std::tuple<binning_loc0<C, S>, binning_loc1<C, S>>;
+    };
+
+    /// @brief Check boundary values for a local point.
+    ///
+    /// @tparam bounds_t any type of boundary values
+    ///
+    /// @note the parameters are ignored
+    ///
+    /// @return always true
+    template <typename bounds_t, typename point_t, typename scalar_t>
+    DETRAY_HOST_DEVICE inline constexpr bool check_boundaries(
+        const bounds_t& /*bounds*/, const point_t& /*loc_p*/,
+        const scalar_t /*tol*/) const {
+        return true;
+    }
 };
 
-}  // namespace detray
+}  // namespace detray
\ No newline at end of file
diff --git a/core/include/detray/propagator/navigator.hpp b/core/include/detray/propagator/navigator.hpp
index 4f627fb6fe..712638bc8a 100644
--- a/core/include/detray/propagator/navigator.hpp
+++ b/core/include/detray/propagator/navigator.hpp
@@ -7,6 +7,7 @@
 
 #pragma once
 
+// Project include(s)
 #include "detray/core/detector.hpp"
 #include "detray/definitions/detail/accessor.hpp"
 #include "detray/definitions/indexing.hpp"
@@ -14,8 +15,13 @@
 #include "detray/intersection/detail/trajectories.hpp"
 #include "detray/intersection/intersection.hpp"
 #include "detray/intersection/intersection_kernel.hpp"
+#include "detray/surface_finders/neighborhood_kernel.hpp"
 #include "detray/utils/enumerate.hpp"
 
+// vecmem include(s)
+#include <vecmem/containers/data/jagged_vector_buffer.hpp>
+#include <vecmem/memory/memory_resource.hpp>
+
 namespace detray {
 
 namespace navigation {
@@ -428,12 +434,12 @@ class navigator {
         const auto &tf_store = det->transform_store();
         const auto &mask_store = det->mask_store();
 
-        for (const auto [obj_idx, obj] : enumerate(det->surfaces(), volume)) {
+        for (const auto [obj_idx, obj] : find_surfaces(det, volume, track)) {
 
             std::size_t count =
-                mask_store.template execute<intersection_initialize>(
-                    obj.mask_type(), navigation.candidates(),
-                    detail::ray(track), obj, tf_store);
+                mask_store.template call<intersection_initialize>(
+                    obj.mask(), navigation.candidates(), detail::ray(track),
+                    obj, tf_store);
 
             // TODO: Do NOT use index but use other member variable
             for (std::size_t i = navigation.candidates().size() - count;
@@ -682,8 +688,8 @@ class navigator {
 
         const auto &mask_store = det->mask_store();
         const auto &sf = det->surface_by_index(obj_idx);
-        candidate = mask_store.template execute<intersection_update>(
-            sf.mask_type(), detail::ray(track), sf, det->transform_store());
+        candidate = mask_store.template call<intersection_update>(
+            sf.mask(), detail::ray(track), sf, det->transform_store());
 
         candidate.index = obj_idx;
         // Check whether this candidate is reachable by the track
@@ -691,6 +697,30 @@ class navigator {
                candidate.path >= track.overstep_tolerance();
     }
 
+    /// Helper method that performs the neighborhood lookup
+    ///
+    /// @tparam track_t type of the track parametrization
+    ///
+    /// @param track the track information
+    ///
+    /// @returns an iterable over the detector surface container
+    template <typename track_t>
+    DETRAY_HOST_DEVICE inline auto find_surfaces(
+        const detector_type *det, const volume_type &volume,
+        const track_t & /*track*/) const {
+        // Gain access to all surface finders in the detector
+        /*const auto &sf_finders = det->sf_finder_store();
+
+        // Return an index range for now
+        dindex_range neighborhood =
+            sf_finders.template call<neighborhood_getter>(
+                volume.sf_finder_link(), *det, volume, track);
+
+        // Enumerate the surfaces that are close to the track position
+        return enumerate(det->surfaces(), neighborhood);*/
+        return enumerate(det->surfaces(), volume);
+    }
+
     /// Helper to evict all unreachable/invalid candidates from the cache:
     /// Finds the first unreachable candidate (has been invalidated during
     /// update) in a sorted (!) cache.
@@ -714,12 +744,14 @@ class navigator {
 // restricted to much smaller value
 template <typename detector_t>
 DETRAY_HOST vecmem::data::jagged_vector_buffer<line_plane_intersection>
-create_candidates_buffer(const detector_t &det, const unsigned int n_tracks,
-                         vecmem::memory_resource &device_resource) {
+create_candidates_buffer(
+    const detector_t &det, const unsigned int n_tracks,
+    vecmem::memory_resource &device_resource,
+    vecmem::memory_resource *host_access_resource = nullptr) {
     return vecmem::data::jagged_vector_buffer<line_plane_intersection>(
         std::vector<std::size_t>(n_tracks, 0),
         std::vector<std::size_t>(n_tracks, det.get_n_max_objects_per_volume()),
-        device_resource, det.resource());
+        device_resource, host_access_resource);
 }
 
 }  // namespace detray
\ No newline at end of file
diff --git a/core/include/detray/surface_finders/brute_force_finder.hpp b/core/include/detray/surface_finders/brute_force_finder.hpp
new file mode 100644
index 0000000000..0df0fb7198
--- /dev/null
+++ b/core/include/detray/surface_finders/brute_force_finder.hpp
@@ -0,0 +1,47 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Detray include(s).
+#include "detray/definitions/indexing.hpp"
+#include "detray/definitions/qualifiers.hpp"
+
+// VecMem include(s).
+#include <vecmem/memory/memory_resource.hpp>
+
+namespace detray {
+
+/// @brief A surface finder that returns all surfaces in a volume (brute force)
+struct brute_force_finder {
+
+    /// Default constructor
+    brute_force_finder() = default;
+
+    /// Constructor from memory resource: Not needed
+    DETRAY_HOST
+    brute_force_finder(vecmem::memory_resource & /*mr*/) {}
+
+    /// Constructor from a vecmem view: Not needed
+    template <typename view_t,
+              std::enable_if_t<
+                  !std::is_same_v<brute_force_finder, view_t> &&
+                      !std::is_base_of_v<vecmem::memory_resource, view_t>,
+                  bool> = true>
+    DETRAY_HOST_DEVICE brute_force_finder(const view_t & /*view*/) {}
+
+    /// @returns the complete surface range of the search volume
+    template <typename detector_t, typename track_t>
+    DETRAY_HOST_DEVICE dindex_range
+    search(const detector_t & /*det*/,
+           const typename detector_t::volume_type &volume,
+           const track_t & /*track*/) const {
+        return volume.range();
+    }
+};
+
+}  // namespace detray
diff --git a/core/include/detray/surface_finders/grid/axis.hpp b/core/include/detray/surface_finders/grid/axis.hpp
new file mode 100644
index 0000000000..ceafd372a4
--- /dev/null
+++ b/core/include/detray/surface_finders/grid/axis.hpp
@@ -0,0 +1,339 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s).
+#include "detray/core/type_registry.hpp"
+#include "detray/definitions/detail/accessor.hpp"  // detail::first_t
+#include "detray/definitions/indexing.hpp"
+#include "detray/definitions/qualifiers.hpp"
+#include "detray/surface_finders/grid/detail/axis_binning.hpp"
+#include "detray/surface_finders/grid/detail/axis_helpers.hpp"
+#include "detray/surface_finders/grid/detail/axis_shape.hpp"
+
+// VecMem include(s).
+#include <vecmem/memory/memory_resource.hpp>
+
+// System include(s).
+#include <cstddef>
+#include <type_traits>
+
+namespace detray {
+
+namespace n_axis {
+
+/// @brief A single axis.
+///
+/// The axis ties together shape and binning behaviour with the bin edges
+/// storage. The shape determines how bin indices are mapped at the over-
+/// and underflow bins. The type of binning determines whether the axis has
+/// regular or irregular binning. The bin edges needed to find bin indices
+/// are not owned by the axis, but are passed to the binning type.
+template <typename shape_t, typename binning_t>
+struct single_axis {
+
+    /// Make axis shape accessible
+    using shape_type = shape_t;
+    /// Make axis binning type accessible
+    using binning_type = binning_t;
+
+    // Extract container types
+    using scalar_type = typename binning_type::scalar_type;
+    using container_types = typename binning_type::container_types;
+    template <typename T>
+    using vector_type = typename binning_type::template vector_type<T>;
+    template <typename T, std::size_t N>
+    using array_type = typename binning_type::template array_type<T, N>;
+
+    /// Defines the geometrical shape of the axis as a service:
+    /// open, closed or circular
+    shape_type m_shape{};
+    /// Defines the binning on the axis as a service: regular vs irregular
+    binning_type m_binning{};
+
+    /// Parameterized constructor - empty binning
+    single_axis() = default;
+
+    /// Parametrized constructor that builds the binning scheme
+    template <typename... Args>
+    DETRAY_HOST_DEVICE single_axis(const dindex_range *indx_range,
+                                   const vector_type<scalar_type> *edges)
+        : m_shape(), m_binning(indx_range, edges) {}
+
+    /// @returns the axis shape label, i.e. x, y, z, r or phi axis.
+    DETRAY_HOST_DEVICE
+    constexpr auto label() const -> n_axis::label { return shape_type::label; }
+
+    /// @returns the type of shape of the axis, i.e. closed, open or circular.
+    DETRAY_HOST_DEVICE
+    constexpr auto shape() const -> n_axis::shape { return shape_type::type; }
+
+    /// @returns the type of binning of the axis, i.e. regular or irregular.
+    DETRAY_HOST_DEVICE
+    constexpr auto binning() const -> n_axis::binning {
+        return binning_type::type;
+    }
+
+    /// @returns the total number of bins
+    DETRAY_HOST_DEVICE
+    inline std::size_t nbins() const { return m_binning.nbins(); }
+
+    /// Given a value on the axis, find the correct bin.
+    ///
+    /// @param v is the value for the bin search
+    ///
+    /// @returns the bin index.
+    DETRAY_HOST_DEVICE
+    inline dindex bin(const scalar_type v) const {
+        return m_shape.map(m_binning.bin(v), m_binning.nbins());
+    }
+
+    /// Given a value on the axis and a neighborhood, find the correct bin range
+    ///
+    /// @param v is the value for the bin search
+    /// @param nhood is the neighborhood range (in #bins or value interval)
+    ///
+    /// @returns a dindex_range around the bin index.
+    template <typename neighbor_t>
+    DETRAY_HOST_DEVICE dindex_range
+    range(const scalar_type v, const array_type<neighbor_t, 2> &nhood) const {
+        return m_shape.map(m_binning.range(v, nhood), m_binning.nbins());
+    }
+
+    /// @returns the bin edges for a given @param ibin .
+    DETRAY_HOST_DEVICE
+    inline array_type<scalar_type, 2> bin_edges(const dindex ibin) const {
+        return m_binning.bin_edges(ibin);
+    }
+
+    /// @returns the values of the bin edges. Is a succession of lower edges.
+    DETRAY_HOST_DEVICE
+    inline vector_type<scalar_type> bin_edges() const {
+        return m_binning.bin_edges();
+    }
+
+    /// @returns the axis span [min, max).
+    DETRAY_HOST_DEVICE
+    inline array_type<scalar_type, 2> span() const { return m_binning.span(); }
+
+    /// @returns the axis span [min, max).
+    DETRAY_HOST_DEVICE
+    inline scalar_type min() const { return m_binning.span()[0]; }
+
+    /// @returns the axis span [min, max).
+    DETRAY_HOST_DEVICE
+    inline scalar_type max() const { return m_binning.span()[1]; }
+};
+
+/// @brief A collection of single axes.
+///
+/// Given a point in the grid local coordinate system, which is spanned by the
+/// axes in this multi-axes type, the corresponding bin multi-index or
+/// multi-index range is returned.
+///
+/// @note can be owning the data (as member of a standalone grid) or can be
+/// non-owning if the grid is part of a larger collection.
+template <bool ownership, typename local_frame_t, typename... axis_ts>
+struct multi_axis {
+
+    /// Dimension of the local coordinate system that is spanned by the axes
+    static constexpr dindex Dim = sizeof...(axis_ts);
+    static constexpr bool is_owning = ownership;
+
+    // Extract container types
+    using scalar_type =
+        typename detray::detail::first_t<axis_ts...>::scalar_type;
+    using container_types =
+        typename detray::detail::first_t<axis_ts...>::container_types;
+    template <typename T>
+    using vector_type = typename container_types::template vector_type<T>;
+    template <typename... T>
+    using tuple_type = typename container_types::template tuple_type<T...>;
+
+    /// Projection onto local coordinate system that is spanned by the axes
+    using local_frame_type = local_frame_t;
+    /// Vecmem based multi-axis view type
+    using view_type =
+        dmulti_view<dvector_view<dindex_range>, dvector_view<scalar_type>>;
+    /// Interal storage type depends on whether the class owns the data or not
+    using storage_type = std::conditional_t<
+        is_owning, detail::multi_axis_data<container_types, scalar_type>,
+        detail::multi_axis_view<container_types, scalar_type>>;
+
+    /// Match an axis to its label at compile time
+    using axis_reg = registry_base<n_axis::label, true, axis_ts...>;
+    template <n_axis::label L>
+    using label_matcher = typename axis_reg::template get_type<L, tuple_type>;
+
+    /// Default constructor
+    multi_axis() = default;
+
+    /// Constructor with specific vecmem memory resource if the class owns data
+    DETRAY_HOST multi_axis(vecmem::memory_resource &resource)
+        : m_data(resource) {}
+
+    /// Constructor from data containers - move
+    DETRAY_HOST_DEVICE
+    multi_axis(vector_type<dindex_range> &&axes_data,
+               vector_type<scalar_type> &&edges)
+        : m_data(std::move(axes_data), std::move(edges)) {}
+
+    /// Constructor from externally owned data containers.
+    DETRAY_HOST_DEVICE
+    multi_axis(const vector_type<dindex_range> *axes_data_ptr,
+               const vector_type<scalar_type> *edges_ptr, dindex offset = 0)
+        : m_data(axes_data_ptr, edges_ptr, offset) {}
+
+    /// Device-side construction from a vecmem based view type
+    template <typename axes_view_t,
+              typename std::enable_if_t<
+                  std::is_base_of_v<dbase_view, axes_view_t>, bool> = true>
+    DETRAY_HOST_DEVICE multi_axis(const axes_view_t &view)
+        : m_data(detray::detail::get<0>(view.m_views),
+                 detray::detail::get<1>(view.m_views)) {}
+
+    /// Build an axis object in place.
+    ///
+    /// @tparam index the position of the axis in the parameter pack. Also
+    ///               determines which axes data are used to build the instance.
+    ///
+    /// @returns an axis object, corresponding to the index.
+    template <std::size_t index>
+    DETRAY_HOST_DEVICE typename label_matcher<axis_reg::to_id(index)>::type
+    get_axis() const {
+        return {m_data.axis_data(index), m_data.edges()};
+    }
+
+    /// Build an axis object in place.
+    ///
+    /// @tparam L label of the axis.
+    ///
+    /// @returns an axis object, corresponding to the label.
+    template <n_axis::label L>
+    DETRAY_HOST_DEVICE typename label_matcher<L>::type get_axis() const {
+        return get_axis<axis_reg::to_index(L)>();
+    }
+
+    /// Build an axis object in place.
+    ///
+    /// @tparam axis_t type of the axis.
+    ///
+    /// @returns an axis object of the given type.
+    template <typename axis_t>
+    DETRAY_HOST_DEVICE axis_t get_axis() const {
+        return get_axis<axis_t::shape_type::label>();
+    }
+
+    /// Query the bin index for every coordinate of the given point on the axes.
+    ///
+    /// @tparam point_t the point in the local coordinate system that is spanned
+    ///                 by the axes.
+    ///
+    /// @returns a multi bin that contains the resulting bin indices for
+    ///          every axis in the corresponding entry (e.g. bin_x in entry 0)
+    template <typename point_t>
+    DETRAY_HOST_DEVICE multi_bin<Dim> bins(const point_t &p) const {
+        // Empty bin indices to be filled
+        multi_bin<Dim> bin_indices{};
+        // Run the bin resolution for every axis in this multi-axis type
+        (single_bin(get_axis<axis_ts>(), p, bin_indices), ...);
+
+        return bin_indices;
+    }
+
+    /// @brief Get a bin range on every axis corresponding to the given point
+    /// and the neighborhood around it.
+    ///
+    /// The neighborhood around the point can be defined in two ways:
+    /// - scalar: neighborhood around the axis value,
+    /// - index: neighborhood in #bins
+    /// The resulting bin index range will contain all bins that belong to a
+    /// given neighborhood around the lookup point.
+    ///
+    /// @tparam point_t the point in the local coordinate system that is spanned
+    ///                 by the axes.
+    /// @tparam neighbor_t the type of neighborhood defined on the axis around
+    ///                    the point
+    ///
+    /// @returns a multi bin range that contains the resulting bin ranges for
+    ///          every axis in the corresponding entry (e.g. rng_x in entry 0)
+    template <typename point_t, typename neighbor_t>
+    DETRAY_HOST_DEVICE multi_bin_range<Dim> bin_ranges(
+        const point_t &p, const std::array<neighbor_t, 2> &nhood) const {
+        // Empty bin ranges to be filled
+        multi_bin_range<Dim> bin_ranges{};
+        // Run the range resolution for every axis in this multi-axis type
+        (single_range(get_axis<axis_ts>(), p, nhood, bin_ranges), ...);
+
+        return bin_ranges;
+    }
+
+    /// Perform the bin lookup on a particular axis
+    ///
+    /// @tparam axis_t defines the axis for the lookup (axis types are unique)
+    /// @tparam point_t is the point type in the axes local coordinates.
+    ///
+    /// @param ax the axis that performs the lookup
+    /// @param p the point to be looked up on the axis
+    /// @param bin_indices the multi-bin object that is filled with the results
+    ///                    (axis index corresponds to entry of the multi-bin
+    ///                    (e.g. binx <=> 0)
+    template <typename axis_t, typename point_t>
+    DETRAY_HOST_DEVICE void single_bin(const axis_t &ax, const point_t &p,
+                                       multi_bin<Dim> &bin_indices) const {
+        // Get the index corresponding to the axis label (e.g. bin_x <=> 0)
+        constexpr dindex loc_idx =
+            axis_reg::to_index(axis_t::shape_type::label);
+        bin_indices.indices[loc_idx] = ax.bin(p[loc_idx]);
+    }
+
+    /// Perform the bin lookup on a particular axis within a given bin
+    /// neighborhood
+    ///
+    /// @tparam axis_t defines the axis for the lookup (axis types are unique)
+    /// @tparam point_t is the point type in the axes local coordinates.
+    /// @tparam neighbor_t the type of neighborhood defined on the axis around
+    ///                    the point
+    ///
+    /// @param ax the axis that performs the lookup
+    /// @param p the point to be looked up on the axis
+    /// @param nhood the neighborhood around the point for the range lookup
+    /// @param bin_indices the multi-bin object that is filled with the results
+    ///                    (axis index corresponds to entry of the multi-range
+    ///                    (e.g. bin_rangex <=> 0)
+    template <typename axis_t, typename point_t, typename neighbor_t>
+    DETRAY_HOST_DEVICE void single_range(
+        const axis_t &ax, const point_t &p,
+        const std::array<neighbor_t, 2> &nhood,
+        multi_bin_range<Dim> &bin_ranges) const {
+        // Get the index corresponding to the axis label (e.g. bin_range_x = 0)
+        constexpr dindex loc_idx =
+            axis_reg::to_index(axis_t::shape_type::label);
+        bin_ranges.indices[loc_idx] = ax.range(p[loc_idx], nhood);
+    }
+
+    /// Internal storage of axes boundary ranges and bin edges
+    storage_type m_data{};
+};
+
+}  // namespace n_axis
+
+template <bool is_owning, typename local_frame, typename... axis_ts>
+inline
+    typename n_axis::multi_axis<is_owning, local_frame, axis_ts...>::view_type
+    get_data(
+        n_axis::multi_axis<is_owning, local_frame, axis_ts...> &mult_axis) {
+    static_assert(is_owning,
+                  "Only mulit-axis types that own their data can move the data "
+                  "to device!");
+
+    return {vecmem::get_data(mult_axis.m_data.m_axes_data),
+            vecmem::get_data(mult_axis.m_data.m_edges)};
+}
+
+}  // namespace detray
diff --git a/core/include/detray/surface_finders/grid/detail/axis_binning.hpp b/core/include/detray/surface_finders/grid/detail/axis_binning.hpp
new file mode 100644
index 0000000000..88ce20c07b
--- /dev/null
+++ b/core/include/detray/surface_finders/grid/detail/axis_binning.hpp
@@ -0,0 +1,298 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s).
+#include "detray/definitions/detail/accessor.hpp"
+#include "detray/definitions/indexing.hpp"
+#include "detray/definitions/qualifiers.hpp"
+
+// System include(s).
+#include <cstddef>
+
+namespace detray {
+
+namespace n_axis {
+
+/// axis binning type names.
+enum class binning {
+    e_regular = 0,
+    e_irregular = 1,
+};
+
+/// @brief A regular binning scheme.
+///
+/// The binning on the input parameter space is regular and therefore only needs
+/// the span and the number of bins to match a value to a bin.
+template <typename dcontainers = host_container_types,
+          typename scalar_t = scalar>
+struct regular {
+
+    // Extract container types
+    using scalar_type = scalar_t;
+    using container_types = dcontainers;
+    template <typename T>
+    using vector_type = typename dcontainers::template vector_type<T>;
+    template <typename T, std::size_t N>
+    using array_type = typename dcontainers::template array_type<T, N>;
+
+    static constexpr binning type = binning::e_regular;
+
+    /// For the regular binning, the range contains the offset into the
+    /// bin edges container and the total number of bins. This is because
+    /// the number of entries in the bin edge container is always two and
+    /// instead the number of bins has to be known.
+    const dindex_range *m_edges_range{nullptr};
+    /// Access to the bin edges
+    const vector_type<scalar_t> *m_bin_edges{nullptr};
+
+    /// Default constructor (no concrete memory acces)
+    regular() = default;
+
+    /// Constructor from an index range and bin edges - non-owning
+    ///
+    /// @param range range of bin boundary entries in an external storage
+    /// @param edges lower edges for all bins in an external storage
+    DETRAY_HOST_DEVICE
+    regular(const dindex_range *range, const vector_type<scalar_t> *edges)
+        : m_edges_range(range), m_bin_edges(edges) {}
+
+    /// @returns the total number of bins, which for the regular axis is simply
+    /// the second entry in the range
+    DETRAY_HOST_DEVICE
+    std::size_t nbins() const { return detail::get<1>(*m_edges_range); }
+
+    /// Access function to a single bin from a value v
+    ///
+    /// @param v is the value for the bin search
+    ///
+    /// @returns the corresponding bin index
+    DETRAY_HOST_DEVICE
+    int bin(const scalar_t v) const {
+        return static_cast<int>((v - span()[0]) / bin_width() + 1);
+    }
+
+    /// Access function to a range with binned neighborhood
+    ///
+    /// @param v is the value for the bin search
+    /// @param nhood is the neighborhood bin index range (# neighboring bins)
+    ///
+    /// @returns the corresponding range of bin indices
+    DETRAY_HOST_DEVICE
+    array_type<int, 2> range(const scalar_t v,
+                             const array_type<dindex, 2> &nhood) const {
+        const int ibin{bin(v)};
+        const int ibinmin{ibin - static_cast<int>(nhood[0])};
+        const int ibinmax{ibin + static_cast<int>(nhood[1])};
+
+        return {ibinmin, ibinmax};
+    }
+
+    /// Access function to a range with scalar neighborhood
+    ///
+    /// @param v is the value for the bin search
+    /// @param nhood is the neighborhood value range (range on axis values)
+    ///
+    /// @returns the corresponding range of bin indices
+    DETRAY_HOST_DEVICE
+    array_type<int, 2> range(const scalar_t v,
+                             const array_type<scalar_t, 2> &nhood) const {
+        return {bin(v - nhood[0]), bin(v + nhood[1])};
+    }
+
+    /// @return the bin edges for a given @param ibin
+    DETRAY_HOST_DEVICE
+    array_type<scalar_t, 2> bin_edges(const dindex ibin) const {
+        const scalar_t width{bin_width()};
+        const scalar_t lower_edge{span()[0] + ibin * width};
+        return {lower_edge, lower_edge + width};
+    }
+
+    /// @return the values of the edges of all bins - uses dynamic memory
+    // TODO: return generator view instead to make it work properly in device
+    DETRAY_HOST_DEVICE
+    vector_type<scalar_t> bin_edges() const {
+        // Output vector has to be constructed, because the edges are
+        // calculated on the fly
+        vector_type<scalar_t> edges;
+        detail::call_reserve(edges, nbins());
+
+        // Calculate bin edges from number of bins and axis span
+        const array_type<scalar_t, 2> sp = span();
+        const scalar_t step{bin_width()};
+
+        for (dindex ib = 0; ib < nbins(); ++ib) {
+            edges.push_back(sp[0] + ib * step);
+        }
+
+        return edges;
+    }
+
+    /// @return the bin width between any two bins.
+    DETRAY_HOST_DEVICE
+    scalar_t bin_width() const {
+        // Get the binning information
+        const dindex ibin{detail::get<0>(*m_edges_range)};
+        const scalar_t min{(*m_bin_edges)[ibin]};
+        const scalar_t max{(*m_bin_edges)[ibin + 1]};
+
+        const scalar_t step_size{(max - min) / static_cast<scalar_t>(nbins())};
+
+        return step_size;
+    }
+
+    /// @return the span of the binning (equivalent to the span of the axis:
+    /// [min, max) )
+    DETRAY_HOST_DEVICE
+    array_type<scalar_t, 2> span() const {
+        // Get the binning information
+        const dindex ibin{detail::get<0>(*m_edges_range)};
+        const scalar_t min{(*m_bin_edges)[ibin]};
+        const scalar_t max{(*m_bin_edges)[ibin + 1]};
+
+        return {min, max};
+    }
+};
+
+/// @brief An irregular binning scheme.
+///
+/// The bin edges are irregular in the underlying parameter space.
+/// Therefore, the correct bin index has to be searched for.
+///
+/// @note The bin search makes this type comparatively expensive. Only use when
+/// absolutely needed.
+template <typename dcontainers = host_container_types,
+          typename scalar_t = scalar>
+struct irregular {
+
+    // Extract container types
+    using scalar_type = scalar_t;
+    using container_types = dcontainers;
+    template <typename T>
+    using vector_type = typename dcontainers::template vector_type<T>;
+    template <typename T, std::size_t N>
+    using array_type = typename dcontainers::template array_type<T, N>;
+
+    static constexpr binning type = binning::e_irregular;
+
+    /// Index range into the bin edges container
+    const dindex_range *m_edges_range{nullptr};
+    /// Access to the bin edges
+    const vector_type<scalar_t> *m_bin_edges{nullptr};
+
+    /// Default constructor (no concrete memory access)
+    irregular() = default;
+
+    /// Constructor from an index range and bin edges - non-owning
+    ///
+    /// @param range range of bin boundary entries in an external storage
+    /// @param edges lower edges for all bins in an external storage
+    DETRAY_HOST_DEVICE
+    irregular(const dindex_range *range, const vector_type<scalar_t> *edges)
+        : m_edges_range(range), m_bin_edges(edges) {}
+
+    /// @returns the total number of bins
+    DETRAY_HOST_DEVICE
+    std::size_t nbins() const {
+        return detail::get<1>(*m_edges_range) - detail::get<0>(*m_edges_range);
+    }
+
+    /// Access function to a single bin from a value v
+    ///
+    /// @param v is the value for the bin search
+    ///
+    /// @returns the corresponding bin index
+    DETRAY_HOST_DEVICE
+    int bin(const scalar_t v) const {
+        auto bins_begin = m_bin_edges->begin() + detail::get<0>(*m_edges_range);
+        auto bins_end = m_bin_edges->begin() + detail::get<1>(*m_edges_range);
+
+        return static_cast<int>(detail::upper_bound(bins_begin, bins_end, v) -
+                                bins_begin);
+    }
+
+    /// Access function to a range with binned neighborhood
+    ///
+    /// @param v is the value for the bin search
+    /// @param nhood is the neighborhood range (# neighboring bins)
+    ///
+    /// @returns the corresponding range of bin indices
+    DETRAY_HOST_DEVICE
+    array_type<int, 2> range(const scalar_t v,
+                             const array_type<dindex, 2> &nhood) const {
+        const int ibin{bin(v)};
+        const int ibinmin{ibin - static_cast<int>(nhood[0])};
+        const int ibinmax{ibin + static_cast<int>(nhood[1])};
+
+        return {ibinmin, ibinmax};
+    }
+
+    /// Access function to a range with scalar neighborhood
+    ///
+    /// @param v is the value for the bin search
+    /// @param nhood is the neighborhood range (range on axis values)
+    ///
+    /// @returns the corresponding range of bin indices
+    DETRAY_HOST_DEVICE
+    array_type<int, 2> range(const scalar_t v,
+                             const array_type<scalar_t, 2> &nhood) const {
+        const int nbin{bin(v - nhood[0])};
+        const int pbin{bin(v + nhood[1])};
+        return {nbin, pbin};
+    }
+
+    /// @return the bin edges for a given @param ibin
+    DETRAY_HOST_DEVICE
+    array_type<scalar_t, 2> bin_edges(const dindex ibin) const {
+        // Offset into global container for this binning
+        const dindex offset{detail::get<0>(*m_edges_range)};
+
+        return {(*m_bin_edges)[offset + ibin],
+                (*m_bin_edges)[offset + ibin + 1]};
+    }
+
+    /// @return the values of the edges of all bins - uses dynamic memory
+    // TODO: return range view instead to make it work properly in device
+    DETRAY_HOST_DEVICE
+    vector_type<scalar_t> bin_edges() const {
+        // Transcribe the subvector for this binning from the global storage
+        vector_type<scalar_t> edges;
+        detail::call_reserve(edges, nbins());
+
+        edges.insert(edges->end(),
+                     m_bin_edges->begin() + detail::get<0>(*m_edges_range),
+                     m_bin_edges->begin() + detail::get<1>(*m_edges_range));
+
+        return edges;
+    }
+
+    /// @return the bin width of a bin with index @param ibin.
+    DETRAY_HOST_DEVICE
+    scalar_t bin_width(const dindex ibin) const {
+
+        // Get the binning information
+        const array_type<scalar_t, 2> edges = bin_edges(ibin);
+
+        return edges[1] - edges[0];
+    }
+
+    /// @return the span of the binning (equivalent to the span of the axis:
+    /// [min, max) )
+    DETRAY_HOST_DEVICE
+    array_type<scalar_t, 2> span() const {
+        // Get the binning information
+        const scalar_t min{(*m_bin_edges)[detail::get<0>(*m_edges_range)]};
+        const scalar_t max{(*m_bin_edges)[detail::get<1>(*m_edges_range)]};
+
+        return {min, max};
+    }
+};
+
+}  // namespace n_axis
+
+}  // namespace detray
diff --git a/core/include/detray/surface_finders/grid/detail/axis_helpers.hpp b/core/include/detray/surface_finders/grid/detail/axis_helpers.hpp
new file mode 100644
index 0000000000..77566bf2fa
--- /dev/null
+++ b/core/include/detray/surface_finders/grid/detail/axis_helpers.hpp
@@ -0,0 +1,169 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s).
+#include "detray/definitions/indexing.hpp"
+#include "detray/definitions/qualifiers.hpp"
+
+namespace detray {
+
+namespace n_axis {
+
+/// @brief Multi-bin: contains bin indices from multiple axes
+template <std::size_t DIM>
+struct multi_bin : public dmulti_index<dindex, DIM> {};
+
+/// @brief Multi-bin-range: contains bin index ranges from multiple axes
+template <std::size_t DIM>
+struct multi_bin_range : public dmulti_index<dindex_range, DIM> {};
+
+namespace detail {
+
+// TODO: Replace by iterator based approach, along the lines of std::ranges
+
+/// @brief data state of a multi-axis - owning
+///
+/// The multi-axis is owning the axis and binning data: Directly holds the
+/// vector containers for the axis data and bin edges.
+template <typename containers = host_container_types,
+          typename scalar_t = scalar>
+struct multi_axis_data {
+
+    // Extract container types
+    template <typename T>
+    using vector_type = typename containers::template vector_type<T>;
+
+    /// Data that the axes keep: bin boundary ranges in the edges container
+    vector_type<dindex_range> m_axes_data{};
+    /// Contains all bin edges for all axes
+    vector_type<scalar_t> m_edges{};
+
+    /// Default constructor (empty data)
+    multi_axis_data() = default;
+
+    /// Construct containers using a specific memory resources
+    DETRAY_HOST_DEVICE
+    multi_axis_data(vecmem::memory_resource &resource)
+        : m_axes_data(&resource), m_edges(&resource) {}
+
+    /// Construct from containers - move
+    DETRAY_HOST_DEVICE
+    multi_axis_data(vector_type<dindex_range> &&axes_data,
+                    vector_type<scalar_t> &&edges)
+        : m_axes_data(std::move(axes_data)), m_edges(std::move(edges)) {}
+
+    /// Construct containers from vecmem based view types
+    ///
+    /// @param axes_view vecmem view on the axes data
+    /// @param edges_view vecmem view on the bin edges
+    DETRAY_HOST_DEVICE
+    multi_axis_data(const dvector_view<dindex_range> &axes_view,
+                    const dvector_view<scalar_t> &edges_view)
+        : m_axes_data(axes_view.m_view), m_edges(edges_view.m_view) {}
+
+    /// @returns pointer to all of the axes data
+    DETRAY_HOST_DEVICE
+    auto axes_data() const -> const vector_type<dindex_range> * {
+        return &m_axes_data;
+    }
+
+    /// @returns pointer to all of the axes data
+    // TODO: Don't do...
+    DETRAY_HOST_DEVICE
+    auto axes_data() -> vector_type<dindex_range> * { return &m_axes_data; }
+
+    /// @returns pointer to the data for one particular @param i axis
+    DETRAY_HOST_DEVICE
+    auto axis_data(const dindex i) const -> const dindex_range * {
+        return &(m_axes_data[i]);
+    }
+
+    /// @returns pointer to the entire bin edges collection for every axis
+    DETRAY_HOST_DEVICE
+    auto edges() const -> const vector_type<scalar_t> * { return &m_edges; }
+
+    /// @returns pointer to the entire bin edges collection for every axis
+    DETRAY_HOST_DEVICE
+    auto edges() -> vector_type<scalar_t> * { return &m_edges; }
+
+    /// @returns offset of this multi-axis in the global data container (not
+    /// needed when data is owned)
+    DETRAY_HOST_DEVICE
+    constexpr auto offset() const -> dindex { return 0; }
+};
+
+/// @brief data state of a multi-axis - non-owning (i.e. container view)
+///
+/// The multi-axis obtains a view of a global collection of data
+/// which it uses to provide the bin index lookup as a pure service to the
+/// grid. This type is NOT used to move the @c multi_axis_data between host
+/// and device when the data is owned by the multi-axis.
+template <typename containers = host_container_types,
+          typename scalar_t = scalar>
+struct multi_axis_view {
+
+    // Extract container types
+    template <typename T>
+    using vector_type = typename containers::template vector_type<T>;
+
+    /// Data that the axes keep: bin boundary ranges in the edges container
+    const vector_type<dindex_range> *m_axes_data{nullptr};
+    /// Contains all bin edges for all the axes
+    const vector_type<scalar_t> *m_edges{nullptr};
+    /// Offset for this multi-axis into the global container
+    dindex m_offset{0};
+
+    /// Default constructor (no concrete memory access)
+    multi_axis_view() = default;
+
+    /// Construct from explicitly given pointers to global containers
+    ///
+    /// @param axes_data_ptr const pointer to axes data
+    /// @param edges_ptr const pointer to bin edges
+    /// @param offset in the axes data and bin edges collections pointed to
+    DETRAY_HOST_DEVICE
+    multi_axis_view(const vector_type<dindex_range> *axes_data_ptr,
+                    const vector_type<scalar_t> *edges_ptr, const dindex offset)
+        : m_axes_data(axes_data_ptr), m_edges(edges_ptr), m_offset{offset} {}
+
+    /// @returns pointer to all(!) of the axes data - const
+    DETRAY_HOST_DEVICE
+    auto axes_data() const -> const vector_type<dindex_range> * {
+        return m_axes_data;
+    }
+
+    /// @returns pointer to all(!) of the axes data - non-const
+    // TODO: Don't do...
+    DETRAY_HOST_DEVICE
+    auto axes_data() -> vector_type<dindex_range> * { return m_axes_data; }
+
+    /// @returns pointer to the data for one particular @param i axis
+    DETRAY_HOST_DEVICE
+    auto axis_data(const dindex i) const -> const dindex_range * {
+        return &((*m_axes_data)[m_offset + i]);
+    }
+
+    /// @returns pointer to the entire(!) bin edges collection for every axis
+    DETRAY_HOST_DEVICE
+    auto edges() const -> const vector_type<scalar_t> * { return m_edges; }
+
+    /// @returns pointer to the entire(!) bin edges collection for every axis
+    DETRAY_HOST_DEVICE
+    auto edges() -> vector_type<scalar_t> * { return m_edges; }
+
+    /// @returns offset of this multi-axis in the global data container
+    DETRAY_HOST_DEVICE
+    auto offset() const -> dindex { return m_offset; }
+};
+
+}  // namespace detail
+
+}  // namespace n_axis
+
+}  // namespace detray
diff --git a/core/include/detray/surface_finders/grid/detail/axis_shape.hpp b/core/include/detray/surface_finders/grid/detail/axis_shape.hpp
new file mode 100644
index 0000000000..41c509e34c
--- /dev/null
+++ b/core/include/detray/surface_finders/grid/detail/axis_shape.hpp
@@ -0,0 +1,272 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s).
+#include "detray/definitions/indexing.hpp"
+#include "detray/definitions/qualifiers.hpp"
+
+// System include(s).
+#include <cstddef>
+#include <type_traits>
+
+namespace detray {
+
+namespace n_axis {
+
+/// axis shape names.
+enum class shape {
+    e_open = 0,
+    e_closed = 1,
+    e_circular = 1,
+};
+
+/// axis coordinate names. Used to get a specific axes from an axes collection.
+enum class label {
+    e_x = 0,
+    e_y = 1,
+    e_z = 2,
+    e_r = 0,
+    e_phi = 1,
+    e_rphi = 0,
+    e_cyl_z = 1,
+};
+
+/// @brief Helper to tie two bin indices to a range.
+///
+/// @note Cannot use dindex_range for signed integer bin indices.
+struct bin_range {
+    /// lower bin in the range
+    int lower{0};
+    /// upper bin in the range
+    int upper{0};
+
+    /// Default constructor.
+    bin_range() = default;
+
+    /// Construction from two bin indices @param l (lower) @param u (upper).
+    DETRAY_HOST_DEVICE
+    bin_range(const int l, const int u) : lower{l}, upper{u} {}
+
+    /// Implicit conversion from an @tparam array_t container of bin indices.
+    template <template <typename, std::size_t> class array_t>
+    DETRAY_HOST_DEVICE bin_range(const array_t<int, 2>& bin_array)
+        : lower{bin_array[0]}, upper{bin_array[1]} {}
+
+    /// Equality operator @returns true if both bin indices match.
+    DETRAY_HOST_DEVICE
+    inline bool operator==(const bin_range& rhs) const {
+        return (lower == rhs.lower && upper == rhs.upper);
+    }
+
+    /// @returns the distance between the two bin indices.
+    DETRAY_HOST_DEVICE
+    int nbins() const { return upper - lower; }
+};
+
+/// @brief Describes the behaviour of an open axis.
+///
+/// The axis will be open, i.e. each underflow bin is mapped to 0 and each
+/// overflow bin is mapped to #bins + 1: [0, #bins + 1]. Where 0 and #bins + 1
+/// are the overflow bins.
+///
+/// @tparam axis_label the label of the axis, i.e. x, y, z or r.
+template <n_axis::label axis_label>
+struct open {
+
+    static constexpr n_axis::label label = axis_label;
+    static constexpr n_axis::shape type = shape::e_open;
+
+    /// Access function to a single bin from a value v.
+    ///
+    /// @param ibin bin index to be mapped to axis shape
+    /// @param nbins is the total number of bins
+    ///
+    /// @returns an open axis bin index
+    DETRAY_HOST_DEVICE inline dindex map(const int ibin,
+                                         const std::size_t nbins) const {
+        if (ibin <= 0) {
+            return 0;
+        } else if (ibin > static_cast<int>(nbins)) {
+            return static_cast<dindex>(nbins + 1);
+        } else {
+            return static_cast<dindex>(ibin);
+        }
+    }
+
+    /// Access function to a range of bins.
+    ///
+    /// @param lbin the lower bin of the range.
+    /// @param ubin is the upper bin of the range.
+    /// @param nbins is the total number of bins
+    ///
+    /// @returns open bin range
+    DETRAY_HOST_DEVICE
+    inline dindex_range map(const int lbin, const int ubin,
+                            const std::size_t nbins) const {
+
+        dindex min_bin = (lbin > 0) ? static_cast<dindex>(lbin) : 0;
+        dindex max_bin = (ubin <= static_cast<int>(nbins))
+                             ? static_cast<dindex>(ubin)
+                             : static_cast<dindex>(nbins + 1);
+
+        return {min_bin, max_bin};
+    }
+
+    /// Access function to a range of bins - convenience function
+    ///
+    /// @param range signed range to be mapped to axis shape
+    /// @param nbins is the total number of bins
+    ///
+    /// @returns open bin range
+    DETRAY_HOST_DEVICE
+    inline dindex_range map(const bin_range range,
+                            const std::size_t nbins) const {
+        return map(range.lower, range.upper, nbins);
+    }
+};
+
+/// @brief Describes the behaviour of a closed axis.
+///
+/// The axis will be closed, i.e. each underflow bin is mapped to 0 and each
+/// overflow bin is mapped to #bins - 1. [0, #bins - 1]. Meaning, there are no
+/// actual over- or underflow bins (they would be -1 and #bins).
+///
+/// @tparam axis_label the label of the axis, i.e. x, y, z or r.
+template <n_axis::label axis_label>
+struct closed {
+
+    static constexpr n_axis::label label = axis_label;
+    static constexpr shape type = shape::e_closed;
+
+    /// Access function to a single bin from a value v
+    ///
+    /// @param ibin bin index to be mapped to axis shape
+    /// @param nbins is the total number of bins
+    ///
+    /// @returns a closed axis bin index
+    DETRAY_HOST_DEVICE inline dindex map(const int ibin,
+                                         const std::size_t nbins) const {
+        if (ibin <= 0) {
+            return 0;
+        } else if (ibin > static_cast<int>(nbins) - 1) {
+            return static_cast<dindex>(static_cast<int>(nbins) - 1);
+        } else {
+            return static_cast<dindex>(ibin - 1);
+        }
+    }
+
+    /// Access function to a range of bins
+    ///
+    /// @param lbin the lower bin of the range
+    /// @param ubin is the upper bin of the range
+    /// @param nbins is the total number of bins
+    ///
+    /// @returns closed bin range
+    DETRAY_HOST_DEVICE
+    inline dindex_range map(const int lbin, const int ubin,
+                            const std::size_t nbins) const {
+
+        dindex min_bin = (lbin > 0) ? static_cast<dindex>(lbin - 1) : 0;
+        dindex max_bin = (ubin > static_cast<int>(nbins) - 1)
+                             ? static_cast<dindex>(static_cast<int>(nbins) - 1)
+                             : static_cast<dindex>(ubin - 1);
+
+        return {min_bin, max_bin};
+    }
+
+    /// Access function to a range of bins - convenience function
+    ///
+    /// @param range signed range to be mapped to axis shape
+    /// @param nbins is the total number of bins
+    ///
+    /// @returns closed bin range
+    DETRAY_HOST_DEVICE
+    inline dindex_range map(const bin_range range,
+                            const std::size_t nbins) const {
+        return map(range.lower, range.upper, nbins);
+    }
+};
+
+/// @brief Describes the behaviour of a circular axis.
+///
+/// The axis will be periodic, i.e. underflow and underflow bins map into 0:
+/// 0 = #bins, so that [0, #bins - 1].
+// TODO: rename to circular, once there is no name clash
+template <n_axis::label axis_label = n_axis::label::e_phi>
+struct circular {
+
+    static constexpr n_axis::label label = axis_label;
+    static constexpr shape type = shape::e_circular;
+
+    /// Access function to a single bin from a value v
+    ///
+    /// @param ibin bin index to be mapped to axis shape
+    /// @param nbins is the total number of bins
+    ///
+    /// @returns a circular axis bin index
+    DETRAY_HOST_DEVICE inline dindex map(const int ibin,
+                                         const std::size_t nbins) const {
+        if (ibin > 0 and ibin < static_cast<int>(nbins)) {
+            return static_cast<dindex>(ibin);
+        } else {
+            return static_cast<dindex>(wrap(ibin, nbins));
+        }
+    }
+
+    /// Access function to a range of bins
+    ///
+    /// @param lbin the lower bin of the range
+    /// @param ubin is the upper bin of the range
+    /// @param nbins is the total number of bins
+    ///
+    /// The axis is circular: it @returns an ordered dindex_range: If the
+    /// second range index is larger than the first, there has been a wraparound
+    DETRAY_HOST_DEVICE
+    inline dindex_range map(const int lbin, const int ubin,
+                            const std::size_t nbins) const {
+        dindex min_bin = static_cast<dindex>(wrap(lbin, nbins));
+        dindex max_bin = static_cast<dindex>(wrap(ubin, nbins));
+        return {min_bin, max_bin};
+    }
+
+    /// Access function to a range of bins - convenience function
+    ///
+    /// @param range signed range to be mapped to axis shape
+    /// @param nbins is the total number of bins
+    ///
+    /// The axis is circular: it @returns an ordered dindex_range: If the
+    /// second range index is larger than the first, there has been a wraparound
+    DETRAY_HOST_DEVICE
+    inline dindex_range map(const bin_range range,
+                            const std::size_t nbins) const {
+        return map(range.lower, range.upper, nbins);
+    }
+
+    /// Wraps the bin index around for the periodic boundary condition
+    ///
+    /// @param ibin bin index to be mapped to axis shape
+    /// @param nbins is the total number of bins
+    ///
+    /// @return an index of a remapped bin
+    DETRAY_HOST_DEVICE inline int wrap(const int ibin,
+                                       const std::size_t nbins) const {
+        const int bins = static_cast<int>(nbins);
+        return (bins + ((ibin - 1) % bins)) % bins;
+    }
+};
+
+/// Determine axis shape as either 'open' or 'closed' for non-circular axes
+template <n_axis::shape s, n_axis::label axis_label>
+using shape_t =
+    std::conditional_t<s == n_axis::shape::e_open, n_axis::open<axis_label>,
+                       n_axis::closed<axis_label>>;
+
+}  // namespace n_axis
+
+}  // namespace detray
\ No newline at end of file
diff --git a/core/include/detray/surface_finders/grid/detail/grid_helpers.hpp b/core/include/detray/surface_finders/grid/detail/grid_helpers.hpp
new file mode 100644
index 0000000000..5957f9ccb8
--- /dev/null
+++ b/core/include/detray/surface_finders/grid/detail/grid_helpers.hpp
@@ -0,0 +1,99 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s).
+#include "detray/definitions/indexing.hpp"
+#include "detray/definitions/qualifiers.hpp"
+
+namespace detray {
+
+namespace detail {
+
+// TODO: Replace by iterator based approach, along the lines of std::ranges
+
+/// @brief data state of a grid - owning
+///
+/// The data that is owned and managed by the grid. Does not contain the
+/// data of the axes, as that is managed by the multi-axis type directly.
+template <typename backend_storage_type>
+struct grid_data {
+    /// Contains all bin data
+    backend_storage_type m_bin_data{};
+
+    /// Default constructor
+    grid_data() = default;
+
+    /// Construct containers using a memory resources
+    DETRAY_HOST_DEVICE
+    grid_data(vecmem::memory_resource &resource) : m_bin_data(&resource) {}
+
+    /// Construct grid data from containers - move
+    DETRAY_HOST_DEVICE
+    grid_data(backend_storage_type &&bin_data)
+        : m_bin_data(std::move(bin_data)) {}
+
+    /// Construct containers from a vecmem view
+    DETRAY_HOST_DEVICE
+    grid_data(
+        const dvector_view<typename backend_storage_type::value_type> &view)
+        : m_bin_data(view.m_view) {}
+
+    /// @returns pointer to the entire bin data for the grid - const
+    DETRAY_HOST_DEVICE
+    auto bin_data() const -> const backend_storage_type * {
+        return &m_bin_data;
+    }
+
+    /// @returns pointer to the entire bin data for the grid - non-const
+    DETRAY_HOST_DEVICE
+    auto bin_data() -> backend_storage_type * { return &m_bin_data; }
+
+    /// @returns the offset of this grid in a global grid collection
+    /// (not needed if the grid owns its data)
+    DETRAY_HOST_DEVICE
+    constexpr auto offset() const -> dindex { return 0; }
+};
+
+/// @brief data state of a grid - non-owning (i.e. container view)
+///
+/// The grid holds a view onto a global collection of data. This type is NOT
+/// used to move @c grid_data from host to device.
+template <typename backend_storage_type>
+struct grid_view {
+    /// Contains all bin edges for all the axes
+    backend_storage_type *m_bin_data{nullptr};
+    /// Offset for this grid into the global container
+    dindex m_offset{0};
+
+    /// Default constructor
+    grid_view() = default;
+
+    /// Construct from explicitly given data pointers
+    DETRAY_HOST_DEVICE
+    grid_view(backend_storage_type *bin_data_ptr, const dindex offset)
+        : m_bin_data(bin_data_ptr), m_offset{offset} {}
+
+    /// @returns pointer to the entire bin edges collection for every axis -
+    /// const
+    DETRAY_HOST_DEVICE
+    auto bin_data() const -> const backend_storage_type * { return m_bin_data; }
+
+    /// @returns pointer to the entire bin edges collection for every axis -
+    /// non_const
+    DETRAY_HOST_DEVICE
+    auto bin_data() -> backend_storage_type * { return m_bin_data; }
+
+    /// @returns offset of this multi-axis in the global data container
+    DETRAY_HOST_DEVICE
+    auto offset() const -> dindex { return m_offset; }
+};
+
+}  // namespace detail
+
+}  // namespace detray
diff --git a/core/include/detray/surface_finders/grid/detail/populator_impl.hpp b/core/include/detray/surface_finders/grid/detail/populator_impl.hpp
new file mode 100644
index 0000000000..c7f342ab15
--- /dev/null
+++ b/core/include/detray/surface_finders/grid/detail/populator_impl.hpp
@@ -0,0 +1,342 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s).
+#include "detray/definitions/indexing.hpp"
+#include "detray/definitions/qualifiers.hpp"
+#include "detray/utils/enumerate.hpp"
+#include "detray/utils/invalid_values.hpp"
+
+namespace detray {
+
+/// @brief base type for the storage element that wraps a bin content in the
+///        grid backend storage.
+///
+/// The storage element also facilitates to provide a specific 'view' on the bin
+/// content. This is usefull e.g. if the bin content is an iterable collection
+/// of entries. The populators determine the behaviour of bin population, while
+/// the entry type of an content is determined by the grid.
+template <typename content_t, template <typename> class view_t,
+          typename T = void>
+struct bin_base {
+    content_t m_content{};
+    using content_type = content_t;
+    using view_type = view_t<content_t>;
+    using const_view_type = view_t<const content_t>;
+
+    /// @returns the content that a bin stores
+    DETRAY_HOST_DEVICE
+    auto view() const -> const_view_type { return const_view_type(m_content); }
+
+    /// Access to the bin content
+    DETRAY_HOST_DEVICE
+    auto view() -> view_type { return view_type(m_content); }
+
+    /// @returns the bin content - const
+    DETRAY_HOST_DEVICE
+    auto content() const -> const content_t & { return m_content; }
+
+    /// @returns the bin content
+    DETRAY_HOST_DEVICE
+    auto content() -> content_t & { return m_content; }
+
+    /// Insert a @param new_content into the backend storage - move
+    DETRAY_HOST_DEVICE
+    void insert(content_t &&new_content) { m_content = std::move(new_content); }
+
+    /// Insert a @param new_content into the backend storage - copy
+    DETRAY_HOST_DEVICE
+    void insert(const content_t &new_content) { m_content = new_content; }
+};
+
+/// @brief default implementation of an element in the grid backend storage
+template <typename content_t, template <typename> class view_t>
+struct bin
+    : public bin_base<
+          content_t, view_t,
+          typename std::enable_if_t<std::is_standard_layout_v<content_t>>> {};
+
+/// A replace populator that overrides whatever current content is in the bin
+/// with a new entry.
+///
+/// @note entry type and bin content type are identicial in this case
+struct replacer {
+
+    /// Sort the entries contained in a bin content when fetched: not needed,
+    /// as there is only a single entry
+    static constexpr bool do_sort = false;
+
+    template <typename content_t>
+    using bin_type = bin<content_t, single_iterator>;
+
+    /// Replace the bin content with a new entry - forwarding
+    ///
+    /// @param storage the grid backend storage
+    /// @param gbin the global grid bin index to be populated
+    /// @param content new content to be added
+    template <typename bin_storage_t, typename content_t>
+    DETRAY_HOST_DEVICE void operator()(bin_storage_t &storage,
+                                       const dindex gbin,
+                                       content_t &&entry) const {
+        storage[gbin].insert(std::forward<content_t>(entry));
+    }
+
+    /// Fetch a bin content from a storage element in the backend storage
+    ///
+    /// @param storage the grid backend storage
+    /// @param gbin the global grid bin index to be fetched
+    ///
+    /// @return a const iterator view on the bin content
+    template <typename bin_storage_t>
+    DETRAY_HOST_DEVICE auto view(const bin_storage_t &storage,
+                                 const dindex gbin) const {
+        return storage[gbin].view();
+    }
+
+    /// @returns an initialized bin in the backend storage
+    template <typename content_t>
+    DETRAY_HOST_DEVICE static constexpr auto init(
+        content_t content = detail::invalid_value<content_t>())
+        -> bin_type<content_t> {
+        return {{content}};
+    }
+};
+
+/// A complete populator that adds elements to a bin content which contains an
+/// array of entries, until it is completed - ignored afterwards.
+///
+/// @tparam kDIM the dimension of the array in the bin content
+/// @tparam entry_t the type of a single element in the bin content
+/// @tparam kSORT sort the entries in the bin content
+///
+/// @note the entry type must be default constructible, since its default
+/// entry may be interpreted as the empty element in which to put the new entry.
+template <std::size_t kDIM = 1, bool kSORT = false,
+          template <typename, std::size_t> class array_t = darray>
+struct completer {
+
+    /// Sort the entries contained in a bin content when viewed
+    static constexpr bool do_sort = kSORT;
+
+    template <typename entry_t>
+    using bin_type = bin<array_t<entry_t, kDIM>, standard_iterator>;
+
+    /// Complete the bin content with a new entry - copy
+    ///
+    /// @param storage the grid backend storage
+    /// @param gbin the global grid bin index to be populated
+    /// @param entry new entry to complete the bin array with
+    template <typename bin_storage_t, typename entry_t>
+    DETRAY_HOST_DEVICE void operator()(bin_storage_t &storage,
+                                       const dindex gbin,
+                                       const entry_t entry) const {
+        for (entry_t &stored_entry : storage[gbin].content()) {
+            if (stored_entry == detail::invalid_value<entry_t>()) {
+                stored_entry = entry;
+            }
+        }
+    }
+
+    /// Fetch a bin content from a storage element in the backend storage
+    ///
+    /// @param storage the grid backend storage
+    /// @param gbin the global grid bin to be viewed
+    ///
+    /// @return a const iterator view on the bin content
+    template <typename bin_storage_t>
+    DETRAY_HOST_DEVICE decltype(auto) view(const bin_storage_t &storage,
+                                           const dindex gbin) const {
+        return storage[gbin].view();
+    }
+
+    /// @returns an initialized storage element that contains @param entry in
+    /// the first entry and sets all other entries to 'invalid'
+    template <typename entry_t>
+    DETRAY_HOST_DEVICE static constexpr auto init(
+        entry_t entry = detail::invalid_value<entry_t>()) -> bin_type<entry_t> {
+        // Initialize the storage element
+        array_t<entry_t, kDIM> stored{};
+        std::fill(stored.begin(), stored.end(),
+                  detail::invalid_value<entry_t>());
+
+        // The first entry always exists
+        stored[0] = entry;
+
+        return {{stored}};
+    }
+};
+
+/// A regular attach populator that adds a new entry to a given bin.
+///
+/// @tparam kDIM the dimension of the bin content (array)
+/// @tparam entry_t the type of a single element in the bin content
+/// @tparam kSORT sort the entries in the bin
+///
+/// @note the number of entries are assumed to be the same in every bin.
+/// @note the entry type must be default constructible, since its default
+/// entry may be interpreted as the empty element in which to put the new entry.
+template <std::size_t kDIM = 1, bool kSORT = false,
+          template <typename, std::size_t> class array_t = darray>
+struct regular_attacher {
+
+    /// Sort the entries contained in a bin entry when viewed
+    static constexpr bool do_sort = kSORT;
+
+    template <typename entry_t>
+    using bin_type = bin<array_t<entry_t, kDIM>, standard_iterator>;
+
+    /// Append a new entry to the bin - forwarding
+    ///
+    /// @param storage the grid backend storage
+    /// @param gbin the global grid bin index to be populated
+    /// @param entry new entry to add to the bin
+    template <typename bin_storage_t, typename entry_t>
+    DETRAY_HOST_DEVICE void operator()(bin_storage_t &storage,
+                                       const dindex gbin,
+                                       entry_t &&entry) const {
+        for (auto &stored : storage[gbin].content()) {
+            if (stored ==
+                detail::invalid_value<std::remove_reference_t<entry_t>>()) {
+                stored = std::forward<entry_t>(entry);
+                break;
+            }
+        }
+    }
+
+    /// Fetch a bin from a storage element in the backend storage - const
+    ///
+    /// @param storage the grid backend storage
+    /// @param gbin the global grid bin index to be viewed
+    ///
+    /// @return a const iterator view on the bin content
+    template <typename bin_storage_t>
+    DETRAY_HOST_DEVICE auto view(const bin_storage_t &storage,
+                                 const dindex gbin) const {
+        return storage[gbin].view();
+    }
+
+    /// @returns an initialized storage element that contains @param entry in
+    /// the first element of the bin
+    template <typename entry_t>
+    DETRAY_HOST_DEVICE static constexpr auto init(
+        entry_t entry = detail::invalid_value<entry_t>()) -> bin_type<entry_t> {
+        // Initialize the storage element
+        array_t<entry_t, kDIM> stored{};
+        std::fill(stored.begin(), stored.end(),
+                  detail::invalid_value<entry_t>());
+
+        // The first element always exists
+        stored[0] = entry;
+
+        return {{stored}};
+    }
+};
+
+/// An irregular attach populator that adds the new entry to the collection of
+/// entries in a given bin: each bin is dynamically sized.
+///
+/// @tparam kDIM the dimension of the array in the bin content
+/// @tparam entry_t the type of a single element in the bin content
+/// @tparam kSORT sort the elements in the bin content
+///
+/// @note since this type performs a bin search upon insertion and bin lookup,
+/// it is comparatively slow and should only be used if there is a large
+/// difference in the number of elements in the bin entries. Otherwise, use the
+/// @c regular_attacher.
+/// @note the entry type must be default constructible, since its default
+/// entry may be interpreted as the empty element in which to put the new entry.
+/*template <typename entry_t = dindex, std::size_t kDIM = 1, bool kSORT = false,
+          template <typename...> class vector_t = dvector>
+struct irregular_attacher {
+
+    /// The storage element saves additional information to find the correct
+    /// bin in a 'jagged' memory layout.
+    template <typename T, template <typename> class V>
+    struct indexed_bin
+        : public bin_base<
+              T, V, typename std::enable_if_t<std::is_standard_layout_v<T>>> {
+        using base_type = bin_base<T, V, void>;
+        using view_type = typename base_type::view_type;
+        using const_view_type = typename base_type::view_type;
+        /// The global bin a single entry in a bin content is associated with
+        dindex gbin;
+
+        /// Set to invalid entries by default
+        indexed_bin() : gbin{dindex_invalid} {
+            this->entry = detail::invalid_value<entry_t>();
+        }
+    };
+
+    /// Sort the entries contained in a bin entry when fetched
+    static constexpr bool do_sort = kSORT;
+
+    template <typename entry_t>
+    using bin_type = bin<vector_t<entry_t, kDIM>, single_iterator>;
+
+    /// Add a new entry to the storage element - move
+    ///
+    /// @param storage the grid backend storage
+    /// @param gbin the global grid bin to be populated
+    /// @param entry new entry to be added to the vector
+    template<typename bin_storage_t, typename entry_t>
+    DETRAY_HOST
+    void operator()(bin_storage_t &storage,
+                    const dindex &gbin, entry_t &&entry) const {
+        auto last_gbin_entry = detail::upper_bound(storage.begin(),
+storage.end(), entry); *last_gbin_entry = std::move(entry);
+    }
+
+    /// Add a new entry to the storage element - copy
+    ///
+    /// @param storage the grid backend storage
+    /// @param gbin the global grid bin to be populated
+    /// @param entry new entry to be added to the vector
+    template<typename bin_storage_t, typename entry_t>
+    DETRAY_HOST
+    void operator()(bin_storage_t &storage,
+                    const dindex gbin, entry_t &entry) const {
+        auto last_gbin_entry = detail::upper_bound(storage.begin(),
+storage.end(), entry); *last_gbin_entry = entry;
+    }
+
+    /// Fetch a bin content from a storage element in the backend storage -
+const
+    ///
+    /// @param storage the grid backend storage
+    /// @param gbin the global grid bin to be fetched
+    /// @param sub_idx fetch a single entry from the bin content
+    ///
+    /// @return the sub-content in the global bin
+    template<typename bin_storage_t>
+    DETRAY_HOST_DEVICE
+    auto view(const bin_storage_t &storage,
+               const dindex gbin) const { auto first_gbin_entry =
+detail::lower_bound(storage.begin(), storage.end(), entry); auto last_gbin_entry
+= detail::upper_bound(storage.begin(), storage.end(), entry);
+
+    }
+
+    /// @returns an initialized bin entry
+    template<typename entry_t>
+    DETRAY_HOST_DEVICE
+    static constexpr auto init(
+        entry_t content = detail::invalid_value<entry_t>()) -> bin_type<entry_t>
+{
+        // Set capacity the storage element
+        entry_t stored(nentries);
+        std::fill(stored.begin(), stored.end(),
+detail::invalid_value<entry_t>());
+
+        stored.at(0) = entry;
+
+        return {stored};
+    }
+};*/
+
+}  // namespace detray
diff --git a/core/include/detray/surface_finders/grid/detail/serializer_impl.hpp b/core/include/detray/surface_finders/grid/detail/serializer_impl.hpp
new file mode 100644
index 0000000000..311d68378d
--- /dev/null
+++ b/core/include/detray/surface_finders/grid/detail/serializer_impl.hpp
@@ -0,0 +1,134 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s).
+#include "detray/definitions/indexing.hpp"
+#include "detray/definitions/qualifiers.hpp"
+#include "detray/surface_finders/grid/axis.hpp"
+
+namespace detray {
+
+/// @brief Transforms a local axis bin index to a global grid bin index and vice
+/// versa
+///
+/// Serializers allow to create a memory local data layout if advantegeous.
+///
+/// @note the bin indices are expected to start at zero.
+template <std::size_t kDIM>
+struct simple_serializer {};
+
+/// @brief Simple serializer specialization for a single axis
+template <>
+struct simple_serializer<1> {
+
+    /// @returns the axis local bin, which is also the global bin
+    template <typename multi_axis_t>
+    DETRAY_HOST_DEVICE auto operator()(multi_axis_t & /*axes*/,
+                                       n_axis::multi_bin<1> mbin) const
+        -> dindex {
+        return mbin[0];
+    }
+
+    /// @returns the global bin, which is also the axis local bin
+    template <typename multi_axis_t,
+              template <typename, std::size_t> class array_t = darray>
+    DETRAY_HOST_DEVICE auto operator()(multi_axis_t & /*axes*/,
+                                       dindex gbin) const
+        -> n_axis::multi_bin<1> {
+        return {{gbin}};
+    }
+};
+
+/// @brief Simple serializer specialization for a 3D multi-axis
+template <>
+struct simple_serializer<2> {
+
+    /// @brief Create a serial bin from a multi-bin - 3D
+    ///
+    /// @tparam multi_axis_t is the type of multi-dimensional axis
+    ///
+    /// @param axes contains all axes (multi-axis)
+    /// @param mbin contains a bin index for every axis in the multi-axis.
+    ///
+    /// @returns a dindex for the bin data storage
+    template <typename multi_axis_t>
+    DETRAY_HOST_DEVICE auto operator()(multi_axis_t &axes,
+                                       n_axis::multi_bin<2> mbin) const
+        -> dindex {
+        dindex offset{mbin[1] * axes.template get_axis<0>().nbins()};
+        return offset + mbin[0];
+    }
+
+    /// @brief Create a bin tuple from a serialized bin - 3D
+    ///
+    /// @tparam multi_axis_t is the type of multi-dimensional axis
+    ///
+    /// @param axes contains all axes (multi-axis)
+    /// @param gbin the global (serial) bin
+    ///
+    /// @return a 2-dimensional multi-bin
+    template <typename multi_axis_t>
+    DETRAY_HOST_DEVICE auto operator()(multi_axis_t &axes, dindex gbin) const
+        -> n_axis::multi_bin<2> {
+        dindex nbins_axis0 = axes.template get_axis<0>().nbins();
+
+        dindex bin0{gbin % nbins_axis0};
+        dindex bin1{static_cast<dindex>(gbin / nbins_axis0)};
+
+        return {{bin0, bin1}};
+    }
+};
+
+/// @brief Simple serializer specialization for a 3D multi-axis
+template <>
+struct simple_serializer<3> {
+
+    /// @brief Create a serial bin from a multi-bin - 3D
+    ///
+    /// @tparam multi_axis_t is the type of multi-dimensional axis
+    ///
+    /// @param axes contains all axes (multi-axis)
+    /// @param mbin contains a bin index for every axis in the multi-axis.
+    ///
+    /// @returns a dindex for the bin data storage
+    template <typename multi_axis_t>
+    DETRAY_HOST_DEVICE auto operator()(multi_axis_t &axes,
+                                       n_axis::multi_bin<3> mbin) const
+        -> dindex {
+        dindex nbins_axis0 = axes.template get_axis<0>().nbins();
+        dindex nbins_axis1 = axes.template get_axis<1>().nbins();
+
+        dindex offset1{mbin[1] * nbins_axis0};
+        dindex offset2{mbin[2] * (nbins_axis0 * nbins_axis1)};
+
+        return offset1 + offset2 + mbin[0];
+    }
+
+    /// @brief Create a bin tuple from a serialized bin - 3D
+    ///
+    /// @tparam multi_axis_t is the type of multi-dimensional axis
+    ///
+    /// @param axes contains all axes (multi-axis)
+    /// @param gbin the global (serial) bin
+    ///
+    /// @return a 3-dimensional multi-bin
+    template <typename multi_axis_t>
+    DETRAY_HOST_DEVICE auto operator()(multi_axis_t &axes, dindex gbin) const
+        -> n_axis::multi_bin<3> {
+        dindex nbins_axis0 = axes.template get_axis<0>().nbins();
+        dindex nbins_axis1 = axes.template get_axis<1>().nbins();
+
+        dindex bin0{gbin % nbins_axis0};
+        dindex bin1{static_cast<dindex>(gbin / (nbins_axis0)) % nbins_axis1};
+        dindex bin2{static_cast<dindex>(gbin / (nbins_axis0 * nbins_axis1))};
+        return {{bin0, bin1, bin2}};
+    }
+};
+
+}  // namespace detray
diff --git a/core/include/detray/surface_finders/grid/grid.hpp b/core/include/detray/surface_finders/grid/grid.hpp
new file mode 100644
index 0000000000..25802bc576
--- /dev/null
+++ b/core/include/detray/surface_finders/grid/grid.hpp
@@ -0,0 +1,303 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s).
+#include "detray/definitions/qualifiers.hpp"
+#include "detray/surface_finders/grid/axis.hpp"
+#include "detray/surface_finders/grid/detail/grid_helpers.hpp"
+#include "detray/surface_finders/grid/populator.hpp"
+#include "detray/surface_finders/grid/serializer.hpp"
+
+// VecMem include(s).
+#include <vecmem/memory/memory_resource.hpp>
+
+// System include(s).
+#include <cstddef>
+#include <type_traits>
+
+namespace detray {
+
+/// @brief An N-dimensional grid for object storage.
+///
+/// @tparam multi_axis_t the types of grid axes
+/// @tparam value_t type of data to be stored in the grid's bins.
+/// @tparam serialzier_t how to serialize axis-local bin indices into global bin
+///                      indices in the grid backend storage and vice versa.
+/// @tparam populator_impl_t is a prescription what to do when a bin gets
+///                          populated or read. It thus also defines the backend
+///                          storage type/value type.
+template <typename multi_axis_t, typename value_t,
+          template <std::size_t> class serializer_t, typename populator_impl_t>
+class grid {
+
+    public:
+    // Single value in a bin entry
+    using value_type = value_t;
+    // Interface to the populator (detramines the bin entry and value type).
+    using populator_type = populator<populator_impl_t>;
+    using bin_type = typename populator_type::template bin_type<value_type>;
+    /// The type of the multi-axis is tied to the type of the grid: a non-
+    /// owning grid holds a non-owning multi-axis member.
+    using axes_type = multi_axis_t;
+    using container_types = typename axes_type::container_types;
+    using local_frame = typename axes_type::local_frame_type;
+    using scalar_type = typename axes_type::scalar_type;
+
+    /// Grid dimension
+    static constexpr std::size_t Dim = axes_type::Dim;
+    static constexpr bool is_owning = axes_type::is_owning;
+
+    /// How to define a neighborhood for this grid
+    template <typename neighbor_t>
+    using neighborhood_type =
+        typename container_types::template array_type<neighbor_t, Dim>;
+
+    /// Backend storage type for the grid
+    using bin_storage_type =
+        typename container_types::template vector_type<bin_type>;
+    /// Vecmem based grid view type - non-const
+    using view_type =
+        dmulti_view<dvector_view<bin_type>, typename axes_type::view_type>;
+    /// Grid backend can be owning (single grid) or non-owning (grid collection)
+    using storage_type =
+        std::conditional_t<is_owning, detail::grid_data<bin_storage_type>,
+                           detail::grid_view<bin_storage_type>>;
+
+    /// Make grid default constructible: Empty grid with empty axis
+    grid() = default;
+
+    /// Create empty grid with empty axes from specific vecmem memory resource
+    DETRAY_HOST
+    grid(vecmem::memory_resource &resource)
+        : m_data(resource), m_axes(resource) {}
+
+    /// Create grid with well defined @param axes and @param bins_data - move
+    DETRAY_HOST_DEVICE
+    grid(bin_storage_type &&bin_data, axes_type &&axes)
+        : m_data(std::move(bin_data)), m_axes(std::move(axes)) {}
+
+    /// Create grid from container pointers - non-owning (both grid and axes)
+    DETRAY_HOST_DEVICE
+    grid(bin_storage_type *bin_data_ptr, axes_type &axes,
+         const dindex offset = 0)
+        : m_data(bin_data_ptr, offset), m_axes(axes) {}
+
+    /// Device-side construction from a vecmem based view type
+    template <typename grid_view_t,
+              typename std::enable_if_t<
+                  std::is_base_of_v<dbase_view, grid_view_t>, bool> = true>
+    DETRAY_HOST_DEVICE grid(grid_view_t &view)
+        : m_data(detray::detail::get<0>(view.m_views)),
+          m_axes(detray::detail::get<1>(view.m_views)) {}
+
+    /// @returns the underlying bin value storage. Either the container
+    /// or a container pointer to a global collection - const
+    DETRAY_HOST_DEVICE
+    auto data() const -> const storage_type & { return m_data; }
+
+    /// @returns the underlying bin value storage. Either the container
+    /// or a container pointer to a global collection - non-const for vecmem
+    // TODO: Don't do
+    DETRAY_HOST_DEVICE
+    auto data() -> storage_type & { return m_data; }
+
+    /// @returns the multi-axis used by the grid - const
+    DETRAY_HOST_DEVICE
+    auto axes() const -> const axes_type & { return m_axes; }
+
+    /// @returns the multi-axis used by the grid - non-const for vecmem
+    // TODO: Don't do
+    DETRAY_HOST_DEVICE
+    auto axes() -> axes_type & { return m_axes; }
+
+    /// @returns an axis object, corresponding to the label.
+    template <n_axis::label L>
+    DETRAY_HOST_DEVICE inline constexpr auto get_axis() const {
+        return m_axes.template get_axis<L>();
+    }
+
+    /// @returns an axis object of the given type.
+    template <typename axis_t>
+    DETRAY_HOST_DEVICE inline constexpr axis_t get_axis() const {
+        return m_axes.template get_axis<axis_t>();
+    }
+
+    /// Transform a point in global cartesian coordinates to local coordinates
+    ///
+    /// @param trf the placement transform of the grid (e.g. from a volume or
+    ///            a surface).
+    /// @param p   the point in global coordinates
+    ///
+    /// @returns a point in the coordinate system that is spanned by the grid's
+    /// axes.
+    template <typename transform_t, typename point3_t>
+    auto global_to_local(const transform_t &trf, const point3_t &p) const {
+        return local_frame{}(trf, p);
+    }
+
+    /// Return the value of a single bin - with direct bin access
+    ///
+    /// @param mbin the multi-index of bins over all axes
+    ///
+    /// @return the const reference to the value in this bin
+    DETRAY_HOST_DEVICE
+    auto at(const n_axis::multi_bin<Dim> &mbin) const {
+        return m_populator.view(*(data().bin_data()),
+                                m_serializer(m_axes, mbin) + m_data.offset());
+    }
+
+    /// Return the value of a single bin - with direct bin access
+    ///
+    /// @param gbin the multi-index of bins over all axes
+    ///
+    /// @return the const reference to the value in this bin
+    DETRAY_HOST_DEVICE
+    auto at(dindex gbin) const {
+        return m_populator.view(*(data().bin_data()), gbin + m_data.offset());
+    }
+
+    /// Find the value of a single bin
+    ///
+    /// @param p is point in the local frame
+    ///
+    /// @return the const reference to the value in this bin
+    template <typename point_t>
+    DETRAY_HOST_DEVICE auto search(const point_t &p) const {
+        return at(m_axes.bins(p));
+    }
+
+    /// @brief Return a neighborhood of values from the grid
+    ///
+    /// The lookup is done with a neighborhood around the bin which contains the
+    /// point
+    ///
+    /// @tparam sort is a directive whether return a sorted neighborhood
+    ///
+    /// @param p is point in the local frame
+    /// @param nhood is the binned/scalar neighborhood
+    ///
+    /// @return the sequence of values
+    template <typename point_t, typename neighbor_t, bool sort = false>
+    DETRAY_HOST_DEVICE auto search(const point_t &p,
+                                   neighborhood_type<neighbor_t> &nhood) const
+        -> void {
+        n_axis::multi_bin_range<Dim> bin_ranges = m_axes.bin_ranges(p, nhood);
+        // Return iterable over bin values in the multi-range
+
+        // Placeholder
+    }
+
+    /// Poupulate a bin with a single of its corresponding values - copy
+    ///
+    /// @param gbin the global bin index to be populated
+    /// @param v the single value the bin will be populated with
+    DETRAY_HOST_DEVICE auto populate(const dindex gbin, const value_type &v)
+        -> void {
+        m_populator(*(data().bin_data()), gbin + m_data.offset(), v);
+    }
+
+    /// Poupulate a bin with a single of its corresponding values - move
+    ///
+    /// @param gbin the global bin index to be populated
+    /// @param v the single value the bin will be populated with
+    DETRAY_HOST_DEVICE auto populate(const dindex gbin, value_type &&v)
+        -> void {
+        m_populator(*(data().bin_data()), gbin + m_data.offset(), std::move(v));
+    }
+
+    /// Poupulate a bin with a single of its corresponding values - copy
+    ///
+    /// @param mbin the multi bin index to be populated
+    /// @param v the single value the bin will be populated with
+    DETRAY_HOST_DEVICE auto populate(const n_axis::multi_bin<Dim> mbin,
+                                     const value_type &v) -> void {
+        populate(m_serializer(m_axes, mbin), v);
+    }
+
+    /// Poupulate a bin with a single of its corresponding values - move
+    ///
+    /// @param mbin the multi bin index to be populated
+    /// @param v the single value the bin will be populated with
+    DETRAY_HOST_DEVICE auto populate(const n_axis::multi_bin<Dim> mbin,
+                                     value_type &&v) -> void {
+        populate(m_serializer(m_axes, mbin), std::move(v));
+    }
+
+    /// Poupulate a bin with a single of its corresponding values - copy
+    ///
+    /// @param p the point in local coordinates that defines the bin to be
+    ///          populated
+    /// @param v the single value the bin will be populated with
+    template <typename point_t>
+    DETRAY_HOST_DEVICE auto populate(const point_t &p, value_type &&v) -> void {
+        populate(m_serializer(m_axes, m_axes.bins(p)), std::move(v));
+    }
+
+    /// Poupulate a bin with a single of its corresponding values - move
+    ///
+    /// @param p the point in local coordinates that defines the bin to be
+    ///          populated
+    /// @param v the single value the bin will be populated with
+    template <typename point_t>
+    DETRAY_HOST_DEVICE auto populate(const point_t &p, const value_type &v)
+        -> void {
+        populate(m_serializer(m_axes, m_axes.bins(p)), v);
+    }
+
+    static constexpr auto serializer() -> serializer_t<Dim> { return {}; }
+
+    private:
+    /// Struct that contains the grid's data state
+    storage_type m_data{};
+    /// The axes of the grid
+    axes_type m_axes{};
+    /// How to write and fetch bin values from the backend storage
+    populator_type m_populator{};
+    /// Serialization/Deserialization of multi-bin indices to the global bin
+    /// data storage
+    serializer_t<Dim> m_serializer{};
+};
+
+/// @returns view of a grid, including the grids mulit_axis. Also valid if the
+/// value type of the grid is cv qualified (then value_t propagates quialifiers)
+template <typename multi_axis_t, typename value_t,
+          template <std::size_t> class serializer_t, typename populator_t>
+inline
+    typename grid<multi_axis_t, value_t, serializer_t, populator_t>::view_type
+    get_data(grid<multi_axis_t, value_t, serializer_t, populator_t> &g) {
+    static_assert(
+        grid<multi_axis_t, value_t, serializer_t, populator_t>::is_owning,
+        "Only grid types that own their data can move the data "
+        "to device!");
+
+    return {vecmem::get_data(*g.data().bin_data()), detray::get_data(g.axes())};
+}
+
+/// @returns const view of a grid, for every grid that is passed as a const
+/// reference
+template <typename multi_axis_t, typename value_t,
+          template <std::size_t> class serializer_t, typename populator_t>
+inline typename grid<multi_axis_t, const value_t, serializer_t,
+                     populator_t>::view_type
+get_data(const grid<multi_axis_t, value_t, serializer_t, populator_t> &g) {
+    static_assert(
+        grid<multi_axis_t, value_t, serializer_t, populator_t>::is_owning,
+        "Only grid types that own their data can move the data "
+        "to device!");
+
+    // add const to grid value type
+    auto const_g = reinterpret_cast<
+        const grid<multi_axis_t, const value_t, serializer_t, populator_t> &>(
+        g);
+
+    return {vecmem::get_data(*const_g.data().bin_data()),
+            detray::get_data(const_g.axes())};
+}
+
+}  // namespace detray
diff --git a/core/include/detray/surface_finders/grid/grid_builder.hpp b/core/include/detray/surface_finders/grid/grid_builder.hpp
new file mode 100644
index 0000000000..8939f666d6
--- /dev/null
+++ b/core/include/detray/surface_finders/grid/grid_builder.hpp
@@ -0,0 +1,131 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s).
+#include "detray/definitions/qualifiers.hpp"
+#include "detray/surface_finders/grid/axis.hpp"
+#include "detray/surface_finders/grid/populator.hpp"
+#include "detray/surface_finders/grid/serializer.hpp"
+
+namespace detray {
+
+namespace detail {
+
+/// @brief Helper type to assemble an multi-axis from shapes tuple and binnings
+template <bool is_owning, typename containers, typename local_frame, typename,
+          typename>
+struct multi_axis_assembler;
+
+/// @brief Specialized struct to extract axis shapes from a tuple
+template <bool is_owning, typename containers, typename local_frame,
+          typename... axis_shapes, typename... binning_ts>
+struct multi_axis_assembler<is_owning, containers, local_frame,
+                            dtuple<axis_shapes...>, dtuple<binning_ts...>> {
+
+    static_assert(sizeof...(axis_shapes) == sizeof...(binning_ts),
+                  "Number of axis shapes for this mask and given binning types "
+                  "don't match!");
+
+    using type =
+        n_axis::multi_axis<is_owning, local_frame,
+                           n_axis::single_axis<axis_shapes, binning_ts>...>;
+};
+
+}  // namespace detail
+
+/// Typedef for easier construction from mask shapes
+template <typename shape_t, bool is_owning = true,
+          typename containers = host_container_types,
+          typename algebra_t = __plugin::transform3<detray::scalar>>
+using coordinate_axes = typename detail::multi_axis_assembler<
+    is_owning, containers,
+    typename shape_t::template coordinate_type<algebra_t>,
+    typename shape_t::axes::types,
+    typename shape_t::axes::template binning<
+        containers, typename algebra_t::scalar_type>>::type;
+
+/// A two-dimensional grid for object storage
+///
+/// @tparam populator_t  is a prescription what to do when a bin gets
+/// pupulated, it broadcasts also the value type
+/// @tparam serialzier_t  type of the serializer to the storage represenations
+/*template<typename value_t, typename serializer_t,
+         typename populator_t, typename containers, typename algebra>
+class grid_builder {
+
+    public:
+
+    static constexpr bool is_owning = true;
+    using value_type = value_t;
+    using populator_type = populator_t<value_type>;
+    using serializer_type = serializer_t;
+
+    grid(vecmem::memory_resource &resource) : m_resource(resource) {}
+
+    /// Single grid
+    template <typename mask_t>
+    DETRAY_HOST void grid(bin_data_view_t &&bin_data, ) {
+        using axes_t = coordinate_system<true, containers, algebra, mask_t,
+binning_ts...>;
+
+        axes_t axes = construct_axes<true, mask_t>();
+        using grid_t = grid<value_type, serializer_type, axes_t, true,
+containers, algebra>;
+
+        grid_t grid(m_resource);
+
+        for(auto&& bin : bin_data) {
+            grid.populate(bin.pos(), bin.value());
+        }
+    }
+
+    /// Fill/populate from volume
+    template <typename detector_t, typename volume_t>
+    DETRAY_HOST void grid(const volume_t &vol, const detector_t &det) {
+        for (const auto [sf, sf_idx]: enumerate(vol, det.surfaces())) {
+            ...
+        }
+    }
+
+    /// Fill/populate from surface
+    template <typename detector_t, typename surface_t,
+              template <typename, typename> class... binning_ts>
+    DETRAY_HOST void grid(const surface_t &sf, const detector_t &det) {
+        using mask_t = typename detector_t::mask_defs ...
+        using axes_t = coordinate_system<true, containers, algebra, mask_t,
+binning_ts...>;
+    }
+
+
+    /// add owning grid to detector collection
+    template<template<bool ownership> class grid_t, typename detector_t>
+    DETRAY_HOST
+    void add_to_collection(grid_t<ownership> &&g, detector_t &det) {
+        auto gr_coll = detail::get<grid_t<not is_owning>>(det.grid_store());
+
+        gr_coll.append(std::forward<grid_t<is_owning>>(g));
+    }
+
+    /// @returns access to the serialized data
+    DETRAY_HOST
+    serialized_storage &finalize() { return _serialized_data; }
+
+    /// @returns reference to the serialized data
+    DETRAY_HOST
+    const serialized_storage &tmp_data_store() const {
+        return _serialized_data;
+    }
+
+    private:
+    storage_type m_serialized_data{};
+    populator_type m_populator{};
+    serializer_type m_serializer{};
+};*/
+
+}  // namespace detray
\ No newline at end of file
diff --git a/core/include/detray/surface_finders/grid/populator.hpp b/core/include/detray/surface_finders/grid/populator.hpp
new file mode 100644
index 0000000000..4a53838e5e
--- /dev/null
+++ b/core/include/detray/surface_finders/grid/populator.hpp
@@ -0,0 +1,68 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s).
+#include "detray/definitions/detail/accessor.hpp"
+#include "detray/definitions/indexing.hpp"
+#include "detray/definitions/qualifiers.hpp"
+#include "detray/surface_finders/grid/detail/populator_impl.hpp"
+
+namespace detray {
+
+/// Enforce the populator interface and implement some common functionality
+template <typename populator_impl_t>
+class populator {
+
+    public:
+    // Insert the correct container/algebra types
+    using impl = populator_impl_t;
+
+    template <typename entry_t>
+    using bin_type = typename impl::template bin_type<entry_t>;
+
+    /// Populate bin with a new entry - forwarding
+    ///
+    /// @param storage the global bin storage
+    /// @param gbin the global bin index to be populated
+    /// @param entry the single entry to be added to the bin content
+    template <typename serialized_storage, typename entry_t>
+    DETRAY_HOST_DEVICE void operator()(serialized_storage &storage,
+                                       const dindex gbin,
+                                       entry_t &&entry) const {
+        m_populator_impl(storage, gbin, std::forward<entry_t>(entry));
+
+        if constexpr (impl::do_sort) {
+            detail::sequential_sort(storage[gbin].content().begin(),
+                                    storage[gbin].content().end());
+        }
+    }
+
+    /// Fetch a bin entry from the grid backend storage
+    template <typename serialized_storage>
+    DETRAY_HOST_DEVICE auto view(const serialized_storage &storage,
+                                 const dindex gbin) const {
+        return m_populator_impl.view(storage, gbin);
+    }
+
+    /// @returns a default initialized bin entry
+    template <typename entry_t>
+    DETRAY_HOST_DEVICE static constexpr auto init() {
+        return impl::template init<entry_t>();
+    }
+
+    /// @returns an initialized bin entry with @param entry.
+    template <typename entry_t>
+    DETRAY_HOST_DEVICE static constexpr auto init(entry_t entry) {
+        return impl::init(entry);
+    }
+
+    impl m_populator_impl{};
+};
+
+}  // namespace detray
diff --git a/core/include/detray/surface_finders/grid/serializer.hpp b/core/include/detray/surface_finders/grid/serializer.hpp
new file mode 100644
index 0000000000..d3d5bce7ef
--- /dev/null
+++ b/core/include/detray/surface_finders/grid/serializer.hpp
@@ -0,0 +1,11 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s).
+#include "detray/surface_finders/grid/detail/serializer_impl.hpp"
\ No newline at end of file
diff --git a/core/include/detray/surface_finders/grid2_finder.hpp b/core/include/detray/surface_finders/grid2_finder.hpp
new file mode 100644
index 0000000000..0f39f42e30
--- /dev/null
+++ b/core/include/detray/surface_finders/grid2_finder.hpp
@@ -0,0 +1,41 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2021-2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+#include "detray/grids/axis.hpp"
+#include "detray/grids/grid2.hpp"
+#include "detray/grids/populator.hpp"
+#include "detray/grids/serializer2.hpp"
+
+namespace detray {
+
+template <template <typename...> class vector_t = dvector,
+          template <typename...> class jagged_vector_t = djagged_vector,
+          template <typename, std::size_t> class array_t = darray,
+          template <typename...> class tuple_t = dtuple>
+using regular_circular_grid =
+    grid2<attach_populator, axis::regular, axis::circular, serializer2,
+          vector_t, jagged_vector_t, array_t, tuple_t, dindex, false>;
+
+template <template <typename...> class vector_t = dvector,
+          template <typename...> class jagged_vector_t = djagged_vector,
+          template <typename, std::size_t> class array_t = darray,
+          template <typename...> class tuple_t = dtuple>
+using regular_circular_grid2 =
+    grid2<replace_populator, axis::regular, axis::circular, serializer2,
+          vector_t, jagged_vector_t, array_t, tuple_t, dindex, false>;
+
+template <template <typename...> class vector_t = dvector,
+          template <typename...> class jagged_vector_t = djagged_vector,
+          template <typename, std::size_t> class array_t = darray,
+          template <typename...> class tuple_t = dtuple>
+using regular_regular_grid =
+    grid2<attach_populator, axis::regular, axis::regular, serializer2, vector_t,
+          jagged_vector_t, array_t, tuple_t, dindex, false>;
+
+}  // namespace detray
\ No newline at end of file
diff --git a/core/include/detray/surface_finders/neighborhood_kernel.hpp b/core/include/detray/surface_finders/neighborhood_kernel.hpp
new file mode 100644
index 0000000000..5b11128ec2
--- /dev/null
+++ b/core/include/detray/surface_finders/neighborhood_kernel.hpp
@@ -0,0 +1,37 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/definitions/qualifiers.hpp"
+
+namespace detray {
+
+/// A functor to find surfaces in the neighborhood of a track position
+struct neighborhood_getter {
+
+    using output_type = dindex_range;
+
+    /// Call operator that forwards the neighborhood search call in a volume
+    /// to a surface finder data structure
+    template <typename sf_finder_group_t, typename sf_finder_index_t,
+              typename detector_t, typename track_t>
+    DETRAY_HOST_DEVICE inline output_type operator()(
+        const sf_finder_group_t &group, const sf_finder_index_t index,
+        const detector_t &detector,
+        const typename detector_t::volume_type &volume,
+        const track_t &track) const {
+
+        // Get surface finder for volume and perform the surface neighborhood
+        // lookup
+        const auto &sf_finder = group[index];
+        return sf_finder.search(detector, volume, track);
+    }
+};
+
+}  // namespace detray
\ No newline at end of file
diff --git a/core/include/detray/tools/bin_association.hpp b/core/include/detray/tools/bin_association.hpp
index 6685063a6a..53b55fbed1 100644
--- a/core/include/detray/tools/bin_association.hpp
+++ b/core/include/detray/tools/bin_association.hpp
@@ -18,13 +18,6 @@
 
 namespace detray {
 
-namespace {
-
-using point2 = __plugin::point2<detray::scalar>;
-using point3 = __plugin::point3<detray::scalar>;
-
-}  // namespace
-
 /** Run the bin association of surfaces (via their contour)
  *  - to a given grid.
  *
@@ -44,6 +37,9 @@ static inline void bin_association(const context_t & /*context*/,
                                    const std::array<scalar, 2> &bin_tolerance,
                                    bool absolute_tolerance = true) {
 
+    using point2_t = typename detector_t::point2;
+    using point3_t = typename detector_t::point3;
+
     // Get surfaces, transforms and masks
     const auto &dc = detector.data();
     const auto &surface_masks = detector.mask_store();
@@ -79,31 +75,33 @@ static inline void bin_association(const context_t & /*context*/,
                         : bin_tolerance[1] * (phi_borders[1] - phi_borders[0]);
 
                 // Create a contour for the bin
-                std::vector<point2> bin_contour = r_phi_polygon(
-                    r_borders[0] - r_add, r_borders[1] + r_add,
-                    phi_borders[0] - phi_add, phi_borders[1] + phi_add);
+                std::vector<point2_t> bin_contour =
+                    r_phi_polygon<scalar, point2_t>(
+                        r_borders[0] - r_add, r_borders[1] + r_add,
+                        phi_borders[0] - phi_add, phi_borders[1] + phi_add);
 
                 // Run through the surfaces and associate them by contour
                 for (auto [isf, sf] : enumerate(dc.surfaces, volume)) {
+
+                    // Add only sensitive surfaces to the grid
+                    if (sf.is_portal()) {
+                        continue;
+                    }
+
                     // Unroll the mask container and generate vertices
                     const auto &transform = dc.transforms[sf.transform()];
 
-                    const auto &mask_context = sf.mask_type();
-                    const auto &mask_range = sf.mask_range();
-
-                    auto vertices_per_masks = unroll_masks_for_vertices(
-                        surface_masks, mask_range, mask_context,
-                        std::make_integer_sequence<
-                            dindex, std::tuple_size_v<
-                                        typename detector_t::mask_container::
-                                            container_type>>{});
+                    auto vertices_per_masks =
+                        surface_masks
+                            .template call<vertexer<point2_t, point3_t>>(
+                                sf.mask());
 
                     // Usually one mask per surface, but design allows - a
                     // single association  is sufficient though
                     for (auto &vertices : vertices_per_masks) {
                         if (not vertices.empty()) {
                             // Create a surface contour
-                            std::vector<point2> surface_contour;
+                            std::vector<point2_t> surface_contour;
                             surface_contour.reserve(vertices.size());
                             for (const auto &v : vertices) {
                                 auto vg = transform.point_to_global(v);
@@ -148,42 +146,42 @@ static inline void bin_association(const context_t & /*context*/,
                 scalar phi_min_rep = phi_borders[0];
                 scalar phi_max_rep = phi_borders[1];
 
-                point2 p0_bin = {z_min - z_add, phi_min_rep - phi_add};
-                point2 p1_bin = {z_min - z_add, phi_max_rep + phi_add};
-                point2 p2_bin = {z_max + z_add, phi_max_rep + phi_add};
-                point2 p3_bin = {z_max + z_add, phi_min_rep - phi_add};
+                point2_t p0_bin = {z_min - z_add, phi_min_rep - phi_add};
+                point2_t p1_bin = {z_min - z_add, phi_max_rep + phi_add};
+                point2_t p2_bin = {z_max + z_add, phi_max_rep + phi_add};
+                point2_t p3_bin = {z_max + z_add, phi_min_rep - phi_add};
 
-                std::vector<point2> bin_contour = {p0_bin, p1_bin, p2_bin,
-                                                   p3_bin};
+                std::vector<point2_t> bin_contour = {p0_bin, p1_bin, p2_bin,
+                                                     p3_bin};
 
                 // Loop over the surfaces within a volume
                 for (auto [isf, sf] : enumerate(dc.surfaces, volume)) {
 
+                    // Add only sensitive surfaces to the grid
+                    if (sf.is_portal()) {
+                        continue;
+                    }
+
                     // Unroll the mask container and generate vertices
                     const auto &transform = dc.transforms[sf.transform()];
 
-                    const auto &mask_context = sf.mask_type();
-                    const auto &mask_range = sf.mask_range();
-
-                    auto vertices_per_masks = unroll_masks_for_vertices(
-                        surface_masks, mask_range, mask_context,
-                        std::make_integer_sequence<
-                            dindex, std::tuple_size_v<
-                                        typename detector_t::mask_container::
-                                            container_type>>{});
+                    auto vertices_per_masks =
+                        surface_masks
+                            .template call<vertexer<point2_t, point3_t>>(
+                                sf.mask());
 
                     for (auto &vertices : vertices_per_masks) {
 
                         if (not vertices.empty()) {
                             // Create a surface contour
-                            std::vector<point2> surface_contour;
+                            std::vector<point2_t> surface_contour;
                             surface_contour.reserve(vertices.size());
                             scalar phi_min = std::numeric_limits<scalar>::max();
                             scalar phi_max =
                                 -std::numeric_limits<scalar>::max();
                             // We poentially need the split vertices
-                            std::vector<point2> s_c_neg;
-                            std::vector<point2> s_c_pos;
+                            std::vector<point2_t> s_c_neg;
+                            std::vector<point2_t> s_c_pos;
                             scalar z_min_neg =
                                 std::numeric_limits<scalar>::max();
                             scalar z_max_neg =
@@ -194,7 +192,8 @@ static inline void bin_association(const context_t & /*context*/,
                                 -std::numeric_limits<scalar>::max();
 
                             for (const auto &v : vertices) {
-                                const point3 vg = transform.point_to_global(v);
+                                const point3_t vg =
+                                    transform.point_to_global(v);
                                 scalar phi = std::atan2(vg[1], vg[0]);
                                 phi_min = std::min(phi, phi_min);
                                 phi_max = std::max(phi, phi_max);
@@ -210,7 +209,7 @@ static inline void bin_association(const context_t & /*context*/,
                                 }
                             }
                             // Check for phi wrapping
-                            std::vector<std::vector<point2>> surface_contours;
+                            std::vector<std::vector<point2_t>> surface_contours;
                             if (phi_max - phi_min > M_PI and
                                 phi_max * phi_min < 0.) {
                                 s_c_neg.push_back({z_max_neg, -M_PI});
diff --git a/core/include/detray/tools/generators.hpp b/core/include/detray/tools/generators.hpp
index 0288a0a519..c6b1f20662 100644
--- a/core/include/detray/tools/generators.hpp
+++ b/core/include/detray/tools/generators.hpp
@@ -11,15 +11,6 @@
 
 namespace detray {
 
-namespace {
-
-using transform3 = __plugin::transform3<detray::scalar>;
-using point2 = __plugin::point2<detray::scalar>;
-using point3 = __plugin::point3<detray::scalar>;
-using vector3 = __plugin::vector3<detray::scalar>;
-
-}  // anonymous namespace
-
 /** Generate phi values
  *
  * @param start_phi is the start for the arc generation
@@ -28,16 +19,18 @@ using vector3 = __plugin::vector3<detray::scalar>;
  *
  * @return a vector of phi values for the arc
  */
-static inline dvector<scalar> phi_values(scalar start_phi, scalar end_phi,
-                                         unsigned int lseg) {
-    dvector<scalar> values;
+template <typename scalar_t>
+static inline dvector<scalar_t> phi_values(scalar_t start_phi, scalar_t end_phi,
+                                           unsigned int lseg) {
+    dvector<scalar_t> values;
     values.reserve(lseg + 1);
-    scalar step_phi = (end_phi - start_phi) / lseg;
+    scalar_t step_phi = (end_phi - start_phi) / lseg;
     for (unsigned int istep = 0; istep <= lseg; ++istep) {
         values.push_back(start_phi + istep * step_phi);
     }
     return values;
 }
+
 /** Generate vertices, specialized for masks: annulus2
  *
  * @note template types are simply forwarded to mask
@@ -47,26 +40,28 @@ static inline dvector<scalar> phi_values(scalar start_phi, scalar end_phi,
  *
  * @return a generated list of vertices
  */
-template <typename transform3_t, template <class> typename intersector_t,
-          template <class> typename local_t, typename links_t>
-dvector<point3> vertices(
-    const annulus2<transform3_t, intersector_t, local_t, links_t> &annulus_mask,
+template <typename point2_t, typename point3_t, typename links_t,
+          typename transform3_t>
+dvector<point3_t> vertices(
+    const mask<annulus2D<>, links_t, transform3_t> &annulus_mask,
     unsigned int lseg) {
+    using scalar_t = typename transform3_t::scalar_type;
 
     const auto &m_values = annulus_mask.values();
 
-    scalar min_r = m_values[0];
-    scalar max_r = m_values[1];
-    scalar min_phi_rel = m_values[2];
-    scalar max_phi_rel = m_values[3];
-    // scalar avg_phi = m_values[4];
-    scalar origin_x = m_values[5];
-    scalar origin_y = m_values[6];
+    scalar_t min_r = m_values[0];
+    scalar_t max_r = m_values[1];
+    scalar_t min_phi_rel = m_values[2];
+    scalar_t max_phi_rel = m_values[3];
+    // scalar_t avg_phi = m_values[4];
+    scalar_t origin_x = m_values[5];
+    scalar_t origin_y = m_values[6];
 
-    point2 origin_m = {origin_x, origin_y};
+    point2_t origin_m = {origin_x, origin_y};
 
     /// Helper method: find inner outer radius at edges in STRIP PC
-    auto circIx = [](scalar O_x, scalar O_y, scalar r, scalar phi) -> point2 {
+    auto circIx = [](scalar_t O_x, scalar_t O_y, scalar_t r,
+                     scalar_t phi) -> point2_t {
         //                      _____________________________________________
         //                     /      2  2                    2    2  2    2
         //     O_x + O_y*m - \/  - O_x *m  + 2*O_x*O_y*m - O_y  + m *r  + r
@@ -76,50 +71,50 @@ dvector<point3> vertices(
         //
         // y = m*x
         //
-        scalar m = std::tan(phi);
-        point2 dir = {std::cos(phi), std::sin(phi)};
-        scalar x1 =
+        scalar_t m = std::tan(phi);
+        point2_t dir = {std::cos(phi), std::sin(phi)};
+        scalar_t x1 =
             (O_x + O_y * m -
              std::sqrt(-std::pow(O_x, 2) * std::pow(m, 2) + 2 * O_x * O_y * m -
                        std::pow(O_y, 2) + std::pow(m, 2) * std::pow(r, 2) +
                        std::pow(r, 2))) /
             (std::pow(m, 2) + 1);
-        scalar x2 =
+        scalar_t x2 =
             (O_x + O_y * m +
              std::sqrt(-std::pow(O_x, 2) * std::pow(m, 2) + 2 * O_x * O_y * m -
                        std::pow(O_y, 2) + std::pow(m, 2) * std::pow(r, 2) +
                        std::pow(r, 2))) /
             (std::pow(m, 2) + 1);
 
-        point2 v1 = {x1, m * x1};
+        point2_t v1 = {x1, m * x1};
         if (vector::dot(v1, dir) > 0)
             return v1;
         return {x2, m * x2};
     };
 
     // calculate corners in STRIP XY, keep them we need them for minDistance()
-    point2 ul_xy = circIx(origin_x, origin_y, max_r, max_phi_rel);
-    point2 ll_xy = circIx(origin_x, origin_y, min_r, max_phi_rel);
-    point2 ur_xy = circIx(origin_x, origin_y, max_r, min_phi_rel);
-    point2 lr_xy = circIx(origin_x, origin_y, min_r, min_phi_rel);
+    point2_t ul_xy = circIx(origin_x, origin_y, max_r, max_phi_rel);
+    point2_t ll_xy = circIx(origin_x, origin_y, min_r, max_phi_rel);
+    point2_t ur_xy = circIx(origin_x, origin_y, max_r, min_phi_rel);
+    point2_t lr_xy = circIx(origin_x, origin_y, min_r, min_phi_rel);
 
     auto inner_phi = phi_values(getter::phi(ll_xy - origin_m),
                                 getter::phi(lr_xy - origin_m), lseg);
     auto outer_phi = phi_values(getter::phi(ur_xy - origin_m),
                                 getter::phi(ul_xy - origin_m), lseg);
 
-    dvector<point3> annulus_vertices;
+    dvector<point3_t> annulus_vertices;
     annulus_vertices.reserve(inner_phi.size() + outer_phi.size());
     for (auto iphi : inner_phi) {
-        annulus_vertices.push_back(point3{min_r * std::cos(iphi) + origin_x,
-                                          min_r * std::sin(iphi) + origin_y,
-                                          0.});
+        annulus_vertices.push_back(point3_t{min_r * std::cos(iphi) + origin_x,
+                                            min_r * std::sin(iphi) + origin_y,
+                                            0.});
     }
 
     for (auto ophi : outer_phi) {
-        annulus_vertices.push_back(point3{max_r * std::cos(ophi) + origin_x,
-                                          max_r * std::sin(ophi) + origin_y,
-                                          0.});
+        annulus_vertices.push_back(point3_t{max_r * std::cos(ophi) + origin_x,
+                                            max_r * std::sin(ophi) + origin_y,
+                                            0.});
     }
 
     return annulus_vertices;
@@ -134,11 +129,11 @@ dvector<point3> vertices(
  *
  * @return a generated list of vertices
  */
-template <bool kRadialCheck, typename transform3_t,
-          template <class> typename intersector_t,
-          template <class> typename local_t, typename links_t>
-dvector<point3> vertices(
-    const cylinder3<transform3_t, intersector_t, local_t, links_t, kRadialCheck>
+template <typename point2_t, typename point3_t, bool kRadialCheck,
+          template <class> typename intersector_t, typename links_t,
+          typename transform3_t>
+dvector<point3_t> vertices(
+    const mask<cylinder2D<kRadialCheck, intersector_t>, links_t, transform3_t>
         & /*cylinder_mask*/,
     unsigned int /*lseg*/) {
 
@@ -154,20 +149,20 @@ dvector<point3> vertices(
  *
  * @return a generated list of vertices
  */
-template <typename transform3_t, template <class> typename intersector_t,
-          template <class> typename local_t, typename links_t>
-dvector<point3> vertices(const rectangle2<transform3_t, intersector_t, local_t,
-                                          links_t> &rectangle_mask,
-                         unsigned int /*ignored*/) {
+template <typename point2_t, typename point3_t, typename links_t,
+          typename transform3_t>
+dvector<point3_t> vertices(
+    const mask<rectangle2D<>, links_t, transform3_t> &rectangle_mask,
+    unsigned int /*ignored*/) {
     const auto &m_values = rectangle_mask.values();
     // left hand lower corner
-    point3 lh_lc = {-m_values[0], -m_values[1], 0.};
+    point3_t lh_lc = {-m_values[0], -m_values[1], 0.};
     // right hand lower corner
-    point3 rh_lc = {m_values[0], -m_values[1], 0.};
+    point3_t rh_lc = {m_values[0], -m_values[1], 0.};
     // right hand upper corner
-    point3 rh_uc = {m_values[0], m_values[1], 0.};
+    point3_t rh_uc = {m_values[0], m_values[1], 0.};
     // left hand upper corner
-    point3 lh_uc = {-m_values[0], m_values[1], 0.};
+    point3_t lh_uc = {-m_values[0], m_values[1], 0.};
     return {lh_lc, rh_lc, rh_uc, lh_uc};
     // Return the confining vertices
 }
@@ -181,10 +176,10 @@ dvector<point3> vertices(const rectangle2<transform3_t, intersector_t, local_t,
  *
  * @return a generated list of vertices
  */
-template <typename transform3_t, template <class> typename intersector_t,
-          template <class> typename local_t, typename links_t>
-dvector<point3> vertices(
-    const ring2<transform3_t, intersector_t, local_t, links_t> & /*ring_mask*/,
+template <typename point2_t, typename point3_t, typename links_t,
+          typename transform3_t>
+dvector<point3_t> vertices(
+    const mask<ring2D<>, links_t, transform3_t> & /*ring_mask*/,
     unsigned int /*lseg*/) {
     return {};
 }
@@ -198,111 +193,52 @@ dvector<point3> vertices(
  *
  * @return a generated list of vertices
  */
-template <typename transform3_t, template <class> typename intersector_t,
-          template <class> typename local_t, typename links_t>
-dvector<point3> vertices(const trapezoid2<transform3_t, intersector_t, local_t,
-                                          links_t> &trapezoid_mask,
-                         unsigned int /* ignored */) {
+template <typename point2_t, typename point3_t, typename links_t,
+          typename transform3_t>
+dvector<point3_t> vertices(
+    const mask<trapezoid2D<>, links_t, transform3_t> &trapezoid_mask,
+    unsigned int /* ignored */) {
 
     const auto &m_values = trapezoid_mask.values();
     // left hand lower corner
-    point3 lh_lc = {-m_values[0], -m_values[2], 0.};
+    point3_t lh_lc = {-m_values[0], -m_values[2], 0.};
     // right hand lower corner
-    point3 rh_lc = {m_values[0], -m_values[2], 0.};
+    point3_t rh_lc = {m_values[0], -m_values[2], 0.};
     // right hand upper corner
-    point3 rh_uc = {m_values[1], m_values[2], 0.};
+    point3_t rh_uc = {m_values[1], m_values[2], 0.};
     // left hand upper corner
-    point3 lh_uc = {-m_values[1], m_values[2], 0.};
+    point3_t lh_uc = {-m_values[1], m_values[2], 0.};
     // Return the confining vertices
     return {lh_lc, rh_lc, rh_uc, lh_uc};
 }
 
-/** Specialized method to generate vertices per maks group
- *
- * @tparam mask_group_t is the type of the split out mask group from all masks
- * @tparam mask_range_t is the type of the according mask range object
- *
- * @param masks is the associated (and split out) mask group
- * @param range is the range list of masks to be processed
- *
- * @return a jagged vector of points of the mask vertices (one per maks)
- **/
-template <typename mask_group_t, typename mask_range_t>
-auto vertices_for_mask_group(const mask_group_t &masks,
-                             const mask_range_t &range, dindex n_segments = 1) {
-    dvector<dvector<point3>> mask_vertices = {};
-    for (auto i : sequence(range)) {
-        const auto &mask = masks[i];
-        mask_vertices.push_back(vertices(mask, n_segments));
-    }
-    return mask_vertices;
-}
-
-/** Variadic unrolled intersection - last entry
- *
- * @tparam mask_container_t is the type of the type of the mask container
- * @tparam mask_range_t is the mask range type
- * @tparam last_mask_id is the last mask group id
- *
- * @param masks the masks container
- * @param range the range within the mask group to be checked
- * @param mask_id the last mask group id
- *
- * @return a jagged vector of points of the mask vertices (one per maks)
- **/
-template <typename mask_container_t, typename mask_range_t, dindex last_mask_id>
-auto vertices_for_last_mask_group(const mask_container_t &masks,
-                                  const mask_range_t &range, dindex mask_id) {
-    dvector<dvector<point3>> mask_vertices = {};
-    if (mask_id == last_mask_id) {
-        mask_vertices = vertices_for_mask_group(
-            masks.template group<mask_container_t::to_id(last_mask_id)>(),
-            range);
-    }
-    return mask_vertices;
-}
-
-/** Variadic unrolled intersection - any integer sequence
- *
- * @tparam mask_container_t is the type of the type of the mask container
- * @tparam mask_range_t is the mask range type
- * @tparam first_mask_id is the first mask group id
- *
- * @param masks the masks container
- * @param range the range within the mask group to be checked
- * @param mask_id the last mask group id
- * @param available_ids the mask contices to be checked
- *
- * @return a jagged vector of points of the mask vertices (one per maks)
- **/
-template <typename mask_container_t, typename mask_range_t,
-          dindex first_mask_id, dindex... remaining_mask_ids>
-auto unroll_masks_for_vertices(
-    const mask_container_t &masks, const mask_range_t &range, dindex mask_id,
-    std::integer_sequence<dindex, first_mask_id, remaining_mask_ids...>
-    /*available_ids*/) {
-    // Pick the first one for interseciton
-    if (mask_id == first_mask_id) {
-        return vertices_for_mask_group(
-            masks.template group<mask_container_t::to_id(first_mask_id)>(),
-            range);
-    }
-    // The reduced integer sequence
-    std::integer_sequence<dindex, remaining_mask_ids...> remaining;
-    // Unroll as long as you have at least 2 entries
-    if constexpr (remaining.size() > 1) {
-        auto mask_vertices =
-            unroll_masks_for_vertices(masks, range, mask_id, remaining);
-        if (not mask_vertices.empty()) {
-            return mask_vertices;
+/// Functor to produce vertices on a mask collection in a mask tuple container.
+template <typename point2_t, typename point3_t>
+struct vertexer {
+
+    using output_type = dvector<dvector<point3_t>>;
+
+    /// Specialized method to generate vertices per maks group
+    ///
+    /// @tparam mask_group_t is the type of the mask collection in a mask cont.
+    /// @tparam mask_range_t is the type of the according mask range object
+    ///
+    /// @param masks is the associated (and split out) mask group
+    /// @param range is the range list of masks to be processed
+    ///
+    /// @return a jagged vector of points of the mask vertices (one per maks)
+    template <typename mask_group_t, typename mask_range_t>
+    output_type operator()(const mask_group_t &masks, const mask_range_t &range,
+                           dindex n_segments = 1) {
+        output_type mask_vertices = {};
+        for (auto i : sequence(range)) {
+            const auto &mask = masks[i];
+            mask_vertices.push_back(
+                vertices<point2_t, point3_t>(mask, n_segments));
         }
+        return mask_vertices;
     }
-    // Last chance - intersect the last index if possible
-    return vertices_for_last_mask_group<
-        mask_container_t, mask_range_t,
-        std::tuple_size_v<typename mask_container_t::container_type> - 1>(
-        masks, range, mask_id);
-}
+};
 
 /** Create a r-phi polygon from principle parameters
  *
@@ -313,16 +249,18 @@ auto unroll_masks_for_vertices(
  *
  * @return a polygon representation of the bin
  **/
-std::vector<point2> r_phi_polygon(scalar rmin, scalar rmax, scalar phimin,
-                                  scalar phimax, unsigned int nsegments = 1) {
+template <typename scalar_t, typename point2_t>
+std::vector<point2_t> r_phi_polygon(scalar_t rmin, scalar_t rmax,
+                                    scalar_t phimin, scalar_t phimax,
+                                    unsigned int nsegments = 1) {
 
-    std::vector<point2> r_phi_poly;
+    std::vector<point2_t> r_phi_poly;
     r_phi_poly.reserve(2 * nsegments + 2);
 
-    scalar cos_min_phi = std::cos(phimin);
-    scalar sin_min_phi = std::sin(phimin);
-    scalar cos_max_phi = std::cos(phimax);
-    scalar sin_max_phi = std::sin(phimax);
+    scalar_t cos_min_phi = std::cos(phimin);
+    scalar_t sin_min_phi = std::sin(phimin);
+    scalar_t cos_max_phi = std::cos(phimax);
+    scalar_t sin_max_phi = std::sin(phimax);
 
     // @TODO add phi generators
     r_phi_poly.push_back({rmin * cos_min_phi, rmin * sin_min_phi});
@@ -333,4 +271,4 @@ std::vector<point2> r_phi_polygon(scalar rmin, scalar rmax, scalar phimin,
     return r_phi_poly;
 }
 
-}  // namespace detray
+}  // namespace detray
\ No newline at end of file
diff --git a/core/include/detray/utils/enumerate.hpp b/core/include/detray/utils/enumerate.hpp
index 38f6b6d93f..1f1a0a2b17 100644
--- a/core/include/detray/utils/enumerate.hpp
+++ b/core/include/detray/utils/enumerate.hpp
@@ -6,6 +6,7 @@
  */
 #pragma once
 
+#include <iterator>
 #include <tuple>
 #include <type_traits>
 
@@ -15,6 +16,59 @@
 
 namespace detray {
 
+/// @brief Iterator-like access to a single value instead of a collection
+template <typename value_t>
+struct single_iterator {
+    using container_type_iter = value_t *;
+
+    /// Delete default constructor
+    single_iterator() = delete;
+
+    /// Construct iterator pointing to a @param value.
+    DETRAY_HOST_DEVICE single_iterator(value_t &value) : m_value(&value) {}
+
+    /// @returns start position, which is at the wrapped value.
+    DETRAY_HOST_DEVICE
+    inline auto begin() -> value_t * { return m_value; }
+
+    /// @returns end position, which is the position behind the wrapped value.
+    DETRAY_HOST_DEVICE
+    inline auto end() -> const value_t * {
+        return m_value + static_cast<std::ptrdiff_t>(1);
+    }
+
+    /// @returns true if it points to the same address.
+    DETRAY_HOST_DEVICE
+    bool operator!=(const single_iterator &rhs) {
+        return m_value != rhs.m_value;
+    }
+
+    /// Does nothing
+    DETRAY_HOST_DEVICE
+    inline constexpr auto operator++() -> void {}
+
+    /// @returns the single value that the iterator points to
+    DETRAY_HOST_DEVICE
+    inline constexpr auto operator*() const -> const value_t {
+        return *m_value;
+    }
+
+    /// @return element at position i, relative to iterator range. */
+    DETRAY_HOST_DEVICE
+    inline constexpr auto operator[](const dindex /*i*/) -> value_t {
+        return *m_value;
+    }
+
+    /// @return element at position i, relative to iterator range - const
+    DETRAY_HOST_DEVICE
+    inline constexpr auto operator[](const dindex /*i*/) const
+        -> const value_t & {
+        return *m_value;
+    }
+
+    value_t *m_value;
+};
+
 /** @brief Struct that implements a range by providing start and end iterators.
  *
  * @tparam container_t the container on which to perform the iteration
@@ -25,35 +79,73 @@ template <typename container_t>
 struct iterator_range {
     using container_type_iter =
         decltype(std::begin(std::declval<container_t>()));
+    using difference_type =
+        typename std::iterator_traits<container_type_iter>::difference_type;
 
     /** Delete default constructor */
     iterator_range() = delete;
 
-    /** Always construct from a container and a range
+    /** Construct from a container -> iterates the entire range
+     *
+     * @param iterable container to iterate over
+     * @param range start and end position for iteration
+     */
+    DETRAY_HOST_DEVICE iterator_range(container_t &iterable)
+        : _start(std::begin(iterable)), _end(std::end(iterable)) {}
+
+    /** Construct from a container and a range
      *
      * @param iterable container to iterate over
      * @param range start and end position for iteration
      */
     template <typename range_t>
-    DETRAY_HOST_DEVICE iterator_range(const container_t &iterable,
+    DETRAY_HOST_DEVICE iterator_range(container_t &iterable,
                                       const range_t &range)
-        : _start(std::begin(iterable) + detail::get<0>(range)),
-          _end(std::begin(iterable) + detail::get<1>(range)) {}
+        : _start(std::begin(iterable) +
+                 static_cast<difference_type>(detail::get<0>(range))),
+          _end(std::begin(iterable) +
+               static_cast<difference_type>(detail::get<1>(range))) {
+        // Observe end of the iterable
+        // const auto& const_itr = const_cast<const container_t&>(iterable);
+        /*if (std::distance(_end, std::end(const_cast<const
+        container_t&>(iterable))) <= 0) { _end = std::end(iterable);
+        }*/
+    }
+
+    /** @return start position of range on container. */
+    DETRAY_HOST_DEVICE
+    inline const auto &begin() const { return _start; }
 
     /** @return start position of range on container. */
     DETRAY_HOST_DEVICE
     inline auto &begin() { return _start; }
 
+    /** @return start position of range on container. */
+    DETRAY_HOST_DEVICE
+    inline const auto &end() const { return _end; }
+
     /** @return end position of range on container. */
     DETRAY_HOST_DEVICE
     inline auto &end() { return _end; }
 
+    /** @return end position of range on container. */
+    DETRAY_HOST_DEVICE
+    inline auto size() const { return _end - _start; }
+
     /** Does this describe the same range? */
     DETRAY_HOST_DEVICE
-    bool operator!=(const iterator_range &rhs) {
+    bool operator!=(iterator_range &rhs) const {
         return _start != rhs._start or _end != rhs._end;
     }
 
+    /** @return element at position i, relative to iterator range. */
+    DETRAY_HOST_DEVICE
+    inline auto operator*() { return *_start; }
+
+    /** @return element at position i, relative to iterator range. */
+    DETRAY_HOST_DEVICE
+    inline const auto &operator*() const { return *_start; }
+
     /** @return element at position i, relative to iterator range. */
     DETRAY_HOST_DEVICE
     inline auto &operator[](const dindex i) { return *(_start + i); }
@@ -66,7 +158,7 @@ struct iterator_range {
 
     /** @return the offset of the range start into the container. */
     DETRAY_HOST_DEVICE
-    inline auto offset(const container_t &iterable) {
+    inline auto offset(container_t &iterable) const -> difference_type {
         return std::distance(_start, std::begin(iterable));
     }
 
@@ -74,6 +166,9 @@ struct iterator_range {
     container_type_iter _start, _end;
 };
 
+template <typename container_t>
+using standard_iterator = iterator_range<container_t>;
+
 /** @brief Struct that increments a given iterator in lockstep with the
  *        iteration index for convenience.
  *
@@ -202,17 +297,17 @@ DETRAY_HOST_DEVICE constexpr inline auto enumerate(const container_t &iterable,
 
     struct iterable_wrapper {
         const container_type_iter iter;
-        iterator_range<container_t> range_iter;
+        iterator_range<const container_t> range_iter;
 
         DETRAY_HOST_DEVICE
         decltype(auto) begin() {
-            return enumerator<container_t>(
+            return enumerator<const container_t>(
                 static_cast<size_t>(std::distance(iter, range_iter.begin())),
                 range_iter.begin());
         }
         DETRAY_HOST_DEVICE
         decltype(auto) end() {
-            return enumerator<container_t>(
+            return enumerator<const container_t>(
                 static_cast<size_t>(std::distance(iter, range_iter.begin())),
                 range_iter.end());
         }
@@ -320,4 +415,4 @@ DETRAY_HOST_DEVICE constexpr auto sequence(range_t range) {
     return iterable_wrapper{std::forward<range_t>(range)};
 }
 
-}  // namespace detray
+}  // namespace detray
\ No newline at end of file
diff --git a/core/include/detray/utils/invalid_values.hpp b/core/include/detray/utils/invalid_values.hpp
index 846d85a03e..04fa39b18f 100644
--- a/core/include/detray/utils/invalid_values.hpp
+++ b/core/include/detray/utils/invalid_values.hpp
@@ -1,39 +1,32 @@
 /** Detray library, part of the ACTS project (R&D line)
  *
- * (c) 2020 CERN for the benefit of the ACTS project
+ * (c) 2020-2022 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
 
 #pragma once
 
+// System include(s)
 #include <limits>
+#include <type_traits>
 
-#include "detray/definitions/qualifiers.hpp"
+namespace detray::detail {
 
-namespace detray {
-
-template <typename T>
-DETRAY_HOST_DEVICE inline T invalid_value() {
-    return T::invalid_value();
-}
-
-// specialization for int
-template <>
-DETRAY_HOST_DEVICE inline int invalid_value() {
-    return std::numeric_limits<int>::max();
+/// Invalid value for fundamental types - constexpr
+template <typename T,
+          typename std::enable_if_t<std::is_fundamental_v<T>, bool> = true>
+DETRAY_HOST_DEVICE inline constexpr T invalid_value() {
+    return std::numeric_limits<T>::max();
 }
 
-// specialization for unsigned int
-template <>
-DETRAY_HOST_DEVICE inline unsigned int invalid_value() {
-    return std::numeric_limits<unsigned int>::max();
-}
-
-// specialization for long unsigned int
-template <>
-DETRAY_HOST_DEVICE inline long unsigned int invalid_value() {
-    return std::numeric_limits<long unsigned int>::max();
+/// Invalid value for types that cannot be constructed constexpr, e.g. Eigen
+template <typename T,
+          typename std::enable_if_t<not std::is_fundamental_v<T> and
+                                        std::is_default_constructible_v<T>,
+                                    bool> = true>
+DETRAY_HOST_DEVICE inline T invalid_value() {
+    return T{};
 }
 
-}  // namespace detray
\ No newline at end of file
+}  // namespace detray::detail
\ No newline at end of file
diff --git a/core/include/detray/utils/type_traits.hpp b/core/include/detray/utils/type_traits.hpp
index 588a88cdbc..8a510f0185 100644
--- a/core/include/detray/utils/type_traits.hpp
+++ b/core/include/detray/utils/type_traits.hpp
@@ -7,7 +7,7 @@
 
 #pragma once
 
-namespace detray::details {
+namespace detray::detail {
 
 /// Helper trait for detecting when a type is a non-const version of another
 ///
@@ -24,4 +24,4 @@ struct is_same_nc<const TYPE, TYPE> {
     static constexpr bool value = true;
 };
 
-}  // namespace detray::details
+}  // namespace detray::detail
diff --git a/io/csv/include/detray/io/csv_io.hpp b/io/csv/include/detray/io/csv_io.hpp
index 42b532961a..e3b176804a 100644
--- a/io/csv/include/detray/io/csv_io.hpp
+++ b/io/csv/include/detray/io/csv_io.hpp
@@ -11,10 +11,9 @@
 #include "detray/core/detector.hpp"
 #include "detray/geometry/volume_connector.hpp"
 #include "detray/grids/axis.hpp"
-#include "detray/grids/grid2.hpp"
-#include "detray/grids/populator.hpp"
-#include "detray/grids/serializer2.hpp"
 #include "detray/io/csv_io_types.hpp"
+#include "detray/surface_finders/brute_force_finder.hpp"
+#include "detray/surface_finders/grid2_finder.hpp"
 #include "detray/tools/bin_association.hpp"
 
 // Vecmem include(s)
@@ -27,6 +26,58 @@
 
 namespace detray {
 
+namespace {
+
+/// Functor that writes grid entries from the surface finder
+/// container to file
+struct grid_writer {
+    using output_type = bool;
+
+    template <
+        typename grid_group_t, typename grid_index_t, typename grid_entry_t,
+        typename writer_t,
+        std::enable_if_t<not std::is_same_v<typename grid_group_t::value_type,
+                                            brute_force_finder>,
+                         bool> = true>
+    inline output_type operator()(const grid_group_t &grid_group,
+                                  const grid_index_t &grid_idx,
+                                  grid_entry_t &csv_ge,
+                                  writer_t &sge_writer) const {
+
+        const auto &grid = grid_group.at(grid_idx);
+
+        size_t nbins0 = grid.axis_p0().bins();
+        size_t nbins1 = grid.axis_p1().bins();
+        for (size_t b0 = 0; b0 < nbins0; ++b0) {
+            for (size_t b1 = 0; b1 < nbins1; ++b1) {
+                csv_ge.detray_bin0 = b0;
+                csv_ge.detray_bin1 = b1;
+                for (auto e : grid.bin(b0, b1)) {
+                    csv_ge.detray_entry = e;
+                    sge_writer.append(csv_ge);
+                }
+            }
+        }
+
+        return true;
+    }
+
+    /// Call for the brute force type (do nothing)
+    template <typename grid_group_t, typename grid_index_t,
+              typename grid_entry_t, typename writer_t,
+              std::enable_if_t<std::is_same_v<typename grid_group_t::value_type,
+                                              brute_force_finder>,
+                               bool> = true>
+    inline output_type operator()(const grid_group_t & /*grid_group*/,
+                                  const grid_index_t & /*grid_idx*/,
+                                  const grid_entry_t & /*csv_ge*/,
+                                  writer_t & /*sge_writer*/) {
+        return true;
+    }
+};
+
+}  // anonymous namespace
+
 /// Function to read the detector from the CSV file
 ///
 /// @tparam array_type is the type of the array used for the detector class
@@ -67,6 +118,7 @@ detector_from_csv(const std::string &detector_name,
     using alignable_store = static_transform_store<vector_type>;
     using detector_t = detector<detector_registry, array_type, tuple_type,
                                 vector_type, jagged_vector_type>;
+    using vector3_t = typename detector_t::vector3;
 
     name_map[0] = detector_name;
     detector_t d(resource);
@@ -228,81 +280,8 @@ detector_from_csv(const std::string &detector_name,
         return {_r_min, _r_max, _z_min, _z_max, _phi_min, _phi_max};
     };
 
-    // Create the surface finders & reserve
-    std::map<volume_layer_index, dindex> surface_finder_entries;
-
-    using surfaces_finder = typename detector_t::surfaces_finder_type;
-    using surfaces_regular_circular_grid =
-        typename surfaces_finder::surfaces_regular_circular_grid;
-
-    using surfaces_r_axis =
-        typename surfaces_regular_circular_grid::axis_p0_type;
-    using surfaces_z_axis =
-        typename surfaces_regular_circular_grid::axis_p0_type;
-    using surfaces_phi_axis =
-        typename surfaces_regular_circular_grid::axis_p1_type;
-
-    using surfaces_r_phi_grid = surfaces_regular_circular_grid;
-    using surfaces_z_phi_grid = surfaces_regular_circular_grid;
-
-    surfaces_finder &detector_surfaces_finders = d.get_surfaces_finder();
-
-    // (B) Pre-read the grids & create local object finders
-    int sg_counts = 0;
-
-    while (sg_reader.read(io_surface_grid)) {
-        assert(sg_counts <
-               static_cast<int>(detector_t::surfaces_finder_type::N_GRIDS));
-
-        volume_layer_index c_index = {io_surface_grid.volume_id,
-                                      io_surface_grid.layer_id};
-
-        surface_finder_entries[c_index] = detector_surfaces_finders.size();
-
-        bool is_disk = (io_surface_grid.type_loc0 == 3);
-
-        // Prepare z axis parameters
-        scalar _z_min = is_disk ? std::numeric_limits<scalar>::min()
-                                : io_surface_grid.min_loc1;
-        scalar _z_max = is_disk ? std::numeric_limits<scalar>::max()
-                                : io_surface_grid.max_loc1;
-        dindex _z_bins =
-            is_disk ? 1u : static_cast<dindex>(io_surface_grid.nbins_loc1);
-
-        // Prepare r axis parameters
-        scalar _r_min = is_disk ? io_surface_grid.min_loc0 : 0.;
-        scalar _r_max = is_disk ? io_surface_grid.max_loc0
-                                : std::numeric_limits<scalar>::max();
-        dindex _r_bins =
-            is_disk ? static_cast<dindex>(io_surface_grid.nbins_loc0) : 1u;
-
-        // Prepare phi axis parameters
-        scalar _phi_min =
-            is_disk ? io_surface_grid.min_loc1 : io_surface_grid.min_loc0;
-        scalar _phi_max =
-            is_disk ? io_surface_grid.max_loc1 : io_surface_grid.max_loc0;
-        dindex _phi_bins =
-            is_disk ? static_cast<dindex>(io_surface_grid.nbins_loc1)
-                    : static_cast<dindex>(io_surface_grid.nbins_loc0);
-
-        surfaces_z_axis z_axis{_z_bins, _z_min, _z_max, resource};
-        surfaces_r_axis r_axis{_r_bins, _r_min, _r_max, resource};
-        surfaces_phi_axis phi_axis{_phi_bins, _phi_min, _phi_max, resource};
-
-        // negative / positive / inner / outer
-        surfaces_r_phi_grid rphi_grid_n(r_axis, phi_axis, resource);
-        surfaces_r_phi_grid rphi_grid_p(r_axis, phi_axis, resource);
-        surfaces_z_phi_grid zphi_grid_i{z_axis, phi_axis, resource};
-        surfaces_z_phi_grid zphi_grid_o{z_axis, phi_axis, resource};
-
-        detector_surfaces_finders[sg_counts++] = std::move(rphi_grid_n);
-        detector_surfaces_finders[sg_counts++] = std::move(rphi_grid_p);
-        detector_surfaces_finders[sg_counts++] = std::move(zphi_grid_i);
-        detector_surfaces_finders[sg_counts++] = std::move(zphi_grid_o);
-    }
-
     using mask_defs = typename detector_t::masks;
-    typename detector_t::surface_type::edge_type mask_edge{};
+    typename detector_t::surface_type::volume_link_type mask_volume_link{};
     typename mask_defs::link_type mask_index{};
     constexpr auto cylinder_id = mask_defs::id::e_cylinder3;
     constexpr auto rectangle_id = mask_defs::id::e_rectangle2;
@@ -347,21 +326,13 @@ detector_from_csv(const std::string &detector_name,
             auto _volume_bounds =
                 synchronize_bounds(unsynchronized_volume_bounds, is_gap);
 
-            // Check if this volume has a surface finder entry associated
-            dindex surfaces_finder_entry = dindex_invalid;
-            auto surface_finder_itr = surface_finder_entries.find(c_index);
-            if (surface_finder_itr != surface_finder_entries.end()) {
-                surfaces_finder_entry = surface_finder_itr->second;
-            }
-
             std::string volume_name = detector_name;
             volume_name +=
                 std::string("_vol_") + std::to_string(io_surface.volume_id);
             volume_name +=
                 std::string("_lay_") + std::to_string(io_surface.layer_id);
 
-            auto &new_volume =
-                d.new_volume(_volume_bounds, surfaces_finder_entry);
+            auto &new_volume = d.new_volume(_volume_bounds);
 
             name_map[new_volume.index() + 1] = volume_name;
 
@@ -388,9 +359,11 @@ detector_from_csv(const std::string &detector_name,
             const bool is_portal = false;
 
             // Read the transform
-            vector3 t{io_surface.cx, io_surface.cy, io_surface.cz};
-            vector3 x{io_surface.rot_xu, io_surface.rot_yu, io_surface.rot_zu};
-            vector3 z{io_surface.rot_xw, io_surface.rot_yw, io_surface.rot_zw};
+            vector3_t t{io_surface.cx, io_surface.cy, io_surface.cz};
+            vector3_t x{io_surface.rot_xu, io_surface.rot_yu,
+                        io_surface.rot_zu};
+            vector3_t z{io_surface.rot_xw, io_surface.rot_yw,
+                        io_surface.rot_zw};
 
             // Translate the mask & add it to the mask container
             unsigned int bounds_type = io_surface.bounds_type;
@@ -409,11 +382,11 @@ detector_from_csv(const std::string &detector_name,
 
                 // Add a new cylinder mask
                 dindex cylinder_index = c_masks.template size<cylinder_id>();
-                mask_edge = {c_volume->index(), dindex_invalid};
+                mask_volume_link = c_volume->index();
                 c_masks.template add_value<cylinder_id>(
                     io_surface.bound_param0,
                     io_surface.cz - io_surface.bound_param1,
-                    io_surface.cz + io_surface.bound_param1, mask_edge);
+                    io_surface.cz + io_surface.bound_param1, mask_volume_link);
                 // The read is valid: set the index
                 mask_index = {cylinder_id, cylinder_index};
 
@@ -440,7 +413,7 @@ detector_from_csv(const std::string &detector_name,
                 scalar half_y =
                     0.5 * (io_surface.bound_param3 - io_surface.bound_param1);
                 c_masks.template add_value<rectangle_id>(half_x, half_y,
-                                                         mask_edge);
+                                                         mask_volume_link);
                 // The read is valid: set the index
                 mask_index = {rectangle_id, rectangle_index};
 
@@ -462,7 +435,7 @@ detector_from_csv(const std::string &detector_name,
                 dindex trapezoid_index = c_masks.template size<trapezoid_id>();
                 c_masks.template add_value<trapezoid_id>(
                     io_surface.bound_param0, io_surface.bound_param1,
-                    io_surface.bound_param2, mask_edge);
+                    io_surface.bound_param2, mask_volume_link);
 
                 // The read is valid: set the index
                 mask_index = {trapezoid_id, trapezoid_index};
@@ -487,7 +460,7 @@ detector_from_csv(const std::string &detector_name,
                     io_surface.bound_param0, io_surface.bound_param1,
                     io_surface.bound_param2, io_surface.bound_param3,
                     io_surface.bound_param4, io_surface.bound_param5,
-                    io_surface.bound_param6, mask_edge);
+                    io_surface.bound_param6, mask_volume_link);
 
                 // The read is valid: set the index
                 mask_index = {annulus_id, annulus_index};
@@ -507,6 +480,142 @@ detector_from_csv(const std::string &detector_name,
         }  // end of exclusion for navigation layers
     }
 
+    // Create the surface finders & reserve
+    // std::map<volume_layer_index, std::pair<dindex, dindex>>
+    //    surface_finder_entries;
+
+    constexpr auto r_phi_grid_id = detector_t::sf_finders::id::e_r_phi_grid;
+    constexpr auto z_phi_grid_id = detector_t::sf_finders::id::e_z_phi_grid;
+
+    using surfaces_r_phi_grid =
+        typename detector_t::sf_finders::template get_type<r_phi_grid_id>::type;
+    using surfaces_z_phi_grid =
+        typename detector_t::sf_finders::template get_type<z_phi_grid_id>::type;
+
+    using surfaces_r_axis = typename surfaces_r_phi_grid::axis_p0_type;
+    using surfaces_z_axis = typename surfaces_r_phi_grid::axis_p0_type;
+    using surfaces_phi_axis = typename surfaces_r_phi_grid::axis_p1_type;
+
+    const auto &detector_surface_finders = d.sf_finder_store();
+
+    // (B) Pre-read the grids & create local object finders
+    int sg_counts = 0;
+
+    surface_grid_entries_writer sge_writer("grid-entries.csv");
+    bool write_grid_entries =
+        (grid_entries_file_name.find("write") != std::string::npos);
+    bool read_grid_entries =
+        not grid_entries_file_name.empty() and not write_grid_entries and
+        not(grid_entries_file_name.find("none") != std::string::npos);
+
+    while (sg_reader.read(io_surface_grid)) {
+
+        /*volume_layer_index c_index = {io_surface_grid.volume_id,
+                                      io_surface_grid.layer_id};
+
+        surface_finder_entries[c_index] = std::make_pair<dindex, dindex>(
+             io_surface_grid.type_loc0, detector_surfaces_finders.size());*/
+
+        bool is_disk = (io_surface_grid.type_loc0 == 3);
+
+        // Prepare z axis parameters
+        scalar _z_min = is_disk ? std::numeric_limits<scalar>::min()
+                                : io_surface_grid.min_loc1;
+        scalar _z_max = is_disk ? std::numeric_limits<scalar>::max()
+                                : io_surface_grid.max_loc1;
+        dindex _z_bins =
+            is_disk ? 1u : static_cast<dindex>(io_surface_grid.nbins_loc1);
+
+        // Prepare r axis parameters
+        scalar _r_min = is_disk ? io_surface_grid.min_loc0 : 0.;
+        scalar _r_max = is_disk ? io_surface_grid.max_loc0
+                                : std::numeric_limits<scalar>::max();
+        dindex _r_bins =
+            is_disk ? static_cast<dindex>(io_surface_grid.nbins_loc0) : 1u;
+
+        // Prepare phi axis parameters
+        scalar _phi_min =
+            is_disk ? io_surface_grid.min_loc1 : io_surface_grid.min_loc0;
+        scalar _phi_max =
+            is_disk ? io_surface_grid.max_loc1 : io_surface_grid.max_loc0;
+        dindex _phi_bins =
+            is_disk ? static_cast<dindex>(io_surface_grid.nbins_loc1)
+                    : static_cast<dindex>(io_surface_grid.nbins_loc0);
+
+        surfaces_z_axis z_axis{_z_bins, _z_min, _z_max, resource};
+        surfaces_r_axis r_axis{_r_bins, _r_min, _r_max, resource};
+        surfaces_phi_axis phi_axis{_phi_bins, _phi_min, _phi_max, resource};
+
+        typename detector_t::volume_type &vol =
+            d.volume_by_index(io_surface_grid.volume_id);
+        if (is_disk) {
+            assert(
+                sg_counts <
+                static_cast<int>(
+                    detector_surface_finders.template size<r_phi_grid_id>()));
+            surfaces_r_phi_grid r_phi_grid(r_axis, phi_axis, resource);
+            d.template add_grid<surfaces_r_phi_grid, r_phi_grid_id>(vol,
+                                                                    r_phi_grid);
+
+            // Fast option, read the grid entries back in
+            if (read_grid_entries) {
+                surface_grid_entries_reader sge_reader(grid_entries_file_name);
+                csv_surface_grid_entry surface_grid_entry;
+                while (sge_reader.read(surface_grid_entry)) {
+                    // Get the volume bounds for filling
+                    assert(vol.index() ==
+                           static_cast<dindex>(
+                               surface_grid_entry.detray_volume_id));
+                    r_phi_grid.populate(
+                        static_cast<dindex>(surface_grid_entry.detray_bin0),
+                        static_cast<dindex>(surface_grid_entry.detray_bin1),
+                        static_cast<dindex>(surface_grid_entry.detray_entry));
+                }
+            } else {
+                // Auto-fill the grids using the bin association
+                d.fill_grid(surface_default_context, vol, r_phi_grid);
+            }
+        } else {
+            assert(
+                sg_counts <
+                static_cast<int>(
+                    detector_surface_finders.template size<z_phi_grid_id>()));
+            surfaces_z_phi_grid z_phi_grid(z_axis, phi_axis, resource);
+            d.template add_grid<surfaces_z_phi_grid, z_phi_grid_id>(vol,
+                                                                    z_phi_grid);
+
+            // Fast option, read the grid entries back in
+            if (read_grid_entries) {
+                surface_grid_entries_reader sge_reader(grid_entries_file_name);
+                csv_surface_grid_entry surface_grid_entry;
+                while (sge_reader.read(surface_grid_entry)) {
+                    // Get the volume bounds for filling
+                    assert(vol.index() ==
+                           static_cast<dindex>(
+                               surface_grid_entry.detray_volume_id));
+                    z_phi_grid.populate(
+                        static_cast<dindex>(surface_grid_entry.detray_bin0),
+                        static_cast<dindex>(surface_grid_entry.detray_bin1),
+                        static_cast<dindex>(surface_grid_entry.detray_entry));
+                }
+            } else {
+                // Auto-fill the grids using the bin association
+                d.fill_grid(surface_default_context, vol, z_phi_grid);
+            }
+        }
+        ++sg_counts;
+        // negative / positive / inner / outer
+        /*surfaces_r_phi_grid rphi_grid_n(r_axis, phi_axis, resource);
+        surfaces_r_phi_grid rphi_grid_p(r_axis, phi_axis, resource);
+        surfaces_z_phi_grid zphi_grid_i{z_axis, phi_axis, resource};
+        surfaces_z_phi_grid zphi_grid_o{z_axis, phi_axis, resource};
+
+        detector_surfaces_finders[sg_counts++] = std::move(rphi_grid_n);
+        detector_surfaces_finders[sg_counts++] = std::move(rphi_grid_p);
+        detector_surfaces_finders[sg_counts++] = std::move(zphi_grid_i);
+        detector_surfaces_finders[sg_counts++] = std::move(zphi_grid_o);*/
+    }
+
     /** Helper method to sort and remove duplicates
      *
      * @param att attribute vector for sorting and duplicate removal
@@ -542,14 +651,6 @@ detector_from_csv(const std::string &detector_name,
     // difference
     scalar stepsilon = 1.;
 
-    // Run the bin association and write out
-    surface_grid_entries_writer sge_writer("grid-entries.csv");
-    bool write_grid_entries =
-        (grid_entries_file_name.find("write") != std::string::npos);
-    bool read_grid_entries =
-        not grid_entries_file_name.empty() and not write_grid_entries and
-        not(grid_entries_file_name.find("none") != std::string::npos);
-
     // Loop over the volumes
     // - fill the volume grid
     // - run the bin association
@@ -568,65 +669,26 @@ detector_from_csv(const std::string &detector_name,
         auto z_low = v_grid.axis_p1().borders(izl)[0];
         auto z_high = v_grid.axis_p1().borders(izh)[1];*/
 
-        bool is_cylinder = std::abs(v_bounds[1] - v_bounds[0]) <
-                           std::abs(v_bounds[3] - v_bounds[2]);
-
         for (dindex ir = irl; ir <= irh; ++ir) {
             for (dindex iz = izl; iz <= izh; ++iz) {
                 v_grid.populate(ir, iz, std::move(volume_index));
             }
         }
 
-        dindex sfi = v.surfaces_finder_entry();
+        dindex sfi = v.sf_finder_index();
         if (sfi != dindex_invalid and write_grid_entries) {
-            auto &grid = is_cylinder ? detector_surfaces_finders[sfi + 2]
-                                     : detector_surfaces_finders[sfi];
-            bin_association(surface_default_context, d, v, grid, {0.1, 0.1},
-                            false);
+
+            // bin_association(surface_default_context, d, v, grid, {0.1, 0.1},
+            //                 false);
 
             csv_surface_grid_entry csv_ge;
             csv_ge.detray_volume_id = static_cast<int>(iv);
-            size_t nbins0 = grid.axis_p0().bins();
-            size_t nbins1 = grid.axis_p1().bins();
-            for (size_t b0 = 0; b0 < nbins0; ++b0) {
-                for (size_t b1 = 0; b1 < nbins1; ++b1) {
-                    csv_ge.detray_bin0 = b0;
-                    csv_ge.detray_bin1 = b1;
-                    for (auto e : grid.bin(b0, b1)) {
-                        csv_ge.detray_entry = e;
-                        sge_writer.append(csv_ge);
-                    }
-                }
-            }
-        }
-    }
-
-    // Fast option, read the grid entries back in
-    if (read_grid_entries) {
-
-        surface_grid_entries_reader sge_reader(grid_entries_file_name);
-        csv_surface_grid_entry surface_grid_entry;
-        while (sge_reader.read(surface_grid_entry)) {
-            // Get the volume bounds for fillind
-            const auto &v =
-                d.volume_by_index(surface_grid_entry.detray_volume_id);
-            const auto &v_bounds = v.bounds();
-            dindex sfi = v.surfaces_finder_entry();
-            if (sfi != dindex_invalid) {
-                bool is_cylinder = std::abs(v_bounds[1] - v_bounds[0]) <
-                                   std::abs(v_bounds[3] - v_bounds[2]);
-                auto &grid = is_cylinder ? detector_surfaces_finders[sfi + 2]
-                                         : detector_surfaces_finders[sfi];
-                // Fill the entry
-                grid.populate(
-                    static_cast<dindex>(surface_grid_entry.detray_bin0),
-                    static_cast<dindex>(surface_grid_entry.detray_bin1),
-                    static_cast<dindex>(surface_grid_entry.detray_entry));
-            }
+            d.sf_finder_store().template call<grid_writer>(v.sf_finder_link(),
+                                                           csv_ge, sge_writer);
         }
     }
 
-    // Connect the cylindrical volumes
+    // Connect the cylindrical volumes via portals
     connect_cylindrical_volumes<detector_t, array_type, tuple_type,
                                 vector_type>(d, v_grid);
 
diff --git a/tests/benchmarks/cuda/benchmark_propagator_cuda.cpp b/tests/benchmarks/cuda/benchmark_propagator_cuda.cpp
index 30ec0e8416..92de70fd49 100644
--- a/tests/benchmarks/cuda/benchmark_propagator_cuda.cpp
+++ b/tests/benchmarks/cuda/benchmark_propagator_cuda.cpp
@@ -112,7 +112,7 @@ static void BM_PROPAGATOR_CUDA(benchmark::State &state) {
 
         // Create navigator candidates buffer
         auto candidates_buffer =
-            create_candidates_buffer(det, tracks.size(), dev_mr);
+            create_candidates_buffer(det, tracks.size(), dev_mr, &mng_mr);
         copy.setup(candidates_buffer);
 
         // Run the propagator test for GPU device
diff --git a/tests/common/include/tests/common/benchmark_find_volume.inl b/tests/common/include/tests/common/benchmark_find_volume.inl
index 720b94adb5..3f14de4a2a 100644
--- a/tests/common/include/tests/common/benchmark_find_volume.inl
+++ b/tests/common/include/tests/common/benchmark_find_volume.inl
@@ -12,20 +12,31 @@
 #include <string>
 #include <vecmem/memory/host_memory_resource.hpp>
 
+#include "tests/common/tools/create_toy_geometry.hpp"
 #include "tests/common/tools/detector_metadata.hpp"
-#include "tests/common/tools/read_geometry.hpp"
 
 using namespace detray;
 
+namespace {
+
+using transform3 = __plugin::transform3<detray::scalar>;
+using point2 = __plugin::point2<detray::scalar>;
+using point3 = __plugin::point3<detray::scalar>;
+using vector3 = __plugin::vector3<detray::scalar>;
+
+}  // namespace
+
 #ifdef DETRAY_BENCHMARKS_REP
 unsigned int gbench_repetitions = DETRAY_BENCHMARKS_REP;
 #else
 unsigned int gbench_repetitions = 0;
 #endif
 
+// Detector configuration
+constexpr std::size_t n_brl_layers{4};
+constexpr std::size_t n_edc_layers{7};
 vecmem::host_memory_resource host_mr;
-auto [d, name_map] =
-    read_from_csv<detector_registry::tml_detector>(tml_files, host_mr);
+auto d = create_toy_geometry(host_mr, n_brl_layers, n_edc_layers);
 
 const unsigned int itest = 10000;
 
diff --git a/tests/common/include/tests/common/benchmark_intersect_all.inl b/tests/common/include/tests/common/benchmark_intersect_all.inl
index d20e3dcda5..f1d5b71eef 100644
--- a/tests/common/include/tests/common/benchmark_intersect_all.inl
+++ b/tests/common/include/tests/common/benchmark_intersect_all.inl
@@ -10,8 +10,8 @@
 #include "detray/intersection/intersection_kernel.hpp"
 #include "detray/tracks/tracks.hpp"
 #include "detray/utils/enumerate.hpp"
+#include "tests/common/tools/create_toy_geometry.hpp"
 #include "tests/common/tools/detector_metadata.hpp"
-#include "tests/common/tools/read_geometry.hpp"
 #include "tests/common/tools/track_generators.hpp"
 
 // Vecmem include(s)
@@ -38,9 +38,11 @@ unsigned int theta_steps = 100;
 unsigned int phi_steps = 100;
 bool stream_file = false;
 
+// Detector configuration
+constexpr std::size_t n_brl_layers{4};
+constexpr std::size_t n_edc_layers{7};
 vecmem::host_memory_resource host_mr;
-auto [d, name_map] =
-    read_from_csv<detector_registry::tml_detector>(tml_files, host_mr);
+auto d = create_toy_geometry(host_mr, n_brl_layers, n_edc_layers);
 
 using detector_t = decltype(d);
 constexpr auto k_surfaces = detector_t::objects::e_surface;
@@ -79,8 +81,8 @@ static void BM_INTERSECT_ALL(benchmark::State &state) {
                 for (const auto sf : range(data_core.surfaces, v)) {
 
                     auto sfi =
-                        data_core.masks.template execute<intersection_update>(
-                            sf.mask_type(), detail::ray(track), sf,
+                        data_core.masks.template call<intersection_update>(
+                            sf.mask(), detail::ray(track), sf,
                             data_core.transforms);
 
                     benchmark::DoNotOptimize(hits);
diff --git a/tests/common/include/tests/common/benchmark_intersect_surfaces.inl b/tests/common/include/tests/common/benchmark_intersect_surfaces.inl
index 0cfd723816..ec33c36abf 100644
--- a/tests/common/include/tests/common/benchmark_intersect_surfaces.inl
+++ b/tests/common/include/tests/common/benchmark_intersect_surfaces.inl
@@ -31,7 +31,7 @@ unsigned int gbench_repetitions = 0;
 
 enum mask_ids : unsigned int {
     e_rectangle2 = 0,
-    e_cylinder3 = 1,
+    e_cylinder2 = 1,
     e_conc_cylinder3 = 2,
 };
 
@@ -39,11 +39,9 @@ enum material_ids : unsigned int {
     e_slab = 0,
 };
 
-using cylinder3_t = cylinder3<>;
-
 using mask_defs = tuple_vector_registry<
-    mask_ids, rectangle2<>, cylinder3<>,
-    cylinder3<transform3, concentric_cylinder_intersector>>;
+    mask_ids, mask<rectangle2D<>>, mask<cylinder2D<>>,
+    mask<cylinder2D<false, concentric_cylinder_intersector>>>;
 
 using material_defs =
     tuple_vector_registry<material_ids, material_slab<scalar>>;
@@ -63,7 +61,7 @@ static void BM_INTERSECT_PLANES(benchmark::State &state) {
 
     auto planes =
         planes_along_direction(dists, vector::normalize(vector3{1., 1., 1.}));
-    rectangle2<> rect{10., 20., 0u};
+    mask<rectangle2D<>> rect{0UL, 10.f, 20.f};
     point3 ori = {0., 0., 0.};
 
     for (auto _ : state) {
@@ -103,17 +101,17 @@ BENCHMARK(BM_INTERSECT_PLANES)
 static void BM_INTERSECT_CYLINDERS(benchmark::State &state) {
 
     using cylinder_mask =
-        typename mask_defs::template get_type<e_cylinder3>::type;
+        typename mask_defs::template get_type<e_cylinder2>::type;
 
     unsigned int sfhit = 0;
     unsigned int sfmiss = 0;
     dvector<cylinder_mask> cylinders;
 
-    for (auto r : dists) {
-        cylinders.push_back(cylinder_mask{r, -10., 10., 0u});
+    for (scalar r : dists) {
+        cylinders.push_back(cylinder_mask{0UL, r, -10.f, 10.f});
     }
 
-    typename mask_defs::link_type mask_link{e_cylinder3, 0};
+    typename mask_defs::link_type mask_link{e_cylinder2, 0};
     typename material_defs::link_type material_link{e_slab, 0};
     plane_surface plain(transform3(), mask_link, material_link, 0, false,
                         false);
@@ -176,8 +174,8 @@ static void BM_INTERSECT_CONCETRIC_CYLINDERS(benchmark::State &state) {
         typename mask_defs::template get_type<e_conc_cylinder3>::type;
     ;
     dvector<cylinder_mask> cylinders;
-    for (auto r : dists) {
-        cylinders.push_back(cylinder_mask{r, -10., 10., 0u});
+    for (scalar r : dists) {
+        cylinders.push_back(cylinder_mask(0UL, r, -10.f, 10.f));
     }
 
     typename mask_defs::link_type mask_link{e_conc_cylinder3, 0};
diff --git a/tests/common/include/tests/common/benchmark_masks.inl b/tests/common/include/tests/common/benchmark_masks.inl
index 9e57c65360..5ee6ef40c1 100644
--- a/tests/common/include/tests/common/benchmark_masks.inl
+++ b/tests/common/include/tests/common/benchmark_masks.inl
@@ -1,6 +1,6 @@
 /** Detray library, part of the ACTS project (R&D line)
  *
- * (c) 2020 CERN for the benefit of the ACTS project
+ * (c) 2020-2022 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -11,11 +11,8 @@
 #include <fstream>
 #include <iostream>
 
-#include "detray/masks/annulus2.hpp"
-#include "detray/masks/cylinder3.hpp"
-#include "detray/masks/rectangle2.hpp"
-#include "detray/masks/ring2.hpp"
-#include "detray/masks/trapezoid2.hpp"
+#include "detray/intersection/intersection.hpp"
+#include "detray/masks/masks.hpp"
 
 using namespace detray;
 using namespace __plugin;
@@ -35,39 +32,46 @@ unsigned int steps_y2 = steps_x2;
 
 bool screen_output = false;
 
+using transform_t = __plugin::transform3<detray::scalar>;
+using point3_t = __plugin::point3<detray::scalar>;
+const transform_t trf{};
+
 namespace {
 
-// This test runs a rectangle2 maks test operation
-static void BM_RECTANGLE2_MASK(benchmark::State &state) {
-    using local_type = cartesian2<__plugin::transform3<scalar>>;
-    using point2 = __plugin::point2<detray::scalar>;
+// This runs a benchmark on a rectangle2D mask
+static void BM_RECTANGLE_2D_MASK(benchmark::State &state) {
+    using point_t = typename mask<rectangle2D<>>::loc_point_t;
 
-    rectangle2<> r{3, 4, 0u};
+    mask<rectangle2D<>, dindex, transform_t> r{0UL, 3.f, 4.f};
 
     scalar world = 10.;
     scalar area = 4 * r[0] * r[1];
     scalar rest = world * world - area;
 
-    scalar sx = world / steps_x2;
-    scalar sy = world / steps_y2;
+    scalar sx = world / steps_x3;
+    scalar sy = world / steps_y3;
+    scalar sz = world / steps_z3;
+
     unsigned long inside = 0;
     unsigned long outside = 0;
 
     for (auto _ : state) {
-        for (unsigned int ix = 0; ix < steps_x2; ++ix) {
+        for (unsigned int ix = 0; ix < steps_x3; ++ix) {
             scalar x = -0.5 * world + ix * sx;
-            for (unsigned int iy = 0; iy < steps_y2; ++iy) {
+            for (unsigned int iy = 0; iy < steps_y3; ++iy) {
                 scalar y = -0.5 * world + iy * sy;
+                for (unsigned int iz = 0; iz < steps_z3; ++iz) {
+                    scalar z = -0.5 * world + iz * sz;
 
-                benchmark::DoNotOptimize(inside);
-                benchmark::DoNotOptimize(outside);
-                if (r.is_inside<local_type>(point2{x, y}) ==
-                    intersection::status::e_inside) {
-                    ++inside;
-                } else {
-                    ++outside;
+                    benchmark::DoNotOptimize(inside);
+                    benchmark::DoNotOptimize(outside);
+                    point_t loc_p{r.to_local_frame(trf, {x, y, z})};
+                    if (r.is_inside(loc_p) == intersection::status::e_inside) {
+                        ++inside;
+                    } else {
+                        ++outside;
+                    }
                 }
-                benchmark::ClobberMemory();
             }
         }
     }
@@ -80,37 +84,40 @@ static void BM_RECTANGLE2_MASK(benchmark::State &state) {
     }
 }
 
-// This test runs intersection a trapezoid2 mask operation
-static void BM_TRAPEZOID2_MASK(benchmark::State &state) {
-    using local_type = cartesian2<__plugin::transform3<scalar>>;
-    using point2 = __plugin::point2<detray::scalar>;
+// This runs a benchmark on a trapezoid2D mask
+static void BM_TRAPEZOID_2D_MASK(benchmark::State &state) {
+    using point_t = typename mask<trapezoid2D<>>::loc_point_t;
 
-    trapezoid2<> t{2, 3, 4, 0u};
+    mask<trapezoid2D<>> t{0UL, 2.f, 3.f, 4.f};
 
     scalar world = 10.;
     scalar area = 2 * (t[0] + t[1]) * t[2];
     scalar rest = world * world - area;
 
-    scalar sx = world / steps_x2;
-    scalar sy = world / steps_y2;
+    scalar sx = world / steps_x3;
+    scalar sy = world / steps_y3;
+    scalar sz = world / steps_z3;
+
     unsigned long inside = 0;
     unsigned long outside = 0;
 
     for (auto _ : state) {
-        for (unsigned int ix = 0; ix < steps_x2; ++ix) {
+        for (unsigned int ix = 0; ix < steps_x3; ++ix) {
             scalar x = -0.5 * world + ix * sx;
-            for (unsigned int iy = 0; iy < steps_y2; ++iy) {
+            for (unsigned int iy = 0; iy < steps_y3; ++iy) {
                 scalar y = -0.5 * world + iy * sy;
+                for (unsigned int iz = 0; iz < steps_z3; ++iz) {
+                    scalar z = -0.5 * world + iz * sz;
 
-                benchmark::DoNotOptimize(inside);
-                benchmark::DoNotOptimize(outside);
-                if (t.is_inside<local_type>(point2{x, y}) ==
-                    intersection::status::e_inside) {
-                    ++inside;
-                } else {
-                    ++outside;
+                    benchmark::DoNotOptimize(inside);
+                    benchmark::DoNotOptimize(outside);
+                    point_t loc_p{t.to_local_frame(trf, {x, y, z})};
+                    if (t.is_inside(loc_p) == intersection::status::e_inside) {
+                        ++inside;
+                    } else {
+                        ++outside;
+                    }
                 }
-                benchmark::ClobberMemory();
             }
         }
     }
@@ -123,37 +130,40 @@ static void BM_TRAPEZOID2_MASK(benchmark::State &state) {
     }
 }
 
-// This test runs a ring2 mask operation
-static void BM_RING2_MASK(benchmark::State &state) {
-    using local_type = cartesian2<__plugin::transform3<scalar>>;
-    using point2 = __plugin::point2<detray::scalar>;
+// This runs a benchmark on a ring2D mask (as disc)
+static void BM_RING_2D_MASK(benchmark::State &state) {
+    using point_t = typename mask<ring2D<>>::loc_point_t;
 
-    ring2<> r{0., 5., 0u};
+    mask<ring2D<>> r{0UL, 0.f, 5.f};
 
     scalar world = 10.;
     scalar area = r[1] * r[1] * M_PI;
     scalar rest = world * world - area;
 
-    scalar sx = world / steps_x2;
-    scalar sy = world / steps_y2;
+    scalar sx = world / steps_x3;
+    scalar sy = world / steps_y3;
+    scalar sz = world / steps_z3;
+
     unsigned long inside = 0;
     unsigned long outside = 0;
 
     for (auto _ : state) {
-        for (unsigned int ix = 0; ix < steps_x2; ++ix) {
+        for (unsigned int ix = 0; ix < steps_x3; ++ix) {
             scalar x = -0.5 * world + ix * sx;
-            for (unsigned int iy = 0; iy < steps_y2; ++iy) {
+            for (unsigned int iy = 0; iy < steps_y3; ++iy) {
                 scalar y = -0.5 * world + iy * sy;
+                for (unsigned int iz = 0; iz < steps_z3; ++iz) {
+                    scalar z = -0.5 * world + iz * sz;
 
-                benchmark::DoNotOptimize(inside);
-                benchmark::DoNotOptimize(outside);
-                if (r.is_inside<local_type>(point2{x, y}) ==
-                    intersection::status::e_inside) {
-                    ++inside;
-                } else {
-                    ++outside;
+                    benchmark::DoNotOptimize(inside);
+                    benchmark::DoNotOptimize(outside);
+                    point_t loc_p{r.to_local_frame(trf, {x, y, z})};
+                    if (r.is_inside(loc_p) == intersection::status::e_inside) {
+                        ++inside;
+                    } else {
+                        ++outside;
+                    }
                 }
-                benchmark::ClobberMemory();
             }
         }
     }
@@ -165,37 +175,40 @@ static void BM_RING2_MASK(benchmark::State &state) {
     }
 }
 
-// This test runs mask oeration on a disc2
-static void BM_DISC2_MASK(benchmark::State &state) {
-    using local_type = cartesian2<__plugin::transform3<scalar>>;
-    using point2 = __plugin::point2<detray::scalar>;
+// This runs a benchmark on a ring2D mask
+static void BM_DISC_2D_MASK(benchmark::State &state) {
+    using point_t = typename mask<ring2D<>>::loc_point_t;
 
-    ring2<> r{2., 5., 0u};
+    mask<ring2D<>> r{0UL, 2.f, 5.f};
 
     scalar world = 10.;
     scalar area = (r[1] * r[1] - r[0] * r[0]) * M_PI;
     scalar rest = world * world - area;
 
-    scalar sx = world / steps_x2;
-    scalar sy = world / steps_y2;
+    scalar sx = world / steps_x3;
+    scalar sy = world / steps_y3;
+    scalar sz = world / steps_z3;
+
     unsigned long inside = 0;
     unsigned long outside = 0;
 
     for (auto _ : state) {
-        for (unsigned int ix = 0; ix < steps_x2; ++ix) {
+        for (unsigned int ix = 0; ix < steps_x3; ++ix) {
             scalar x = -0.5 * world + ix * sx;
-            for (unsigned int iy = 0; iy < steps_y2; ++iy) {
+            for (unsigned int iy = 0; iy < steps_y3; ++iy) {
                 scalar y = -0.5 * world + iy * sy;
+                for (unsigned int iz = 0; iz < steps_z3; ++iz) {
+                    scalar z = -0.5 * world + iz * sz;
 
-                benchmark::DoNotOptimize(inside);
-                benchmark::DoNotOptimize(outside);
-                if (r.is_inside<local_type>(point2{x, y}) ==
-                    intersection::status::e_inside) {
-                    ++inside;
-                } else {
-                    ++outside;
+                    benchmark::DoNotOptimize(inside);
+                    benchmark::DoNotOptimize(outside);
+                    point_t loc_p{r.to_local_frame(trf, {x, y, z})};
+                    if (r.is_inside(loc_p) == intersection::status::e_inside) {
+                        ++inside;
+                    } else {
+                        ++outside;
+                    }
                 }
-                benchmark::ClobberMemory();
             }
         }
     }
@@ -207,12 +220,11 @@ static void BM_DISC2_MASK(benchmark::State &state) {
     }
 }
 
-// This test runs masking operations on a cylinder3 mask
-static void BM_CYLINDER3_MASK(benchmark::State &state) {
-    using local_type = cartesian2<__plugin::transform3<scalar>>;
-    using point3 = __plugin::point3<detray::scalar>;
+// This runs a benchmark on a cylinder2D mask
+static void BM_CYLINDER_2D_MASK(benchmark::State &state) {
+    using point_t = typename mask<cylinder2D<>>::loc_point_t;
 
-    cylinder3<> c{3., 5., 0., 0u};
+    mask<cylinder2D<>> c{0UL, 3.f, 5.f, 0.f};
 
     scalar world = 10.;
 
@@ -233,54 +245,58 @@ static void BM_CYLINDER3_MASK(benchmark::State &state) {
 
                     benchmark::DoNotOptimize(inside);
                     benchmark::DoNotOptimize(outside);
-                    if (c.is_inside<local_type>(point3{x, y, z}, 0.1) ==
+                    point_t loc_p{c.to_local_frame(trf, {x, y, z})};
+                    if (c.is_inside(loc_p, 0.1) ==
                         intersection::status::e_inside) {
                         ++inside;
                     } else {
                         ++outside;
                     }
-                    benchmark::ClobberMemory();
                 }
             }
         }
     }
     if (screen_output) {
-        std::cout << "Ring : Inside/outside ..." << inside << " / " << outside
-                  << " = "
+        std::cout << "Cylinder : Inside/outside ..." << inside << " / "
+                  << outside << " = "
                   << static_cast<scalar>(inside) / static_cast<scalar>(outside)
                   << std::endl;
     }
 }
 
-// This test runs a annulus mask operation
-static void BM_ANNULUS_MASK(benchmark::State &state) {
-    using local_type = cartesian2<__plugin::transform3<scalar>>;
-    using point2 = __plugin::point2<detray::scalar>;
+// This runs a benchmark on an annulus2D mask
+static void BM_ANNULUS_2D_MASK(benchmark::State &state) {
+    using point_t = typename mask<annulus2D<>>::loc_point_t;
 
-    annulus2<> ann{2.5, 5., -0.64299, 4.13173, 1., 0.5, 0., 0u};
+    mask<annulus2D<>> ann{0UL, 2.5f, 5.f, -0.64299f, 4.13173f, 1.f, 0.5f, 0.f};
 
     scalar world = 10.;
 
-    scalar sx = world / steps_x2;
-    scalar sy = world / steps_y2;
+    scalar sx = world / steps_x3;
+    scalar sy = world / steps_y3;
+    scalar sz = world / steps_z3;
+
     unsigned long inside = 0;
     unsigned long outside = 0;
 
     for (auto _ : state) {
-        for (unsigned int ix = 0; ix < steps_x2; ++ix) {
+        for (unsigned int ix = 0; ix < steps_x3; ++ix) {
             scalar x = -0.5 * world + ix * sx;
-            for (unsigned int iy = 0; iy < steps_y2; ++iy) {
+            for (unsigned int iy = 0; iy < steps_y3; ++iy) {
                 scalar y = -0.5 * world + iy * sy;
+                for (unsigned int iz = 0; iz < steps_z3; ++iz) {
+                    scalar z = -0.5 * world + iz * sz;
 
-                benchmark::DoNotOptimize(inside);
-                benchmark::DoNotOptimize(outside);
-                if (ann.is_inside<local_type>(point2{x, y}) ==
-                    intersection::status::e_inside) {
-                    ++inside;
-                } else {
-                    ++outside;
+                    benchmark::DoNotOptimize(inside);
+                    benchmark::DoNotOptimize(outside);
+                    point_t loc_p{ann.to_local_frame(trf, {x, y, z})};
+                    if (ann.is_inside(loc_p) ==
+                        intersection::status::e_inside) {
+                        ++inside;
+                    } else {
+                        ++outside;
+                    }
                 }
-                benchmark::ClobberMemory();
             }
         }
     }
@@ -292,42 +308,42 @@ static void BM_ANNULUS_MASK(benchmark::State &state) {
     }
 }
 
-BENCHMARK(BM_RECTANGLE2_MASK)
+BENCHMARK(BM_RECTANGLE_2D_MASK)
 #ifdef DETRAY_BENCHMARKS_MULTITHREAD
     ->ThreadPerCpu()
 #endif
     ->Unit(benchmark::kMillisecond)
     ->Repetitions(gbench_repetitions)
     ->DisplayAggregatesOnly(true);
-BENCHMARK(BM_TRAPEZOID2_MASK)
+BENCHMARK(BM_TRAPEZOID_2D_MASK)
 #ifdef DETRAY_BENCHMARKS_MULTITHREAD
     ->ThreadPerCpu()
 #endif
     ->Unit(benchmark::kMillisecond)
     ->Repetitions(gbench_repetitions)
     ->DisplayAggregatesOnly(true);
-BENCHMARK(BM_DISC2_MASK)
+BENCHMARK(BM_DISC_2D_MASK)
 #ifdef DETRAY_BENCHMARKS_MULTITHREAD
     ->ThreadPerCpu()
 #endif
     ->Unit(benchmark::kMillisecond)
     ->Repetitions(gbench_repetitions)
     ->DisplayAggregatesOnly(true);
-BENCHMARK(BM_RING2_MASK)
+BENCHMARK(BM_RING_2D_MASK)
 #ifdef DETRAY_BENCHMARKS_MULTITHREAD
     ->ThreadPerCpu()
 #endif
     ->Unit(benchmark::kMillisecond)
     ->Repetitions(gbench_repetitions)
     ->DisplayAggregatesOnly(true);
-BENCHMARK(BM_CYLINDER3_MASK)
+BENCHMARK(BM_CYLINDER_2D_MASK)
 #ifdef DETRAY_BENCHMARKS_MULTITHREAD
     ->ThreadPerCpu()
 #endif
     ->Unit(benchmark::kMillisecond)
     ->Repetitions(gbench_repetitions)
     ->DisplayAggregatesOnly(true);
-BENCHMARK(BM_ANNULUS_MASK)
+BENCHMARK(BM_ANNULUS_2D_MASK)
 #ifdef DETRAY_BENCHMARKS_MULTITHREAD
     ->ThreadPerCpu()
 #endif
diff --git a/tests/common/include/tests/common/coordinates.inl b/tests/common/include/tests/common/coordinates.inl
index db64df2b88..ca8e91d375 100644
--- a/tests/common/include/tests/common/coordinates.inl
+++ b/tests/common/include/tests/common/coordinates.inl
@@ -190,7 +190,7 @@ TEST(test_host_basics, cylindrical2) {
     // Define cylinder mask
     struct cylinder_mask {
         scalar r = 0.;
-        scalar radius() const { return r; }
+        scalar operator[](dindex) const { return r; }
     };
 
     const scalar r = 2.;
diff --git a/tests/common/include/tests/common/core_container.inl b/tests/common/include/tests/common/core_container.inl
index d94ef8cb62..8106c65c31 100644
--- a/tests/common/include/tests/common/core_container.inl
+++ b/tests/common/include/tests/common/core_container.inl
@@ -30,7 +30,7 @@ struct test_func {
     using output_type = std::size_t;
 
     template <typename container_t>
-    output_type operator()(const container_t& gr) {
+    output_type operator()(const container_t& gr, const int /*index*/) {
         return gr.size();
     }
 };
@@ -97,9 +97,9 @@ TEST(container, tuple_vector_container) {
     EXPECT_FLOAT_EQ(container.group<2>()[3], 7.6);
 
     // unrolling test
-    EXPECT_EQ(container.execute<test_func>(0), 5);
-    EXPECT_EQ(container.execute<test_func>(1), 3);
-    EXPECT_EQ(container.execute<test_func>(2), 4);
+    EXPECT_EQ(container.call<test_func>(std::make_pair(0, 0)), 5);
+    EXPECT_EQ(container.call<test_func>(std::make_pair(1, 0)), 3);
+    EXPECT_EQ(container.call<test_func>(std::make_pair(2, 0)), 4);
 }
 
 using grid2r =
diff --git a/tests/common/include/tests/common/core_detector.inl b/tests/common/include/tests/common/core_detector.inl
index 10fd249979..d466fd7b52 100644
--- a/tests/common/include/tests/common/core_detector.inl
+++ b/tests/common/include/tests/common/core_detector.inl
@@ -41,25 +41,23 @@ TEST(detector, detector_kernel) {
     detector_t::mask_container masks(host_mr);
     detector_t::material_container materials(host_mr);
 
-    typename detector_t::surface_type::edge_type mask_edge{0, 0};
-
     /// Surface 0
     point3 t0{0., 0., 0.};
     trfs.emplace_back(ctx0, t0);
-    masks.template add_value<mask_ids::e_rectangle2>(-3., 3., mask_edge);
+    masks.template add_value<mask_ids::e_rectangle2>(0UL, -3.f, 3.f);
     materials.template add_value<material_ids::e_slab>(gold<scalar>(), 3.);
 
     /// Surface 1
     point3 t1{1., 0., 0.};
     trfs.emplace_back(ctx0, t1);
-    masks.template add_value<mask_ids::e_annulus2>(1., 2., 3., 4., 5., 6., 7.,
-                                                   mask_edge);
+    masks.template add_value<mask_ids::e_annulus2>(0UL, 1.f, 2.f, 3.f, 4.f, 5.f,
+                                                   6.f, 7.f);
     materials.template add_value<material_ids::e_slab>(tungsten<scalar>(), 12.);
 
     /// Surface 2
     point3 t2{2., 0., 0.};
     trfs.emplace_back(ctx0, t2);
-    masks.template add_value<mask_ids::e_trapezoid2>(1., 2., 3., mask_edge);
+    masks.template add_value<mask_ids::e_trapezoid2>(0UL, 1.f, 2.f, 3.f);
     materials.template add_value<material_ids::e_rod>(aluminium<scalar>(), 4.);
 
     detector_t d(host_mr);
diff --git a/tests/common/include/tests/common/core_mask_store.inl b/tests/common/include/tests/common/core_mask_store.inl
index 32a23273a8..01f854f886 100644
--- a/tests/common/include/tests/common/core_mask_store.inl
+++ b/tests/common/include/tests/common/core_mask_store.inl
@@ -34,12 +34,12 @@ TEST(ALGEBRA_PLUGIN, static_mask_store) {
         e_single3 = 5,
     };
 
-    using rectangle = rectangle2<>;
-    using trapezoid = trapezoid2<>;
-    using annulus = annulus2<>;
-    using cylinder = cylinder3<>;
-    using ring = ring2<>;
-    using single = single3<0>;
+    using rectangle = mask<rectangle2D<>>;
+    using trapezoid = mask<trapezoid2D<>>;
+    using annulus = mask<annulus2D<>>;
+    using cylinder = mask<cylinder2D<>>;
+    using ring = mask<ring2D<>>;
+    using single = mask<single3D<>>;
 
     // Types must be sorted according to their id (here: masks/mask_identifier)
     using mask_defs = tuple_vector_registry<mask_ids, rectangle, trapezoid,
@@ -55,7 +55,7 @@ TEST(ALGEBRA_PLUGIN, static_mask_store) {
     ASSERT_TRUE(store.empty<id::e_single3>());
     ASSERT_TRUE(store.empty<id::e_trapezoid2>());
 
-    store.add_value<id::e_cylinder3>(1., 0.5, 2.0, 0u);
+    store.add_value<id::e_cylinder3>(0UL, 1.f, 0.5f, 2.0f);
 
     ASSERT_TRUE(store.empty<id::e_annulus2>());
     ASSERT_EQ(store.size<id::e_cylinder3>(), 1);
@@ -64,11 +64,11 @@ TEST(ALGEBRA_PLUGIN, static_mask_store) {
     ASSERT_TRUE(store.empty<id::e_single3>());
     ASSERT_TRUE(store.empty<id::e_trapezoid2>());
 
-    store.add_value<id::e_cylinder3>(1., 1.5, 2.0, 0u);
-    store.add_value<id::e_trapezoid2>(0.5, 1.5, 4.0, 0u);
-    store.add_value<id::e_rectangle2>(1.0, 2.0, 0u);
-    store.add_value<id::e_rectangle2>(2.0, 1.0, 0u);
-    store.add_value<id::e_rectangle2>(10.0, 100.0, 0u);
+    store.add_value<id::e_cylinder3>(0UL, 1.f, 1.5f, 2.0f);
+    store.add_value<id::e_trapezoid2>(0UL, 0.5f, 1.5f, 4.0f);
+    store.add_value<id::e_rectangle2>(0UL, 1.0f, 2.0f);
+    store.add_value<id::e_rectangle2>(0UL, 2.0f, 1.0f);
+    store.add_value<id::e_rectangle2>(0UL, 10.0f, 100.0f);
 
     ASSERT_TRUE(store.empty<id::e_annulus2>());
     ASSERT_EQ(store.size<id::e_cylinder3>(), 2);
@@ -77,11 +77,11 @@ TEST(ALGEBRA_PLUGIN, static_mask_store) {
     ASSERT_TRUE(store.empty<id::e_single3>());
     ASSERT_EQ(store.size<id::e_trapezoid2>(), 1);
 
-    store.add_value<id::e_annulus2>(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 0u);
-    store.add_value<id::e_ring2>(10.0, 100.0, 0u);
-    store.add_value<id::e_ring2>(10.0, 100.0, 0u);
-    store.add_value<id::e_ring2>(10.0, 100.0, 0u);
-    store.add_value<id::e_ring2>(10.0, 100.0, 0u);
+    store.add_value<id::e_annulus2>(0UL, 1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f);
+    store.add_value<id::e_ring2>(0UL, 10.f, 100.f);
+    store.add_value<id::e_ring2>(0UL, 10.f, 100.f);
+    store.add_value<id::e_ring2>(0UL, 10.f, 100.f);
+    store.add_value<id::e_ring2>(0UL, 10.f, 100.f);
 
     const auto &annulus_masks = store.group<id::e_annulus2>();
     const auto &cylinder_masks = store.group<id::e_cylinder3>();
diff --git a/tests/common/include/tests/common/geometry_volume.inl b/tests/common/include/tests/common/geometry_volume.inl
index 5129a58fbf..01dffe891e 100644
--- a/tests/common/include/tests/common/geometry_volume.inl
+++ b/tests/common/include/tests/common/geometry_volume.inl
@@ -17,28 +17,36 @@ TEST(ALGEBRA_PLUGIN, volume) {
     using namespace detray;
     using namespace __plugin;
 
-    // dummy types
+    // dummy types for testing
+    enum sf_finder_ids : unsigned int {
+        e_default = 0,
+    };
+
     using surface_t = dindex;
-    // using sf_finder_t = dindex;
+    using sf_finder_t = dindex;
     using object_defs = object_registry<surface_t>;
-    // using sf_finder_defs = default_sf_finder_registry<sf_finder_t>;
-    using volume = volume<object_defs, detray::scalar>;
+    using sf_finder_defs =
+        tuple_array_registry<sf_finder_ids, std::index_sequence<1>,
+                             sf_finder_t>;
+    using volume = volume<object_defs, scalar, sf_finder_defs::link_type>;
 
     // Check construction, setters and getters
     darray<scalar, 6> bounds = {0., 10., -5., 5., -M_PI, M_PI};
     volume v1 = volume(bounds);
     v1.set_index(12345);
-    v1.set_surfaces_finder(12);
+    v1.set_sf_finder({sf_finder_defs::id::e_default, 12});
 
     ASSERT_TRUE(v1.empty());
     ASSERT_TRUE(v1.index() == 12345);
     ASSERT_TRUE(v1.bounds() == bounds);
-    ASSERT_TRUE(v1.surfaces_finder_entry() == 12);
+    ASSERT_TRUE(v1.sf_finder_type() == sf_finder_defs::id::e_default);
+    ASSERT_TRUE(v1.sf_finder_index() == 12);
 
     // Check surface and portal ranges
     dindex_range surface_range{2, 8};
     dindex_range portal_range{8, 24};
     dindex_range full_range{2, 24};
+    sf_finder_defs::link_type sf_finder_link{sf_finder_defs::id::e_default, 12};
     v1.update_range<object_defs::e_surface>(surface_range);
     v1.update_range<object_defs::e_portal>(portal_range);
     ASSERT_TRUE(v1.range<object_defs::e_surface>() == full_range);
@@ -46,12 +54,13 @@ TEST(ALGEBRA_PLUGIN, volume) {
     ASSERT_FALSE(v1.empty());
     ASSERT_EQ(v1.template n_objects<object_defs::e_surface>(), 22);
     ASSERT_EQ(v1.template n_objects<object_defs::e_portal>(), 22);
+    ASSERT_TRUE(v1.sf_finder_link() == sf_finder_link);
 
     // Check copy constructor
     const auto v2 = volume(v1);
     ASSERT_TRUE(v2.index() == 12345);
     ASSERT_TRUE(v2.bounds() == bounds);
-    ASSERT_TRUE(v2.surfaces_finder_entry() == 12);
+    ASSERT_TRUE(v2.sf_finder_link() == sf_finder_link);
     ASSERT_TRUE(v2.template range<object_defs::e_surface>() == full_range);
     ASSERT_TRUE(v2.template range<object_defs::e_portal>() == full_range);
 }
diff --git a/tests/common/include/tests/common/grid_axis.inl b/tests/common/include/tests/common/grid_axis.inl
new file mode 100644
index 0000000000..56219d3d82
--- /dev/null
+++ b/tests/common/include/tests/common/grid_axis.inl
@@ -0,0 +1,420 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include <gtest/gtest.h>
+
+#include <climits>
+
+// detray test
+#include <vecmem/containers/device_vector.hpp>
+#include <vecmem/containers/vector.hpp>
+#include <vecmem/memory/host_memory_resource.hpp>
+
+// detray core
+#include "detray/definitions/indexing.hpp"
+#include "detray/masks/masks.hpp"
+#include "detray/surface_finders/grid/axis.hpp"
+
+using namespace detray;
+using namespace detray::n_axis;
+
+namespace {
+
+using point3 = __plugin::point3<scalar>;
+
+// Alias for testing
+template <bool ownership, typename containers>
+using cartesian_3D =
+    multi_axis<ownership, cartesian3<__plugin::transform3<scalar>>,
+               single_axis<closed<label::e_x>, regular<containers, scalar>>,
+               single_axis<closed<label::e_y>, regular<containers, scalar>>,
+               single_axis<closed<label::e_z>, regular<containers, scalar>>>;
+
+// Floating point comparison
+constexpr scalar tol{1e-5};
+
+}  // anonymous namespace
+
+TEST(grid, open_regular_axis) {
+
+    // Lower bin edges: min and max bin edge for the regular axis
+    vecmem::vector<scalar> bin_edges = {-10, -5, -3, 7, 7, 14, 20};
+    // Regular axis: first entry is the offset in the bin edges vector (2), the
+    // second entry is the number of bins (10): Lower and upper bin edges of
+    // the max and min bin are -3 and 7 => stepsize is (7 - (-3)) / 10 = 1
+    // ... -3, -2, -1,  0,  1,  2,  3,  4,  5,  6,  7 ...
+    //  [0]  [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11]
+    dindex_range edge_range = {2, 10};
+
+    // An open regular x-axis
+    single_axis<open<label::e_x>, regular<>> or_axis{&edge_range, &bin_edges};
+
+    // Test axis shape
+    EXPECT_EQ(or_axis.label(), n_axis::label::e_x);
+    EXPECT_EQ(or_axis.shape(), n_axis::shape::e_open);
+    EXPECT_EQ(or_axis.binning(), n_axis::binning::e_regular);
+
+    // N bins
+    EXPECT_EQ(or_axis.nbins(), 10u);
+    EXPECT_NEAR(or_axis.span()[0], scalar{-3}, tol);
+    EXPECT_NEAR(or_axis.span()[1], scalar{7}, tol);
+    // Axis bin access
+    // Axis is open: Every value smaller than -3 is mapped into bin 0:
+    // which is (inf, -3)
+    EXPECT_EQ(or_axis.bin(-4.), 0u);
+    EXPECT_EQ(or_axis.bin(2.5), 6u);
+    // Axis is open: Every value greater than 7 is mapped into bin 11:
+    // which is (7, inf)
+    EXPECT_EQ(or_axis.bin(8.), 11u);
+
+    // Axis range access - binned (symmetric & asymmetric)
+    darray<dindex, 2> nhood00i = {0u, 0u};
+    darray<dindex, 2> nhood01i = {0u, 1u};
+    darray<dindex, 2> nhood11i = {1u, 1u};
+    darray<dindex, 2> nhood44i = {4u, 4u};
+    darray<dindex, 2> nhood55i = {5u, 5u};
+
+    dindex_range expected_range = {6u, 6u};
+    EXPECT_EQ(or_axis.range(2.5, nhood00i), expected_range);
+    expected_range = {6u, 7u};
+    EXPECT_EQ(or_axis.range(2.5, nhood01i), expected_range);
+    expected_range = {5u, 7u};
+    EXPECT_EQ(or_axis.range(2.5, nhood11i), expected_range);
+    expected_range = {2u, 10u};
+    EXPECT_EQ(or_axis.range(2.5, nhood44i), expected_range);
+    expected_range = {1u, 11u};
+    EXPECT_EQ(or_axis.range(2.5, nhood55i), expected_range);
+    expected_range = {1u, 9u};
+    EXPECT_EQ(or_axis.range(1.5, nhood44i), expected_range);
+    expected_range = {4u, 11u};
+    EXPECT_EQ(or_axis.range(5.5, nhood55i), expected_range);
+
+    // Axis range access - scalar (symmteric & asymmetric)
+    darray<scalar, 2> nhood00s = {0., 0.};
+    darray<scalar, 2> epsilon = {0.01, 0.01};
+    darray<scalar, 2> nhood11s = {1., 1.};
+    darray<scalar, 2> nhoodAlls = {10., 10.};
+
+    expected_range = {6u, 6u};
+    EXPECT_EQ(or_axis.range(2.5, nhood00s), expected_range);
+    EXPECT_EQ(or_axis.range(2.5, epsilon), expected_range);
+    expected_range = {5u, 7u};
+    EXPECT_EQ(or_axis.range(2.5, nhood11s), expected_range);
+    expected_range = {0u, 11u};
+    EXPECT_EQ(or_axis.range(2.5, nhoodAlls), expected_range);
+}
+
+TEST(grid, closed_regular_axis) {
+
+    // Lower bin edges: min and max bin edge for the regular axis
+    vecmem::vector<scalar> bin_edges = {-10, -3, -3, 7, 7, 14};
+    // Regular axis: first entry is the offset in the bin edges vector (2), the
+    // second entry is the number of bins (10): Lower and upper bin edges of
+    // the max and min bin are -3 and 7 => stepsize is (7 - (-3)) / 10 = 1
+    // -3, -2, -1,  0,  1,  2,  3,  4,  5,  6,  7
+    //   [0] [1] [2] [3] [4] [5] [6] [7] [8] [9]
+    dindex_range edge_range = {2, 10};
+
+    // A closed regular r-axis
+    single_axis<closed<label::e_r>, regular<>> cr_axis{&edge_range, &bin_edges};
+
+    // Test axis shape
+    EXPECT_EQ(cr_axis.label(), n_axis::label::e_r);
+    EXPECT_EQ(cr_axis.shape(), n_axis::shape::e_closed);
+    EXPECT_EQ(cr_axis.binning(), n_axis::binning::e_regular);
+
+    // N bins
+    EXPECT_EQ(cr_axis.nbins(), 10u);
+    EXPECT_NEAR(cr_axis.span()[0], scalar{-3}, tol);
+    EXPECT_NEAR(cr_axis.span()[1], scalar{7}, tol);
+    // Axis bin access
+    // Axis is closed: Every value smaller than -3 is mapped into bin 0:
+    // which is [-3, -2)
+    EXPECT_EQ(cr_axis.bin(-4.), 0u);
+    EXPECT_EQ(cr_axis.bin(2.5), 5u);
+    // Axis is closed: Every value greater than 7 is mapped into bin 9:
+    // which is (6, 7]
+    EXPECT_EQ(cr_axis.bin(8.), 9u);
+
+    // Axis range access - binned (symmetric & asymmetric)
+    darray<dindex, 2> nhood00i = {0u, 0u};
+    darray<dindex, 2> nhood01i = {0u, 1u};
+    darray<dindex, 2> nhood11i = {1u, 1u};
+    darray<dindex, 2> nhood44i = {4u, 4u};
+    darray<dindex, 2> nhood55i = {5u, 5u};
+
+    dindex_range expected_range = {5u, 5u};
+    EXPECT_EQ(cr_axis.range(2.5, nhood00i), expected_range);
+    expected_range = {5u, 6u};
+    EXPECT_EQ(cr_axis.range(2.5, nhood01i), expected_range);
+    expected_range = {4u, 6u};
+    EXPECT_EQ(cr_axis.range(2.5, nhood11i), expected_range);
+    expected_range = {1u, 9u};
+    EXPECT_EQ(cr_axis.range(2.5, nhood44i), expected_range);
+    expected_range = {0u, 9u};
+    EXPECT_EQ(cr_axis.range(2.5, nhood55i), expected_range);
+    expected_range = {0u, 8u};
+    EXPECT_EQ(cr_axis.range(1.5, nhood44i), expected_range);
+    expected_range = {3u, 9u};
+    EXPECT_EQ(cr_axis.range(5.5, nhood55i), expected_range);
+
+    // Axis range access - scalar (symmteric & asymmetric)
+    darray<scalar, 2> nhood00s = {0., 0.};
+    darray<scalar, 2> epsilon = {0.01, 0.01};
+    darray<scalar, 2> nhood11s = {1., 1.};
+    darray<scalar, 2> nhoodAlls = {10., 10.};
+
+    expected_range = {5u, 5u};
+    EXPECT_EQ(cr_axis.range(2.5, nhood00s), expected_range);
+    EXPECT_EQ(cr_axis.range(2.5, epsilon), expected_range);
+    expected_range = {4u, 6u};
+    EXPECT_EQ(cr_axis.range(2.5, nhood11s), expected_range);
+    expected_range = {0u, 9u};
+    EXPECT_EQ(cr_axis.range(2.5, nhoodAlls), expected_range);
+}
+
+TEST(grid, circular_regular_axis) {
+
+    scalar epsilon = 10 * std::numeric_limits<scalar>::epsilon();
+
+    // Let's say 36 modules, but with 4 directly at 0, pi/2, pi, -pi2
+    scalar pi{M_PI};
+    scalar pi2{M_PI_2};
+
+    scalar half_module{scalar{2} * pi2 / scalar{72}};
+    scalar phi_min{-pi + half_module};
+    scalar phi_max{pi - half_module};
+
+    // Lower bin edges: min and max bin edge for the regular axis
+    vecmem::vector<scalar> bin_edges = {-10, phi_min, phi_max, 56};
+    // Regular axis: first entry is the offset in the bin edges vector (1), the
+    // second entry is the number of bins (36)
+    dindex_range edge_range = {1, 36};
+
+    // A closed regular x-axis
+    single_axis<circular<>, regular<>> cr_axis(&edge_range, &bin_edges);
+
+    // Test axis shape
+    EXPECT_EQ(cr_axis.label(), n_axis::label::e_phi);
+    EXPECT_EQ(cr_axis.shape(), n_axis::shape::e_circular);
+    EXPECT_EQ(cr_axis.binning(), n_axis::binning::e_regular);
+
+    // N bins
+    EXPECT_EQ(cr_axis.nbins(), 36u);
+    // Axis bin access
+    // overflow
+    EXPECT_EQ(cr_axis.bin(phi_max + epsilon), 0u);
+    // underflow
+    EXPECT_EQ(cr_axis.bin(phi_min - epsilon), 35u);
+    // middle of the axis
+    EXPECT_EQ(cr_axis.bin(0), 19u);
+
+    // Bin wrapping test
+    typename single_axis<circular<>, regular<>>::shape_type circ_shape{};
+    EXPECT_EQ(circ_shape.wrap(4, 36u), 3u);
+    EXPECT_EQ(circ_shape.wrap(0, 36u), 35u);
+    EXPECT_EQ(circ_shape.wrap(-1, 36u), 34u);
+    EXPECT_EQ(circ_shape.wrap(36, 36u), 35u);
+    EXPECT_EQ(circ_shape.wrap(40, 36u), 3u);
+
+    // Axis range access - binned (symmetric & asymmetric)
+    darray<dindex, 2> nhood00i = {0u, 0u};
+    darray<dindex, 2> nhood01i = {0u, 1u};
+    darray<dindex, 2> nhood11i = {1u, 1u};
+    darray<dindex, 2> nhood22i = {2u, 2u};
+
+    dindex_range expected_range = {0u, 0u};
+    EXPECT_EQ(cr_axis.range(pi + epsilon, nhood00i), expected_range);
+    expected_range = {0u, 1u};
+    EXPECT_EQ(cr_axis.range(pi + epsilon, nhood01i), expected_range);
+    expected_range = {35u, 1u};
+    EXPECT_EQ(cr_axis.range(pi + epsilon, nhood11i), expected_range);
+    expected_range = {34u, 2u};
+    EXPECT_EQ(cr_axis.range(pi + epsilon, nhood22i), expected_range);
+
+    // Axis range access - scalar (symmetric & asymmteric)
+    darray<scalar, 2> nhood00s = {0., 0.};
+    darray<scalar, 2> nhoodEpsilon = {scalar{0.5} * epsilon,
+                                      scalar{0.5} * epsilon};
+    scalar bin_step{cr_axis.m_binning.bin_width()};
+    darray<scalar, 2> nhood22s = {2 * bin_step, 2 * bin_step};
+
+    expected_range = {0u, 0u};
+    EXPECT_EQ(cr_axis.range(pi + epsilon, nhood00s), expected_range);
+    EXPECT_EQ(cr_axis.range(pi + epsilon, nhoodEpsilon), expected_range);
+    expected_range = {34u, 2u};
+    EXPECT_EQ(cr_axis.range(pi + epsilon, nhood22s), expected_range);
+}
+
+TEST(grid, closed_irregular_axis) {
+
+    // Lower bin edges: all lower bin edges for irregular binning, plus the
+    // final upper bin edge
+    vecmem::vector<scalar> bin_edges = {-100, -3, 1, 2, 4, 8, 12, 15, 18};
+    // Index range for the bin edges [-3, 15]
+    dindex_range edge_range = {1, 7};
+
+    // A closed irregular z-axis
+    single_axis<closed<label::e_z>, irregular<>> cir_axis(&edge_range,
+                                                          &bin_edges);
+
+    // Test axis shape
+    EXPECT_EQ(cir_axis.label(), n_axis::label::e_z);
+    EXPECT_EQ(cir_axis.shape(), n_axis::shape::e_closed);
+    EXPECT_EQ(cir_axis.binning(), n_axis::binning::e_irregular);
+
+    // Axis bin access
+    //
+    // N bins
+    EXPECT_EQ(cir_axis.nbins(), 6u);
+    // Bin tests
+    EXPECT_EQ(cir_axis.bin(-2), 0u);
+    EXPECT_EQ(cir_axis.bin(10), 4u);
+    EXPECT_EQ(cir_axis.bin(5.8), 3u);
+    // Underflow test
+    EXPECT_EQ(cir_axis.bin(-4), 0u);
+    // Overflow test
+    EXPECT_EQ(cir_axis.bin(17), 5u);
+
+    // Axis range access - binned  (symmetric & asymmetric)
+    darray<dindex, 2> nhood00i = {0u, 0u};
+    darray<dindex, 2> nhood01i = {0u, 1u};
+    darray<dindex, 2> nhood11i = {1u, 1u};
+    darray<dindex, 2> nhood22i = {2u, 2u};
+
+    dindex_range expected_range = {2u, 2u};
+    EXPECT_EQ(cir_axis.range(3., nhood00i), expected_range);
+    expected_range = {1u, 3u};
+    EXPECT_EQ(cir_axis.range(3., nhood11i), expected_range);
+    expected_range = {2u, 3u};
+    EXPECT_EQ(cir_axis.range(3., nhood01i), expected_range);
+    expected_range = {0u, 1u};
+    EXPECT_EQ(cir_axis.range(0., nhood11i), expected_range);
+    expected_range = {2u, 5u};
+    EXPECT_EQ(cir_axis.range(10., nhood22i), expected_range);
+
+    // Axis range access - scalar
+    darray<scalar, 2> nhood00s = {0., 0.};
+    darray<scalar, 2> nhood10s = {1.5, 0.2};
+    darray<scalar, 2> nhood11s = {4., 5.5};
+
+    expected_range = {2u, 2u};
+    EXPECT_EQ(cir_axis.range(3., nhood00s), expected_range);
+    expected_range = {1u, 2u};
+    EXPECT_EQ(cir_axis.range(3., nhood10s), expected_range);
+    expected_range = {0u, 4u};
+    EXPECT_EQ(cir_axis.range(3., nhood11s), expected_range);
+}
+
+TEST(grid, multi_axis) {
+
+    // readable axis ownership definition
+    bool constexpr is_owning = true;
+    bool constexpr is_not_owning = false;
+
+    // Lower bin edges for all axes
+    vecmem::vector<scalar> bin_edges = {-10., 10., -20., 20., 0., 100.};
+    // Offsets into edges container and #bins for all axes
+    vecmem::vector<dindex_range> edge_ranges = {
+        {0u, 20u}, {2u, 40u}, {4u, 50u}};
+
+    // Non-owning multi axis test
+    cartesian_3D<is_not_owning, host_container_types> axes(&edge_ranges,
+                                                           &bin_edges);
+
+    EXPECT_EQ(axes.Dim, 3u);
+
+    // Get single axis objects
+    auto x_axis = axes.get_axis<label::e_x>();
+    EXPECT_EQ(x_axis.nbins(), 20u);
+    auto y_axis = axes.get_axis<label::e_y>();
+    EXPECT_EQ(y_axis.nbins(), 40u);
+    auto z_axis = axes.get_axis<label::e_z>();
+    EXPECT_EQ(z_axis.nbins(), 50u);
+
+    auto ax = axes.get_axis<decltype(y_axis)>();
+    EXPECT_EQ(ax.nbins(), 40u);
+
+    // Test bin search
+    point3 p3{0., 0., 0.};  // origin
+    dmulti_index<dindex, 3> expected_bins{10u, 20u, 0u};
+    EXPECT_EQ(axes.bins(p3), expected_bins);
+    p3 = {-5.5, -3.2, 24.1};
+    expected_bins = {4u, 16u, 12u};
+    EXPECT_EQ(axes.bins(p3), expected_bins);
+    p3 = {-1., 21., 12.};
+    expected_bins = {9u, 39u, 6u};
+    EXPECT_EQ(axes.bins(p3), expected_bins);
+
+    // Test bin range search
+    p3 = {1., 1., 10.};
+    // Axis range access - binned  (symmetric & asymmetric)
+    darray<dindex, 2> nhood00i = {0u, 0u};
+    darray<dindex, 2> nhood01i = {0u, 1u};
+    darray<dindex, 2> nhood22i = {2u, 2u};
+
+    dmulti_index<dindex_range, 3> expected_ranges{};
+    expected_ranges[0] = {11u, 11u};
+    expected_ranges[1] = {21u, 21};
+    expected_ranges[2] = {5u, 5u};
+    EXPECT_EQ(axes.bin_ranges(p3, nhood00i), expected_ranges);
+    expected_ranges[0] = {11u, 12u};
+    expected_ranges[1] = {21u, 22u};
+    expected_ranges[2] = {5u, 6u};
+    EXPECT_EQ(axes.bin_ranges(p3, nhood01i), expected_ranges);
+    expected_ranges[0] = {9u, 13u};
+    expected_ranges[1] = {19u, 23u};
+    expected_ranges[2] = {3u, 7u};
+    EXPECT_EQ(axes.bin_ranges(p3, nhood22i), expected_ranges);
+
+    // Axis range access - scalar
+    darray<scalar, 2> nhood00s = {0., 0.};
+    darray<scalar, 2> nhood10s = {1.5, 0.2};
+    darray<scalar, 2> nhood11s = {4., 5.5};
+
+    expected_ranges[0] = {11u, 11u};
+    expected_ranges[1] = {21u, 21u};
+    expected_ranges[2] = {5u, 5u};
+    EXPECT_EQ(axes.bin_ranges(p3, nhood00s), expected_ranges);
+    expected_ranges[0] = {9u, 11u};
+    expected_ranges[1] = {19u, 21u};
+    expected_ranges[2] = {4u, 5u};
+    EXPECT_EQ(axes.bin_ranges(p3, nhood10s), expected_ranges);
+    expected_ranges[0] = {7u, 16u};
+    expected_ranges[1] = {17u, 26u};
+    expected_ranges[2] = {3u, 7u};
+    EXPECT_EQ(axes.bin_ranges(p3, nhood11s), expected_ranges);
+
+    // Owning multi axis test
+    vecmem::vector<scalar> bin_edges_cp(bin_edges);
+    // Offsets into edges container and #bins for all axes
+    vecmem::vector<dindex_range> edge_ranges_cp(edge_ranges);
+
+    cartesian_3D<is_owning, host_container_types> axes_own(
+        std::move(edge_ranges_cp), std::move(bin_edges_cp));
+
+    EXPECT_EQ(axes_own.bins(p3), axes.bins(p3));
+    EXPECT_EQ(axes_own.bin_ranges(p3, nhood00i), axes.bin_ranges(p3, nhood00i));
+    EXPECT_EQ(axes_own.bin_ranges(p3, nhood01i), axes.bin_ranges(p3, nhood01i));
+    EXPECT_EQ(axes_own.bin_ranges(p3, nhood22i), axes.bin_ranges(p3, nhood22i));
+    EXPECT_EQ(axes_own.bin_ranges(p3, nhood00s), axes.bin_ranges(p3, nhood00s));
+    EXPECT_EQ(axes_own.bin_ranges(p3, nhood10s), axes.bin_ranges(p3, nhood10s));
+    EXPECT_EQ(axes_own.bin_ranges(p3, nhood11s), axes.bin_ranges(p3, nhood11s));
+
+    // Transfer to an owning multi-axis, which uses vecmem::device_vector
+    cartesian_3D<is_owning, host_container_types>::view_type axes_view =
+        get_data(axes_own);
+    cartesian_3D<is_owning, device_container_types> axes_device(axes_view);
+
+    // Get single axis objects
+    auto x_axis_device = axes_device.get_axis<label::e_x>();
+    EXPECT_EQ(x_axis_device.nbins(), 20u);
+    auto y_axis_device = axes_device.get_axis<label::e_y>();
+    EXPECT_EQ(y_axis_device.nbins(), 40u);
+    auto z_axis_device = axes_device.get_axis<label::e_z>();
+    EXPECT_EQ(z_axis_device.nbins(), 50u);
+}
diff --git a/tests/common/include/tests/common/grid_grid.inl b/tests/common/include/tests/common/grid_grid.inl
new file mode 100644
index 0000000000..473216044c
--- /dev/null
+++ b/tests/common/include/tests/common/grid_grid.inl
@@ -0,0 +1,427 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include <gtest/gtest.h>
+
+// Detray include(s)
+#include "detray/definitions/indexing.hpp"
+#include "detray/masks/cuboid3D.hpp"
+#include "detray/surface_finders/grid/axis.hpp"
+#include "detray/surface_finders/grid/grid.hpp"
+#include "detray/surface_finders/grid/grid_builder.hpp"
+#include "detray/surface_finders/grid/populator.hpp"
+#include "detray/surface_finders/grid/serializer.hpp"
+
+// Vecmem include(s)
+#include <vecmem/containers/device_vector.hpp>
+#include <vecmem/containers/vector.hpp>
+#include <vecmem/memory/host_memory_resource.hpp>
+
+// System include(s)
+#include <algorithm>
+#include <climits>
+
+using namespace detray;
+using namespace detray::n_axis;
+
+namespace {
+
+// Algebra definitions
+using point3 = __plugin::point3<scalar>;
+
+constexpr scalar inf{std::numeric_limits<scalar>::max()};
+
+// Either a data owning or non-owning 3D cartesian multi-axis
+template <bool ownership = true, typename containers = host_container_types>
+using cartesian_3D =
+    coordinate_axes<cuboid3D::axes<shape::e_closed, regular, regular, regular>,
+                    ownership, containers>;
+
+// non-owning multi-axis: Takes external containers
+bool constexpr is_owning = true;
+bool constexpr is_n_owning = false;
+
+// Lower bin edges for all axes
+dvector<scalar> bin_edges = {-10, 10., -20., 20., 0., 100.};
+// Offsets into edges container and #bins for all axes
+dvector<dindex_range> edge_ranges = {{0u, 20u}, {2u, 40u}, {4u, 50u}};
+
+// non-owning multi-axis for the non-owning grid
+cartesian_3D<is_n_owning, host_container_types> ax_n_own(&edge_ranges,
+                                                         &bin_edges);
+
+// Create some bin data for non-owning grid
+template <class populator_t, typename entry_t>
+struct increment {
+    using bin_t = typename populator_t::template bin_type<entry_t>;
+
+    bin_t stored_entry;
+    entry_t entry;
+
+    increment() : entry{0} {}
+    bin_t operator()() {
+        entry += entry_t{1};
+        return populator_t::init(entry);
+    }
+};
+
+/// Test bin content element by element
+template <typename grid_t, typename content_t>
+void test_content(const grid_t& g, const point3& p, const content_t& expected) {
+    dindex i = 0;
+    for (const auto& entry : g.search(p)) {
+        ASSERT_FLOAT_EQ(entry, expected[i++]);
+    }
+}
+
+}  // anonymous namespace
+
+/// Unittest: Test single grid construction
+TEST(grid, single_grid) {
+
+    // Owning and non-owning, cartesian, 3-dimensional, replacing grids
+    using grid_owning_t =
+        grid<cartesian_3D<>, scalar, simple_serializer, replacer>;
+
+    using grid_n_owning_t =
+        grid<cartesian_3D<is_n_owning>, scalar, simple_serializer, replacer>;
+
+    using grid_device_t = grid<cartesian_3D<is_owning, device_container_types>,
+                               scalar, simple_serializer, replacer>;
+
+    // Fill the bin data for every test
+    // bin test entries
+    grid_owning_t::bin_storage_type bin_data{};
+    bin_data.resize(40'000);
+    std::generate_n(bin_data.begin(), 40'000u,
+                    increment<grid_owning_t::populator_type, scalar>());
+
+    // Copy data that will be moved into the data owning types
+    dvector<scalar> bin_edges_cp(bin_edges);
+    dvector<dindex_range> edge_ranges_cp(edge_ranges);
+    grid_owning_t::bin_storage_type bin_data_cp(bin_data);
+
+    // Data-owning axes and grid
+    cartesian_3D<is_owning, host_container_types> axes_own(
+        std::move(edge_ranges_cp), std::move(bin_edges_cp));
+    grid_owning_t grid_own(std::move(bin_data_cp), std::move(axes_own));
+
+    // Check a few basics
+    EXPECT_EQ(grid_own.Dim, 3);
+    auto y_axis = grid_own.get_axis<label::e_y>();
+    EXPECT_EQ(y_axis.nbins(), 40u);
+    auto z_axis =
+        grid_own.get_axis<single_axis<closed<label::e_z>, regular<>>>();
+    EXPECT_EQ(z_axis.nbins(), 50u);
+
+    // Create non-owning grid
+    grid_n_owning_t grid_n_own(&bin_data, ax_n_own);
+
+    // Test for consistency with owning grid
+    EXPECT_EQ(grid_n_own.Dim, grid_own.Dim);
+    y_axis = grid_n_own.get_axis<label::e_y>();
+    EXPECT_EQ(y_axis.nbins(), grid_own.get_axis<label::e_y>().nbins());
+    z_axis = grid_n_own.get_axis<label::e_z>();
+    EXPECT_EQ(z_axis.nbins(), grid_own.get_axis<label::e_z>().nbins());
+
+    // Construct a grid from a view
+    grid_owning_t::view_type grid_view = get_data(grid_own);
+    grid_device_t device_grid(grid_view);
+
+    // Test for consistency with non-owning grid
+    EXPECT_EQ(device_grid.Dim, grid_n_own.Dim);
+    auto y_axis_dev = device_grid.get_axis<label::e_y>();
+    EXPECT_EQ(y_axis_dev.nbins(), grid_n_own.get_axis<label::e_y>().nbins());
+    auto z_axis_dev = device_grid.get_axis<label::e_z>();
+    EXPECT_EQ(z_axis_dev.nbins(), grid_n_own.get_axis<label::e_z>().nbins());
+
+    // Test const grid view
+    auto const_grid_view = get_data(const_cast<const grid_owning_t&>(grid_own));
+
+    static_assert(
+        std::is_same_v<decltype(const_grid_view),
+                       typename grid<cartesian_3D<>, const scalar,
+                                     simple_serializer, replacer>::view_type>,
+        "Const grid view was not correctly constructed!");
+
+    grid<cartesian_3D<is_owning, device_container_types>, const scalar,
+         simple_serializer, replacer>
+        const_device_grid(const_grid_view);
+
+    static_assert(
+        std::is_same_v<typename decltype(const_device_grid)::bin_type,
+                       typename replacer::template bin_type<const scalar>>,
+        "Const grid was not correctly constructed from view!");
+}
+
+/// Test bin entry retrieval
+TEST(grid, search) {
+
+    // Non-owning, 3D cartesian, replacing grid
+    /*using grid_t = grid<scalar, simple_serializer, replacer<>,
+                        cartesian_3D, is_n_owning>;
+    // init
+    grid_t::bin_storage_type bin_data{};
+    bin_data.resize(40'000, grid_t::populator_type::init<scalar>());
+
+    grid_t grid_3D(&bin_data, ax_n_own);
+
+    axis::multi_bin<3> mbin{2, 1, 0};
+    EXPECT_FLOAT_EQ(*grid_3D.at(mbin), scalar{23});
+    mbin = {14, 3, 23};
+    EXPECT_FLOAT_EQ(*grid_3D.at(mbin), scalar{42});
+    mbin = {0, 16, 7};
+    EXPECT_FLOAT_EQ(*grid_3D.at(mbin), scalar{42});
+    mbin = {6, 31, 44};
+    EXPECT_FLOAT_EQ(*grid_3D.at(mbin), scalar{42});*/
+}
+
+/// Integration test: Test replace population
+TEST(grid, replace_population) {
+
+    // Non-owning, 3D cartesian, replacing grid
+    using grid_t =
+        grid<cartesian_3D<is_n_owning>, scalar, simple_serializer, replacer>;
+    // init
+    grid_t::bin_storage_type bin_data{};
+    bin_data.resize(40'000, grid_t::populator_type::init<scalar>());
+
+    // Create non-owning grid
+    grid_t g3r(&bin_data, ax_n_own);
+
+    // Test the initialization
+    point3 p = {-10., -20., 0.};
+    for (int ib0 = 0; ib0 < 20; ++ib0) {
+        for (int ib1 = 0; ib1 < 40; ++ib1) {
+            for (int ib2 = 0; ib2 < 100; ib2 += 2) {
+                p = {static_cast<scalar>(-10 + ib0),
+                     static_cast<scalar>(-20 + ib1),
+                     static_cast<scalar>(0. + ib2)};
+                EXPECT_FLOAT_EQ(*g3r.search(p),
+                                std::numeric_limits<scalar>::max());
+            }
+        }
+    }
+
+    p = {-4.5, -4.5, 4.5};
+    // Fill and read
+    g3r.populate(p, 3u);
+    EXPECT_FLOAT_EQ(*g3r.search(p), static_cast<scalar>(3u));
+
+    // Fill and read two times, fill first 0-99, then 100-199
+    for (unsigned int il = 0; il < 2; ++il) {
+        scalar counter{static_cast<scalar>(il * 100)};
+        for (int ib0 = 0; ib0 < 20; ++ib0) {
+            for (int ib1 = 0; ib1 < 40; ++ib1) {
+                for (int ib2 = 0; ib2 < 100; ib2 += 2) {
+                    p = {static_cast<scalar>(-10 + ib0),
+                         static_cast<scalar>(-20 + ib1),
+                         static_cast<scalar>(0. + ib2)};
+                    g3r.populate(p, counter);
+                    EXPECT_FLOAT_EQ(*g3r.search(p), counter);
+                    counter += scalar{1};
+                }
+            }
+        }
+    }
+
+    // A zone test w/o neighbour hood
+    /*p = {-4.5, -4.5, 4.5};
+    auto test = g2.search(p);
+    dvector<dindex> expect = {100u};
+    EXPECT_EQ(test, expect);
+
+    // A zone test with neighbour hood
+    p = {0.5, 0.5};
+
+    darray<dindex, 2> zone11 = {1u, 1u};
+    darray<dindex, 2> zone22 = {2u, 2u};
+
+    test = g2.zone(p, {zone11, zone22}, true);
+    expect = {143u, 144u, 145u, 146u, 147u, 153u, 154u, 155u,
+              156u, 157u, 163u, 164u, 165u, 166u, 167u};
+    EXPECT_EQ(test, expect);
+
+    using grid2cc = grid2<replace_populator, axis::circular, axis::regular,
+                          decltype(serializer)>;
+
+    typename grid2cc::axis_p0_type circular{4, -2., 2., host_mr};
+    typename grid2cc::axis_p1_type closed{5, 0., 5., host_mr};
+
+    grid2cc g2cc(std::move(circular), std::move(closed), host_mr);
+    unsigned int counter = 0;
+    for (unsigned icl = 0; icl < 5; ++icl) {
+        for (unsigned ici = 0; ici < 4; ++ici) {
+            p = {static_cast<scalar>(-1.5 + ici),
+                 static_cast<scalar>(0.5 + icl)};
+            g2cc.populate(p, counter++);
+        }
+    }
+
+    // A zone test for circular testing
+    p = {1.5, 2.5};
+    test = g2cc.zone(p, {zone11, zone11}, true);
+    expect = {4u, 6u, 7u, 8u, 10u, 11u, 12u, 14u, 15u};
+    EXPECT_EQ(test, expect);*/
+}
+
+/// Test bin entry retrieval
+TEST(grid, complete_population) {
+
+    // Non-owning, 3D cartesian, completing grid (4 dims and sort)
+    using grid_t = grid<cartesian_3D<is_n_owning>, scalar, simple_serializer,
+                        completer<4, true>>;
+    using bin_content_t = grid_t::bin_type::content_type;
+
+    // init
+    grid_t::bin_storage_type bin_data{};
+    bin_data.resize(40'000, grid_t::populator_type::init<scalar>());
+    // Create non-owning grid
+    grid_t g3c(&bin_data, ax_n_own);
+
+    // Test the initialization
+    point3 p = {-10., -20., 0.};
+    grid_t::bin_type invalid = grid_t::populator_type::init<scalar>();
+    for (int ib0 = 0; ib0 < 20; ++ib0) {
+        for (int ib1 = 0; ib1 < 40; ++ib1) {
+            for (int ib2 = 0; ib2 < 100; ib2 += 2) {
+                p = {static_cast<scalar>(-10 + ib0),
+                     static_cast<scalar>(-20 + ib1),
+                     static_cast<scalar>(0. + ib2)};
+                test_content(g3c, p, invalid.content());
+            }
+        }
+    }
+
+    p = {-4.5, -4.5, 4.5};
+    bin_content_t expected{4., 4., 4., 4.};
+    // Fill and read
+    g3c.populate(p, 4u);
+    test_content(g3c, p, expected);
+
+    /*
+    auto zone_test = g2.zone(p);
+    dvector<dindex> zone_expected = {4u};
+    EXPECT_EQ(zone_test, zone_expected);
+
+    g2.populate(p, 2u);
+    expected = {4u, 2u, dindex_invalid};
+    test = g2.bin(p);
+    EXPECT_EQ(test, expected);
+
+    g2.populate(p, 7u);
+    expected = {4u, 2u, 7u};
+    test = g2.bin(p);
+    EXPECT_EQ(test, expected);
+
+    // Bin is completed, new content is ignored
+    g2.populate(p, 16u);
+    test = g2.bin(p);
+    EXPECT_EQ(test, expected);
+
+    darray<dindex, 2> zone00 = {0u, 0u};
+    darray<dindex, 2> zone11 = {1u, 1u};
+
+    // Zone test of a complete bin
+    zone_test = g2.zone(p, {zone00, zone00});
+    zone_expected = {4u, 2u, 7u};
+    EXPECT_EQ(zone_test, zone_expected);
+
+    // Fill some other bins
+    p = {0.5, -0.5};
+    g2.populate(p, 16u);
+
+    p = {0.5, 0.5};
+    g2.populate(p, 17u);
+    g2.populate(p, 18u);
+
+    zone_test = g2.zone(p, {zone11, zone11});
+    zone_expected = {4u, 2u, 7u, 16u, 17u, 18u};
+    EXPECT_EQ(zone_test, zone_expected);*/
+}
+
+/// Test bin entry retrieval
+TEST(grid, regular_attach_population) {
+
+    // Non-owning, 3D cartesian, completing grid (4 dims and sort)
+    using grid_t = grid<cartesian_3D<is_n_owning>, scalar, simple_serializer,
+                        regular_attacher<4, true>>;
+    using bin_content_t = grid_t::bin_type::content_type;
+
+    // init
+    grid_t::bin_storage_type bin_data{};
+    bin_data.resize(40'000, grid_t::populator_type::init<scalar>());
+
+    // Create non-owning grid
+    grid_t g3ra(&bin_data, ax_n_own);
+
+    // Test the initialization
+    point3 p = {-10., -20., 0.};
+    grid_t::bin_type invalid = grid_t::populator_type::init<scalar>();
+    for (int ib0 = 0; ib0 < 20; ++ib0) {
+        for (int ib1 = 0; ib1 < 40; ++ib1) {
+            for (int ib2 = 0; ib2 < 100; ib2 += 2) {
+                p = {static_cast<scalar>(-10 + ib0),
+                     static_cast<scalar>(-20 + ib1),
+                     static_cast<scalar>(0. + ib2)};
+                test_content(g3ra, p, invalid.content());
+            }
+        }
+    }
+
+    p = {-4.5, -4.5, 4.5};
+    bin_content_t expected{5., inf, inf, inf};
+    // Fill and read
+    g3ra.populate(p, 5u);
+    test_content(g3ra, p, expected);
+
+    /* auto zone_test = g2.zone(p);
+     dvector<dindex> zone_expected = {4u};
+     EXPECT_EQ(zone_test, zone_expected);
+
+     p = {-0.5, 0.5};
+     g2.populate(p, 9u);
+
+     p = {0.5, -0.5};
+     g2.populate(p, 1u);
+
+     p = {0.5, 0.5};
+     g2.populate(p, 7u);
+
+     expected = {7u};
+     test = g2.bin(p);
+     EXPECT_EQ(test, expected);
+
+     darray<dindex, 2> zone11 = {1u, 1u};
+
+     zone_test = g2.zone(p, {zone11, zone11}, true);
+     zone_expected = {1u, 4u, 7u, 9u};
+     EXPECT_EQ(zone_test, zone_expected);*/
+}
+
+/*TEST(grids, irregular_replace_population) {
+
+    // Non-owning, 3D cartesian, replacing grid
+    using grid_t =
+        grid<scalar, simple_serializer, replacer<>, cartesian_3D, is_n_owning>;
+    // init
+    grid_t::bin_storage_type bin_data{};
+    bin_data.resize(40'000, grid_t::populator_type::init<scalar>());
+
+    // Create non-owning grid
+    grid_t g3r(&bin_data, ax_n_own);
+    typename grid2ir::axis_p0_type xaxis{
+        {-3, -2., 1, 0.5, 0.7, 0.71, 4., 1000.}, host_mr};
+    typename grid2ir::axis_p1_type yaxis{{0.1, 0.8, 0.9, 10., 12., 15.},
+                                         host_mr};
+
+    grid2ir g2(std::move(xaxis), std::move(yaxis), host_mr);
+
+    test::point2<detray::scalar> p = {-0.5, 0.5};
+    g2.populate(p, 4u);
+    EXPECT_EQ(g2.bin(p), 4u);
+}*/
\ No newline at end of file
diff --git a/tests/common/include/tests/common/grid_populator.inl b/tests/common/include/tests/common/grid_populator.inl
new file mode 100644
index 0000000000..1e8f997129
--- /dev/null
+++ b/tests/common/include/tests/common/grid_populator.inl
@@ -0,0 +1,178 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include <gtest/gtest.h>
+
+#include <algorithm>
+#include <climits>
+
+// detray core
+#include "detray/definitions/indexing.hpp"
+#include "detray/surface_finders/grid/populator.hpp"
+
+using namespace detray;
+
+namespace {
+
+constexpr dindex inf{std::numeric_limits<dindex>::max()};
+
+template <class populator_t, typename entry_t>
+struct increment {
+    using bin_t = typename populator_t::template bin_type<entry_t>;
+
+    bin_t stored_content;
+    entry_t entry;
+
+    increment() : entry{0} {}
+    bin_t operator()() {
+        entry += entry_t{1};
+        return populator_t::init(entry);
+    }
+};
+
+/// Test bin content entry by entry
+template <typename populator_t, typename storage_t, typename content_t>
+void test_content(populator_t& p, storage_t& storage, dindex bin_idx,
+                  content_t& expected) {
+    dindex i = 0;
+    for (const auto& entry : p.view(storage, bin_idx)) {
+        EXPECT_EQ(entry, expected[i++]);
+    }
+}
+
+}  // anonymous namespace
+
+/// Replace populator
+TEST(grid, replace_populator) {
+    // No sorting, dindex entries in backend storage, vecmem::vector
+    using populator_t = populator<replacer>;
+    populator_t replace_populator;
+
+    // Create some bin data
+    dvector<populator_t::template bin_type<dindex>> bin_data{};
+    bin_data.reserve(50);
+    std::generate_n(bin_data.begin(), 50, increment<populator_t, dindex>());
+
+    // Check test setup
+    EXPECT_EQ(bin_data[2].content(), 3UL);
+    EXPECT_EQ(*replace_populator.view(bin_data, 2), 3UL);
+    EXPECT_EQ(bin_data[42].content(), 43UL);
+    EXPECT_EQ(*replace_populator.view(bin_data, 42), 43UL);
+
+    // Replace some bin entries
+    dindex entry{15};
+
+    replace_populator(bin_data, 2, entry);
+    EXPECT_EQ(bin_data[2].content(), 15UL);
+    EXPECT_EQ(*replace_populator.view(bin_data, 2), 15UL);
+
+    replace_populator(bin_data, 2, entry);
+    EXPECT_EQ(bin_data[2].content(), 15UL);
+    EXPECT_EQ(*replace_populator.view(bin_data, 2), 15UL);
+}
+
+/// Complete populator
+TEST(grid, complete_populator) {
+
+    // No sorting, 4 dims, dindex entries in backend storage, std::array
+    using populator_t = populator<completer<4>>;
+    populator_t complete_populator{};
+
+    // Create some bin data
+    dvector<populator_t::template bin_type<dindex>> bin_data{};
+    bin_data.reserve(50);
+    std::generate_n(bin_data.begin(), 50, increment<populator_t, dindex>());
+
+    // Check test setup
+    populator_t::template bin_type<dindex>::content_type stored = {3UL, inf,
+                                                                   inf, inf};
+    EXPECT_EQ(bin_data[2].content(), stored);
+    test_content(complete_populator, bin_data, 2, stored);
+    stored = {43UL, inf, inf, inf};
+    EXPECT_EQ(bin_data[42].content(), stored);
+    test_content(complete_populator, bin_data, 42, stored);
+
+    // Fill up some bin entries
+    dindex entry{15};
+
+    stored = {3UL, 15UL, 15UL, 15UL};
+    complete_populator(bin_data, 2, entry);
+    EXPECT_EQ(bin_data[2].content(), stored);
+    test_content(complete_populator, bin_data, 2, stored);
+
+    stored = {43UL, 15UL, 15UL, 15UL};
+    complete_populator(bin_data, 42, entry);
+    EXPECT_EQ(bin_data[42].content(), stored);
+    test_content(complete_populator, bin_data, 42, stored);
+
+    // Do sorting, 4 dims, dindex entries in backend storage, std::array
+    populator<completer<4, true>> sort_complete_populator;
+
+    stored = {2UL, 15UL, 15UL, 15UL};
+    sort_complete_populator(bin_data, 1, entry);
+    EXPECT_EQ(bin_data[1].content(), stored);
+    test_content(sort_complete_populator, bin_data, 1, stored);
+
+    stored = {15UL, 15UL, 15UL, 42UL};
+    sort_complete_populator(bin_data, 41, entry);
+    EXPECT_EQ(bin_data[41].content(), stored);
+    test_content(sort_complete_populator, bin_data, 41, stored);
+}
+
+/// Regular attach populator
+TEST(grid, regular_attach_populator) {
+
+    // No sorting, 4 dims, dindex entries in backend storage, std::array
+    using populator_t = populator<regular_attacher<4>>;
+    populator_t reg_attach_populator{};
+
+    // Create some bin data
+    dvector<populator_t::template bin_type<dindex>> bin_data{};
+    bin_data.reserve(50);
+    std::generate_n(bin_data.begin(), 50, increment<populator_t, dindex>());
+
+    // Check test setup
+    populator_t::template bin_type<dindex>::content_type stored = {3UL, inf,
+                                                                   inf, inf};
+    EXPECT_EQ(bin_data[2].content(), stored);
+    test_content(reg_attach_populator, bin_data, 2, stored);
+    stored = {43UL, inf, inf, inf};
+    EXPECT_EQ(bin_data[42].content(), stored);
+    test_content(reg_attach_populator, bin_data, 42, stored);
+
+    // Attach some bin entries
+    dindex entry1{15}, entry2{8};
+
+    stored = {3UL, 15UL, 8UL, inf};
+    reg_attach_populator(bin_data, 2, entry1);
+    reg_attach_populator(bin_data, 2, entry2);
+    EXPECT_EQ(bin_data[2].content(), stored);
+    test_content(reg_attach_populator, bin_data, 2, stored);
+
+    stored = {43UL, 15UL, 8UL, 16UL};
+    reg_attach_populator(bin_data, 42, entry1);
+    reg_attach_populator(bin_data, 42, entry2);
+    reg_attach_populator(bin_data, 42, entry1 + 1);
+    EXPECT_EQ(bin_data[42].content(), stored);
+    test_content(reg_attach_populator, bin_data, 42, stored);
+
+    // Do sorting, 4 dims, dindex entries in backend storage, std::array
+    populator<regular_attacher<4, true>> sort_reg_attach_populator;
+
+    stored = {2UL, 8UL, 9UL, 15UL};
+    sort_reg_attach_populator(bin_data, 1, entry1);
+    sort_reg_attach_populator(bin_data, 1, entry2);
+    sort_reg_attach_populator(bin_data, 1, entry2 + 1);
+    EXPECT_EQ(bin_data[1].content(), stored);
+    test_content(sort_reg_attach_populator, bin_data, 1, stored);
+
+    stored = {8UL, 15UL, 42UL, inf};
+    sort_reg_attach_populator(bin_data, 41, entry1);
+    sort_reg_attach_populator(bin_data, 41, entry2);
+    EXPECT_EQ(bin_data[41].content(), stored);
+    test_content(sort_reg_attach_populator, bin_data, 41, stored);
+}
diff --git a/tests/common/include/tests/common/grid_serializer.inl b/tests/common/include/tests/common/grid_serializer.inl
new file mode 100644
index 0000000000..a30f2fd7dc
--- /dev/null
+++ b/tests/common/include/tests/common/grid_serializer.inl
@@ -0,0 +1,108 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include <gtest/gtest.h>
+
+#include <climits>
+
+// detray test
+#include <vecmem/containers/vector.hpp>
+#include <vecmem/memory/host_memory_resource.hpp>
+
+// detray core
+#include "detray/definitions/indexing.hpp"
+#include "detray/masks/masks.hpp"
+#include "detray/surface_finders/grid/axis.hpp"
+#include "detray/surface_finders/grid/serializer.hpp"
+
+using namespace detray;
+using namespace detray::n_axis;
+
+namespace {
+
+// Axes types to be serialized
+
+// polar coordinate system with regular binning on both axes
+using polar_axes = multi_axis<
+    true, polar2<__plugin::transform3<scalar>>,
+    single_axis<closed<label::e_r>, regular<host_container_types, scalar>>,
+    single_axis<circular<label::e_phi>, regular<host_container_types, scalar>>>;
+// 3-dim cylindrical coordinate system with regular binning
+using cylinder_axes = multi_axis<
+    true, cylindrical3<__plugin::transform3<scalar>>,
+    single_axis<closed<label::e_r>, regular<host_container_types, scalar>>,
+    single_axis<circular<label::e_phi>, regular<host_container_types, scalar>>,
+    single_axis<closed<label::e_z>, regular<host_container_types, scalar>>>;
+
+// Floating point comparison
+constexpr scalar tol{1e-5};
+
+}  // anonymous namespace
+
+TEST(grid, serializer2D) {
+
+    // Offsets into edges container and #bins for all axes
+    vecmem::vector<dindex_range> edge_ranges = {{0u, 6u}, {2u, 12u}};
+    // Not needed for serializer test
+    vecmem::vector<scalar> bin_edges{};
+
+    polar_axes axes(std::move(edge_ranges), std::move(bin_edges));
+
+    simple_serializer<2> serializer{};
+
+    // Serializing
+    multi_bin<2> mbin{{0u, 0u}};
+    EXPECT_EQ(serializer(axes, mbin), 0u);
+    mbin = {{5u, 0u}};
+    EXPECT_EQ(serializer(axes, mbin), 5u);
+    mbin = {{0u, 1u}};
+    EXPECT_EQ(serializer(axes, mbin), 6u);
+    mbin = {{5u, 2u}};
+    EXPECT_EQ(serializer(axes, mbin), 17u);
+
+    // Deserialize
+    multi_bin<2> expected_mbin{{0u, 0u}};
+    EXPECT_EQ(serializer(axes, 0u), expected_mbin);
+    expected_mbin = {{5u, 0u}};
+    EXPECT_EQ(serializer(axes, 5u), expected_mbin);
+    expected_mbin = {{0u, 1u}};
+    EXPECT_EQ(serializer(axes, 6u), expected_mbin);
+    expected_mbin = {{5u, 2u}};
+    EXPECT_EQ(serializer(axes, 17u), expected_mbin);
+}
+
+TEST(grid, serializer3D) {
+
+    // Offsets into edges container and #bins for all axes
+    vecmem::vector<dindex_range> edge_ranges = {{0u, 4u}, {2u, 2u}, {4u, 2u}};
+    // Not needed for serializer test
+    vecmem::vector<scalar> bin_edges{};
+
+    cylinder_axes axes(std::move(edge_ranges), std::move(bin_edges));
+
+    simple_serializer<3> serializer{};
+
+    // Serializing
+    multi_bin<3> mbin{{0u, 0u, 0u}};
+    EXPECT_EQ(serializer(axes, mbin), 0u);
+    mbin = {{2u, 1u, 0u}};
+    EXPECT_EQ(serializer(axes, mbin), 6u);
+    mbin = {{3u, 0u, 1u}};
+    EXPECT_EQ(serializer(axes, mbin), 11u);
+    mbin = {{1u, 1u, 1u}};
+    EXPECT_EQ(serializer(axes, mbin), 13u);
+
+    // Deserialize
+    multi_bin<3> expected_mbin{{0u, 0u, 0u}};
+    EXPECT_EQ(serializer(axes, 0u), expected_mbin);
+    expected_mbin = {{2u, 1u, 0u}};
+    EXPECT_EQ(serializer(axes, 6u), expected_mbin);
+    expected_mbin = {{3u, 0u, 1u}};
+    EXPECT_EQ(serializer(axes, 11u), expected_mbin);
+    expected_mbin = {{1u, 1u, 1u}};
+    EXPECT_EQ(serializer(axes, 13u), expected_mbin);
+}
diff --git a/tests/common/include/tests/common/masks_annulus2.inl b/tests/common/include/tests/common/masks_annulus2.inl
deleted file mode 100644
index 19a53a810a..0000000000
--- a/tests/common/include/tests/common/masks_annulus2.inl
+++ /dev/null
@@ -1,82 +0,0 @@
-/** Detray library, part of the ACTS project (R&D line)
- *
- * (c) 2020-2022 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#include <gtest/gtest.h>
-
-#include "detray/masks/annulus2.hpp"
-
-using namespace detray;
-using namespace __plugin;
-
-// This tests the basic function of a rectangle
-TEST(mask, annulus2) {
-    using polar = polar2<transform3<scalar>>;
-    using cartesian = cartesian2<transform3<scalar>>;
-    using point2 = __plugin::point2<scalar>;
-
-    scalar minR = 7.2;
-    scalar maxR = 12.0;
-    scalar minPhi = 0.74195;
-    scalar maxPhi = 1.33970;
-    point2 offset = {-2., 2.};
-
-    // points in cartesian module frame
-    point2 p2_in = {7., 7.};
-    point2 p2_out1 = {5., 5.};
-    point2 p2_out2 = {10., 3.};
-    point2 p2_out3 = {10., 10.};
-    point2 p2_out4 = {4., 10.};
-
-    auto toStripFrame = [&](const point2& xy) -> point2 {
-        auto shifted = xy + offset;
-        scalar r = getter::perp(shifted);
-        scalar phi = getter::phi(shifted);
-        return point2{r, phi};
-    };
-
-    annulus2<> ann2{minR, maxR, minPhi, maxPhi, offset[0], offset[1], 0., 0u};
-
-    ASSERT_EQ(ann2[0], static_cast<scalar>(7.2));
-    ASSERT_EQ(ann2[1], static_cast<scalar>(12.0));
-    ASSERT_EQ(ann2[2], static_cast<scalar>(0.74195));
-    ASSERT_EQ(ann2[3], static_cast<scalar>(1.33970));
-    ASSERT_EQ(ann2[4], static_cast<scalar>(-2.0));
-    ASSERT_EQ(ann2[5], static_cast<scalar>(2.0));
-    ASSERT_EQ(ann2[6], static_cast<scalar>(0.));
-
-    ASSERT_TRUE(ann2.is_inside<cartesian>(p2_in + offset) ==
-                intersection::status::e_inside);
-    ASSERT_TRUE(ann2.is_inside<cartesian>(p2_out1 + offset) ==
-                intersection::status::e_outside);
-    ASSERT_TRUE(ann2.is_inside<cartesian>(p2_out2 + offset) ==
-                intersection::status::e_outside);
-    ASSERT_TRUE(ann2.is_inside<cartesian>(p2_out3 + offset) ==
-                intersection::status::e_outside);
-    ASSERT_TRUE(ann2.is_inside<cartesian>(p2_out4 + offset) ==
-                intersection::status::e_outside);
-    // Move outside point inside using a tolerance
-    ASSERT_TRUE(ann2.is_inside<cartesian>(p2_out1 + offset, 1.3) ==
-                intersection::status::e_inside);
-    ASSERT_TRUE(ann2.is_inside<cartesian>(p2_out4 + offset, 0.07) ==
-                intersection::status::e_inside);
-
-    ASSERT_TRUE(ann2.is_inside<polar>(toStripFrame(p2_in)) ==
-                intersection::status::e_inside);
-    ASSERT_TRUE(ann2.is_inside<polar>(toStripFrame(p2_out1)) ==
-                intersection::status::e_outside);
-    ASSERT_TRUE(ann2.is_inside<polar>(toStripFrame(p2_out2)) ==
-                intersection::status::e_outside);
-    ASSERT_TRUE(ann2.is_inside<polar>(toStripFrame(p2_out3)) ==
-                intersection::status::e_outside);
-    ASSERT_TRUE(ann2.is_inside<polar>(toStripFrame(p2_out4)) ==
-                intersection::status::e_outside);
-    // Move outside point inside using a tolerance
-    ASSERT_TRUE(ann2.is_inside<polar>(toStripFrame(p2_out1), 1.3) ==
-                intersection::status::e_inside);
-    ASSERT_TRUE(ann2.is_inside<polar>(toStripFrame(p2_out4), 0.07) ==
-                intersection::status::e_inside);
-}
diff --git a/tests/common/include/tests/common/masks_annulus2D.inl b/tests/common/include/tests/common/masks_annulus2D.inl
new file mode 100644
index 0000000000..92b8d52ff0
--- /dev/null
+++ b/tests/common/include/tests/common/masks_annulus2D.inl
@@ -0,0 +1,66 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2020-2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include <gtest/gtest.h>
+
+#include "detray/definitions/units.hpp"
+#include "detray/masks/masks.hpp"
+
+using namespace detray;
+using namespace __plugin;
+
+/// This tests the basic functionality of a stereo annulus
+TEST(mask, annulus2D) {
+    using point_t = typename mask<annulus2D<>>::loc_point_t;
+
+    constexpr scalar minR{7.2 * unit_constants::mm};
+    constexpr scalar maxR{12.0 * unit_constants::mm};
+    constexpr scalar minPhi{0.74195};
+    constexpr scalar maxPhi{1.33970};
+    point_t offset = {-2., 2.};
+
+    // points in cartesian module frame
+    point_t p2_in = {7., 7.};
+    point_t p2_out1 = {5., 5.};
+    point_t p2_out2 = {10., 3.};
+    point_t p2_out3 = {10., 10.};
+    point_t p2_out4 = {4., 10.};
+
+    auto toStripFrame = [&](const point_t& xy) -> point_t {
+        auto shifted = xy + offset;
+        scalar r{getter::perp(shifted)};
+        scalar phi{getter::phi(shifted)};
+        return point_t{r, phi};
+    };
+
+    mask<annulus2D<>> ann2{0UL,    minR,      maxR,      minPhi,
+                           maxPhi, offset[0], offset[1], 0.f};
+
+    ASSERT_FLOAT_EQ(ann2[annulus2D<>::e_min_r], scalar{7.2});
+    ASSERT_FLOAT_EQ(ann2[annulus2D<>::e_max_r], scalar{12.0});
+    ASSERT_FLOAT_EQ(ann2[annulus2D<>::e_min_phi_rel], scalar{0.74195});
+    ASSERT_FLOAT_EQ(ann2[annulus2D<>::e_max_phi_rel], scalar{1.33970});
+    ASSERT_FLOAT_EQ(ann2[annulus2D<>::e_shift_x], scalar{-2.0});
+    ASSERT_FLOAT_EQ(ann2[annulus2D<>::e_shift_y], scalar{2.0});
+    ASSERT_FLOAT_EQ(ann2[annulus2D<>::e_average_phi], scalar{0.});
+
+    ASSERT_TRUE(ann2.is_inside(toStripFrame(p2_in)) ==
+                intersection::status::e_inside);
+    ASSERT_TRUE(ann2.is_inside(toStripFrame(p2_out1)) ==
+                intersection::status::e_outside);
+    ASSERT_TRUE(ann2.is_inside(toStripFrame(p2_out2)) ==
+                intersection::status::e_outside);
+    ASSERT_TRUE(ann2.is_inside(toStripFrame(p2_out3)) ==
+                intersection::status::e_outside);
+    ASSERT_TRUE(ann2.is_inside(toStripFrame(p2_out4)) ==
+                intersection::status::e_outside);
+    // Move outside point inside using a tolerance
+    ASSERT_TRUE(ann2.is_inside(toStripFrame(p2_out1), 1.3) ==
+                intersection::status::e_inside);
+    ASSERT_TRUE(ann2.is_inside(toStripFrame(p2_out4), 0.07) ==
+                intersection::status::e_inside);
+}
diff --git a/tests/common/include/tests/common/masks_cylinder.inl b/tests/common/include/tests/common/masks_cylinder.inl
new file mode 100644
index 0000000000..f3f4a7c170
--- /dev/null
+++ b/tests/common/include/tests/common/masks_cylinder.inl
@@ -0,0 +1,64 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2020-2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include <gtest/gtest.h>
+
+#include "detray/definitions/units.hpp"
+#include "detray/masks/masks.hpp"
+
+using namespace detray;
+using namespace __plugin;
+
+constexpr scalar r{3. * unit_constants::mm};
+constexpr scalar hz{4. * unit_constants::mm};
+
+/// This tests the basic functionality of a 3D cylinder
+TEST(mask, cylinder3D) {
+    using point_t = typename mask<cylinder3D>::loc_point_t;
+
+    point_t p3_in = {r, 0., -1.};
+    point_t p3_edge = {0., r, hz};
+    point_t p3_out = {static_cast<scalar>(r / std::sqrt(2.)),
+                      static_cast<scalar>(r / std::sqrt(2.)), 4.5};
+    point_t p3_off = {1., 1., -9.};
+
+    // Test radius to be on surface, too
+    mask<cylinder3D> c{0UL, r, -hz, hz};
+
+    ASSERT_FLOAT_EQ(c[cylinder3D::e_r], r);
+    ASSERT_FLOAT_EQ(c[cylinder3D::e_n_half_z], -hz);
+    ASSERT_FLOAT_EQ(c[cylinder3D::e_p_half_z], hz);
+
+    ASSERT_TRUE(c.is_inside(p3_in) == intersection::status::e_inside);
+    ASSERT_TRUE(c.is_inside(p3_edge) == intersection::status::e_inside);
+    ASSERT_TRUE(c.is_inside(p3_out) == intersection::status::e_outside);
+    ASSERT_TRUE(c.is_inside(p3_off) == intersection::status::e_outside);
+    // Move outside point inside using a tolerance
+    ASSERT_TRUE(c.is_inside(p3_out, 0.6) == intersection::status::e_inside);
+}
+
+/// This tests the basic functionality of a 2D cylinder
+TEST(mask, cylinder2D) {
+    using point_t = typename mask<cylinder2D<>>::loc_point_t;
+
+    point_t p2_in = {r, -1.};
+    point_t p2_edge = {r, hz};
+    point_t p2_out = {3.5, 4.5};
+
+    // Test radius to be on surface, too
+    mask<cylinder2D<>> c{0UL, r, -hz, hz};
+
+    ASSERT_FLOAT_EQ(c[cylinder2D<>::e_r], r);
+    ASSERT_FLOAT_EQ(c[cylinder2D<>::e_n_half_z], -hz);
+    ASSERT_FLOAT_EQ(c[cylinder2D<>::e_p_half_z], hz);
+
+    ASSERT_TRUE(c.is_inside(p2_in) == intersection::status::e_inside);
+    ASSERT_TRUE(c.is_inside(p2_edge) == intersection::status::e_inside);
+    ASSERT_TRUE(c.is_inside(p2_out) == intersection::status::e_outside);
+    // Move outside point inside using a tolerance
+    ASSERT_TRUE(c.is_inside(p2_out, 0.6) == intersection::status::e_inside);
+}
\ No newline at end of file
diff --git a/tests/common/include/tests/common/masks_cylinder3.inl b/tests/common/include/tests/common/masks_cylinder3.inl
deleted file mode 100644
index 1057fc7d86..0000000000
--- a/tests/common/include/tests/common/masks_cylinder3.inl
+++ /dev/null
@@ -1,52 +0,0 @@
-/** Detray library, part of the ACTS project (R&D line)
- *
- * (c) 2020-2022 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#include <gtest/gtest.h>
-
-#include "detray/intersection/cylinder_intersector.hpp"
-#include "detray/masks/cylinder3.hpp"
-
-using namespace detray;
-using transform3_type = __plugin::transform3<detray::scalar>;
-using vector3 = __plugin::vector3<detray::scalar>;
-using point3 = __plugin::point3<detray::scalar>;
-using scalar_type = typename transform3_type::scalar_type;
-using local_type = cartesian2<transform3_type>;
-
-// This tests the basic function of a rectangle
-TEST(mask, cylinder3) {
-
-    scalar_type r = 3.;
-    scalar_type hz = 4.;
-
-    point3 p3_in = {r, 0., -1.};
-    point3 p3_edge = {0., r, hz};
-    point3 p3_out = {static_cast<scalar_type>(r / std::sqrt(2.)),
-                     static_cast<scalar_type>(r / std::sqrt(2.)), 4.5};
-    point3 p3_off = {1., 1., -9.};
-
-    // Test radius to be on surface, too
-    cylinder3<transform3_type, cylinder_intersector, cylindrical2, unsigned int,
-              true>
-        c{r, -hz, hz, 0u};
-
-    ASSERT_EQ(c[0], r);
-    ASSERT_EQ(c[1], -hz);
-    ASSERT_EQ(c[2], hz);
-
-    ASSERT_TRUE(c.is_inside<local_type>(p3_in) ==
-                intersection::status::e_inside);
-    ASSERT_TRUE(c.is_inside<local_type>(p3_edge) ==
-                intersection::status::e_inside);
-    ASSERT_TRUE(c.is_inside<local_type>(p3_out) ==
-                intersection::status::e_outside);
-    ASSERT_TRUE(c.is_inside<local_type>(p3_off) ==
-                intersection::status::e_missed);
-    // Move outside point inside using a tolerance
-    ASSERT_TRUE(c.is_inside<local_type>(p3_out, 0.6) ==
-                intersection::status::e_inside);
-}
diff --git a/tests/common/include/tests/common/masks_line.inl b/tests/common/include/tests/common/masks_line.inl
index 5461296891..f7aa6bd189 100644
--- a/tests/common/include/tests/common/masks_line.inl
+++ b/tests/common/include/tests/common/masks_line.inl
@@ -7,25 +7,33 @@
 
 #include <gtest/gtest.h>
 
-#include "detray/masks/line.hpp"
+#include "detray/definitions/units.hpp"
+#include "detray/masks/masks.hpp"
 
 using namespace detray;
-using transform3 = __plugin::transform3<scalar>;
-using point3 = __plugin::point3<scalar>;
 
-// This tests the basic function of a line
-TEST(mask, line_radial_scope) {
+namespace {
 
-    const point3 ln_in{0.1, 0.2, 0.5};
-    const point3 ln_edge{1., 0., 50.};
-    const point3 ln_out1{1.2, 0.3, 0};
-    const point3 ln_out2{0.1, 0., -51.};
+// 50 mm wire with 1 mm radial cell size
+constexpr scalar cell_size{1. * unit_constants::mm};
+constexpr scalar hz{50. * unit_constants::mm};
 
-    // 50 mm wire with 1 mm radial cell size
-    const line<> ln{1., 50., 0u};
+}  // anonymous namespace
 
-    ASSERT_FLOAT_EQ(ln[0], 1.);
-    ASSERT_FLOAT_EQ(ln[1], 50.);
+/// This tests the basic functionality of a line with a radial cross section
+TEST(mask, line_radial_cross_sect) {
+    using point_t = typename mask<line<>>::loc_point_t;
+
+    const point_t ln_in{0.09, 0.5};
+    const point_t ln_edge{1., 50.};
+    const point_t ln_out1{1.2, 0};
+    const point_t ln_out2{0.09, -51.};
+
+    const mask<line<>> ln{0UL, cell_size, hz};
+
+    ASSERT_FLOAT_EQ(ln[line<>::e_cross_section],
+                    scalar{1. * unit_constants::mm});
+    ASSERT_FLOAT_EQ(ln[line<>::e_half_z], scalar{50. * unit_constants::mm});
 
     ASSERT_TRUE(ln.is_inside(ln_in) == intersection::status::e_inside);
     ASSERT_TRUE(ln.is_inside(ln_edge) == intersection::status::e_inside);
@@ -33,18 +41,20 @@ TEST(mask, line_radial_scope) {
     ASSERT_TRUE(ln.is_inside(ln_out2) == intersection::status::e_outside);
 }
 
-TEST(mask, line_square_scope) {
+/// This tests the basic functionality of a line with a square cross section
+TEST(mask, line_square_cross_sect) {
+    using point_t = typename mask<line<true>>::loc_point_t;
 
-    const point3 ln_in{1., 0., 0};
-    const point3 ln_edge{1., 1., 0.};
-    const point3 ln_out{1.1, 0., 0};
+    const point_t ln_in{0.9, 0.9, 0};
+    const point_t ln_edge{1., 1., 0.};
+    const point_t ln_out{1.1, 0., 0};
 
-    // 50 mm wire with 1 mm square cell size
-    const line<transform3, line_intersector, cartesian2, dindex, true> ln{
-        1., 50., 0u};
+    // 50 mm wire with 1 mm square cell sizes
+    const mask<line<true>> ln{0UL, cell_size, hz};
 
-    ASSERT_FLOAT_EQ(ln[0], 1.);
-    ASSERT_FLOAT_EQ(ln[1], 50.);
+    ASSERT_FLOAT_EQ(ln[line<>::e_cross_section],
+                    scalar{1. * unit_constants::mm});
+    ASSERT_FLOAT_EQ(ln[line<>::e_half_z], scalar{50. * unit_constants::mm});
 
     ASSERT_TRUE(ln.is_inside(ln_in) == intersection::status::e_inside);
     ASSERT_TRUE(ln.is_inside(ln_edge, 1e-5) == intersection::status::e_inside);
diff --git a/tests/common/include/tests/common/masks_rectangle2.inl b/tests/common/include/tests/common/masks_rectangle2.inl
deleted file mode 100644
index 656b1626a4..0000000000
--- a/tests/common/include/tests/common/masks_rectangle2.inl
+++ /dev/null
@@ -1,43 +0,0 @@
-/** Detray library, part of the ACTS project (R&D line)
- *
- * (c) 2020-2022 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#include <gtest/gtest.h>
-
-#include <climits>
-
-#include "detray/masks/rectangle2.hpp"
-
-using namespace detray;
-using point2 = __plugin::point2<detray::scalar>;
-using transform3 = __plugin::transform3<detray::scalar>;
-
-// This tests the basic function of a rectangle
-TEST(mask, rectangle2) {
-    using local_type = cartesian2<transform3>;
-
-    point2 p2_in = {0.5, -9.};
-    point2 p2_edge = {1., 9.3};
-    point2 p2_out = {1.5, -9.};
-
-    scalar hx = 1.;
-    scalar hy = 9.3;
-
-    rectangle2<> r2{hx, hy, 0u};
-
-    ASSERT_EQ(r2[0], hx);
-    ASSERT_EQ(r2[1], hy);
-
-    ASSERT_TRUE(r2.is_inside<local_type>(p2_in) ==
-                intersection::status::e_inside);
-    ASSERT_TRUE(r2.is_inside<local_type>(p2_edge) ==
-                intersection::status::e_inside);
-    ASSERT_TRUE(r2.is_inside<local_type>(p2_out) ==
-                intersection::status::e_outside);
-    // Move outside point inside using a tolerance
-    ASSERT_TRUE(r2.is_inside<local_type>(p2_out, 1.) ==
-                intersection::status::e_inside);
-}
diff --git a/tests/common/include/tests/common/masks_rectangle2D.inl b/tests/common/include/tests/common/masks_rectangle2D.inl
new file mode 100644
index 0000000000..3a0dc78657
--- /dev/null
+++ b/tests/common/include/tests/common/masks_rectangle2D.inl
@@ -0,0 +1,59 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2020-2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include <gtest/gtest.h>
+
+#include "detray/definitions/units.hpp"
+#include "detray/masks/masks.hpp"
+
+using namespace detray;
+using namespace __plugin;
+
+constexpr scalar hx{1. * unit_constants::mm};
+constexpr scalar hy{9.3 * unit_constants::mm};
+constexpr scalar hz{0.5 * unit_constants::mm};
+
+/// This tests the basic functionality of a rectangle
+TEST(mask, rectangle2D) {
+    using point_t = typename mask<rectangle2D<>>::loc_point_t;
+
+    point_t p2_in = {0.5, -9.};
+    point_t p2_edge = {1., 9.3};
+    point_t p2_out = {1.5, -9.};
+
+    mask<rectangle2D<>> r2{0UL, hx, hy};
+
+    ASSERT_FLOAT_EQ(r2[rectangle2D<>::e_half_x], hx);
+    ASSERT_FLOAT_EQ(r2[rectangle2D<>::e_half_y], hy);
+
+    ASSERT_TRUE(r2.is_inside(p2_in) == intersection::status::e_inside);
+    ASSERT_TRUE(r2.is_inside(p2_edge) == intersection::status::e_inside);
+    ASSERT_TRUE(r2.is_inside(p2_out) == intersection::status::e_outside);
+    // Move outside point inside using a tolerance
+    ASSERT_TRUE(r2.is_inside(p2_out, 1.) == intersection::status::e_inside);
+}
+
+/// This tests the basic functionality of a cuboid3D
+TEST(mask, cuboid3D) {
+    using point_t = typename mask<cuboid3D>::loc_point_t;
+
+    point_t p2_in = {0.5, 8.0, -0.4};
+    point_t p2_edge = {1., 9.3, 0.5};
+    point_t p2_out = {1.5, -9., 0.55};
+
+    mask<cuboid3D> c3{0UL, hx, hy, hz};
+
+    ASSERT_FLOAT_EQ(c3[cuboid3D::e_half_x], hx);
+    ASSERT_FLOAT_EQ(c3[cuboid3D::e_half_y], hy);
+    ASSERT_FLOAT_EQ(c3[cuboid3D::e_half_z], hz);
+
+    ASSERT_TRUE(c3.is_inside(p2_in) == intersection::status::e_inside);
+    ASSERT_TRUE(c3.is_inside(p2_edge) == intersection::status::e_inside);
+    ASSERT_TRUE(c3.is_inside(p2_out) == intersection::status::e_outside);
+    // Move outside point inside using a tolerance
+    ASSERT_TRUE(c3.is_inside(p2_out, 1.) == intersection::status::e_inside);
+}
diff --git a/tests/common/include/tests/common/masks_ring2.inl b/tests/common/include/tests/common/masks_ring2.inl
deleted file mode 100644
index d2e0018271..0000000000
--- a/tests/common/include/tests/common/masks_ring2.inl
+++ /dev/null
@@ -1,51 +0,0 @@
-/** Detray library, part of the ACTS project (R&D line)
- *
- * (c) 2020-2022 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#include <gtest/gtest.h>
-
-#include "detray/masks/ring2.hpp"
-
-using namespace detray;
-using point2 = __plugin::point2<scalar>;
-using transform3 = __plugin::transform3<detray::scalar>;
-
-// This tests the basic function of a rectangle
-TEST(mask, ring2) {
-
-    point2 p2_pl_in = {0.5, -2.};
-    point2 p2_pl_edge = {0., 3.5};
-    point2 p2_pl_out = {3.6, 5.};
-
-    point2 p2_c_in = {0.5, -2.};
-    point2 p2_c_edge = {0., 3.5};
-    point2 p2_c_out = {3.5, 3.5};
-
-    ring2<> r2{0., 3.5, 0u};
-
-    ASSERT_EQ(r2[0], 0.);
-    ASSERT_EQ(r2[1], 3.5);
-
-    ASSERT_TRUE(r2.is_inside<polar2<transform3>>(p2_pl_in) ==
-                intersection::status::e_inside);
-    ASSERT_TRUE(r2.is_inside<polar2<transform3>>(p2_pl_edge) ==
-                intersection::status::e_inside);
-    ASSERT_TRUE(r2.is_inside<polar2<transform3>>(p2_pl_out) ==
-                intersection::status::e_outside);
-    // Move outside point inside using a tolerance
-    ASSERT_TRUE(r2.is_inside<polar2<transform3>>(p2_pl_out, 1.2) ==
-                intersection::status::e_inside);
-
-    ASSERT_TRUE(r2.is_inside<cartesian2<transform3>>(p2_c_in) ==
-                intersection::status::e_inside);
-    ASSERT_TRUE(r2.is_inside<cartesian2<transform3>>(p2_c_edge) ==
-                intersection::status::e_inside);
-    ASSERT_TRUE(r2.is_inside<cartesian2<transform3>>(p2_c_out) ==
-                intersection::status::e_outside);
-    // Move outside point inside using a tolerance
-    ASSERT_TRUE(r2.is_inside<cartesian2<transform3>>(p2_c_out, 1.45) ==
-                intersection::status::e_inside);
-}
diff --git a/tests/common/include/tests/common/masks_ring2D.inl b/tests/common/include/tests/common/masks_ring2D.inl
new file mode 100644
index 0000000000..69ebd71bea
--- /dev/null
+++ b/tests/common/include/tests/common/masks_ring2D.inl
@@ -0,0 +1,36 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2020-2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include <gtest/gtest.h>
+
+#include "detray/definitions/units.hpp"
+#include "detray/masks/masks.hpp"
+
+using namespace detray;
+
+/// This tests the basic functionality of a ring
+TEST(mask, ring2D) {
+    using point_t = typename mask<ring2D<>>::loc_point_t;
+
+    point_t p2_pl_in = {0.5, -2.};
+    point_t p2_pl_edge = {0., 3.5};
+    point_t p2_pl_out = {3.6, 5.};
+
+    constexpr scalar inner_r{0. * unit_constants::mm};
+    constexpr scalar outer_r{3.5 * unit_constants::mm};
+
+    mask<ring2D<>> r2{0UL, inner_r, outer_r};
+
+    ASSERT_FLOAT_EQ(r2[ring2D<>::e_inner_r], static_cast<scalar>(0.));
+    ASSERT_FLOAT_EQ(r2[ring2D<>::e_outer_r], static_cast<scalar>(3.5));
+
+    ASSERT_TRUE(r2.is_inside(p2_pl_in) == intersection::status::e_inside);
+    ASSERT_TRUE(r2.is_inside(p2_pl_edge) == intersection::status::e_inside);
+    ASSERT_TRUE(r2.is_inside(p2_pl_out) == intersection::status::e_outside);
+    // Move outside point inside using a tolerance
+    ASSERT_TRUE(r2.is_inside(p2_pl_out, 1.2) == intersection::status::e_inside);
+}
diff --git a/tests/common/include/tests/common/masks_single3.inl b/tests/common/include/tests/common/masks_single3.inl
deleted file mode 100644
index 8c6eb84102..0000000000
--- a/tests/common/include/tests/common/masks_single3.inl
+++ /dev/null
@@ -1,93 +0,0 @@
-/** Detray library, part of the ACTS project (R&D line)
- *
- * (c) 2020-2022 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#include <gtest/gtest.h>
-
-#include <climits>
-
-#include "detray/masks/single3.hpp"
-
-using namespace detray;
-using namespace __plugin;
-
-// This tests the basic function of a rectangle
-TEST(mask, single3_0) {
-    using local_type = __plugin::transform3<detray::scalar>;
-    using point3 = __plugin::point3<detray::scalar>;
-
-    point3 p3_in = {0.5, -9., 0.};
-    point3 p3_edge = {1., 9.3, 2.};
-    point3 p3_out = {1.5, -9.8, 8.};
-
-    scalar h0 = 1.;
-    single3<0> m1_0{-h0, h0, 0u};
-
-    ASSERT_EQ(m1_0[0], -h0);
-    ASSERT_EQ(m1_0[1], h0);
-
-    ASSERT_TRUE(m1_0.is_inside<local_type>(p3_in) ==
-                intersection::status::e_inside);
-    ASSERT_TRUE(m1_0.is_inside<local_type>(p3_edge) ==
-                intersection::status::e_inside);
-    ASSERT_TRUE(m1_0.is_inside<local_type>(p3_out) ==
-                intersection::status::e_outside);
-    // Move outside point inside using a tolerance - take t0 not t1
-    ASSERT_TRUE(m1_0.is_inside<local_type>(p3_out, 0.6) ==
-                intersection::status::e_inside);
-}
-
-// This tests the basic function of a rectangle
-TEST(mask, single3_1) {
-    using local_type = __plugin::transform3<detray::scalar>;
-    using point3 = __plugin::point3<detray::scalar>;
-
-    point3 p3_in = {0.5, -9., 0.};
-    point3 p3_edge = {1., 9.3, 2.};
-    point3 p3_out = {1.5, -9.8, 8.};
-
-    scalar h1 = 9.3;
-    single3<1> m1_1 = {-h1, h1, 0u};
-
-    ASSERT_EQ(m1_1[0], -h1);
-    ASSERT_EQ(m1_1[1], h1);
-
-    ASSERT_TRUE(m1_1.is_inside<local_type>(p3_in) ==
-                intersection::status::e_inside);
-    ASSERT_TRUE(m1_1.is_inside<local_type>(p3_edge) ==
-                intersection::status::e_inside);
-    ASSERT_TRUE(m1_1.is_inside<local_type>(p3_out) ==
-                intersection::status::e_outside);
-    // Move outside point inside using a tolerance - take t1 not t1
-    ASSERT_TRUE(m1_1.is_inside<local_type>(p3_out, 0.6) ==
-                intersection::status::e_inside);
-}
-
-// This tests the basic function of a rectangle
-TEST(mask, single3_2) {
-    using local_type = __plugin::transform3<detray::scalar>;
-    using point3 = __plugin::point3<detray::scalar>;
-
-    point3 p3_in = {0.5, -9., 0.};
-    point3 p3_edge = {1., 9.3, 2.};
-    point3 p3_out = {1.5, -9.8, 8.};
-
-    scalar h2 = 2.;
-    single3<2> m1_2 = {-h2, h2, 0u};
-
-    ASSERT_EQ(m1_2[0], -h2);
-    ASSERT_EQ(m1_2[1], h2);
-
-    ASSERT_TRUE(m1_2.is_inside<local_type>(p3_in) ==
-                intersection::status::e_inside);
-    ASSERT_TRUE(m1_2.is_inside<local_type>(p3_edge) ==
-                intersection::status::e_inside);
-    ASSERT_TRUE(m1_2.is_inside<local_type>(p3_out) ==
-                intersection::status::e_outside);
-    // Move outside point inside using a tolerance - take t1 not t1
-    ASSERT_TRUE(m1_2.is_inside<local_type>(p3_out, 6.1) ==
-                intersection::status::e_inside);
-}
diff --git a/tests/common/include/tests/common/masks_single3D.inl b/tests/common/include/tests/common/masks_single3D.inl
new file mode 100644
index 0000000000..7ef05a806c
--- /dev/null
+++ b/tests/common/include/tests/common/masks_single3D.inl
@@ -0,0 +1,77 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2020-2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include <gtest/gtest.h>
+
+#include "detray/definitions/units.hpp"
+#include "detray/masks/masks.hpp"
+
+using namespace detray;
+using namespace __plugin;
+
+/// This tests the basic functionality of a single value mask (index 0)
+TEST(mask, single3_0) {
+    using point_t = typename mask<single3D<>>::loc_point_t;
+
+    point_t p3_in = {0.5, -9., 0.};
+    point_t p3_edge = {1., 9.3, 2.};
+    point_t p3_out = {1.5, -9.8, 8.};
+
+    constexpr scalar h0{1. * unit_constants::mm};
+    mask<single3D<>> m1_0{0UL, -h0, h0};
+
+    ASSERT_FLOAT_EQ(m1_0[single3D<>::e_lower], -h0);
+    ASSERT_FLOAT_EQ(m1_0[single3D<>::e_upper], h0);
+
+    ASSERT_TRUE(m1_0.is_inside(p3_in) == intersection::status::e_inside);
+    ASSERT_TRUE(m1_0.is_inside(p3_edge) == intersection::status::e_inside);
+    ASSERT_TRUE(m1_0.is_inside(p3_out) == intersection::status::e_outside);
+    // Move outside point inside using a tolerance - take t0 not t1
+    ASSERT_TRUE(m1_0.is_inside(p3_out, 0.6) == intersection::status::e_inside);
+}
+
+/// This tests the basic functionality of a single value mask (index 1)
+TEST(mask, single3_1) {
+    using point_t = typename mask<single3D<1>>::loc_point_t;
+
+    point_t p3_in = {0.5, -9., 0.};
+    point_t p3_edge = {1., 9.3, 2.};
+    point_t p3_out = {1.5, -9.8, 8.};
+
+    constexpr scalar h1{9.3 * unit_constants::mm};
+    mask<single3D<1>> m1_1{0UL, -h1, h1};
+
+    ASSERT_FLOAT_EQ(m1_1[single3D<>::e_lower], -h1);
+    ASSERT_FLOAT_EQ(m1_1[single3D<>::e_upper], h1);
+
+    ASSERT_TRUE(m1_1.is_inside(p3_in) == intersection::status::e_inside);
+    ASSERT_TRUE(m1_1.is_inside(p3_edge) == intersection::status::e_inside);
+    ASSERT_TRUE(m1_1.is_inside(p3_out) == intersection::status::e_outside);
+    // Move outside point inside using a tolerance - take t1 not t1
+    ASSERT_TRUE(m1_1.is_inside(p3_out, 0.6) == intersection::status::e_inside);
+}
+
+/// This tests the basic functionality of a single value mask (index 2)
+TEST(mask, single3_2) {
+    using point_t = typename mask<single3D<2>>::loc_point_t;
+
+    point_t p3_in = {0.5, -9., 0.};
+    point_t p3_edge = {1., 9.3, 2.};
+    point_t p3_out = {1.5, -9.8, 8.};
+
+    constexpr scalar h2{2. * unit_constants::mm};
+    mask<single3D<2>> m1_2{0UL, -h2, h2};
+
+    ASSERT_FLOAT_EQ(m1_2[single3D<>::e_lower], -h2);
+    ASSERT_FLOAT_EQ(m1_2[single3D<>::e_upper], h2);
+
+    ASSERT_TRUE(m1_2.is_inside(p3_in) == intersection::status::e_inside);
+    ASSERT_TRUE(m1_2.is_inside(p3_edge) == intersection::status::e_inside);
+    ASSERT_TRUE(m1_2.is_inside(p3_out) == intersection::status::e_outside);
+    // Move outside point inside using a tolerance - take t1 not t1
+    ASSERT_TRUE(m1_2.is_inside(p3_out, 6.1) == intersection::status::e_inside);
+}
diff --git a/tests/common/include/tests/common/masks_trapezoid2.inl b/tests/common/include/tests/common/masks_trapezoid2.inl
deleted file mode 100644
index b5b24da503..0000000000
--- a/tests/common/include/tests/common/masks_trapezoid2.inl
+++ /dev/null
@@ -1,45 +0,0 @@
-/** Detray library, part of the ACTS project (R&D line)
- *
- * (c) 2020-2022 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#include <gtest/gtest.h>
-
-#include "detray/masks/trapezoid2.hpp"
-
-using namespace detray;
-using point2 = __plugin::point2<detray::scalar>;
-using transform3 = __plugin::transform3<detray::scalar>;
-
-// This tests the basic function of a trapezoid
-TEST(mask, trapezoid2) {
-    using local_type = cartesian2<transform3>;
-
-    point2 p2_in = {1., -0.5};
-    point2 p2_edge = {2.5, 1.};
-    point2 p2_out = {3., 1.5};
-
-    scalar hx_miny = 1.;
-    scalar hx_maxy = 3.;
-    scalar hy = 2.;
-    scalar divisor = 1. / (2. * hy);
-
-    trapezoid2<> t2{hx_miny, hx_maxy, hy, 0u};
-
-    ASSERT_EQ(t2[0], hx_miny);
-    ASSERT_EQ(t2[1], hx_maxy);
-    ASSERT_EQ(t2[2], hy);
-    ASSERT_EQ(t2[3], divisor);
-
-    ASSERT_TRUE(t2.is_inside<local_type>(p2_in) ==
-                intersection::status::e_inside);
-    ASSERT_TRUE(t2.is_inside<local_type>(p2_edge) ==
-                intersection::status::e_inside);
-    ASSERT_TRUE(t2.is_inside<local_type>(p2_out) ==
-                intersection::status::e_outside);
-    // Move outside point inside using a tolerance
-    ASSERT_TRUE(t2.is_inside<local_type>(p2_out, 1.) ==
-                intersection::status::e_inside);
-}
diff --git a/tests/common/include/tests/common/masks_trapezoid2D.inl b/tests/common/include/tests/common/masks_trapezoid2D.inl
new file mode 100644
index 0000000000..25b7c94f6b
--- /dev/null
+++ b/tests/common/include/tests/common/masks_trapezoid2D.inl
@@ -0,0 +1,41 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2020-2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include <gtest/gtest.h>
+
+#include "detray/definitions/units.hpp"
+#include "detray/masks/masks.hpp"
+
+using namespace detray;
+using namespace __plugin;
+
+/// This tests the basic functionality of a trapezoid
+TEST(mask, trapezoid2D) {
+    using point_t = typename mask<trapezoid2D<>>::loc_point_t;
+
+    point_t p2_in = {1., -0.5};
+    point_t p2_edge = {2.5, 1.};
+    point_t p2_out = {3., 1.5};
+
+    constexpr scalar hx_miny{1. * unit_constants::mm};
+    constexpr scalar hx_maxy{3. * unit_constants::mm};
+    constexpr scalar hy{2. * unit_constants::mm};
+    constexpr scalar divisor{1. / (2. * hy)};
+
+    mask<trapezoid2D<>> t2{0UL, hx_miny, hx_maxy, hy, divisor};
+
+    ASSERT_EQ(t2[trapezoid2D<>::e_half_length_0], hx_miny);
+    ASSERT_EQ(t2[trapezoid2D<>::e_half_length_1], hx_maxy);
+    ASSERT_EQ(t2[trapezoid2D<>::e_half_length_2], hy);
+    ASSERT_EQ(t2[trapezoid2D<>::e_divisor], divisor);
+
+    ASSERT_TRUE(t2.is_inside(p2_in) == intersection::status::e_inside);
+    ASSERT_TRUE(t2.is_inside(p2_edge) == intersection::status::e_inside);
+    ASSERT_TRUE(t2.is_inside(p2_out) == intersection::status::e_outside);
+    // Move outside point inside using a tolerance
+    ASSERT_TRUE(t2.is_inside(p2_out, 1.) == intersection::status::e_inside);
+}
diff --git a/tests/common/include/tests/common/masks_unmasked.inl b/tests/common/include/tests/common/masks_unmasked.inl
index ba9b262a59..2339f2d573 100644
--- a/tests/common/include/tests/common/masks_unmasked.inl
+++ b/tests/common/include/tests/common/masks_unmasked.inl
@@ -7,24 +7,15 @@
 
 #include <gtest/gtest.h>
 
-#include "detray/masks/unmasked.hpp"
+#include "detray/masks/masks.hpp"
 
 using namespace detray;
-using point2 = __plugin::point2<scalar>;
-using transform3 = __plugin::transform3<detray::scalar>;
 
-// This tests the construction of a surface
+/// This tests the basic functionality of an unmasked plane
 TEST(mask, unmasked) {
-    using local_type = cartesian2<transform3>;
-    point2 p2 = {0.5, -9.};
+    typename mask<unmasked>::loc_point_t p2 = {0.5, -9.};
 
-    unmasked u;
-    ASSERT_TRUE(u.is_inside<local_type>(p2, 0) ==
-                intersection::status::e_inside);
-    /*
-    ASSERT_TRUE(u.is_inside<local_type>() ==
-                intersection::status::e_inside);
-    ASSERT_TRUE(u.is_inside<local_type>(p2, false) ==
-                intersection::status::e_outside);
-    */
+    mask<unmasked> u{};
+
+    ASSERT_TRUE(u.is_inside(p2, 0) == intersection::status::e_inside);
 }
diff --git a/tests/common/include/tests/common/materials.inl b/tests/common/include/tests/common/materials.inl
index 0711b589cd..e9c05c9043 100644
--- a/tests/common/include/tests/common/materials.inl
+++ b/tests/common/include/tests/common/materials.inl
@@ -8,7 +8,7 @@
 /// Project include(s)
 #include "detray/definitions/units.hpp"
 #include "detray/intersection/line_intersector.hpp"
-#include "detray/masks/line.hpp"
+#include "detray/masks/masks.hpp"
 #include "detray/materials/material.hpp"
 #include "detray/materials/material_rod.hpp"
 #include "detray/materials/material_slab.hpp"
@@ -152,8 +152,8 @@ TEST(materials, material_rod) {
     const free_track_parameters<transform3> trk(pos, 0, dir, -1);
 
     // Infinite wire with 1 mm radial cell size
-    const line<> ln{1. * unit_constants::mm,
-                    std::numeric_limits<scalar>::infinity(), 0u};
+    const mask<line<>> ln{0UL, static_cast<scalar>(1. * unit_constants::mm),
+                          std::numeric_limits<scalar>::infinity()};
 
     line_plane_intersection is =
         line_intersector<transform3>()(detail::ray<transform3>(trk), ln, tf)[0];
diff --git a/tests/common/include/tests/common/test_core.inl b/tests/common/include/tests/common/test_core.inl
index 1bb1a4cc08..e3aa2e5b83 100644
--- a/tests/common/include/tests/common/test_core.inl
+++ b/tests/common/include/tests/common/test_core.inl
@@ -9,15 +9,15 @@
 #include "detray/core/type_registry.hpp"
 #include "detray/geometry/surface.hpp"
 #include "detray/intersection/intersection.hpp"
-#include "detray/masks/unmasked.hpp"
+#include "detray/masks/masks.hpp"
 #include "detray/materials/material_slab.hpp"
 
 // Google test include(s)
 #include <gtest/gtest.h>
 
 // System include(s)
-#include <climits>
 #include <cmath>
+#include <limits>
 
 /// @note __plugin has to be defined with a preprocessor command
 
@@ -30,7 +30,7 @@ enum mask_ids : unsigned int {
     e_unmasked = 0,
 };
 
-using mask_defs = tuple_vector_registry<mask_ids, unmasked<>>;
+using mask_defs = tuple_vector_registry<mask_ids, mask<unmasked>>;
 using mask_link_type = typename mask_defs::link_type;
 
 /// Define material types
diff --git a/tests/common/include/tests/common/test_defs.hpp b/tests/common/include/tests/common/test_defs.hpp
index adabc9eeb2..bd94f786d8 100644
--- a/tests/common/include/tests/common/test_defs.hpp
+++ b/tests/common/include/tests/common/test_defs.hpp
@@ -61,10 +61,4 @@ DETRAY_HOST_DEVICE inline bool operator==(const test::point3<T> &lhs,
     return true;
 }
 
-// invalid value specialization for test::point3
-template <>
-DETRAY_HOST_DEVICE inline test::point3<scalar> invalid_value() {
-    return test::point3<scalar>{0, 0, 0};
-}
-
 }  // namespace detray
diff --git a/tests/common/include/tests/common/test_toy_geometry.inl b/tests/common/include/tests/common/test_toy_geometry.inl
index 4c4acafe17..ff59256078 100644
--- a/tests/common/include/tests/common/test_toy_geometry.inl
+++ b/tests/common/include/tests/common/test_toy_geometry.inl
@@ -13,25 +13,75 @@
 
 using namespace detray;
 
-template <std::size_t current_id = 0, std::size_t n_types = 4,
-          typename container_t, typename link_t>
-inline auto get_edge(const container_t& collection, const link_t& links) {
+namespace {
 
-    if (current_id == detail::get<0>(links)) {
-        auto& group = detail::get<current_id>(collection);
-        return group[detail::get<1>(links)].links();
+/// Functor that returns the volume/sf_finder links of a particluar mask
+/// instance in the mask container of a detector
+struct volume_link_getter {
+    using output_type = dindex;
+
+    template <typename mask_group_t, typename mask_range_t>
+    inline output_type operator()(mask_group_t& mask_group,
+                                  mask_range_t& mask_range) {
+        return mask_group[mask_range].volume_link();
     }
+};
+
+/// Functor that tests the volume indices of surfaces in the grid
+struct surface_grid_tester {
+    using output_type = bool;
+
+    /// Call for grid types
+    template <
+        typename grid_group_t, typename surface_container_t,
+        std::enable_if_t<not std::is_same_v<typename grid_group_t::value_type,
+                                            brute_force_finder>,
+                         bool> = true>
+    inline output_type operator()(const grid_group_t& grid_group,
+                                  const dindex grid_index,
+                                  const dindex volume_index,
+                                  const surface_container_t& surfaces,
+                                  const darray<dindex, 2>& /*range*/) {
+
+        const auto& sf_grid = grid_group.at(grid_index);
+
+        std::vector<dindex> indices;
+
+        // Check if right volume is linked to surface in grid
+        for (unsigned int i = 0; i < sf_grid.axis_p0().bins(); ++i) {
+            for (unsigned int j = 0; j < sf_grid.axis_p1().bins(); ++j) {
+                auto sf_indices = sf_grid.bin(i, j);
+                for (const auto sf_idx : sf_indices) {
+                    EXPECT_EQ(surfaces.at(sf_idx).volume(), volume_index);
+                    indices.push_back(sf_idx);
+                }
+            }
+        }
 
-    // Next type
-    if constexpr (current_id < n_types - 1) {
-        return get_edge<current_id + 1>(collection, links);
+        // Check if surface indices are consistent with given range of
+        // modules
+        /*EXPECT_EQ(indices.size(), range[1] - range[0]);
+        for (dindex pti = range[0]; pti < range[1]; ++pti) {
+            EXPECT_TRUE(std::find(indices.begin(), indices.end(), pti) !=
+                        indices.end());
+        }*/
+
+        return true;
     }
-    // Group no 0 will always exist
-    using group_t =
-        std::remove_reference_t<decltype(detail::get<0>(collection))>;
-    using edge_t = typename group_t::value_type::links_type;
-    return edge_t{};
-}
+
+    /// Call for the brute force type (do nothing)
+    template <typename grid_group_t, typename surface_container_t,
+              std::enable_if_t<std::is_same_v<typename grid_group_t::value_type,
+                                              brute_force_finder>,
+                               bool> = true>
+    inline output_type operator()(const grid_group_t&, const dindex,
+                                  const dindex, const surface_container_t&,
+                                  const darray<dindex, 2>&) {
+        return true;
+    }
+};
+
+}  // anonymous namespace
 
 // This test check the building of the tml based toy geometry
 TEST(ALGEBRA_PLUGIN, toy_geometry) {
@@ -40,7 +90,8 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     std::size_t n_brl_layers = 4;
     std::size_t n_edc_layers = 3;
 
-    auto toy_det = create_toy_geometry(host_mr, n_brl_layers, n_edc_layers);
+    const auto toy_det =
+        create_toy_geometry(host_mr, n_brl_layers, n_edc_layers);
 
     using detector_t = decltype(toy_det);
     using volume_t = typename detector_t::volume_type;
@@ -49,10 +100,13 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     using mask_link_t = typename detector_t::surface_type::mask_link;
     using material_link_t = typename detector_t::surface_type::material_link;
     using material_ids = typename detector_t::materials::id;
+    using sf_finder_ids = typename detector_t::sf_finders::id;
+    using sf_finder_link_t = typename volume_t::sf_finder_link_type;
+
     context_t ctx{};
     auto& volumes = toy_det.volumes();
     auto& surfaces = toy_det.surfaces();
-    auto& surfaces_finder = toy_det.get_surfaces_finder();
+    // auto& sf_finders = toy_det.sf_finder_store();
     auto& transforms = toy_det.transform_store();
     auto& masks = toy_det.mask_store();
     auto& materials = toy_det.material_store();
@@ -65,25 +119,42 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     auto pixel_mat =
         material_slab<scalar>(silicon_tml<scalar>(), 0.15 * unit_constants::mm);
 
-    /** source link */
-    const dindex inv_sf_finder = dindex_invalid;
-
     /** Link to outer world (leaving detector) */
     const dindex leaving_world = dindex_invalid;
 
     // Check number of geomtery objects
     EXPECT_EQ(volumes.size(), 20);
     EXPECT_EQ(surfaces.size(), 3244);
-    EXPECT_EQ(surfaces_finder.size(), detector_registry::toy_detector::n_grids);
-    EXPECT_EQ(surfaces_finder.effective_size(),
-              n_brl_layers + 2 * n_edc_layers);
+    /*EXPECT_EQ(sf_finders.template size<sf_finder_ids::e_brute_force>(), 1);
+    EXPECT_EQ(sf_finders.template size<sf_finder_ids::e_z_phi_grid>(),
+              n_brl_layers);
+    EXPECT_EQ(sf_finders.template size<sf_finder_ids::e_r_phi_grid>(), 14);*/
     EXPECT_EQ(transforms.size(ctx), 3244);
     EXPECT_EQ(masks.template size<mask_ids::e_rectangle2>(), 2492);
     EXPECT_EQ(masks.template size<mask_ids::e_trapezoid2>(), 648);
-    EXPECT_EQ(masks.template size<mask_ids::e_portal_cylinder3>(), 52);
+    EXPECT_EQ(masks.template size<mask_ids::e_portal_cylinder2>(), 52);
     EXPECT_EQ(masks.template size<mask_ids::e_portal_ring2>(), 52);
     EXPECT_EQ(materials.template size<material_ids::e_slab>(), 3244);
 
+    /** Test the links of a volume.
+     *
+     * @param vol_index volume the modules belong to
+     * @param sf_itr iterator into the surface container, start of the modules
+     * @param range index range of the modules in the surface container
+     * @param trf_index index of the transform (trf container) for the module
+     * @param mask_index type and index of module mask in respective mask cont
+     * @param volume_links links to next volume and next surfaces finder
+     */
+    auto test_volume_links =
+        [&](decltype(volumes.begin())& vol_itr, const dindex vol_index,
+            const darray<scalar, 6>& bounds, const darray<dindex, 2>& range,
+            const sf_finder_link_t& /*sf_finder_link*/) {
+            EXPECT_EQ(vol_itr->index(), vol_index);
+            EXPECT_EQ(vol_itr->bounds(), bounds);
+            EXPECT_EQ(vol_itr->range(), range);
+            // EXPECT_EQ(vol_itr->sf_finder_link(), sf_finder_link);
+        };
+
     /** Test the links of portals (into the next volume or invalid if we leave
      * the detector).
      *
@@ -92,21 +163,22 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
      * @param range index range of the portals in the surface container
      * @param trf_index index of the transform (trf container) for the portal
      * @param mask_index type and index of portal mask in respective mask cont
-     * @param edges links to next volume and next surfaces finder
+     * @param volume_links links to next volume contained in the masks
      */
-    auto test_portal_links = [&](dindex vol_index,
+    auto test_portal_links = [&](const dindex vol_index,
                                  decltype(surfaces.begin())&& sf_itr,
-                                 darray<dindex, 2>& range, dindex trf_index,
-                                 mask_link_t&& mask_index,
+                                 const darray<dindex, 2>& range,
+                                 dindex trf_index, mask_link_t&& mask_link,
                                  material_link_t&& material_index,
                                  const material_slab<scalar>& mat,
-                                 dvector<darray<dindex, 2>>&& edges) {
+                                 const dvector<dindex>&& volume_links) {
         for (dindex pti = range[0]; pti < range[1]; ++pti) {
             EXPECT_EQ(sf_itr->volume(), vol_index);
             EXPECT_EQ(sf_itr->transform(), trf_index);
-            EXPECT_EQ(sf_itr->mask(), mask_index);
-            EXPECT_EQ(get_edge(masks, sf_itr->mask()), edges[pti - range[0]]);
-
+            EXPECT_EQ(sf_itr->mask(), mask_link);
+            const auto volume_link =
+                masks.template call<volume_link_getter>(sf_itr->mask());
+            EXPECT_EQ(volume_link, volume_links[pti - range[0]]);
             EXPECT_EQ(
                 materials
                     .group<material_ids::e_slab>()[sf_itr->material_range()],
@@ -114,7 +186,7 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
 
             ++sf_itr;
             ++trf_index;
-            ++mask_index;
+            ++mask_link;
             ++material_index;
         }
     };
@@ -126,21 +198,23 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
      * @param range index range of the modules in the surface container
      * @param trf_index index of the transform (trf container) for the module
      * @param mask_index type and index of module mask in respective mask cont
-     * @param edges links to next volume and next surfaces finder
+     * @param volume_links links to next volume contained in the masks
      */
-    auto test_module_links = [&](dindex vol_index,
+    auto test_module_links = [&](const dindex vol_index,
                                  decltype(surfaces.begin())&& sf_itr,
-                                 darray<dindex, 2>& range, dindex trf_index,
-                                 mask_link_t&& mask_index,
+                                 const darray<dindex, 2>& range,
+                                 dindex trf_index, mask_link_t&& mask_index,
                                  material_link_t&& material_index,
                                  const material_slab<scalar>& mat,
-                                 dvector<darray<dindex, 2>>&& edges) {
+                                 const dvector<dindex>&& volume_links) {
         for (dindex pti = range[0]; pti < range[1]; ++pti) {
             EXPECT_EQ(sf_itr->volume(), vol_index);
             EXPECT_EQ(sf_itr->transform(), trf_index);
             EXPECT_EQ(sf_itr->mask(), mask_index);
             EXPECT_EQ(sf_itr->material(), material_index);
-            EXPECT_EQ(get_edge(masks, sf_itr->mask()), edges[0]);
+            const auto volume_link =
+                masks.template call<volume_link_getter>(sf_itr->mask());
+            EXPECT_EQ(volume_link, volume_links[0]);
             EXPECT_EQ(
                 materials
                     .group<material_ids::e_slab>()[sf_itr->material_range()],
@@ -155,39 +229,20 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     /** Test the surface grid.
      *
      * @param volume volume of detector being tested
-     * @param sf_finder surface finder of detector
-     * @param sf_container surface container of detector
+     * @param sf_finders surface finder container of detector
+     * @param surfaces surface container of detector
      * @param range index range of the modules in the surface container
      */
-    auto test_surfaces_grid =
+    /*auto test_surfaces_grid =
         [](decltype(volumes.begin())& vol_itr,
-           const typename detector_t::surfaces_finder_type& sf_finder,
-           const typename detector_t::surface_container& sf_container,
+           const typename detector_t::sf_finder_container& sf_finder_cont,
+           const typename detector_t::surface_container& surface_cont,
            darray<dindex, 2>& range) {
-            auto sf_grid = sf_finder[vol_itr->surfaces_finder_entry()];
-
-            std::vector<dindex> indices;
-
-            // Check if right volume is linked to surface in grid
-            for (unsigned int i = 0; i < sf_grid.axis_p0().bins(); ++i) {
-                for (unsigned int j = 0; j < sf_grid.axis_p1().bins(); ++j) {
-                    auto sf_indices = sf_grid.bin(i, j);
-                    for (auto sf_idx : sf_indices) {
-                        EXPECT_EQ(sf_container[sf_idx].volume(),
-                                  vol_itr->index());
-                        indices.push_back(sf_idx);
-                    }
-                }
-            }
-
-            // Check if surface indices are consistent with given range of
-            // modules
-            EXPECT_EQ(indices.size(), range[1] - range[0]);
-            for (dindex pti = range[0]; pti < range[1]; ++pti) {
-                EXPECT_TRUE(std::find(indices.begin(), indices.end(), pti) !=
-                            indices.end());
-            }
-        };
+            // Call test functor
+            sf_finder_cont.template call<surface_grid_tester>(
+                vol_itr->sf_finder_link(), vol_itr->index(), surface_cont,
+                range);
+        };*/
 
     //
     // beampipe
@@ -197,48 +252,36 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     auto vol_itr = volumes.begin();
     darray<scalar, 6> bounds = {0., 27., -825., 825., -M_PI, M_PI};
     darray<dindex, 2> range = {0, 16};
-    EXPECT_EQ(vol_itr->index(), 0);
-    EXPECT_EQ(vol_itr->bounds(), bounds);
-    EXPECT_EQ(vol_itr->range(), range);
-    EXPECT_EQ(vol_itr->get_grid_type(), volume_t::grid_type::e_no_grid);
-    EXPECT_EQ(vol_itr->surfaces_finder_entry(), dindex_invalid);
+    sf_finder_link_t sf_finder_link{sf_finder_ids::e_brute_force, 0};
+
+    // Test the links in the volumes
+    test_volume_links(vol_itr, 0, bounds, range, sf_finder_link);
 
     // Check links of beampipe itself
     range = {0, 1};
     test_module_links(vol_itr->index(), surfaces.begin(), range, range[0],
-                      {mask_ids::e_cylinder3, 0}, {material_ids::e_slab, 0},
-                      beampipe_mat, {{vol_itr->index(), inv_sf_finder}});
+                      {mask_ids::e_cylinder2, 0}, {material_ids::e_slab, 0},
+                      beampipe_mat, {vol_itr->index()});
 
     // Check links of portals
     // cylinder portals
     range = {1, 8};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
-                      range[0], {mask_ids::e_portal_cylinder3, 1},
+                      range[0], {mask_ids::e_portal_cylinder2, 1},
                       {material_ids::e_slab, 1}, portal_mat,
-                      {{1, inv_sf_finder},
-                       {2, inv_sf_finder},
-                       {3, inv_sf_finder},
-                       {4, inv_sf_finder},
-                       {5, inv_sf_finder},
-                       {6, inv_sf_finder},
-                       {7, inv_sf_finder}});
+                      {1, 2, 3, 4, 5, 6, 7});
     range = {8, 14};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
-                      range[0], {mask_ids::e_portal_cylinder3, 8},
+                      range[0], {mask_ids::e_portal_cylinder2, 8},
                       {material_ids::e_slab, 8}, portal_mat,
-                      {{14, inv_sf_finder},
-                       {15, inv_sf_finder},
-                       {16, inv_sf_finder},
-                       {17, inv_sf_finder},
-                       {18, inv_sf_finder},
-                       {19, inv_sf_finder}});
+                      {14, 15, 16, 17, 18, 19});
 
     // disc portals
     range = {14, 16};
-    test_portal_links(
-        vol_itr->index(), surfaces.begin() + range[0], range, range[0],
-        {mask_ids::e_portal_ring2, 0}, {material_ids::e_slab, 14}, portal_mat,
-        {{leaving_world, inv_sf_finder}, {leaving_world, inv_sf_finder}});
+    test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
+                      range[0], {mask_ids::e_portal_ring2, 0},
+                      {material_ids::e_slab, 14}, portal_mat,
+                      {leaving_world, leaving_world});
 
     //
     // neg endcap (layer 3)
@@ -248,34 +291,34 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     ++vol_itr;
     bounds = {27., 180., -825., -815., -M_PI, M_PI};
     range = {16, 128};
-    EXPECT_EQ(vol_itr->index(), 1);
-    EXPECT_EQ(vol_itr->bounds(), bounds);
-    EXPECT_EQ(vol_itr->range(), range);
-    EXPECT_EQ(vol_itr->get_grid_type(), volume_t::grid_type::e_r_phi_grid);
+    sf_finder_link = {sf_finder_ids::e_r_phi_grid, 0};
+
+    // Test the links in the volumes
+    test_volume_links(vol_itr, 1, bounds, range, sf_finder_link);
 
     // Check the trapezoid modules
     range = {16, 124};
     test_module_links(vol_itr->index(), surfaces.begin() + range[0], range,
                       range[0], {mask_ids::e_trapezoid2, 0},
                       {material_ids::e_slab, 16}, pixel_mat,
-                      {{vol_itr->index(), inv_sf_finder}});
+                      {vol_itr->index()});
 
     // Check link of surfaces in surface finder
-    test_surfaces_grid(vol_itr, surfaces_finder, surfaces, range);
+    // test_surfaces_grid(vol_itr, sf_finders, surfaces, range);
 
     // Check links of portals
     // cylinder portals
     range = {124, 126};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
-                      range[0], {mask_ids::e_portal_cylinder3, 14},
+                      range[0], {mask_ids::e_portal_cylinder2, 14},
                       {material_ids::e_slab, 124}, portal_mat,
-                      {{0, inv_sf_finder}, {leaving_world, inv_sf_finder}});
+                      {0, leaving_world});
     // disc portals
     range = {126, 128};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
                       range[0], {mask_ids::e_portal_ring2, 2},
                       {material_ids::e_slab, 126}, portal_mat,
-                      {{leaving_world, inv_sf_finder}, {2, inv_sf_finder}});
+                      {leaving_world, 2});
 
     //
     // gap
@@ -285,25 +328,23 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     ++vol_itr;
     bounds = {27., 180., -815., -705., -M_PI, M_PI};
     range = {128, 132};
-    EXPECT_EQ(vol_itr->index(), 2);
-    EXPECT_EQ(vol_itr->bounds(), bounds);
-    EXPECT_EQ(vol_itr->range(), range);
-    EXPECT_EQ(vol_itr->get_grid_type(), volume_t::grid_type::e_no_grid);
-    EXPECT_EQ(vol_itr->surfaces_finder_entry(), dindex_invalid);
+    sf_finder_link = {sf_finder_ids::e_brute_force, 0};
+
+    // Test the links in the volumes
+    test_volume_links(vol_itr, 2, bounds, range, sf_finder_link);
 
     // Check links of portals
     // cylinder portals
     range = {128, 130};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
-                      range[0], {mask_ids::e_portal_cylinder3, 16},
+                      range[0], {mask_ids::e_portal_cylinder2, 16},
                       {material_ids::e_slab, 128}, portal_mat,
-                      {{0, inv_sf_finder}, {leaving_world, inv_sf_finder}});
+                      {0, leaving_world});
     // disc portals
     range = {130, 132};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
                       range[0], {mask_ids::e_portal_ring2, 4},
-                      {material_ids::e_slab, 130}, portal_mat,
-                      {{1, inv_sf_finder}, {3, inv_sf_finder}});
+                      {material_ids::e_slab, 130}, portal_mat, {1, 3});
 
     //
     // neg endcap (layer 2)
@@ -313,34 +354,33 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     ++vol_itr;
     bounds = {27., 180., -705., -695., -M_PI, M_PI};
     range = {132, 244};
-    EXPECT_EQ(vol_itr->index(), 3);
-    EXPECT_EQ(vol_itr->bounds(), bounds);
-    EXPECT_EQ(vol_itr->range(), range);
-    EXPECT_EQ(vol_itr->get_grid_type(), volume_t::grid_type::e_r_phi_grid);
+    sf_finder_link = {sf_finder_ids::e_r_phi_grid, 1};
+
+    // Test the links in the volumes
+    test_volume_links(vol_itr, 3, bounds, range, sf_finder_link);
 
     // Check the trapezoid modules
     range = {132, 240};
     test_module_links(vol_itr->index(), surfaces.begin() + range[0], range,
                       range[0], {mask_ids::e_trapezoid2, 108},
                       {material_ids::e_slab, 132}, pixel_mat,
-                      {{vol_itr->index(), inv_sf_finder}});
+                      {vol_itr->index()});
 
     // Check link of surfaces in surface finder
-    test_surfaces_grid(vol_itr, surfaces_finder, surfaces, range);
+    // test_surfaces_grid(vol_itr, sf_finders, surfaces, range);
 
     // Check links of portals
     // cylinder portals
     range = {240, 242};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
-                      range[0], {mask_ids::e_portal_cylinder3, 18},
+                      range[0], {mask_ids::e_portal_cylinder2, 18},
                       {material_ids::e_slab, 240}, portal_mat,
-                      {{0, inv_sf_finder}, {leaving_world, inv_sf_finder}});
+                      {0, leaving_world});
     // disc portals
     range = {242, 244};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
                       range[0], {mask_ids::e_portal_ring2, 6},
-                      {material_ids::e_slab, 242}, portal_mat,
-                      {{2, inv_sf_finder}, {4, inv_sf_finder}});
+                      {material_ids::e_slab, 242}, portal_mat, {2, 4});
 
     //
     // gap
@@ -350,25 +390,23 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     ++vol_itr;
     bounds = {27., 180., -695., -605., -M_PI, M_PI};
     range = {244, 248};
-    EXPECT_EQ(vol_itr->index(), 4);
-    EXPECT_EQ(vol_itr->bounds(), bounds);
-    EXPECT_EQ(vol_itr->range(), range);
-    EXPECT_EQ(vol_itr->get_grid_type(), volume_t::grid_type::e_no_grid);
-    EXPECT_EQ(vol_itr->surfaces_finder_entry(), dindex_invalid);
+    sf_finder_link = {sf_finder_ids::e_brute_force, 0};
+
+    // Test the links in the volumes
+    test_volume_links(vol_itr, 4, bounds, range, sf_finder_link);
 
     // Check links of portals
     // cylinder portals
     range = {244, 246};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
-                      range[0], {mask_ids::e_portal_cylinder3, 20},
+                      range[0], {mask_ids::e_portal_cylinder2, 20},
                       {material_ids::e_slab, 244}, portal_mat,
-                      {{0, inv_sf_finder}, {leaving_world, inv_sf_finder}});
+                      {0, leaving_world});
     // disc portals
     range = {246, 248};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
                       range[0], {mask_ids::e_portal_ring2, 8},
-                      {material_ids::e_slab, 246}, portal_mat,
-                      {{3, inv_sf_finder}, {5, inv_sf_finder}});
+                      {material_ids::e_slab, 246}, portal_mat, {3, 5});
 
     //
     // neg endcap (layer 1)
@@ -378,34 +416,33 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     ++vol_itr;
     bounds = {27., 180., -605., -595., -M_PI, M_PI};
     range = {248, 360};
-    EXPECT_EQ(vol_itr->index(), 5);
-    EXPECT_EQ(vol_itr->bounds(), bounds);
-    EXPECT_EQ(vol_itr->range(), range);
-    EXPECT_EQ(vol_itr->get_grid_type(), volume_t::grid_type::e_r_phi_grid);
+    sf_finder_link = {sf_finder_ids::e_r_phi_grid, 2};
+
+    // Test the links in the volumes
+    test_volume_links(vol_itr, 5, bounds, range, sf_finder_link);
 
     // Check the trapezoid modules
     range = {248, 356};
     test_module_links(vol_itr->index(), surfaces.begin() + range[0], range,
                       range[0], {mask_ids::e_trapezoid2, 216},
                       {material_ids::e_slab, 248}, pixel_mat,
-                      {{vol_itr->index(), inv_sf_finder}});
+                      {vol_itr->index()});
 
     // Check link of surfaces in surface finder
-    test_surfaces_grid(vol_itr, surfaces_finder, surfaces, range);
+    // test_surfaces_grid(vol_itr, sf_finders, surfaces, range);
 
     // Check links of portals
     // cylinder portals
     range = {356, 358};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
-                      range[0], {mask_ids::e_portal_cylinder3, 22},
+                      range[0], {mask_ids::e_portal_cylinder2, 22},
                       {material_ids::e_slab, 356}, portal_mat,
-                      {{0, inv_sf_finder}, {leaving_world, inv_sf_finder}});
+                      {0, leaving_world});
     // disc portals
     range = {358, 360};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
                       range[0], {mask_ids::e_portal_ring2, 10},
-                      {material_ids::e_slab, 358}, portal_mat,
-                      {{4, inv_sf_finder}, {6, inv_sf_finder}});
+                      {material_ids::e_slab, 358}, portal_mat, {4, 6});
 
     //
     // gap
@@ -415,32 +452,24 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     ++vol_itr;
     bounds = {27., 180., -595., -500., -M_PI, M_PI};
     range = {360, 370};
-    EXPECT_EQ(vol_itr->index(), 6);
-    EXPECT_EQ(vol_itr->bounds(), bounds);
-    EXPECT_EQ(vol_itr->range(), range);
-    EXPECT_EQ(vol_itr->get_grid_type(), volume_t::grid_type::e_no_grid);
-    EXPECT_EQ(vol_itr->surfaces_finder_entry(), dindex_invalid);
+    sf_finder_link = {sf_finder_ids::e_brute_force, 0};
+
+    // Test the links in the volumes
+    test_volume_links(vol_itr, 6, bounds, range, sf_finder_link);
 
     // Check links of portals
     // cylinder portals
     range = {360, 362};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
-                      range[0], {mask_ids::e_portal_cylinder3, 24},
+                      range[0], {mask_ids::e_portal_cylinder2, 24},
                       {material_ids::e_slab, 360}, portal_mat,
-                      {{0, inv_sf_finder}, {leaving_world, inv_sf_finder}});
+                      {0, leaving_world});
     // disc portals
     range = {362, 370};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
                       range[0], {mask_ids::e_portal_ring2, 12},
                       {material_ids::e_slab, 362}, portal_mat,
-                      {{5, inv_sf_finder},
-                       {7, inv_sf_finder},
-                       {8, inv_sf_finder},
-                       {9, inv_sf_finder},
-                       {10, inv_sf_finder},
-                       {11, inv_sf_finder},
-                       {12, inv_sf_finder},
-                       {13, inv_sf_finder}});
+                      {5, 7, 8, 9, 10, 11, 12, 13});
 
     //
     // barrel
@@ -454,35 +483,33 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     ++vol_itr;
     bounds = {27., 38., -500., 500, -M_PI, M_PI};
     range = {370, 598};
-    EXPECT_EQ(vol_itr->index(), 7);
-    EXPECT_EQ(vol_itr->bounds(), bounds);
-    EXPECT_EQ(vol_itr->range(), range);
-    EXPECT_EQ(vol_itr->get_grid_type(), volume_t::grid_type::e_z_phi_grid);
+    sf_finder_link = {sf_finder_ids::e_z_phi_grid, 0};
+
+    // Test the links in the volumes
+    test_volume_links(vol_itr, 7, bounds, range, sf_finder_link);
 
     // Check links of modules
     range = {370, 594};
     test_module_links(vol_itr->index(), surfaces.begin() + range[0], range,
                       range[0], {mask_ids::e_rectangle2, 0},
                       {material_ids::e_slab, 370}, pixel_mat,
-                      {{vol_itr->index(), inv_sf_finder}});
+                      {vol_itr->index()});
 
     // Check link of surfaces in surface finder
-    test_surfaces_grid(vol_itr, surfaces_finder, surfaces, range);
+    // test_surfaces_grid(vol_itr, sf_finders, surfaces, range);
 
     // Check links of portals
     // cylinder portals
     range = {594, 596};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
-                      range[0], {mask_ids::e_portal_cylinder3, 26},
-                      {material_ids::e_slab, 594}, portal_mat,
-                      {{0, inv_sf_finder}, {8, inv_sf_finder}});
+                      range[0], {mask_ids::e_portal_cylinder2, 26},
+                      {material_ids::e_slab, 594}, portal_mat, {0, 8});
 
     // disc portals
     range = {596, 598};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
                       range[0], {mask_ids::e_portal_ring2, 20},
-                      {material_ids::e_slab, 596}, portal_mat,
-                      {{6, inv_sf_finder}, {14, inv_sf_finder}});
+                      {material_ids::e_slab, 596}, portal_mat, {6, 14});
 
     //
     // gap
@@ -492,25 +519,22 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     ++vol_itr;
     bounds = {38., 64., -500., 500, -M_PI, M_PI};
     range = {598, 602};
-    EXPECT_EQ(vol_itr->index(), 8);
-    EXPECT_EQ(vol_itr->bounds(), bounds);
-    EXPECT_EQ(vol_itr->range(), range);
-    EXPECT_EQ(vol_itr->get_grid_type(), volume_t::grid_type::e_no_grid);
-    EXPECT_EQ(vol_itr->surfaces_finder_entry(), dindex_invalid);
+    sf_finder_link = {sf_finder_ids::e_brute_force, 0};
+
+    // Test the links in the volumes
+    test_volume_links(vol_itr, 8, bounds, range, sf_finder_link);
 
     // Check links of portals
     // cylinder portals
     range = {598, 600};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
-                      range[0], {mask_ids::e_portal_cylinder3, 28},
-                      {material_ids::e_slab, 598}, portal_mat,
-                      {{7, inv_sf_finder}, {9, inv_sf_finder}});
+                      range[0], {mask_ids::e_portal_cylinder2, 28},
+                      {material_ids::e_slab, 598}, portal_mat, {7, 9});
     // disc portals
     range = {600, 602};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
                       range[0], {mask_ids::e_portal_ring2, 22},
-                      {material_ids::e_slab, 600}, portal_mat,
-                      {{6, inv_sf_finder}, {14, inv_sf_finder}});
+                      {material_ids::e_slab, 600}, portal_mat, {6, 14});
 
     //
     // second layer
@@ -520,35 +544,33 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     ++vol_itr;
     bounds = {64., 80., -500., 500, -M_PI, M_PI};
     range = {602, 1054};
-    EXPECT_EQ(vol_itr->index(), 9);
-    EXPECT_EQ(vol_itr->bounds(), bounds);
-    EXPECT_EQ(vol_itr->range(), range);
-    EXPECT_EQ(vol_itr->get_grid_type(), volume_t::grid_type::e_z_phi_grid);
+    sf_finder_link = {sf_finder_ids::e_z_phi_grid, 1};
+
+    // Test the links in the volumes
+    test_volume_links(vol_itr, 9, bounds, range, sf_finder_link);
 
     // Check links of modules
     range = {602, 1050};
     test_module_links(vol_itr->index(), surfaces.begin() + range[0], range,
                       range[0], {mask_ids::e_rectangle2, 224},
                       {material_ids::e_slab, 602}, pixel_mat,
-                      {{vol_itr->index(), inv_sf_finder}});
+                      {vol_itr->index()});
 
     // Check link of surfaces in surface finder
-    test_surfaces_grid(vol_itr, surfaces_finder, surfaces, range);
+    // test_surfaces_grid(vol_itr, sf_finders, surfaces, range);
 
     // Check links of portals
     // cylinder portals
     range = {1050, 1052};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
-                      range[0], {mask_ids::e_portal_cylinder3, 30},
-                      {material_ids::e_slab, 1050}, portal_mat,
-                      {{8, inv_sf_finder}, {10, inv_sf_finder}});
+                      range[0], {mask_ids::e_portal_cylinder2, 30},
+                      {material_ids::e_slab, 1050}, portal_mat, {8, 10});
 
     // disc portals
     range = {1052, 1054};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
                       range[0], {mask_ids::e_portal_ring2, 24},
-                      {material_ids::e_slab, 1052}, portal_mat,
-                      {{6, inv_sf_finder}, {14, inv_sf_finder}});
+                      {material_ids::e_slab, 1052}, portal_mat, {6, 14});
 
     //
     // gap
@@ -558,25 +580,22 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     ++vol_itr;
     bounds = {80., 108., -500., 500, -M_PI, M_PI};
     range = {1054, 1058};
-    EXPECT_EQ(vol_itr->index(), 10);
-    EXPECT_EQ(vol_itr->bounds(), bounds);
-    EXPECT_EQ(vol_itr->range(), range);
-    EXPECT_EQ(vol_itr->get_grid_type(), volume_t::grid_type::e_no_grid);
-    EXPECT_EQ(vol_itr->surfaces_finder_entry(), dindex_invalid);
+    sf_finder_link = {sf_finder_ids::e_brute_force, 0};
+
+    // Test the links in the volumes
+    test_volume_links(vol_itr, 10, bounds, range, sf_finder_link);
 
     // Check links of portals
     // cylinder portals
     range = {1054, 1056};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
-                      range[0], {mask_ids::e_portal_cylinder3, 32},
-                      {material_ids::e_slab, 1054}, portal_mat,
-                      {{9, inv_sf_finder}, {11, inv_sf_finder}});
+                      range[0], {mask_ids::e_portal_cylinder2, 32},
+                      {material_ids::e_slab, 1054}, portal_mat, {9, 11});
     // disc portals
     range = {1056, 1058};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
                       range[0], {mask_ids::e_portal_ring2, 26},
-                      {material_ids::e_slab, 1056}, portal_mat,
-                      {{6, inv_sf_finder}, {14, inv_sf_finder}});
+                      {material_ids::e_slab, 1056}, portal_mat, {6, 14});
 
     //
     // third layer
@@ -586,35 +605,33 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     ++vol_itr;
     bounds = {108., 124., -500., 500, -M_PI, M_PI};
     range = {1058, 1790};
-    EXPECT_EQ(vol_itr->index(), 11);
-    EXPECT_EQ(vol_itr->bounds(), bounds);
-    EXPECT_EQ(vol_itr->range(), range);
-    EXPECT_EQ(vol_itr->get_grid_type(), volume_t::grid_type::e_z_phi_grid);
+    sf_finder_link = {sf_finder_ids::e_z_phi_grid, 2};
+
+    // Test the links in the volumes
+    test_volume_links(vol_itr, 11, bounds, range, sf_finder_link);
 
     // Check links of modules
     range = {1058, 1786};
     test_module_links(vol_itr->index(), surfaces.begin() + range[0], range,
                       range[0], {mask_ids::e_rectangle2, 672},
                       {material_ids::e_slab, 1058}, pixel_mat,
-                      {{vol_itr->index(), inv_sf_finder}});
+                      {vol_itr->index()});
 
     // Check link of surfaces in surface finder
-    test_surfaces_grid(vol_itr, surfaces_finder, surfaces, range);
+    // test_surfaces_grid(vol_itr, sf_finders, surfaces, range);
 
     // Check links of portals
     // cylinder portals
     range = {1786, 1788};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
-                      range[0], {mask_ids::e_portal_cylinder3, 34},
-                      {material_ids::e_slab, 1786}, portal_mat,
-                      {{10, inv_sf_finder}, {12, inv_sf_finder}});
+                      range[0], {mask_ids::e_portal_cylinder2, 34},
+                      {material_ids::e_slab, 1786}, portal_mat, {10, 12});
 
     // disc portals
     range = {1788, 1790};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
                       range[0], {mask_ids::e_portal_ring2, 28},
-                      {material_ids::e_slab, 1788}, portal_mat,
-                      {{6, inv_sf_finder}, {14, inv_sf_finder}});
+                      {material_ids::e_slab, 1788}, portal_mat, {6, 14});
 
     //
     // gap
@@ -624,25 +641,22 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     ++vol_itr;
     bounds = {124., 164., -500., 500, -M_PI, M_PI};
     range = {1790, 1794};
-    EXPECT_EQ(vol_itr->index(), 12);
-    EXPECT_EQ(vol_itr->bounds(), bounds);
-    EXPECT_EQ(vol_itr->range(), range);
-    EXPECT_EQ(vol_itr->get_grid_type(), volume_t::grid_type::e_no_grid);
-    EXPECT_EQ(vol_itr->surfaces_finder_entry(), dindex_invalid);
+    sf_finder_link = {sf_finder_ids::e_brute_force, 0};
+
+    // Test the links in the volumes
+    test_volume_links(vol_itr, 12, bounds, range, sf_finder_link);
 
     // Check links of portals
     // cylinder portals
     range = {1790, 1792};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
-                      range[0], {mask_ids::e_portal_cylinder3, 36},
-                      {material_ids::e_slab, 1790}, portal_mat,
-                      {{11, inv_sf_finder}, {13, inv_sf_finder}});
+                      range[0], {mask_ids::e_portal_cylinder2, 36},
+                      {material_ids::e_slab, 1790}, portal_mat, {11, 13});
     // disc portals
     range = {1792, 1794};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
                       range[0], {mask_ids::e_portal_ring2, 30},
-                      {material_ids::e_slab, 1792}, portal_mat,
-                      {{6, inv_sf_finder}, {14, inv_sf_finder}});
+                      {material_ids::e_slab, 1792}, portal_mat, {6, 14});
 
     //
     // fourth layer
@@ -652,35 +666,34 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     ++vol_itr;
     bounds = {164., 180., -500., 500, -M_PI, M_PI};
     range = {1794, 2890};
-    EXPECT_EQ(vol_itr->index(), 13);
-    EXPECT_EQ(vol_itr->bounds(), bounds);
-    EXPECT_EQ(vol_itr->range(), range);
-    EXPECT_EQ(vol_itr->get_grid_type(), volume_t::grid_type::e_z_phi_grid);
+    sf_finder_link = {sf_finder_ids::e_z_phi_grid, 3};
+
+    // Test the links in the volumes
+    test_volume_links(vol_itr, 13, bounds, range, sf_finder_link);
 
     // Check links of modules
     range = {1794, 2886};
     test_module_links(vol_itr->index(), surfaces.begin() + range[0], range,
                       range[0], {mask_ids::e_rectangle2, 1400},
                       {material_ids::e_slab, 1794}, pixel_mat,
-                      {{vol_itr->index(), inv_sf_finder}});
+                      {vol_itr->index()});
 
     // Check link of surfaces in surface finder
-    test_surfaces_grid(vol_itr, surfaces_finder, surfaces, range);
+    // test_surfaces_grid(vol_itr, sf_finders, surfaces, range);
 
     // Check links of portals
     // cylinder portals
     range = {2886, 2888};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
-                      range[0], {mask_ids::e_portal_cylinder3, 38},
+                      range[0], {mask_ids::e_portal_cylinder2, 38},
                       {material_ids::e_slab, 2886}, portal_mat,
-                      {{12, inv_sf_finder}, {leaving_world, inv_sf_finder}});
+                      {12, leaving_world});
 
     // disc portals
     range = {2888, 2890};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
                       range[0], {mask_ids::e_portal_ring2, 32},
-                      {material_ids::e_slab, 2888}, portal_mat,
-                      {{6, inv_sf_finder}, {14, inv_sf_finder}});
+                      {material_ids::e_slab, 2888}, portal_mat, {6, 14});
 
     //
     // positive endcap
@@ -694,32 +707,24 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     ++vol_itr;
     bounds = {27., 180., 500., 595., -M_PI, M_PI};
     range = {2890, 2900};
-    EXPECT_EQ(vol_itr->index(), 14);
-    EXPECT_EQ(vol_itr->bounds(), bounds);
-    EXPECT_EQ(vol_itr->range(), range);
-    EXPECT_EQ(vol_itr->get_grid_type(), volume_t::grid_type::e_no_grid);
-    EXPECT_EQ(vol_itr->surfaces_finder_entry(), dindex_invalid);
+    sf_finder_link = {sf_finder_ids::e_brute_force, 0};
+
+    // Test the links in the volumes
+    test_volume_links(vol_itr, 14, bounds, range, sf_finder_link);
 
     // Check links of portals
     // cylinder portals
     range = {2890, 2892};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
-                      range[0], {mask_ids::e_portal_cylinder3, 40},
+                      range[0], {mask_ids::e_portal_cylinder2, 40},
                       {material_ids::e_slab, 2890}, portal_mat,
-                      {{0, inv_sf_finder}, {leaving_world, inv_sf_finder}});
+                      {0, leaving_world});
     // disc portals
     range = {2892, 2900};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
                       range[0], {mask_ids::e_portal_ring2, 34},
                       {material_ids::e_slab, 2892}, portal_mat,
-                      {{15, inv_sf_finder},
-                       {7, inv_sf_finder},
-                       {8, inv_sf_finder},
-                       {9, inv_sf_finder},
-                       {10, inv_sf_finder},
-                       {11, inv_sf_finder},
-                       {12, inv_sf_finder},
-                       {13, inv_sf_finder}});
+                      {15, 7, 8, 9, 10, 11, 12, 13});
 
     //
     // pos endcap (layer 1)
@@ -729,34 +734,33 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     ++vol_itr;
     bounds = {27., 180., 595., 605., -M_PI, M_PI};
     range = {2900, 3012};
-    EXPECT_EQ(vol_itr->index(), 15);
-    EXPECT_EQ(vol_itr->bounds(), bounds);
-    EXPECT_EQ(vol_itr->range(), range);
-    EXPECT_EQ(vol_itr->get_grid_type(), volume_t::grid_type::e_r_phi_grid);
+    sf_finder_link = {sf_finder_ids::e_r_phi_grid, 3};
+
+    // Test the links in the volumes
+    test_volume_links(vol_itr, 15, bounds, range, sf_finder_link);
 
     // Check the trapezoid modules
     range = {2900, 3008};
     test_module_links(vol_itr->index(), surfaces.begin() + range[0], range,
                       range[0], {mask_ids::e_trapezoid2, 324},
                       {material_ids::e_slab, 2900}, pixel_mat,
-                      {{vol_itr->index(), inv_sf_finder}});
+                      {vol_itr->index()});
 
     // Check link of surfaces in surface finder
-    test_surfaces_grid(vol_itr, surfaces_finder, surfaces, range);
+    // test_surfaces_grid(vol_itr, sf_finders, surfaces, range);
 
     // Check links of portals
     // cylinder portals
     range = {3008, 3010};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
-                      range[0], {mask_ids::e_portal_cylinder3, 42},
+                      range[0], {mask_ids::e_portal_cylinder2, 42},
                       {material_ids::e_slab, 3008}, portal_mat,
-                      {{0, inv_sf_finder}, {leaving_world, inv_sf_finder}});
+                      {0, leaving_world});
     // disc portals
     range = {3010, 3012};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
                       range[0], {mask_ids::e_portal_ring2, 42},
-                      {material_ids::e_slab, 3010}, portal_mat,
-                      {{14, inv_sf_finder}, {16, inv_sf_finder}});
+                      {material_ids::e_slab, 3010}, portal_mat, {14, 16});
 
     //
     // gap
@@ -766,25 +770,23 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     ++vol_itr;
     bounds = {27., 180., 605., 695., -M_PI, M_PI};
     range = {3012, 3016};
-    EXPECT_EQ(vol_itr->index(), 16);
-    EXPECT_EQ(vol_itr->bounds(), bounds);
-    EXPECT_EQ(vol_itr->range(), range);
-    EXPECT_EQ(vol_itr->get_grid_type(), volume_t::grid_type::e_no_grid);
-    EXPECT_EQ(vol_itr->surfaces_finder_entry(), dindex_invalid);
+    sf_finder_link = {sf_finder_ids::e_brute_force, 0};
+
+    // Test the links in the volumes
+    test_volume_links(vol_itr, 16, bounds, range, sf_finder_link);
 
     // Check links of portals
     // cylinder portals
     range = {3012, 3014};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
-                      range[0], {mask_ids::e_portal_cylinder3, 44},
+                      range[0], {mask_ids::e_portal_cylinder2, 44},
                       {material_ids::e_slab, 3012}, portal_mat,
-                      {{0, inv_sf_finder}, {leaving_world, inv_sf_finder}});
+                      {0, leaving_world});
     // disc portals
     range = {3014, 3016};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
                       range[0], {mask_ids::e_portal_ring2, 44},
-                      {material_ids::e_slab, 3014}, portal_mat,
-                      {{15, inv_sf_finder}, {17, inv_sf_finder}});
+                      {material_ids::e_slab, 3014}, portal_mat, {15, 17});
 
     //
     // pos endcap (layer 2)
@@ -794,34 +796,33 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     ++vol_itr;
     bounds = {27., 180., 695., 705., -M_PI, M_PI};
     range = {3016, 3128};
-    EXPECT_EQ(vol_itr->index(), 17);
-    EXPECT_EQ(vol_itr->bounds(), bounds);
-    EXPECT_EQ(vol_itr->range(), range);
-    EXPECT_EQ(vol_itr->get_grid_type(), volume_t::grid_type::e_r_phi_grid);
+    sf_finder_link = {sf_finder_ids::e_r_phi_grid, 4};
+
+    // Test the links in the volumes
+    test_volume_links(vol_itr, 17, bounds, range, sf_finder_link);
 
     // Check the trapezoid modules
     range = {3016, 3124};
     test_module_links(vol_itr->index(), surfaces.begin() + range[0], range,
                       range[0], {mask_ids::e_trapezoid2, 432},
                       {material_ids::e_slab, 3016}, pixel_mat,
-                      {{vol_itr->index(), inv_sf_finder}});
+                      {vol_itr->index()});
 
     // Check link of surfaces in surface finder
-    test_surfaces_grid(vol_itr, surfaces_finder, surfaces, range);
+    // test_surfaces_grid(vol_itr, sf_finders, surfaces, range);
 
     // Check links of portals
     // cylinder portals
     range = {3124, 3126};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
-                      range[0], {mask_ids::e_portal_cylinder3, 46},
+                      range[0], {mask_ids::e_portal_cylinder2, 46},
                       {material_ids::e_slab, 3124}, portal_mat,
-                      {{0, inv_sf_finder}, {leaving_world, inv_sf_finder}});
+                      {0, leaving_world});
     // disc portals
     range = {3126, 3128};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
                       range[0], {mask_ids::e_portal_ring2, 46},
-                      {material_ids::e_slab, 3126}, portal_mat,
-                      {{16, inv_sf_finder}, {18, inv_sf_finder}});
+                      {material_ids::e_slab, 3126}, portal_mat, {16, 18});
 
     //
     // gap
@@ -831,25 +832,23 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     ++vol_itr;
     bounds = {27., 180., 705., 815., -M_PI, M_PI};
     range = {3128, 3132};
-    EXPECT_EQ(vol_itr->index(), 18);
-    EXPECT_EQ(vol_itr->bounds(), bounds);
-    EXPECT_EQ(vol_itr->range(), range);
-    EXPECT_EQ(vol_itr->get_grid_type(), volume_t::grid_type::e_no_grid);
-    EXPECT_EQ(vol_itr->surfaces_finder_entry(), dindex_invalid);
+    sf_finder_link = {sf_finder_ids::e_brute_force, 0};
+
+    // Test the links in the volumes
+    test_volume_links(vol_itr, 18, bounds, range, sf_finder_link);
 
     // Check links of portals
     // cylinder portals
     range = {3128, 3130};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
-                      range[0], {mask_ids::e_portal_cylinder3, 48},
+                      range[0], {mask_ids::e_portal_cylinder2, 48},
                       {material_ids::e_slab, 3128}, portal_mat,
-                      {{0, inv_sf_finder}, {leaving_world, inv_sf_finder}});
+                      {0, leaving_world});
     // disc portals
     range = {3130, 3132};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
                       range[0], {mask_ids::e_portal_ring2, 48},
-                      {material_ids::e_slab, 3130}, portal_mat,
-                      {{17, inv_sf_finder}, {19, inv_sf_finder}});
+                      {material_ids::e_slab, 3130}, portal_mat, {17, 19});
 
     //
     // pos endcap (layer 3)
@@ -859,32 +858,32 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     ++vol_itr;
     bounds = {27., 180., 815., 825., -M_PI, M_PI};
     range = {3132, 3244};
-    EXPECT_EQ(vol_itr->index(), 19);
-    EXPECT_EQ(vol_itr->bounds(), bounds);
-    EXPECT_EQ(vol_itr->range(), range);
-    EXPECT_EQ(vol_itr->get_grid_type(), volume_t::grid_type::e_r_phi_grid);
+    sf_finder_link = {sf_finder_ids::e_r_phi_grid, 5};
+
+    // Test the links in the volumes
+    test_volume_links(vol_itr, 19, bounds, range, sf_finder_link);
 
     // Check the trapezoid modules
     range = {3132, 3240};
     test_module_links(vol_itr->index(), surfaces.begin() + range[0], range,
                       range[0], {mask_ids::e_trapezoid2, 540},
                       {material_ids::e_slab, 3132}, pixel_mat,
-                      {{vol_itr->index(), inv_sf_finder}});
+                      {vol_itr->index()});
 
     // Check link of surfaces in surface finder
-    test_surfaces_grid(vol_itr, surfaces_finder, surfaces, range);
+    // test_surfaces_grid(vol_itr, sf_finders, surfaces, range);
 
     // Check links of portals
     // cylinder portals
     range = {3240, 3242};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
-                      range[0], {mask_ids::e_portal_cylinder3, 50},
+                      range[0], {mask_ids::e_portal_cylinder2, 50},
                       {material_ids::e_slab, 3240}, portal_mat,
-                      {{0, inv_sf_finder}, {leaving_world, inv_sf_finder}});
+                      {0, leaving_world});
     // disc portals
     range = {3242, 3244};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
                       range[0], {mask_ids::e_portal_ring2, 50},
                       {material_ids::e_slab, 3242}, portal_mat,
-                      {{18, inv_sf_finder}, {leaving_world, inv_sf_finder}});
+                      {18, leaving_world});
 }
diff --git a/tests/common/include/tests/common/tools/create_telescope_detector.hpp b/tests/common/include/tests/common/tools/create_telescope_detector.hpp
index 33a7674edc..bdf92e998f 100644
--- a/tests/common/include/tests/common/tools/create_telescope_detector.hpp
+++ b/tests/common/include/tests/common/tools/create_telescope_detector.hpp
@@ -118,13 +118,13 @@ inline void create_telescope(context_t &ctx, track_t &track, stepper_t &stepper,
                              material_container_t &materials,
                              transform_container_t &transforms, config_t &cfg) {
     using surface_type = typename surface_container_t::value_type;
-    using edge_t = typename surface_type::edge_type;
+    using volume_link_t = typename surface_type::volume_link_type;
     using mask_link_type = typename surface_type::mask_link;
     using material_defs = typename surface_type::material_defs;
     using material_link_type = typename surface_type::material_link;
 
     auto volume_id = volume.index();
-    edge_t mask_edge{volume_id, dindex_invalid};
+    volume_link_t mask_volume_link{volume_id};
     constexpr auto slab_id = material_defs::id::e_slab;
 
     // Create the module centers
@@ -141,24 +141,24 @@ inline void create_telescope(context_t &ctx, track_t &track, stepper_t &stepper,
         const auto trf_index = transforms.size(ctx);
         surfaces.emplace_back(trf_index, mask_link, material_link, volume_id,
                               dindex_invalid, false);
-        surfaces.back().set_grid_status(false);
 
         // The last surface acts as portal that leaves the telescope
         if (m_placement == m_placements.back()) {
-            mask_edge = {dindex_invalid, dindex_invalid};
+            mask_volume_link = dindex_invalid;
         }
 
         if constexpr (mask_id ==
                       telescope_types::mask_ids::e_unbounded_plane2) {
             // No bounds for this module
             masks.template add_value<
-                telescope_types::mask_ids::e_unbounded_plane2>(mask_edge);
+                telescope_types::mask_ids::e_unbounded_plane2>(
+                mask_volume_link);
             materials.template add_value<telescope_types::material_ids::e_slab>(
                 cfg.m_mat, cfg.m_thickness);
         } else {
             // The rectangle bounds for this module
             masks.template add_value<telescope_types::mask_ids::e_rectangle2>(
-                cfg.m_half_x, cfg.m_half_y, mask_edge);
+                mask_volume_link, cfg.m_half_x, cfg.m_half_y);
             materials.template add_value<telescope_types::material_ids::e_slab>(
                 cfg.m_mat, cfg.m_thickness);
         }
diff --git a/tests/common/include/tests/common/tools/create_toy_geometry.hpp b/tests/common/include/tests/common/tools/create_toy_geometry.hpp
index dd718f3d61..337e860ef2 100644
--- a/tests/common/include/tests/common/tools/create_toy_geometry.hpp
+++ b/tests/common/include/tests/common/tools/create_toy_geometry.hpp
@@ -41,35 +41,35 @@ using point2 = __plugin::point2<detray::scalar>;
  * @param r raius of the cylinder
  * @param lower_z lower extend in z
  * @param upper_z upper extend in z
- * @param edge link to next volume and surfaces finder
+ * @param volume_link link to next volume for the masks
  */
 template <typename context_t, typename surface_container_t,
           typename mask_container_t, typename material_container_t,
-          typename transform_container_t, typename edge_links>
+          typename transform_container_t, typename volume_links>
 inline void add_cylinder_surface(
     const dindex volume_id, context_t &ctx, surface_container_t &surfaces,
     mask_container_t &masks, material_container_t &materials,
     transform_container_t &transforms, const scalar r, const scalar lower_z,
-    const scalar upper_z, const edge_links edge, const material<scalar> &mat,
-    const scalar thickness) {
+    const scalar upper_z, const volume_links volume_link,
+    const material<scalar> &mat, const scalar thickness) {
     using surface_type = typename surface_container_t::value_type;
     using mask_defs = typename surface_type::mask_defs;
     using mask_link_type = typename surface_type::mask_link;
     using material_defs = typename surface_type::material_defs;
     using material_link_type = typename surface_type::material_link;
 
-    constexpr auto cylinder_id = mask_defs::id::e_portal_cylinder3;
+    constexpr auto cylinder_id = mask_defs::id::e_portal_cylinder2;
     constexpr auto slab_id = material_defs::id::e_slab;
 
-    const scalar min_z = std::min(lower_z, upper_z);
-    const scalar max_z = std::max(lower_z, upper_z);
+    const scalar min_z{std::min(lower_z, upper_z)};
+    const scalar max_z{std::max(lower_z, upper_z)};
 
     // translation
     point3 tsl{0., 0., 0};
 
     // add transform and masks
     transforms.emplace_back(ctx, tsl);
-    masks.template add_value<cylinder_id>(r, min_z, max_z, edge);
+    masks.template add_value<cylinder_id>(volume_link, r, min_z, max_z);
 
     // Add material slab
     materials.template add_value<slab_id>(mat, thickness);
@@ -79,7 +79,7 @@ inline void add_cylinder_surface(
                              masks.template size<cylinder_id>() - 1};
     material_link_type material_link{slab_id,
                                      materials.template size<slab_id>() - 1};
-    const bool is_portal = std::get<0>(edge) != volume_id;
+    const bool is_portal = (volume_link != volume_id);
     surfaces.emplace_back(transforms.size(ctx) - 1, mask_link, material_link,
                           volume_id, dindex_invalid, is_portal);
 }
@@ -96,16 +96,16 @@ inline void add_cylinder_surface(
  * @param min_r lower radius of the disc
  * @param max_r upper radius of the disc
  * @param z z position of the disc
- * @param edge link to next volume and surfaces finder
+ * @param volume_link link to next volume for the masks
  */
 template <typename context_t, typename surface_container_t,
           typename mask_container_t, typename material_container_t,
-          typename transform_container_t, typename edge_links>
+          typename transform_container_t, typename volume_links>
 inline void add_disc_surface(
     const dindex volume_id, context_t &ctx, surface_container_t &surfaces,
     mask_container_t &masks, material_container_t &materials,
     transform_container_t &transforms, const scalar inner_r,
-    const scalar outer_r, const scalar z, const edge_links edge,
+    const scalar outer_r, const scalar z, const volume_links volume_link,
     const material<scalar> &mat, const scalar thickness) {
     using surface_type = typename surface_container_t::value_type;
     using mask_defs = typename surface_type::mask_defs;
@@ -116,15 +116,15 @@ inline void add_disc_surface(
     constexpr auto disc_id = mask_defs::id::e_portal_ring2;
     constexpr auto slab_id = material_defs::id::e_slab;
 
-    const scalar min_r = std::min(inner_r, outer_r);
-    const scalar max_r = std::max(inner_r, outer_r);
+    const scalar min_r{std::min(inner_r, outer_r)};
+    const scalar max_r{std::max(inner_r, outer_r)};
 
     // translation
     point3 tsl{0., 0., z};
 
     // add transform and mask
     transforms.emplace_back(ctx, tsl);
-    masks.template add_value<disc_id>(min_r, max_r, edge);
+    masks.template add_value<disc_id>(volume_link, min_r, max_r);
 
     // Add material slab
     materials.template add_value<slab_id>(mat, thickness);
@@ -133,7 +133,7 @@ inline void add_disc_surface(
     mask_link_type mask_link{disc_id, masks.template size<disc_id>() - 1};
     material_link_type material_link{slab_id,
                                      materials.template size<slab_id>() - 1};
-    const bool is_portal = std::get<0>(edge) != volume_id;
+    const bool is_portal = (volume_link != volume_id);
     surfaces.emplace_back(transforms.size(ctx) - 1, mask_link, material_link,
                           volume_id, dindex_invalid, is_portal);
 }
@@ -151,7 +151,7 @@ inline void add_disc_surface(
  * @param lay_outer_r outer radius of volume
  * @param lay_neg_r lower extend of volume
  * @param lay_pos_r upper extend of volume
- * @param edges volume and surfaces finder links for the portals of the volume
+ * @param volume_links volume links for the portals of the volume
  * @param module_factory functor that adds module surfaces to volume
  */
 
@@ -168,7 +168,8 @@ void create_cyl_volume(
     detector_t &det, vecmem::memory_resource &resource,
     typename detector_t::context &ctx, const scalar lay_inner_r,
     const scalar lay_outer_r, const scalar lay_neg_z, const scalar lay_pos_z,
-    const std::vector<typename detector_t::surface_type::edge_type> &edges,
+    const std::vector<typename detector_t::surface_type::volume_link_type>
+        &volume_links,
     factory_t &module_factory) {
     // volume bounds
     const scalar inner_r = std::min(lay_inner_r, lay_outer_r);
@@ -178,8 +179,7 @@ void create_cyl_volume(
 
     auto &cyl_volume =
         det.new_volume({inner_r, outer_r, lower_z, upper_z, -M_PI, M_PI});
-    typename detector_t::surfaces_finder_type::surfaces_regular_circular_grid
-        cyl_surfaces_grid(resource);
+    cyl_volume.set_sf_finder(detector_t::sf_finders::id::e_default, 0);
 
     // Add module surfaces to volume
     typename detector_t::surface_container surfaces(&resource);
@@ -189,29 +189,23 @@ void create_cyl_volume(
 
     // fill the surfaces
     module_factory(ctx, cyl_volume, surfaces, masks, materials, transforms);
-    // create the surface grid
-    module_factory(cyl_surfaces_grid, *det.resource());
 
     // negative and positive, inner and outer portal surface
     add_cylinder_surface(cyl_volume.index(), ctx, surfaces, masks, materials,
-                         transforms, inner_r, lower_z, upper_z, edges[0],
+                         transforms, inner_r, lower_z, upper_z, volume_links[0],
                          vacuum<scalar>(), 0. * unit_constants::mm);
     add_cylinder_surface(cyl_volume.index(), ctx, surfaces, masks, materials,
-                         transforms, outer_r, lower_z, upper_z, edges[1],
+                         transforms, outer_r, lower_z, upper_z, volume_links[1],
                          vacuum<scalar>(), 0. * unit_constants::mm);
     add_disc_surface(cyl_volume.index(), ctx, surfaces, masks, materials,
-                     transforms, inner_r, outer_r, lower_z, edges[2],
+                     transforms, inner_r, outer_r, lower_z, volume_links[2],
                      vacuum<scalar>(), 0. * unit_constants::mm);
     add_disc_surface(cyl_volume.index(), ctx, surfaces, masks, materials,
-                     transforms, inner_r, outer_r, upper_z, edges[3],
+                     transforms, inner_r, outer_r, upper_z, volume_links[3],
                      vacuum<scalar>(), 0. * unit_constants::mm);
 
     det.add_objects_per_volume(ctx, cyl_volume, surfaces, masks, materials,
                                transforms);
-    if (cyl_volume.get_grid_type() !=
-        detector_t::volume_type::grid_type::e_no_grid) {
-        det.add_surfaces_grid(ctx, cyl_volume, cyl_surfaces_grid);
-    }
 }
 
 /** Helper function that creates a layer of rectangular barrel modules.
@@ -236,7 +230,7 @@ inline void create_barrel_modules(context_t &ctx, volume_type &vol,
                                   transform_container_t &transforms,
                                   config_t cfg) {
     using surface_type = typename surface_container_t::value_type;
-    using edge_t = typename surface_type::edge_type;
+    using volume_link_t = typename surface_type::volume_link_type;
     using mask_defs = typename surface_type::mask_defs;
     using mask_link_type = typename surface_type::mask_link;
     using material_defs = typename surface_type::material_defs;
@@ -246,9 +240,7 @@ inline void create_barrel_modules(context_t &ctx, volume_type &vol,
     constexpr auto slab_id = material_defs::id::e_slab;
 
     auto volume_id = vol.index();
-    edge_t mask_edge{volume_id, dindex_invalid};
-
-    vol.set_grid_type(volume_type::grid_type::e_z_phi_grid);
+    volume_link_t mask_volume_link{volume_id};
 
     // Create the module centers
 
@@ -260,25 +252,24 @@ inline void create_barrel_modules(context_t &ctx, volume_type &vol,
     m_centers.reserve(n_phi_bins * n_z_bins);
 
     // prep work
-    // scalar pi{static_cast<scalar>(M_PI)};
-    scalar phi_step = 2 * M_PI / (n_phi_bins);
-    scalar min_phi = -M_PI + 0.5 * phi_step;
+    scalar pi{static_cast<scalar>(M_PI)};
+    scalar phi_step{scalar{2} * pi / (n_phi_bins)};
+    scalar min_phi{-pi + scalar{0.5} * phi_step};
 
-    auto z_axis_info = cfg.get_z_axis_info();
-    auto &z_start = std::get<0>(z_axis_info);
-    // auto &z_end = std::get<1>(z_axis_info);
-    auto &z_step = std::get<2>(z_axis_info);
+    scalar z_start{scalar{-0.5} * (n_z_bins - 1) *
+                   (scalar{2} * cfg.m_half_y - cfg.m_long_overlap)};
+    scalar z_step{(std::abs(z_start) - z_start) / (n_z_bins - 1)};
 
     // loop over the z bins
     for (size_t z_bin = 0; z_bin < size_t(n_z_bins); ++z_bin) {
         // prepare z and r
-        scalar m_z = z_start + z_bin * z_step;
-        scalar m_r = (z_bin % 2) != 0u
-                         ? cfg.layer_r - 0.5 * cfg.m_radial_stagger
-                         : cfg.layer_r + 0.5 * cfg.m_radial_stagger;
+        scalar m_z{z_start + z_bin * z_step};
+        scalar m_r{(z_bin % 2) != 0u
+                       ? cfg.layer_r - scalar{0.5} * cfg.m_radial_stagger
+                       : cfg.layer_r + scalar{0.5} * cfg.m_radial_stagger};
         for (size_t phiBin = 0; phiBin < size_t(n_phi_bins); ++phiBin) {
             // calculate the current phi value
-            scalar m_phi = min_phi + phiBin * phi_step;
+            scalar m_phi{min_phi + phiBin * phi_step};
             m_centers.push_back(
                 point3{m_r * std::cos(m_phi), m_r * std::sin(m_phi), m_z});
         }
@@ -295,16 +286,15 @@ inline void create_barrel_modules(context_t &ctx, volume_type &vol,
         const auto trf_index = transforms.size(ctx);
         surfaces.emplace_back(trf_index, mask_link, material_link, volume_id,
                               dindex_invalid, false);
-        surfaces.back().set_grid_status(true);
 
         // The rectangle bounds for this module
-        masks.template add_value<rectangle_id>(cfg.m_half_x, cfg.m_half_y,
-                                               mask_edge);
+        masks.template add_value<rectangle_id>(mask_volume_link, cfg.m_half_x,
+                                               cfg.m_half_y);
         materials.template add_value<slab_id>(cfg.mat, cfg.thickness);
 
         // Build the transform
         // The local phi
-        scalar m_phi = algebra::getter::phi(m_center);
+        scalar m_phi{algebra::getter::phi(m_center)};
         // Local z axis is the normal vector
         vector3 m_local_z{std::cos(m_phi + cfg.m_tilt_phi),
                           std::sin(m_phi + cfg.m_tilt_phi), 0.};
@@ -323,24 +313,62 @@ inline void create_barrel_modules(context_t &ctx, volume_type &vol,
  * @param resource vecmem memory resource
  * @param cfg config struct for module creation
  */
-template <typename surfaces_grid_t, typename config_t>
-inline void create_barrel_grid(surfaces_grid_t &surfaces_grid,
-                               vecmem::memory_resource &resource,
-                               config_t cfg) {
-    auto z_axis_info = cfg.get_z_axis_info();
-    auto &z_start = std::get<0>(z_axis_info);
-    auto &z_end = std::get<1>(z_axis_info);
-    auto &z_step = std::get<2>(z_axis_info);
+/*template <typename detector_t, typename config_t>
+inline void add_z_phi_grid(const typename detector_t::context &ctx,
+                           typename detector_t::volume_type &vol,
+                           detector_t &det, vecmem::memory_resource &resource,
+                           const config_t &cfg) {
+    // Get correct grid type
+    constexpr auto grid_id = detector_t::sf_finders::id::e_z_phi_grid;
+    using surface_grid_t =
+        typename detector_t::sf_finders::template get_type<grid_id>::type;
+
+    // return the first z position of module
+    std::size_t n_z_bins = cfg.m_binning.second;
+    scalar z_start{scalar{-0.5} * (n_z_bins - 1) *
+                   (scalar{2} * cfg.m_half_y - cfg.m_long_overlap)};
+    scalar z_end{std::abs(z_start)};
+    scalar z_half_step{scalar{0.5} * (z_end - z_start) / (n_z_bins - 1)};
 
     // add surface grid
-    typename surfaces_grid_t::axis_p0_type z_axis(
-        cfg.m_binning.second, z_start - z_step * 0.5, z_end + z_step * 0.5,
-        resource);
-    typename surfaces_grid_t::axis_p1_type phi_axis(cfg.m_binning.first, -M_PI,
-                                                    M_PI, resource);
+    typename surface_grid_t::axis_p0_type z_axis(
+        n_z_bins, z_start - z_half_step, z_end + z_half_step, resource);
+    typename surface_grid_t::axis_p1_type phi_axis(cfg.m_binning.first, -M_PI,
+                                                   M_PI, resource);
 
-    surfaces_grid = surfaces_grid_t(z_axis, phi_axis, resource);
-}
+    // Add new grid to the detector
+    surface_grid_t z_phi_grid(z_axis, phi_axis, resource);
+    det.template add_sf_finder<surface_grid_t, grid_id>(ctx, vol, z_phi_grid);
+}*/
+
+/** Helper function that creates a surface grid of trapezoidal endcap modules.
+ *
+ * @param vol the detector volume that should be equipped with a grid
+ * @param surfaces_grid the grid to be created with proper axes
+ * @param resource vecmem memory resource
+ * @param cfg config struct for module creation
+ */
+/*template <typename detector_t, typename config_t>
+inline void add_r_phi_grid(const typename detector_t::context &ctx,
+                           typename detector_t::volume_type &vol,
+                           detector_t &det, vecmem::memory_resource &resource,
+                           const config_t &cfg) {
+    // Get correct grid type
+    constexpr auto grid_id = detector_t::sf_finders::id::e_r_phi_grid;
+    using surface_grid_t =
+        typename detector_t::sf_finders::template get_type<grid_id>::type;
+
+    // add surface grid
+    // TODO: What is the proper value of n_phi_bins?
+    typename surface_grid_t::axis_p0_type r_axis(
+        cfg.disc_binning.size(), cfg.inner_r, cfg.outer_r, resource);
+    typename surface_grid_t::axis_p1_type phi_axis(cfg.disc_binning.front(),
+                                                   -M_PI, M_PI, resource);
+
+    // Add new grid to the detector
+    surface_grid_t r_phi_grid(r_axis, phi_axis, resource);
+    det.template add_sf_finder<surface_grid_t, grid_id>(ctx, vol, r_phi_grid);
+}*/
 
 /** Helper method for positioning of modules in an endcap ring
  *
@@ -359,9 +387,9 @@ inline auto module_positions_ring(scalar z, scalar radius, scalar phi_stagger,
     r_positions.reserve(n_phi_bins);
 
     // prep work
-    // scalar pi{static_cast<scalar>(M_PI)};
-    scalar phi_step = scalar{2} * M_PI / (n_phi_bins);
-    scalar min_phi = -M_PI + 0.5 * phi_step;
+    scalar pi{static_cast<scalar>(M_PI)};
+    scalar phi_step{scalar{2} * pi / (n_phi_bins)};
+    scalar min_phi{-pi + scalar{0.5} * phi_step};
 
     for (size_t iphi = 0; iphi < size_t(n_phi_bins); ++iphi) {
         // if we have a phi sub stagger presents
@@ -378,9 +406,10 @@ inline auto module_positions_ring(scalar z, scalar radius, scalar phi_stagger,
             }
         }
         // the module phi
-        scalar phi = min_phi + iphi * phi_step;
+        scalar phi{min_phi + iphi * phi_step};
         // main z position depending on phi bin
-        scalar rz = iphi % 2 ? z - 0.5 * phi_stagger : z + 0.5 * phi_stagger;
+        scalar rz{iphi % 2 ? z - scalar{0.5} * phi_stagger
+                           : z + scalar{0.5} * phi_stagger};
         r_positions.push_back(
             vector3{radius * std::cos(phi), radius * std::sin(phi), rz + rzs});
     }
@@ -408,7 +437,7 @@ void create_endcap_modules(context_t &ctx, volume_type &vol,
                            material_container_t &materials,
                            transform_container_t &transforms, config_t cfg) {
     using surface_type = typename surface_container_t::value_type;
-    using edge_t = typename surface_type::edge_type;
+    using volume_link_t = typename surface_type::volume_link_type;
     using mask_defs = typename surface_type::mask_defs;
     using mask_link_type = typename surface_type::mask_link;
     using material_defs = typename surface_type::material_defs;
@@ -418,16 +447,14 @@ void create_endcap_modules(context_t &ctx, volume_type &vol,
     constexpr auto slab_id = material_defs::id::e_slab;
 
     auto volume_id = vol.index();
-    edge_t mask_edge{volume_id, dindex_invalid};
-
-    vol.set_grid_type(volume_type::grid_type::e_r_phi_grid);
+    volume_link_t mask_volume_link{volume_id};
 
     // calculate the radii of the rings
     std::vector<scalar> radii;
     // calculate the radial borders
     // std::vector<scalar> radial_boarders;
     // the radial span of the disc
-    scalar delta_r = cfg.outer_r - cfg.inner_r;
+    scalar delta_r{cfg.outer_r - cfg.inner_r};
 
     // Only one ring
     if (cfg.disc_binning.size() == 1) {
@@ -435,16 +462,16 @@ void create_endcap_modules(context_t &ctx, volume_type &vol,
         // radial_boarders = {inner_r, outer_r};
     } else {
         // sum up the total length of the modules along r
-        scalar tot_length = 0;
+        scalar tot_length{0};
         for (auto &m_hlength : cfg.m_half_y) {
             tot_length += 2 * m_hlength + 0.5;
         }
         // now calculate the overlap (equal pay)
-        scalar r_overlap = (tot_length - delta_r) / (cfg.m_half_y.size() - 1);
+        scalar r_overlap{(tot_length - delta_r) / (cfg.m_half_y.size() - 1)};
         // and now fill the radii and gaps
-        scalar prev_r = cfg.inner_r;
-        scalar prev_hl = 0.;
-        scalar prev_ol = 0.;
+        scalar prev_r{cfg.inner_r};
+        scalar prev_hl{0};
+        scalar prev_ol{0};
         // remember the radial boarders
         // radial_boarders.push_back(inner_r);
         for (auto &m_hlength : cfg.m_half_y) {
@@ -463,14 +490,14 @@ void create_endcap_modules(context_t &ctx, volume_type &vol,
     for (size_t ir = 0; ir < radii.size(); ++ir) {
         // generate the z value
         // convention inner ring is closer to origin : makes sense
-        scalar rz =
+        scalar rz{
             radii.size() == 1
                 ? cfg.edc_position
                 : (ir % 2 ? cfg.edc_position + scalar{0.5} * cfg.ring_stagger
-                          : cfg.edc_position - scalar{0.5} * cfg.ring_stagger);
+                          : cfg.edc_position - scalar{0.5} * cfg.ring_stagger)};
         // fill the ring module positions
-        scalar ps_stagger =
-            cfg.m_phi_sub_stagger.size() ? cfg.m_phi_sub_stagger[ir] : 0.;
+        scalar ps_stagger{
+            cfg.m_phi_sub_stagger.size() ? cfg.m_phi_sub_stagger[ir] : 0};
 
         std::vector<point3> r_postitions =
             module_positions_ring(rz, radii[ir], cfg.m_phi_stagger[ir],
@@ -484,9 +511,10 @@ void create_endcap_modules(context_t &ctx, volume_type &vol,
             material_link_type material_link{
                 slab_id, materials.template size<slab_id>()};
 
-            masks.template add_value<trapezoid_id>(cfg.m_half_x_min_y[ir],
-                                                   cfg.m_half_x_max_y[ir],
-                                                   cfg.m_half_y[ir], mask_edge);
+            masks.template add_value<trapezoid_id>(
+                mask_volume_link, cfg.m_half_x_min_y[ir],
+                cfg.m_half_x_max_y[ir], cfg.m_half_y[ir],
+                static_cast<scalar>(1. / (2. * cfg.m_half_y[ir])));
 
             materials.template add_value<slab_id>(cfg.mat, cfg.thickness);
 
@@ -494,10 +522,9 @@ void create_endcap_modules(context_t &ctx, volume_type &vol,
             surfaces.emplace_back(transforms.size(ctx), mask_link,
                                   material_link, volume_id, dindex_invalid,
                                   false);
-            surfaces.back().set_grid_status(true);
 
             // the module transform from the position
-            scalar m_phi = algebra::getter::phi(m_position);
+            scalar m_phi{algebra::getter::phi(m_position)};
             // the center position of the modules
             point3 m_center{static_cast<scalar>(cfg.side) * m_position};
             // the rotation matrix of the module
@@ -512,26 +539,6 @@ void create_endcap_modules(context_t &ctx, volume_type &vol,
     }
 }
 
-/** Helper function that creates a surface grid of trapezoidal endcap modules.
- *
- * @param surfaces_grid the grid to be created with proper axes
- * @param resource vecmem memory resource
- * @param cfg config struct for module creation
- */
-template <typename surfaces_grid_t, typename config_t>
-inline void create_endcap_grid(surfaces_grid_t &surfaces_grid,
-                               vecmem::memory_resource &resource,
-                               config_t cfg) {
-    // add surface grid
-    // TODO: WHat is the proper value of n_phi_bins?
-    typename surfaces_grid_t::axis_p0_type r_axis(
-        cfg.disc_binning.size(), cfg.inner_r, cfg.outer_r, resource);
-    typename surfaces_grid_t::axis_p1_type phi_axis(cfg.disc_binning.front(),
-                                                    -M_PI, M_PI, resource);
-
-    surfaces_grid = surfaces_grid_t(r_axis, phi_axis, resource);
-}
-
 /** Helper method for creating a beampipe with enclosing volume.
  *
  * @param det detector the volume should be added to
@@ -552,7 +559,6 @@ inline void add_beampipe(
     const std::pair<scalar, scalar> &beampipe_vol_size, const scalar beampipe_r,
     const scalar brl_half_z, const scalar edc_inner_r) {
 
-    const dindex inv_sf_finder = dindex_invalid;
     const dindex leaving_world = dindex_invalid;
 
     scalar max_z =
@@ -568,12 +574,13 @@ inline void add_beampipe(
         det.new_volume({beampipe_vol_size.first, beampipe_vol_size.second,
                         min_z, max_z, -M_PI, M_PI});
     const auto beampipe_idx = beampipe.index();
+    beampipe.set_sf_finder(detector_t::sf_finders::id::e_default, 0);
 
     // This is the beampipe surface
-    typename detector_t::surface_type::edge_type edge = {beampipe_idx,
-                                                         inv_sf_finder};
+    typename detector_t::surface_type::volume_link_type volume_link{
+        beampipe_idx};
     add_cylinder_surface(beampipe_idx, ctx, surfaces, masks, materials,
-                         transforms, beampipe_r, min_z, max_z, edge,
+                         transforms, beampipe_r, min_z, max_z, volume_link,
                          beryllium_tml<scalar>(), 0.8 * unit_constants::mm);
 
     // Get vol sizes in z, including for gap volumes
@@ -587,42 +594,40 @@ inline void add_beampipe(
     vol_sizes.pop_back();
 
     // negative endcap portals
-    unsigned int volume_link = beampipe_idx;
+    dindex link = beampipe_idx;
     for (int i = vol_sizes.size() - 1; i >= 0; --i) {
-        edge = {++volume_link, inv_sf_finder};
+        volume_link = ++link;
         add_cylinder_surface(beampipe_idx, ctx, surfaces, masks, materials,
                              transforms, edc_inner_r, -vol_sizes[i].second,
-                             -vol_sizes[i].first, edge, vacuum<scalar>(),
+                             -vol_sizes[i].first, volume_link, vacuum<scalar>(),
                              0. * unit_constants::mm);
     }
+
     // barrel portals
-    if (n_brl_layers <= 0) {
-        edge = {leaving_world, inv_sf_finder};
-    } else {
-        edge = {volume_link + 1, inv_sf_finder};
-    }
+    volume_link = n_brl_layers <= 0 ? leaving_world : link + 1;
     add_cylinder_surface(beampipe_idx, ctx, surfaces, masks, materials,
-                         transforms, edc_inner_r, -brl_half_z, brl_half_z, edge,
-                         vacuum<scalar>(), 0. * unit_constants::mm);
+                         transforms, edc_inner_r, -brl_half_z, brl_half_z,
+                         volume_link, vacuum<scalar>(),
+                         0. * unit_constants::mm);
 
     // positive endcap portals
-    volume_link += 7;
+    link += 7;
     for (std::size_t i = 0; i < vol_sizes.size(); ++i) {
-        edge = {++volume_link, inv_sf_finder};
+        volume_link = ++link;
         add_cylinder_surface(beampipe_idx, ctx, surfaces, masks, materials,
                              transforms, edc_inner_r, vol_sizes[i].second,
-                             vol_sizes[i].first, edge, vacuum<scalar>(),
+                             vol_sizes[i].first, volume_link, vacuum<scalar>(),
                              0. * unit_constants::mm);
     }
 
     // disc portals
-    edge = {leaving_world, inv_sf_finder};
+    volume_link = leaving_world;
     add_disc_surface(beampipe_idx, ctx, surfaces, masks, materials, transforms,
                      beampipe_vol_size.first, beampipe_vol_size.second, min_z,
-                     edge, vacuum<scalar>(), 0. * unit_constants::mm);
+                     volume_link, vacuum<scalar>(), 0. * unit_constants::mm);
     add_disc_surface(beampipe_idx, ctx, surfaces, masks, materials, transforms,
                      beampipe_vol_size.first, beampipe_vol_size.second, max_z,
-                     edge, vacuum<scalar>(), 0. * unit_constants::mm);
+                     volume_link, vacuum<scalar>(), 0. * unit_constants::mm);
 
     det.add_objects_per_volume(ctx, beampipe, surfaces, masks, materials,
                                transforms);
@@ -664,22 +669,23 @@ inline void add_endcap_barrel_connection(
 
     auto &connector_gap =
         det.new_volume({edc_inner_r, edc_outer_r, min_z, max_z, -M_PI, M_PI});
-    dindex connector_gap_idx = det.volumes().back().index();
-    dindex leaving_world = dindex_invalid, inv_sf_finder = dindex_invalid;
+    connector_gap.set_sf_finder(detector_t::sf_finders::id::e_default, 0);
+    dindex connector_gap_idx{det.volumes().back().index()};
+    dindex leaving_world = dindex_invalid;
 
-    typename detector_t::surface_type::edge_type edge = {beampipe_idx,
-                                                         inv_sf_finder};
+    typename detector_t::surface_type::volume_link_type volume_link = {
+        beampipe_idx};
     add_cylinder_surface(connector_gap_idx, ctx, surfaces, masks, materials,
-                         transforms, edc_inner_r, min_z, max_z, edge,
+                         transforms, edc_inner_r, min_z, max_z, volume_link,
                          vacuum<scalar>(), 0. * unit_constants::mm);
-    edge = {leaving_world, inv_sf_finder};
+    volume_link = leaving_world;
     add_cylinder_surface(connector_gap_idx, ctx, surfaces, masks, materials,
-                         transforms, edc_outer_r, min_z, max_z, edge,
+                         transforms, edc_outer_r, min_z, max_z, volume_link,
                          vacuum<scalar>(), 0. * unit_constants::mm);
-    edge = {edc_vol_idx, inv_sf_finder};
+    volume_link = edc_vol_idx;
     add_disc_surface(connector_gap_idx, ctx, surfaces, masks, materials,
-                     transforms, edc_inner_r, edc_outer_r, edc_disc_z, edge,
-                     vacuum<scalar>(), 0. * unit_constants::mm);
+                     transforms, edc_inner_r, edc_outer_r, edc_disc_z,
+                     volume_link, vacuum<scalar>(), 0. * unit_constants::mm);
 
     // Get vol sizes in z also for gap volumes
     std::vector<std::pair<scalar, scalar>> vol_sizes;
@@ -689,12 +695,12 @@ inline void add_endcap_barrel_connection(
                                brl_lay_sizes[i + 1].first);
     }
 
-    edge = {brl_vol_idx, inv_sf_finder};
+    volume_link = brl_vol_idx;
     for (std::size_t i = 0; i < 2 * n_brl_layers - 1; ++i) {
-        edge = {brl_vol_idx++, inv_sf_finder};
+        volume_link = brl_vol_idx++;
         add_disc_surface(connector_gap_idx, ctx, surfaces, masks, materials,
                          transforms, vol_sizes[i].first, vol_sizes[i].second,
-                         brl_disc_z, edge, vacuum<scalar>(),
+                         brl_disc_z, volume_link, vacuum<scalar>(),
                          0. * unit_constants::mm);
     }
 
@@ -722,47 +728,38 @@ void add_endcap_detector(
     const std::vector<std::pair<scalar, scalar>> &lay_sizes,
     const std::vector<scalar> &lay_positions, config_t cfg) {
 
-    // Generate consecutive linking between volumes (all edges for every vol.)
-    using edge_t = typename detector_t::surface_type::edge_type;
-    std::vector<std::vector<edge_t>> edges_vec;
-    dindex leaving_world = dindex_invalid, inv_sf_finder = dindex_invalid;
+    // Generate consecutive linking between volumes (all volume_links for every
+    // vol.)
+    using volume_link_t = typename detector_t::surface_type::volume_link_type;
+    std::vector<std::vector<volume_link_t>> volume_links_vec;
+    dindex leaving_world = dindex_invalid;
     dindex first_vol_idx = det.volumes().back().index() + 1;
     dindex last_vol_idx = first_vol_idx + 2 * n_layers - 2;
     dindex prev_vol_idx = first_vol_idx - 1;
     dindex next_vol_idx = first_vol_idx + 1;
 
     for (int i = 0; i < 2 * static_cast<int>(n_layers) - 3; ++i) {
-        edges_vec.push_back({{beampipe_idx, inv_sf_finder},
-                             {leaving_world, inv_sf_finder},
-                             {++prev_vol_idx, inv_sf_finder},
-                             {++next_vol_idx, inv_sf_finder}});
+        volume_links_vec.push_back(
+            {beampipe_idx, leaving_world, ++prev_vol_idx, ++next_vol_idx});
     }
     // Edge of the world is flipped
     if (cfg.side < 0) {
-        edges_vec.insert(edges_vec.begin(),
-                         {{beampipe_idx, inv_sf_finder},
-                          {leaving_world, inv_sf_finder},
-                          {leaving_world, inv_sf_finder},
-                          {first_vol_idx + 1, inv_sf_finder}});
-
-        edges_vec.push_back({{beampipe_idx, inv_sf_finder},
-                             {leaving_world, inv_sf_finder},
-                             {last_vol_idx - 1, inv_sf_finder},
-                             {last_vol_idx + 1, inv_sf_finder}});
+        volume_links_vec.insert(
+            volume_links_vec.begin(),
+            {beampipe_idx, leaving_world, leaving_world, first_vol_idx + 1});
+
+        volume_links_vec.push_back(
+            {beampipe_idx, leaving_world, last_vol_idx - 1, last_vol_idx + 1});
     } else {
         // For n_layers=1 no extra gap layer is needed
         if (n_layers > 1) {
-            edges_vec.insert(edges_vec.begin(),
-                             {{beampipe_idx, inv_sf_finder},
-                              {leaving_world, inv_sf_finder},
-                              {first_vol_idx - 1, inv_sf_finder},
-                              {first_vol_idx + 1, inv_sf_finder}});
+            volume_links_vec.insert(volume_links_vec.begin(),
+                                    {beampipe_idx, leaving_world,
+                                     first_vol_idx - 1, first_vol_idx + 1});
         }
 
-        edges_vec.push_back({{beampipe_idx, inv_sf_finder},
-                             {leaving_world, inv_sf_finder},
-                             {last_vol_idx - 1, inv_sf_finder},
-                             {leaving_world, inv_sf_finder}});
+        volume_links_vec.push_back(
+            {beampipe_idx, leaving_world, last_vol_idx - 1, leaving_world});
     }
 
     // Get vol sizes in z, including gap volumes
@@ -791,14 +788,15 @@ void add_endcap_detector(
             create_cyl_volume(det, resource, ctx, cfg.inner_r, cfg.outer_r,
                               cfg.side * (vol_size_itr + cfg.side * i)->first,
                               cfg.side * (vol_size_itr + cfg.side * i)->second,
-                              edges_vec[i], empty_factory);
+                              volume_links_vec[i], empty_factory);
 
         } else {
             m_factory.cfg.edc_position = *(pos_itr + cfg.side * i / 2);
             create_cyl_volume(det, resource, ctx, cfg.inner_r, cfg.outer_r,
                               cfg.side * (vol_size_itr + cfg.side * i)->first,
                               cfg.side * (vol_size_itr + cfg.side * i)->second,
-                              edges_vec[i], m_factory);
+                              volume_links_vec[i], m_factory);
+            // add_r_phi_grid(ctx, det.volumes().back(), det, resource, cfg);
         }
     }
 }
@@ -826,7 +824,7 @@ void add_barrel_detector(
     const std::vector<std::pair<int, int>> &m_binning, config_t cfg) {
 
     // Generate consecutive linking between volumes
-    dindex leaving_world = dindex_invalid, inv_sf_finder = dindex_invalid;
+    dindex leaving_world = dindex_invalid;
     dindex first_vol_idx = det.volumes().back().index();
     dindex last_vol_idx = first_vol_idx + 2 * n_layers;
     dindex prev_vol_idx = first_vol_idx;
@@ -839,23 +837,17 @@ void add_barrel_detector(
     }
 
     // First barrel layer is connected to the beampipe
-    using edge_t = typename detector_t::surface_type::edge_type;
-    std::vector<std::vector<edge_t>> edges_vec{{{beampipe_idx, inv_sf_finder},
-                                                {next_vol_idx, inv_sf_finder},
-                                                {first_vol_idx, inv_sf_finder},
-                                                {last_vol_idx, inv_sf_finder}}};
+    using volume_link_t = typename detector_t::surface_type::volume_link_type;
+    std::vector<std::vector<volume_link_t>> volume_links_vec{
+        {beampipe_idx, next_vol_idx, first_vol_idx, last_vol_idx}};
 
     for (std::size_t i = 1; i < 2 * n_layers - 2; ++i) {
-        edges_vec.push_back({{++prev_vol_idx, inv_sf_finder},
-                             {++next_vol_idx, inv_sf_finder},
-                             {first_vol_idx, inv_sf_finder},
-                             {last_vol_idx, inv_sf_finder}});
+        volume_links_vec.push_back(
+            {++prev_vol_idx, ++next_vol_idx, first_vol_idx, last_vol_idx});
     }
     // Last barrel layer leaves detector world
-    edges_vec.push_back({{++prev_vol_idx, inv_sf_finder},
-                         {leaving_world, inv_sf_finder},
-                         {first_vol_idx, inv_sf_finder},
-                         {last_vol_idx, inv_sf_finder}});
+    volume_links_vec.push_back(
+        {++prev_vol_idx, leaving_world, first_vol_idx, last_vol_idx});
 
     // Get vol sizes in z, including gap volumes
     std::vector<std::pair<scalar, scalar>> vol_sizes{
@@ -875,13 +867,14 @@ void add_barrel_detector(
         if (is_gap) {
             create_cyl_volume(det, resource, ctx, vol_sizes[i].first,
                               vol_sizes[i].second, -brl_half_z, brl_half_z,
-                              edges_vec[i], empty_factory);
+                              volume_links_vec[i], empty_factory);
         } else {
             m_factory.cfg.m_binning = m_binning[j];
             m_factory.cfg.layer_r = lay_positions[j];
             create_cyl_volume(det, resource, ctx, vol_sizes[i].first,
                               vol_sizes[i].second, -brl_half_z, brl_half_z,
-                              edges_vec[i], m_factory);
+                              volume_links_vec[i], m_factory);
+            // add_z_phi_grid(ctx, det.volumes().back(), det, resource, cfg);
         }
     }
 }
@@ -933,17 +926,6 @@ auto create_toy_geometry(vecmem::memory_resource &resource,
         std::pair<int, int> m_binning = {16, 14};
         material<scalar> mat = silicon_tml<scalar>();
         scalar thickness = 0.15 * unit_constants::mm;
-
-        // return the first z position of module
-        std::tuple<scalar, scalar, scalar> get_z_axis_info() {
-            auto n_z_bins = m_binning.second;
-            scalar z_start{scalar{-0.5} * (n_z_bins - 1) *
-                           (scalar{2} * m_half_y - m_long_overlap)};
-            scalar z_end{std::abs(z_start)};
-            scalar z_step{(z_end - z_start) / (n_z_bins - 1)};
-
-            return {z_start, z_end, z_step};
-        }
     };
 
     //
@@ -984,9 +966,6 @@ auto create_toy_geometry(vecmem::memory_resource &resource,
             typename detector_t::mask_container & /*masks*/,
             typename detector_t::material_container & /*materials*/,
             typename detector_t::transform_container & /*transforms*/) {}
-        void operator()(typename detector_t::surfaces_finder_type::
-                            surfaces_regular_circular_grid & /*surfaces_grid*/,
-                        vecmem::memory_resource & /*resource*/) {}
     };
 
     // Fills volume with barrel layer
@@ -1002,11 +981,6 @@ auto create_toy_geometry(vecmem::memory_resource &resource,
             create_barrel_modules(ctx, volume, surfaces, masks, materials,
                                   transforms, cfg);
         }
-        void operator()(typename detector_t::surfaces_finder_type::
-                            surfaces_regular_circular_grid &surfaces_grid,
-                        vecmem::memory_resource &resource) {
-            create_barrel_grid(surfaces_grid, resource, cfg);
-        }
     };
 
     // Fills volume with endcap rings
@@ -1022,11 +996,6 @@ auto create_toy_geometry(vecmem::memory_resource &resource,
             create_endcap_modules(ctx, volume, surfaces, masks, materials,
                                   transforms, cfg);
         }
-        void operator()(typename detector_t::surfaces_finder_type::
-                            surfaces_regular_circular_grid &surfaces_grid,
-                        vecmem::memory_resource &resource) {
-            create_endcap_grid(surfaces_grid, resource, cfg);
-        }
     };
 
     // create empty detector
diff --git a/tests/common/include/tests/common/tools/detector_metadata.hpp b/tests/common/include/tests/common/tools/detector_metadata.hpp
index 95b9da1036..670ee8cacd 100644
--- a/tests/common/include/tests/common/tools/detector_metadata.hpp
+++ b/tests/common/include/tests/common/tools/detector_metadata.hpp
@@ -12,15 +12,13 @@
 #include "detray/core/transform_store.hpp"
 #include "detray/core/type_registry.hpp"
 #include "detray/definitions/indexing.hpp"
-#include "detray/grids/axis.hpp"
-#include "detray/grids/grid2.hpp"
-#include "detray/grids/populator.hpp"
-#include "detray/grids/serializer2.hpp"
 #include "detray/intersection/cylinder_intersector.hpp"
 #include "detray/intersection/plane_intersector.hpp"
 #include "detray/masks/masks.hpp"
 #include "detray/materials/material_rod.hpp"
 #include "detray/materials/material_slab.hpp"
+#include "detray/surface_finders/brute_force_finder.hpp"
+#include "detray/surface_finders/grid2_finder.hpp"
 
 namespace detray {
 
@@ -28,36 +26,26 @@ struct volume_stats {
     std::size_t n_max_objects_per_volume = 0;
 };
 
-/// edge links: next volume, next (local) object finder
-using edge_type = std::array<dindex, 2>;
+/// mask to (next) volume link: next volume(s)
+using volume_link_type = dindex;
 
 /// mask types
-using rectangle = rectangle2<__plugin::transform3<detray::scalar>,
-                             plane_intersector, cartesian2, edge_type>;
-using trapezoid = trapezoid2<__plugin::transform3<detray::scalar>,
-                             plane_intersector, cartesian2, edge_type>;
-using annulus = annulus2<__plugin::transform3<detray::scalar>,
-                         plane_intersector, polar2, edge_type>;
-using cylinder = cylinder3<__plugin::transform3<detray::scalar>,
-                           cylinder_intersector, cylindrical2, edge_type>;
-using disc = ring2<__plugin::transform3<detray::scalar>, plane_intersector,
-                   polar2, edge_type>;
-using unbounded_plane = unmasked<__plugin::transform3<detray::scalar>,
-                                 plane_intersector, cartesian2, edge_type>;
+using rectangle = mask<rectangle2D<>, volume_link_type>;
+using trapezoid = mask<trapezoid2D<>, volume_link_type>;
+using annulus = mask<annulus2D<>, volume_link_type>;
+using cylinder = mask<cylinder2D<>, volume_link_type>;
+using disc = mask<ring2D<>, volume_link_type>;
+using unbounded_plane = mask<unmasked, volume_link_type>;
 
 using slab = material_slab<detray::scalar>;
 using rod = material_rod<detray::scalar>;
 
 /// Defines all available types
-template <typename dynamic_data, std::size_t NGRIDS = 1>
+template <typename dynamic_data, std::size_t kBrlGrids = 1,
+          std::size_t kEdcGrids = 1, std::size_t kDefault = 1>
 struct full_metadata {
 
-    // How many grids have to be built
-    enum grids : std::size_t {
-        n_grids = NGRIDS,
-    };
-
-    // How to store and link transforms
+    /// How to store and link transforms
     template <template <typename...> class vector_t = dvector>
     using transform_store = static_transform_store<vector_t>;
 
@@ -66,25 +54,25 @@ struct full_metadata {
 
     /// Give your mask types a name (needs to be consecutive to be matched
     /// to a type!)
-    enum mask_ids : unsigned int {
+    enum class mask_ids {
         e_rectangle2 = 0,
         e_trapezoid2 = 1,
         e_annulus2 = 2,
-        e_cylinder3 = 3,
-        e_portal_cylinder3 = 3,  // no distinction from surface cylinder
+        e_cylinder2 = 3,
+        e_portal_cylinder2 = 3,  // no distinction from surface cylinder
         e_ring2 = 4,
         e_portal_ring2 = 4,
         e_single3 = 5,
     };
 
-    // How to store and link masks
+    /// How to store and link masks
     using mask_definitions =
         tuple_vector_registry<mask_ids, rectangle, trapezoid, annulus, cylinder,
                               disc>;
 
     /// Give your material types a name (needs to be consecutive to be matched
     /// to a type!)
-    enum material_ids : unsigned int {
+    enum class material_ids {
         e_slab = 0,
         e_rod = 1,
     };
@@ -92,7 +80,22 @@ struct full_metadata {
     // How to store and link materials
     using material_definitions = tuple_vector_registry<material_ids, slab, rod>;
 
-    // Accelerator types
+    /// How many grids have to be built
+    enum grids : std::size_t {
+        n_other = kDefault,
+        n_z_phi_grids = kBrlGrids,
+        n_r_phi_grids = kEdcGrids
+    };
+
+    /// Surface finders
+    enum class sf_finder_ids {
+        e_brute_force = 0,  // test all surfaces in a volume (brute force)
+        e_z_phi_grid = 1,   // barrel
+        e_r_phi_grid = 2,   // endcap
+        e_default = e_brute_force,
+    };
+
+    /// Surface finder types
     template <template <typename, std::size_t> class array_t = darray,
               template <typename...> class vector_t = dvector,
               template <typename...> class tuple_t = dtuple,
@@ -106,7 +109,19 @@ struct full_metadata {
               template <typename...> class tuple_t = dtuple,
               template <typename...> class jagged_vector_t = djagged_vector>
     using surface_finder =
-        surfaces_finder<n_grids, array_t, tuple_t, vector_t, jagged_vector_t>;
+        surfaces_finder<n_z_phi_grids + n_r_phi_grids, array_t, tuple_t,
+                        vector_t, jagged_vector_t>;
+
+    template <template <typename, std::size_t> class array_t = darray,
+              template <typename...> class vector_t = dvector,
+              template <typename...> class tuple_t = dtuple,
+              template <typename...> class jagged_vector_t = djagged_vector>
+    using sf_finder_definitions = tuple_array_registry<
+        sf_finder_ids,
+        std::index_sequence<n_other, n_z_phi_grids, n_r_phi_grids>,
+        brute_force_finder,
+        regular_circular_grid<vector_t, jagged_vector_t, array_t, tuple_t>,
+        regular_circular_grid<vector_t, jagged_vector_t, array_t, tuple_t>>;
 
     dynamic_data _data;
 };
@@ -114,12 +129,7 @@ struct full_metadata {
 /// Defines the data types needed for the toy detector
 struct toy_metadata {
 
-    // How many grids have to be built
-    enum grids : std::size_t {
-        n_grids = 20,
-    };
-
-    // How to store and link transforms
+    /// How to store and link transforms
     template <template <typename...> class vector_t = dvector>
     using transform_store = static_transform_store<vector_t>;
 
@@ -128,28 +138,43 @@ struct toy_metadata {
 
     /// Give your mask types a name (needs to be consecutive to be matched
     /// to a type!)
-    enum mask_ids : unsigned int {
+    enum class mask_ids {
         e_rectangle2 = 0,
         e_trapezoid2 = 1,
-        e_cylinder3 = 2,         // Put the beampipe into the same container as
-        e_portal_cylinder3 = 2,  // the cylinder portals
+        e_cylinder2 = 2,         // Put the beampipe into the same container as
+        e_portal_cylinder2 = 2,  // the cylinder portals
         e_portal_ring2 = 3,
     };
 
-    // How to store and link masks
+    /// How to store and link masks
     using mask_definitions =
         tuple_vector_registry<mask_ids, rectangle, trapezoid, cylinder, disc>;
 
     /// Give your material types a name (needs to be consecutive to be matched
     /// to a type!)
-    enum material_ids : unsigned int {
+    enum class material_ids {
         e_slab = 0,
     };
 
-    // How to store and link materials
+    /// How to store and link materials
     using material_definitions = tuple_vector_registry<material_ids, slab>;
 
-    // Accelerator types
+    /// How many grids have to be built
+    enum grids : std::size_t {
+        n_other = 1,
+        n_barrel_grids = 4,
+        n_endcap_grids = 14,
+    };
+
+    /// Surface finders
+    enum class sf_finder_ids {
+        e_brute_force = 0,  // test all surfaces in a volume (brute force)
+        e_z_phi_grid = 1,   // barrel
+        e_r_phi_grid = 2,   // endcap
+        e_default = e_brute_force,
+    };
+
+    ///  Surface finder types
     template <template <typename, std::size_t> class array_t = darray,
               template <typename...> class vector_t = dvector,
               template <typename...> class tuple_t = dtuple,
@@ -163,7 +188,19 @@ struct toy_metadata {
               template <typename...> class tuple_t = dtuple,
               template <typename...> class jagged_vector_t = djagged_vector>
     using surface_finder =
-        surfaces_finder<n_grids, array_t, tuple_t, vector_t, jagged_vector_t>;
+        surfaces_finder<n_barrel_grids + n_endcap_grids, array_t, tuple_t,
+                        vector_t, jagged_vector_t>;
+
+    template <template <typename, std::size_t> class array_t = darray,
+              template <typename...> class vector_t = dvector,
+              template <typename...> class tuple_t = dtuple,
+              template <typename...> class jagged_vector_t = djagged_vector>
+    using sf_finder_definitions = tuple_array_registry<
+        sf_finder_ids,
+        std::index_sequence<n_other, n_barrel_grids, n_endcap_grids>,
+        brute_force_finder,
+        regular_circular_grid<vector_t, jagged_vector_t, array_t, tuple_t>,
+        regular_circular_grid<vector_t, jagged_vector_t, array_t, tuple_t>>;
 
     volume_stats _data;
 };
@@ -171,12 +208,7 @@ struct toy_metadata {
 /// Defines a detector with only rectangle/unbounded surfaces
 struct telescope_metadata {
 
-    // How many grids have to be built
-    enum grids : std::size_t {
-        n_grids = 0,
-    };
-
-    // How to store and link transforms
+    /// How to store and link transforms
     template <template <typename...> class vector_t = dvector>
     using transform_store = static_transform_store<vector_t>;
 
@@ -185,25 +217,36 @@ struct telescope_metadata {
 
     /// Give your mask types a name (needs to be consecutive to be matched
     /// to a type!)
-    enum mask_ids : unsigned int {
+    enum class mask_ids {
         e_rectangle2 = 0,
         e_unbounded_plane2 = 1,
     };
 
-    // How to store and link masks
+    /// How to store and link masks
     using mask_definitions =
         tuple_vector_registry<mask_ids, rectangle, unbounded_plane>;
 
     /// Give your material types a name (needs to be consecutive to be matched
     /// to a type!)
-    enum material_ids : unsigned int {
+    enum class material_ids {
         e_slab = 0,
     };
 
-    // How to store and link materials
+    /// How to store and link materials
     using material_definitions = tuple_vector_registry<material_ids, slab>;
 
-    // Accelerator types (are not used)
+    /// How many grids have to be built
+    enum grids : std::size_t {
+        n_other = 1,
+    };
+
+    /// Surface finders
+    enum class sf_finder_ids {
+        e_brute_force = 0,  // test all surfaces in a volume (brute force)
+        e_default = e_brute_force,
+    };
+
+    ///  Surface finder types (are not used in telescope detector)
     template <template <typename, std::size_t> class array_t = darray,
               template <typename...> class vector_t = dvector,
               template <typename...> class tuple_t = dtuple,
@@ -217,7 +260,15 @@ struct telescope_metadata {
               template <typename...> class tuple_t = dtuple,
               template <typename...> class jagged_vector_t = djagged_vector>
     using surface_finder =
-        surfaces_finder<n_grids, array_t, tuple_t, vector_t, jagged_vector_t>;
+        surfaces_finder<n_other, array_t, tuple_t, vector_t, jagged_vector_t>;
+
+    template <template <typename, std::size_t> class array_t = darray,
+              template <typename...> class vector_t = dvector,
+              template <typename...> class tuple_t = dtuple,
+              template <typename...> class jagged_vector_t = djagged_vector>
+    using sf_finder_definitions =
+        tuple_array_registry<sf_finder_ids, std::index_sequence<n_other>,
+                             brute_force_finder>;
 };
 
 struct detector_registry {
diff --git a/tests/common/include/tests/common/tools/intersectors/helix_cylinder_intersector.hpp b/tests/common/include/tests/common/tools/intersectors/helix_cylinder_intersector.hpp
index 77ad3ec308..a9082dc9d8 100644
--- a/tests/common/include/tests/common/tools/intersectors/helix_cylinder_intersector.hpp
+++ b/tests/common/include/tests/common/tools/intersectors/helix_cylinder_intersector.hpp
@@ -14,6 +14,7 @@
 
 // System include(s)
 #include <cmath>
+#include <limits>
 #include <type_traits>
 
 namespace detray {
@@ -22,13 +23,13 @@ namespace detray {
 /// trajectories.
 ///
 /// The algorithm uses the Newton-Raphson method to find an intersection on
-/// the unbounded surface and then applies the mask. On the @c cylinder3
-/// mask, it switches on the check of the radial distance.
+/// the unbounded surface and then applies the mask.
 template <typename transform3_t>
 struct helix_cylinder_intersector {
 
     using scalar_type = typename transform3_t::scalar_type;
     using matrix_operator = typename transform3_t::matrix_actor;
+    using point2 = typename transform3_t::point2;
     using point3 = typename transform3_t::point3;
     using vector3 = typename transform3_t::vector3;
     using helix_type = detail::helix<transform3_t>;
@@ -55,8 +56,6 @@ struct helix_cylinder_intersector {
 
         output_type ret;
 
-        using local_frame = typename mask_t::local_type;
-
         // Guard against inifinite loops
         constexpr std::size_t max_n_tries{100};
         // Tolerance for convergence
@@ -71,7 +70,7 @@ struct helix_cylinder_intersector {
 
         // Starting point on the helix for the Newton iteration
         // The mask is a cylinder -> it provides its radius as the first value
-        const scalar_type r{mask[0]};
+        const scalar_type r{mask[cylinder2D<>::e_r]};
         // Helix path length parameter
         scalar_type s{r * getter::perp(h.dir(tol))};
         // Path length in the previous iteration step
@@ -108,13 +107,18 @@ struct helix_cylinder_intersector {
 
         is.path = getter::norm(helix_pos);
         is.p3 = helix_pos;
-        constexpr local_frame local_converter{};
-        is.p2 = local_converter.global_to_local(trf, is.p3, h.dir(s));
+        is.p2 = mask.to_local_frame(trf, is.p3, h.dir(s));
+        is.status = mask.is_inside(is.p2, mask_tolerance);
+
+        // Additionally check radial position for Newton solution
+        const scalar_type radial_pos{getter::perp(trf.point_to_local(is.p3))};
+        const bool r_check =
+            std::abs(r - radial_pos) <
+            mask_tolerance + 5 * std::numeric_limits<scalar_type>::epsilon();
+        if (not r_check) {
+            is.status = intersection::status::e_outside;
+        }
 
-        auto local3 = trf.point_to_local(is.p3);
-        // Explicitly check for radial match
-        is.status =
-            mask.template is_inside<local_frame, true>(local3, mask_tolerance);
         is.direction = vector::dot(is.p3, h.dir(s)) > scalar_type{0.}
                            ? intersection::direction::e_along
                            : intersection::direction::e_opposite;
diff --git a/tests/common/include/tests/common/tools/intersectors/helix_intersection_kernel.hpp b/tests/common/include/tests/common/tools/intersectors/helix_intersection_kernel.hpp
index 8838d333bc..d543b3da69 100644
--- a/tests/common/include/tests/common/tools/intersectors/helix_intersection_kernel.hpp
+++ b/tests/common/include/tests/common/tools/intersectors/helix_intersection_kernel.hpp
@@ -36,11 +36,11 @@ struct helix_intersection_update {
     ///
     /// @return the intersection
     ///
-    template <typename mask_group_t, typename traj_t, typename surface_t,
-              typename transform_container_t>
+    template <typename mask_group_t, typename mask_range_t, typename traj_t,
+              typename surface_t, typename transform_container_t>
     DETRAY_HOST_DEVICE inline output_type operator()(
-        const mask_group_t &mask_group, const traj_t &traj,
-        const surface_t &surface,
+        const mask_group_t &mask_group, const mask_range_t &mask_range,
+        const traj_t &traj, const surface_t &surface,
         const transform_container_t &contextual_transforms,
         const scalar mask_tolerance = 0.) const {
 
@@ -54,15 +54,16 @@ struct helix_intersection_update {
         using plane_intersector_type = plane_intersector<transform3_type>;
         using cylinder_intersector_type = cylinder_intersector<transform3_type>;
 
-        const auto &mask_range = surface.mask_range();
         const auto &ctf = contextual_transforms[surface.transform()];
 
         // Run over the masks belonged to the surface
         for (const auto &mask : range(mask_group, mask_range)) {
 
-            if constexpr (std::is_same_v<typename mask_group_t::value_type::
-                                             intersector_type,
-                                         plane_intersector_type>) {
+            using mask_t = typename mask_group_t::value_type;
+            if constexpr (std::is_same_v<
+                              typename mask_t::shape::template intersector_type<
+                                  transform3_type>,
+                              plane_intersector_type>) {
 
                 auto sfi = std::move(helix_plane_intersector_type()(
                     traj, mask, ctf, mask_tolerance));
@@ -73,10 +74,10 @@ struct helix_intersection_update {
                     return sfi[0];
                 }
 
-            } else if constexpr (std::is_same_v<
-                                     typename mask_group_t::value_type::
-                                         intersector_type,
-                                     cylinder_intersector_type>) {
+            } else if constexpr (std::is_same_v<typename mask_t::shape::
+                                                    template intersector_type<
+                                                        transform3_type>,
+                                                cylinder_intersector_type>) {
 
                 auto sfi = std::move(helix_cylinder_intersector_type()(
                     traj, mask, ctf, mask_tolerance));
diff --git a/tests/common/include/tests/common/tools/intersectors/helix_plane_intersector.hpp b/tests/common/include/tests/common/tools/intersectors/helix_plane_intersector.hpp
index 3758ca447e..983bf145f6 100644
--- a/tests/common/include/tests/common/tools/intersectors/helix_plane_intersector.hpp
+++ b/tests/common/include/tests/common/tools/intersectors/helix_plane_intersector.hpp
@@ -52,8 +52,6 @@ struct helix_plane_intersector {
         const helix_type &h, const mask_t &mask, const transform3_t &trf,
         const scalar mask_tolerance = 0) const {
 
-        using local_frame = typename mask_t::local_type;
-
         output_type ret;
 
         // Guard against inifinite loops
@@ -98,10 +96,9 @@ struct helix_plane_intersector {
 
         is.path = getter::norm(helix_pos);
         is.p3 = helix_pos;
-        constexpr local_frame local_converter{};
-        is.p2 = local_converter.global_to_local(trf, is.p3, h.dir(s));
+        is.p2 = mask.to_local_frame(trf, is.p3, h.dir(s));
 
-        is.status = mask.template is_inside<local_frame>(is.p2, mask_tolerance);
+        is.status = mask.is_inside(is.p2, mask_tolerance);
         is.direction = vector::dot(st, h.dir(s)) > scalar{0.}
                            ? intersection::direction::e_along
                            : intersection::direction::e_opposite;
diff --git a/tests/common/include/tests/common/tools/particle_gun.hpp b/tests/common/include/tests/common/tools/particle_gun.hpp
index 8d89d3395f..c172e04acb 100644
--- a/tests/common/include/tests/common/tools/particle_gun.hpp
+++ b/tests/common/include/tests/common/tools/particle_gun.hpp
@@ -57,12 +57,11 @@ struct particle_gun {
                 // NOTE: Change to interection_initialize
                 intersection_type sfi;
                 if constexpr (std::is_same_v<trajectory_t, helix_type>) {
-                    sfi =
-                        mask_store.template execute<helix_intersection_update>(
-                            sf.mask_type(), traj, sf, tf_store, 1e-4);
+                    sfi = mask_store.template call<helix_intersection_update>(
+                        sf.mask(), traj, sf, tf_store, 1e-4);
                 } else {
-                    sfi = mask_store.template execute<intersection_update>(
-                        sf.mask_type(), traj, sf, tf_store);
+                    sfi = mask_store.template call<intersection_update>(
+                        sf.mask(), traj, sf, tf_store);
                 }
                 // Candidate is invalid if it oversteps too far (this is neg!)
                 if (sfi.path < traj.overstep_tolerance()) {
diff --git a/tests/common/include/tests/common/tools/test_surfaces.hpp b/tests/common/include/tests/common/tools/test_surfaces.hpp
index c906f720a0..8255517c5f 100644
--- a/tests/common/include/tests/common/tools/test_surfaces.hpp
+++ b/tests/common/include/tests/common/tools/test_surfaces.hpp
@@ -17,7 +17,7 @@
 #include "detray/grids/grid2.hpp"
 #include "detray/grids/populator.hpp"
 #include "detray/grids/serializer2.hpp"
-#include "detray/masks/rectangle2.hpp"
+#include "detray/masks/rectangle2D.hpp"
 #include "detray/tools/local_object_finder.hpp"
 #include "detray/utils/enumerate.hpp"
 
@@ -39,8 +39,9 @@ enum plane_material_ids : unsigned int {
 using transform3 = __plugin::transform3<detray::scalar>;
 using point3 = __plugin::point3<detray::scalar>;
 using vector3 = __plugin::vector3<detray::scalar>;
-using plane_masks = tuple_vector_registry<plane_mask_ids, rectangle2<>>;
-using plane_materials = tuple_vector_registry<plane_material_ids, rectangle2<>>;
+using plane_masks = tuple_vector_registry<plane_mask_ids, mask<rectangle2D<>>>;
+using plane_materials =
+    tuple_vector_registry<plane_material_ids, mask<rectangle2D<>>>;
 
 using binned_neighborhood = darray<darray<dindex, 2>, 2>;
 
diff --git a/tests/common/include/tests/common/tools_cylinder_intersection.inl b/tests/common/include/tests/common/tools_cylinder_intersection.inl
index 7f5449e140..da3f3957a5 100644
--- a/tests/common/include/tests/common/tools_cylinder_intersection.inl
+++ b/tests/common/include/tests/common/tools_cylinder_intersection.inl
@@ -7,19 +7,25 @@
 
 #include <gtest/gtest.h>
 
-#include <climits>
-#include <cmath>
-
+// Project include(s)
 #include "detray/intersection/concentric_cylinder_intersector.hpp"
 #include "detray/intersection/cylinder_intersector.hpp"
 #include "detray/intersection/detail/trajectories.hpp"
 #include "detray/intersection/intersection.hpp"
 #include "detray/intersection/intersection_kernel.hpp"
-#include "detray/masks/cylinder3.hpp"
+#include "detray/masks/masks.hpp"
 #include "tests/common/tools/intersectors/helix_cylinder_intersector.hpp"
 
-// Three-dimensional definitions
+// System include(s)
+#include <cmath>
+#include <limits>
+
+/// @note __plugin has to be defined with a preprocessor command
 using namespace detray;
+
+namespace {
+
+// Three-dimensional definitions
 using transform3_type = __plugin::transform3<detray::scalar>;
 using vector3 = __plugin::vector3<detray::scalar>;
 using point3 = __plugin::point3<detray::scalar>;
@@ -27,10 +33,14 @@ using scalar_type = typename transform3_type::scalar_type;
 using ray_type = detray::detail::ray<transform3_type>;
 using helix_type = detray::detail::helix<transform3_type>;
 
-constexpr scalar_type epsilon = std::numeric_limits<scalar_type>::epsilon();
-constexpr scalar_type not_defined =
-    std::numeric_limits<scalar_type>::infinity();
-constexpr scalar_type isclose = 1e-5;
+constexpr scalar epsilon = std::numeric_limits<scalar>::epsilon();
+constexpr scalar not_defined = std::numeric_limits<scalar>::infinity();
+constexpr scalar isclose = 1e-5;
+
+const scalar r{4.};
+const scalar hz{10.};
+
+}  // anonymous namespace
 
 // This defines the local frame test suite
 TEST(ALGEBRA_PLUGIN, translated_cylinder) {
@@ -44,8 +54,8 @@ TEST(ALGEBRA_PLUGIN, translated_cylinder) {
     const ray_type ray(ori, 0., dir, 0.);
 
     // Check intersection
-    cylinder3<transform3_type, cylinder_intersector, cylindrical2, unsigned int>
-        cylinder_bound{4., -10., 10., 0u};
+    mask<cylinder2D<>, unsigned int, transform3_type> cylinder_bound{0u, r, -hz,
+                                                                     hz};
     const auto hit_bound = ci(ray, cylinder_bound, shifted)[0];
     ASSERT_TRUE(hit_bound.status == intersection::status::e_inside);
     ASSERT_NEAR(hit_bound.p3[0], 7., epsilon);
@@ -69,8 +79,8 @@ TEST(ALGEBRA_PLUGIN, cylinder_incidence_angle) {
     const ray_type ray(ori, 0., dir, 0.);
 
     // Check intersection
-    cylinder3<transform3_type, cylinder_intersector, cylindrical2, unsigned int>
-        cylinder_bound{4., -10., 10., 0u};
+    mask<cylinder2D<>, unsigned int, transform3_type> cylinder_bound{0u, r, -hz,
+                                                                     hz};
     const auto hit_bound = ci(ray, cylinder_bound, tf)[0];
     ASSERT_NEAR(hit_bound.cos_incidence_angle, std::sqrt(15) / 4., isclose);
 }
@@ -83,11 +93,11 @@ TEST(ALGEBRA_PLUGIN, concentric_cylinders) {
     const ray_type ray(ori, 0., dir, 0.);
 
     // Create a concentric cylinder and test intersection
-    const scalar r = 4.;
-    const scalar hz = 10.;
     const transform3_type identity(vector3{0., 0., 0.});
-    cylinder3<transform3_type, cylinder_intersector, cylindrical2, unsigned int>
-        cylinder{r, -hz, hz, 0u};
+    mask<cylinder2D<>, unsigned int, transform3_type> cylinder{0u, r, -hz, hz};
+    mask<cylinder2D<false, concentric_cylinder_intersector>, unsigned int,
+         transform3_type>
+        conc_cylinder{0u, r, -hz, hz};
     cylinder_intersector<transform3_type> ci;
     concentric_cylinder_intersector<transform3_type> cci;
 
@@ -119,7 +129,7 @@ TEST(ALGEBRA_PLUGIN, concentric_cylinders) {
 TEST(ALGEBRA_PLUGIN, helix_cylinder_intersector) {
     // Create a translated cylinder and test untersection
     const transform3_type shifted(vector3{3., 2., 10.});
-    helix_cylinder_intersector<transform3_type> ci;
+    helix_cylinder_intersector<transform3_type> hi;
 
     // Test helix
     const point3 pos{3., 2., 5.};
@@ -129,9 +139,10 @@ TEST(ALGEBRA_PLUGIN, helix_cylinder_intersector) {
     const helix_type h({pos, 0, mom, -1}, &B);
 
     // Check intersection
-    cylinder3<transform3_type, cylinder_intersector, cylindrical2, unsigned int>
-        cylinder_bound{4., -10., 10., 0u};
-    const auto hit_bound = ci(h, cylinder_bound, shifted)[0];
+    mask<cylinder2D<false, helix_cylinder_intersector>, unsigned int,
+         transform3_type>
+        cylinder_bound{0u, r, -hz, hz};
+    const auto hit_bound = hi(h, cylinder_bound, shifted)[0];
     ASSERT_TRUE(hit_bound.status == intersection::status::e_inside);
     ASSERT_NEAR(hit_bound.p3[0], 7., epsilon);
     ASSERT_NEAR(hit_bound.p3[1], 2., epsilon);
diff --git a/tests/common/include/tests/common/tools_intersection_kernel.inl b/tests/common/include/tests/common/tools_intersection_kernel.inl
index a10a1a6019..50934083f3 100644
--- a/tests/common/include/tests/common/tools_intersection_kernel.inl
+++ b/tests/common/include/tests/common/tools_intersection_kernel.inl
@@ -41,20 +41,16 @@ enum material_ids : unsigned int {
 };
 
 /// Surface components:
-using edge_t = dindex;
+using volume_link_t = dindex;
 using source_link_t = dindex;
-
 /// - masks, with mask identifiers 0,1,2
-using rectangle_t =
-    rectangle2<transform3_type, plane_intersector, cartesian2, edge_t>;
-using trapezoid_t =
-    trapezoid2<transform3_type, plane_intersector, cartesian2, edge_t>;
-using annulus_t =
-    annulus2<transform3_type, plane_intersector, cartesian2, edge_t>;
+using rectangle_t = mask<rectangle2D<>, volume_link_t>;
+using trapezoid_t = mask<trapezoid2D<>, volume_link_t>;
+using annulus_t = mask<annulus2D<>, volume_link_t>;
 
 using mask_defs =
     tuple_vector_registry<mask_ids, rectangle_t, trapezoid_t, annulus_t>;
-using mask_container_t = typename mask_defs::template store_type<>;
+using mask_container_t = typename mask_defs::store_type<>;
 
 constexpr const float epsilon = 1e-3;
 
@@ -72,8 +68,7 @@ TEST(tools, intersection_kernel_ray) {
 
     /// The Surface definition:
     /// <transform_link, volume_link, source_link, link_type_in_mask>
-    using surface_t =
-        surface<mask_defs, material_defs, dindex, dindex, source_link_t>;
+    using surface_t = surface<mask_defs, material_defs, dindex, source_link_t>;
     using surface_container_t = dvector<surface_t>;
 
     // The transforms & their store
@@ -85,10 +80,10 @@ TEST(tools, intersection_kernel_ray) {
     transform_store.emplace_back(static_context, point3{0., -20., 30.});
     // The masks & their store
     mask_container_t mask_store(host_mr);
-    mask_store.template add_value<e_rectangle2>(10., 10., 0);
-    mask_store.template add_value<e_trapezoid2>(10., 20., 30., 0);
-    mask_store.template add_value<e_annulus2>(15., 55., 0.75, 1.95, 2., -2., 0.,
-                                              0);
+    mask_store.template add_value<e_rectangle2>(0UL, 10.f, 10.f);
+    mask_store.template add_value<e_trapezoid2>(0UL, 10.f, 20.f, 30.f);
+    mask_store.template add_value<e_annulus2>(0UL, 15.f, 55.f, 0.75f, 1.95f,
+                                              2.f, -2.f, 0.f);
     // Materials and their store
     material_container_t material_store(host_mr);
     material_store.template add_value<e_slab>(silicon<scalar>(),
@@ -124,17 +119,17 @@ TEST(tools, intersection_kernel_ray) {
     std::vector<line_plane_intersection> sfi_init;
 
     for (const auto& [sf_idx, surface] : enumerate(surfaces)) {
-        mask_store.execute<intersection_initialize>(
-            surface.mask_type(), sfi_init, detail::ray(track), surface,
-            transform_store);
+        mask_store.call<intersection_initialize>(surface.mask(), sfi_init,
+                                                 detail::ray(track), surface,
+                                                 transform_store);
     }
 
     // Update kernel
     std::vector<line_plane_intersection> sfi_update;
 
     for (const auto& [sf_idx, surface] : enumerate(surfaces)) {
-        const auto sfi = mask_store.execute<intersection_update>(
-            surface.mask_type(), detail::ray(track), surface, transform_store);
+        const auto sfi = mask_store.call<intersection_update>(
+            surface.mask(), detail::ray(track), surface, transform_store);
 
         sfi_update.push_back(sfi);
 
@@ -165,8 +160,7 @@ TEST(tools, intersection_kernel_helix) {
 
     /// The Surface definition:
     /// <transform_link, volume_link, source_link, link_type_in_mask>
-    using surface_t =
-        surface<mask_defs, material_defs, dindex, dindex, source_link_t>;
+    using surface_t = surface<mask_defs, material_defs, dindex, source_link_t>;
     using surface_container_t = dvector<surface_t>;
 
     // The transforms & their store
@@ -178,10 +172,10 @@ TEST(tools, intersection_kernel_helix) {
     transform_store.emplace_back(static_context, point3{0., -20., 30.});
     // The masks & their store
     mask_container_t mask_store(host_mr);
-    mask_store.template add_value<e_rectangle2>(10., 10., 0);
-    mask_store.template add_value<e_trapezoid2>(10., 20., 30., 0);
-    mask_store.template add_value<e_annulus2>(15., 55., 0.75, 1.95, 2., -2., 0.,
-                                              0);
+    mask_store.template add_value<e_rectangle2>(0UL, 10.f, 10.f);
+    mask_store.template add_value<e_trapezoid2>(0UL, 10.f, 20.f, 30.f);
+    mask_store.template add_value<e_annulus2>(0UL, 15.f, 55.f, 0.75f, 1.95f,
+                                              2.f, -2.f, 0.f);
     // Materials and their store
     material_container_t material_store(host_mr);
     material_store.template add_value<e_slab>(silicon<scalar>(),
@@ -215,8 +209,8 @@ TEST(tools, intersection_kernel_helix) {
 
     // Try the intersections - with automated dispatching via the kernel
     for (const auto& [sf_idx, surface] : enumerate(surfaces)) {
-        const auto sfi_helix = mask_store.execute<helix_intersection_update>(
-            surface.mask_type(), h, surface, transform_store);
+        const auto sfi_helix = mask_store.call<helix_intersection_update>(
+            surface.mask(), h, surface, transform_store);
 
         ASSERT_NEAR(sfi_helix.p3[0], expected_points[sf_idx][0], 1e-7);
         ASSERT_NEAR(sfi_helix.p3[1], expected_points[sf_idx][1], 1e-7);
diff --git a/tests/common/include/tests/common/tools_line_intersection.inl b/tests/common/include/tests/common/tools_line_intersection.inl
index 9879c0998a..944c2b016f 100644
--- a/tests/common/include/tests/common/tools_line_intersection.inl
+++ b/tests/common/include/tests/common/tools_line_intersection.inl
@@ -9,15 +9,15 @@
 #include "detray/intersection/detail/trajectories.hpp"
 #include "detray/intersection/intersection.hpp"
 #include "detray/intersection/line_intersector.hpp"
-#include "detray/masks/line.hpp"
+#include "detray/masks/masks.hpp"
 #include "detray/tracks/tracks.hpp"
 
 // GTest include(s)
 #include <gtest/gtest.h>
 
 // System include(s)
-#include <climits>
 #include <cmath>
+#include <limits>
 
 /// @note __plugin has to be defined with a preprocessor command
 using namespace detray;
@@ -29,6 +29,7 @@ using vector3 = __plugin::vector3<scalar>;
 using point3 = __plugin::point3<scalar>;
 using point2 = __plugin::point2<scalar>;
 using line_intersector_type = line_intersector<transform3>;
+
 constexpr scalar tolerance = 1e-5;
 
 // Test simplest case
@@ -49,7 +50,7 @@ TEST(tools, line_intersector_case1) {
     trks.emplace_back(point3{1, -1, 2}, 0, vector3{0, 1, -1}, -1);
 
     // Infinite wire with 10 mm radial cell size
-    const line<> ln{10., std::numeric_limits<scalar>::infinity(), 0u};
+    const mask<line<>> ln{0UL, 10.f, std::numeric_limits<scalar>::infinity()};
 
     // Test intersect
     std::vector<line_intersector_type::intersection_type> is(3);
@@ -76,7 +77,7 @@ TEST(tools, line_intersector_case1) {
     EXPECT_NEAR(is[2].p3[2], 1., tolerance);
     EXPECT_NEAR(is[2].p2[0], -1., tolerance);  // right
     EXPECT_NEAR(is[2].p2[1], 1., tolerance);
-    EXPECT_NEAR(is[2].cos_incidence_angle, 1. / sqrt(2), tolerance);
+    EXPECT_NEAR(is[2].cos_incidence_angle, 1. / std::sqrt(2), tolerance);
 }
 
 // Test inclined wire
@@ -94,14 +95,14 @@ TEST(tools, line_intersector_case2) {
 
     // Infinite wire with 10 mm
     // radial cell size
-    const line<> ln{10., std::numeric_limits<scalar>::infinity(), 0u};
+    const mask<line<>> ln{0UL, 10.f, std::numeric_limits<scalar>::infinity()};
 
     // Test intersect
     const line_intersector_type::intersection_type is =
         line_intersector_type()(detail::ray<transform3>(trk), ln, tf)[0];
 
     EXPECT_EQ(is.status, intersection::status::e_inside);
-    EXPECT_FLOAT_EQ(is.path, 2.);
+    EXPECT_NEAR(is.path, 2., tolerance);
     EXPECT_NEAR(is.p3[0], 1., tolerance);
     EXPECT_NEAR(is.p3[1], 1., tolerance);
     EXPECT_NEAR(is.p3[2], 0., tolerance);
@@ -138,8 +139,8 @@ TEST(tools, line_intersector_square_scope) {
     trks.emplace_back(point3{0, -2.1, 0}, 0, vector3{1, 1, 0}, -1);
 
     // Infinite wire with 1 mm square cell size
-    line<transform3, line_intersector, cartesian2, dindex, true> ln{
-        1., std::numeric_limits<scalar>::infinity(), 0u};
+    mask<line<true, line_intersector>, dindex, transform3> ln{
+        0UL, 1.f, std::numeric_limits<scalar>::infinity()};
 
     // Test intersect
     std::vector<line_plane_intersection> is;
diff --git a/tests/common/include/tests/common/tools_planar_intersection.inl b/tests/common/include/tests/common/tools_planar_intersection.inl
index 0cf76300ad..96c4154523 100644
--- a/tests/common/include/tests/common/tools_planar_intersection.inl
+++ b/tests/common/include/tests/common/tools_planar_intersection.inl
@@ -13,8 +13,7 @@
 #include "detray/intersection/detail/trajectories.hpp"
 #include "detray/intersection/intersection.hpp"
 #include "detray/intersection/plane_intersector.hpp"
-#include "detray/masks/rectangle2.hpp"
-#include "detray/masks/unmasked.hpp"
+#include "detray/masks/masks.hpp"
 #include "tests/common/tools/intersectors/helix_plane_intersector.hpp"
 
 /// @note __plugin has to be defined with a preprocessor command
@@ -40,11 +39,10 @@ TEST(ALGEBRA_PLUGIN, translated_plane_ray) {
     const detail::ray<transform3> r(pos, 0., mom, 0.);
 
     // The same test but bound to local frame
-    using unmasked = unmasked<transform3, plane_intersector, cartesian2>;
-    auto pi = typename unmasked::intersector_type();
-
-    unmasked unmasked_bound{};
+    plane_intersector<transform3> pi;
+    mask<unmasked> unmasked_bound{};
     const auto hit_bound = pi(r, unmasked_bound, shifted)[0];
+
     ASSERT_TRUE(hit_bound.status == intersection::status::e_inside);
     // Global intersection information - unchanged
     ASSERT_NEAR(hit_bound.p3[0], 2., epsilon);
@@ -57,7 +55,7 @@ TEST(ALGEBRA_PLUGIN, translated_plane_ray) {
     ASSERT_NEAR(hit_bound.cos_incidence_angle, 1., epsilon);
 
     // The same test but bound to local frame & masked - inside
-    rectangle2<> rect_for_inside{3., 3., 0u};
+    mask<rectangle2D<>> rect_for_inside{0UL, 3.f, 3.f};
     const auto hit_bound_inside = pi(r, rect_for_inside, shifted)[0];
     ASSERT_TRUE(hit_bound_inside.status == intersection::status::e_inside);
     // Global intersection information - unchanged
@@ -69,7 +67,7 @@ TEST(ALGEBRA_PLUGIN, translated_plane_ray) {
     ASSERT_NEAR(hit_bound_inside.p2[1], -1., epsilon);
 
     // The same test but bound to local frame & masked - outside
-    rectangle2<> rect_for_outside{0.5, 3.5, 0u};
+    mask<rectangle2D<>> rect_for_outside{0UL, 0.5f, 3.5f};
     const auto hit_bound_outside = pi(r, rect_for_outside, shifted)[0];
     ASSERT_TRUE(hit_bound_outside.status == intersection::status::e_outside);
     // Global intersection information - unchanged
@@ -98,7 +96,7 @@ TEST(ALGEBRA_PLUGIN, plane_incidence_angle) {
     const detail::ray<transform3> r(pos, 0., mom, 0.);
 
     // The same test but bound to local frame & masked - inside
-    rectangle2<> rect{3., 3., 0u};
+    mask<rectangle2D<>> rect{0UL, 3.f, 3.f};
 
     const line_plane_intersection is = pi(r, rect, rotated)[0];
 
@@ -118,11 +116,10 @@ TEST(ALGEBRA_PLUGIN, translated_plane_helix) {
     const detail::helix<transform3> h({pos, 0, mom, -1}, &B);
 
     // The same test but bound to local frame
-    using unmasked = unmasked<transform3, plane_intersector, cartesian2>;
     helix_plane_intersector<transform3> pi;
-
-    unmasked unmasked_bound{};
+    mask<unmasked> unmasked_bound{};
     const auto hit_bound = pi(h, unmasked_bound, shifted)[0];
+
     ASSERT_TRUE(hit_bound.status == intersection::status::e_inside);
     // Global intersection information - unchanged
     ASSERT_NEAR(hit_bound.p3[0], 2., epsilon);
@@ -135,7 +132,7 @@ TEST(ALGEBRA_PLUGIN, translated_plane_helix) {
     ASSERT_NEAR(hit_bound.cos_incidence_angle, 1., epsilon);
 
     // The same test but bound to local frame & masked - inside
-    rectangle2<> rect_for_inside{3., 3., 0u};
+    mask<rectangle2D<>> rect_for_inside{0UL, 3.f, 3.f};
     const auto hit_bound_inside = pi(h, rect_for_inside, shifted)[0];
     ASSERT_TRUE(hit_bound_inside.status == intersection::status::e_inside);
     // Global intersection information - unchanged
@@ -147,7 +144,7 @@ TEST(ALGEBRA_PLUGIN, translated_plane_helix) {
     ASSERT_NEAR(hit_bound_inside.p2[1], -1., epsilon);
 
     // The same test but bound to local frame & masked - outside
-    rectangle2<> rect_for_outside{0.5, 3.5, 0u};
+    mask<rectangle2D<>> rect_for_outside{0UL, 0.5f, 3.5f};
     const auto hit_bound_outside = pi(h, rect_for_outside, shifted)[0];
     ASSERT_TRUE(hit_bound_outside.status == intersection::status::e_outside);
     // Global intersection information - unchanged
diff --git a/tests/common/include/tests/common/tools_stepper.inl b/tests/common/include/tests/common/tools_stepper.inl
index 4d83b03786..41510b13be 100644
--- a/tests/common/include/tests/common/tools_stepper.inl
+++ b/tests/common/include/tests/common/tools_stepper.inl
@@ -12,7 +12,6 @@
 #include "detray/field/constant_magnetic_field.hpp"
 #include "detray/geometry/surface.hpp"
 #include "detray/intersection/detail/trajectories.hpp"
-#include "detray/masks/rectangle2.hpp"
 #include "detray/propagator/line_stepper.hpp"
 #include "detray/propagator/rk_stepper.hpp"
 #include "detray/tracks/tracks.hpp"
diff --git a/tests/common/include/tests/common/tools_track.inl b/tests/common/include/tests/common/tools_track.inl
index 613c3a0127..c3795b50f6 100644
--- a/tests/common/include/tests/common/tools_track.inl
+++ b/tests/common/include/tests/common/tools_track.inl
@@ -9,7 +9,7 @@
 #include "detray/core/transform_store.hpp"
 #include "detray/core/type_registry.hpp"
 #include "detray/geometry/surface.hpp"
-#include "detray/masks/rectangle2.hpp"
+#include "detray/masks/masks.hpp"
 #include "detray/materials/material_slab.hpp"
 #include "detray/tracks/tracks.hpp"
 
@@ -32,7 +32,7 @@ enum material_ids : unsigned int {
     e_slab = 0,
 };
 
-using mask_defs = tuple_vector_registry<mask_ids, rectangle2<>>;
+using mask_defs = tuple_vector_registry<mask_ids, mask<rectangle2D<>>>;
 using material_defs =
     tuple_vector_registry<material_ids, material_slab<scalar>>;
 
diff --git a/tests/unit_tests/array/CMakeLists.txt b/tests/unit_tests/array/CMakeLists.txt
index 1e3f7cce3b..840bbf20a1 100644
--- a/tests/unit_tests/array/CMakeLists.txt
+++ b/tests/unit_tests/array/CMakeLists.txt
@@ -6,20 +6,47 @@
 
 # Set up all of the "standard" tests.
 detray_add_test( array
-   "array_actor_chain.cpp" "array_annulus2.cpp" "array_container.cpp" "array_coordinates.cpp"
-   "array_core.cpp" "array_covariance_engine.cpp"
-   "array_cylinder_intersection.cpp" "array_cylinder3.cpp" "array_detector.cpp"
-   "array_geometry_volume_graph.cpp" "array_geometry_linking.cpp"
-   "array_geometry_navigation.cpp" "array_geometry_scan.cpp"
-   "array_guided_navigator.cpp" "array_helix_trajectory.cpp"
-   "array_intersection_kernel.cpp" "array_particle_gun.cpp"
-   "array_mask_store.cpp" "array_materials.cpp" "array_navigator.cpp"
-   "array_planar_intersection.cpp" "array_line_intersection.cpp" "array_line.cpp" "array_propagator.cpp"
-   "array_rectangle2.cpp" "array_ring2.cpp" "array_single3.cpp"
-   "array_stepper.cpp" "array_surfaces_finder.cpp"
-   "array_telescope_detector.cpp" "array_toy_geometry.cpp" "array_track.cpp" 
-   "array_transform_store.cpp" "array_trapezoid2.cpp"
-   "array_track_generators.cpp" "array_unmasked.cpp" "array_volume.cpp"
+   "array_actor_chain.cpp"
+   "array_annulus2D.cpp"
+   "array_container.cpp"
+   "array_coordinates.cpp"
+   "array_core.cpp"
+   "array_covariance_engine.cpp"
+   "array_cylinder_intersection.cpp"
+   "array_cylinder.cpp"
+   "array_detector.cpp"
+   "array_geometry_volume_graph.cpp"
+   "array_geometry_linking.cpp"
+   "array_geometry_navigation.cpp" 
+   "array_geometry_scan.cpp"
+   "array_grid_axis.cpp"
+   "array_grid.cpp"
+   "array_grid_populator.cpp"
+   "array_grid_serializer.cpp"
+   "array_guided_navigator.cpp"
+   "array_helix_trajectory.cpp"
+   "array_intersection_kernel.cpp"
+   "array_particle_gun.cpp"
+   "array_mask_store.cpp"
+   "array_materials.cpp"
+   "array_navigator.cpp"
+   "array_planar_intersection.cpp" 
+   "array_line_intersection.cpp"
+   "array_line.cpp"
+   "array_propagator.cpp"
+   "array_rectangle2D.cpp"
+   "array_ring2D.cpp"
+   "array_single3D.cpp"
+   "array_stepper.cpp"
+   "array_surfaces_finder.cpp"
+   "array_telescope_detector.cpp"
+   "array_toy_geometry.cpp"
+   "array_track.cpp"
+   "array_transform_store.cpp"
+   "array_trapezoid2D.cpp"
+   "array_track_generators.cpp"
+   "array_unmasked.cpp"
+   "array_volume.cpp"
    LINK_LIBRARIES GTest::gtest_main detray_tests_common detray::array )
 
 # Set up the "conditional" tests.
diff --git a/tests/unit_tests/array/array_cylinder3.cpp b/tests/unit_tests/array/array_annulus2D.cpp
similarity index 82%
rename from tests/unit_tests/array/array_cylinder3.cpp
rename to tests/unit_tests/array/array_annulus2D.cpp
index 8eaaeca557..12d12ebb3c 100644
--- a/tests/unit_tests/array/array_cylinder3.cpp
+++ b/tests/unit_tests/array/array_annulus2D.cpp
@@ -6,4 +6,4 @@
  */
 
 #include "detray/plugins/algebra/array_definitions.hpp"
-#include "tests/common/masks_cylinder3.inl"
\ No newline at end of file
+#include "tests/common/masks_annulus2D.inl"
diff --git a/tests/unit_tests/array/array_single3.cpp b/tests/unit_tests/array/array_cylinder.cpp
similarity index 83%
rename from tests/unit_tests/array/array_single3.cpp
rename to tests/unit_tests/array/array_cylinder.cpp
index 920e54429f..079a4db19a 100644
--- a/tests/unit_tests/array/array_single3.cpp
+++ b/tests/unit_tests/array/array_cylinder.cpp
@@ -6,4 +6,4 @@
  */
 
 #include "detray/plugins/algebra/array_definitions.hpp"
-#include "tests/common/masks_single3.inl"
\ No newline at end of file
+#include "tests/common/masks_cylinder.inl"
\ No newline at end of file
diff --git a/tests/unit_tests/array/array_grid.cpp b/tests/unit_tests/array/array_grid.cpp
new file mode 100644
index 0000000000..a135d7c1bb
--- /dev/null
+++ b/tests/unit_tests/array/array_grid.cpp
@@ -0,0 +1,9 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include "detray/plugins/algebra/array_definitions.hpp"
+#include "tests/common/grid_grid.inl"
diff --git a/tests/unit_tests/array/array_grid_axis.cpp b/tests/unit_tests/array/array_grid_axis.cpp
new file mode 100644
index 0000000000..2724f4533a
--- /dev/null
+++ b/tests/unit_tests/array/array_grid_axis.cpp
@@ -0,0 +1,9 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include "detray/plugins/algebra/array_definitions.hpp"
+#include "tests/common/grid_axis.inl"
diff --git a/tests/unit_tests/array/array_grid_populator.cpp b/tests/unit_tests/array/array_grid_populator.cpp
new file mode 100644
index 0000000000..f29f06edf8
--- /dev/null
+++ b/tests/unit_tests/array/array_grid_populator.cpp
@@ -0,0 +1,9 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include "detray/plugins/algebra/array_definitions.hpp"
+#include "tests/common/grid_populator.inl"
diff --git a/tests/unit_tests/array/array_grid_serializer.cpp b/tests/unit_tests/array/array_grid_serializer.cpp
new file mode 100644
index 0000000000..07ea1d9f95
--- /dev/null
+++ b/tests/unit_tests/array/array_grid_serializer.cpp
@@ -0,0 +1,9 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include "detray/plugins/algebra/array_definitions.hpp"
+#include "tests/common/grid_serializer.inl"
diff --git a/tests/unit_tests/array/array_rectangle2.cpp b/tests/unit_tests/array/array_rectangle2D.cpp
similarity index 82%
rename from tests/unit_tests/array/array_rectangle2.cpp
rename to tests/unit_tests/array/array_rectangle2D.cpp
index 90a09e7b39..b1dc859b8d 100644
--- a/tests/unit_tests/array/array_rectangle2.cpp
+++ b/tests/unit_tests/array/array_rectangle2D.cpp
@@ -6,4 +6,4 @@
  */
 
 #include "detray/plugins/algebra/array_definitions.hpp"
-#include "tests/common/masks_rectangle2.inl"
\ No newline at end of file
+#include "tests/common/masks_rectangle2D.inl"
\ No newline at end of file
diff --git a/tests/unit_tests/array/array_ring2.cpp b/tests/unit_tests/array/array_ring2D.cpp
similarity index 84%
rename from tests/unit_tests/array/array_ring2.cpp
rename to tests/unit_tests/array/array_ring2D.cpp
index f2775a45fd..eb141691fa 100644
--- a/tests/unit_tests/array/array_ring2.cpp
+++ b/tests/unit_tests/array/array_ring2D.cpp
@@ -6,4 +6,4 @@
  */
 
 #include "detray/plugins/algebra/array_definitions.hpp"
-#include "tests/common/masks_ring2.inl"
\ No newline at end of file
+#include "tests/common/masks_ring2D.inl"
\ No newline at end of file
diff --git a/tests/unit_tests/array/array_annulus2.cpp b/tests/unit_tests/array/array_single3D.cpp
similarity index 83%
rename from tests/unit_tests/array/array_annulus2.cpp
rename to tests/unit_tests/array/array_single3D.cpp
index 6d014d62ea..a5da1efbd4 100644
--- a/tests/unit_tests/array/array_annulus2.cpp
+++ b/tests/unit_tests/array/array_single3D.cpp
@@ -6,4 +6,4 @@
  */
 
 #include "detray/plugins/algebra/array_definitions.hpp"
-#include "tests/common/masks_annulus2.inl"
+#include "tests/common/masks_single3D.inl"
\ No newline at end of file
diff --git a/tests/unit_tests/array/array_trapezoid2.cpp b/tests/unit_tests/array/array_trapezoid2.cpp
deleted file mode 100644
index 95a9f3aef9..0000000000
--- a/tests/unit_tests/array/array_trapezoid2.cpp
+++ /dev/null
@@ -1,9 +0,0 @@
-/** Detray library, part of the ACTS project (R&D line)
- *
- * (c) 2020 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#include "detray/plugins/algebra/array_definitions.hpp"
-#include "tests/common/masks_trapezoid2.inl"
\ No newline at end of file
diff --git a/tests/unit_tests/array/array_trapezoid2D.cpp b/tests/unit_tests/array/array_trapezoid2D.cpp
new file mode 100644
index 0000000000..c9c4c3d276
--- /dev/null
+++ b/tests/unit_tests/array/array_trapezoid2D.cpp
@@ -0,0 +1,9 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2020 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include "detray/plugins/algebra/array_definitions.hpp"
+#include "tests/common/masks_trapezoid2D.inl"
\ No newline at end of file
diff --git a/tests/unit_tests/cuda/CMakeLists.txt b/tests/unit_tests/cuda/CMakeLists.txt
index 9a7d536cba..cea15f475e 100644
--- a/tests/unit_tests/cuda/CMakeLists.txt
+++ b/tests/unit_tests/cuda/CMakeLists.txt
@@ -44,6 +44,8 @@ foreach(algebra ${algebras})
       "navigator_cuda_kernel.cu"
       "rk_stepper_cuda.cpp" "rk_stepper_cuda_kernel.hpp"
       "rk_stepper_cuda_kernel.cu"
+      "sf_finders_grid_cuda.cpp" "sf_finders_grid_cuda_kernel.hpp"
+      "sf_finders_grid_cuda_kernel.cu"
       "propagator_cuda.cpp" "propagator_cuda_kernel.hpp"
       "propagator_cuda_kernel.cu"            
       LINK_LIBRARIES GTest::gtest_main vecmem::cuda detray_tests_common
diff --git a/tests/unit_tests/cuda/detector_cuda_kernel.cu b/tests/unit_tests/cuda/detector_cuda_kernel.cu
index 0321fb1951..a940dd4d81 100644
--- a/tests/unit_tests/cuda/detector_cuda_kernel.cu
+++ b/tests/unit_tests/cuda/detector_cuda_kernel.cu
@@ -64,14 +64,14 @@ __global__ void detector_test_kernel(
     }
 
     auto& cylinders =
-        masks.template group<detector_host_t::masks::id::e_portal_cylinder3>();
+        masks.template group<detector_host_t::masks::id::e_portal_cylinder2>();
     for (unsigned int i = 0; i < cylinders.size(); i++) {
         cylinders_device[i] = cylinders[i];
     }
 
     // print output test for surface finder
-    auto& sf_finder_device = det_device.get_surfaces_finder();
-    for (unsigned int i_s = 0; i_s < sf_finder_device.effective_size(); i_s++) {
+    /*auto& sf_finder_device = det_device.sf_finders_store();
+    for (unsigned int i_s = 0; i_s < sf_finder_device.size(); i_s++) {
         auto& grid = sf_finder_device[i_s];
         for (unsigned int i = 0; i < grid.axis_p0().bins(); i++) {
             for (unsigned int j = 0; j < grid.axis_p1().bins(); j++) {
@@ -81,7 +81,7 @@ __global__ void detector_test_kernel(
                 }
             }
         }
-    }
+    }*/
 }
 
 /// implementation of the test function for detector
diff --git a/tests/unit_tests/cuda/detector_cuda_kernel.hpp b/tests/unit_tests/cuda/detector_cuda_kernel.hpp
index 56588c4a25..b5ef047b4d 100644
--- a/tests/unit_tests/cuda/detector_cuda_kernel.hpp
+++ b/tests/unit_tests/cuda/detector_cuda_kernel.hpp
@@ -41,7 +41,7 @@ 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_cylinder3;
+constexpr auto cylinder_id = mask_defs::id::e_portal_cylinder2;
 
 using rectangle_t = typename mask_defs::template get_type<rectangle_id>::type;
 using disc_t = typename mask_defs::template get_type<disc_id>::type;
diff --git a/tests/unit_tests/cuda/mask_store_cuda.cpp b/tests/unit_tests/cuda/mask_store_cuda.cpp
index d27cd34368..2d9d0096a0 100644
--- a/tests/unit_tests/cuda/mask_store_cuda.cpp
+++ b/tests/unit_tests/cuda/mask_store_cuda.cpp
@@ -24,21 +24,22 @@ TEST(mask_store_cuda, mask_store) {
         store(mng_mr);
 
     ASSERT_TRUE(store.template empty<e_annulus2>());
-    ASSERT_TRUE(store.template empty<e_cylinder3>());
+    ASSERT_TRUE(store.template empty<e_cylinder2>());
     ASSERT_TRUE(store.template empty<e_rectangle2>());
     ASSERT_TRUE(store.template empty<e_ring2>());
     ASSERT_TRUE(store.template empty<e_single3>());
     ASSERT_TRUE(store.template empty<e_trapezoid2>());
 
-    store.template add_value<e_rectangle2>(1.0, 2.0, 0);
-    store.template add_value<e_trapezoid2>(0.5, 1.5, 4.0, 0);
-    store.template add_value<e_ring2>(1.0, 10.0, 0);
-    store.template add_value<e_cylinder3>(1., 0.5, 2.0, 0);
-    // store.group<e_single3>().push_back(single{3.0,6.0});
-    store.template add_value<e_annulus2>(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 0);
+    store.template add_value<e_rectangle2>(0UL, 1.0f, 2.0f);
+    store.template add_value<e_trapezoid2>(0UL, 0.5f, 1.5f, 4.0f);
+    store.template add_value<e_ring2>(0UL, 1.0f, 10.0f);
+    store.template add_value<e_cylinder2>(0UL, 1.f, 0.5f, 2.0f);
+    // store.group<e_single3>().push_back(single{0UL, 3.0f ,6.0f});
+    store.template add_value<e_annulus2>(0UL, 1.f, 2.f, 3.f, 4.f, 5.f, 6.f,
+                                         7.f);
 
     ASSERT_FALSE(store.empty<e_annulus2>());
-    ASSERT_FALSE(store.empty<e_cylinder3>());
+    ASSERT_FALSE(store.empty<e_cylinder2>());
     ASSERT_FALSE(store.empty<e_rectangle2>());
     ASSERT_FALSE(store.empty<e_ring2>());
     // ASSERT_FALSE(store.template empty<e_single3>());
@@ -46,17 +47,17 @@ TEST(mask_store_cuda, mask_store) {
 
     /** Generate random points for test **/
     vecmem::vector<point2> input_point2(n_points, &mng_mr);
-    vecmem::vector<point3> input_point3(n_points, &mng_mr);
+    // vecmem::vector<point3> input_point3(n_points, &mng_mr);
 
     for (int i = 0; i < n_points; i++) {
         point2 rand_point2 = {static_cast<scalar>(rand() % 100 / 10.),
                               static_cast<scalar>(rand() % 100 / 10.)};
-        point3 rand_point3 = {static_cast<scalar>(rand() % 100 / 10.),
+        /*point3 rand_point3 = {static_cast<scalar>(rand() % 100 / 10.),
                               static_cast<scalar>(rand() % 100 / 10.),
-                              static_cast<scalar>(rand() % 100 / 10.)};
+                              static_cast<scalar>(rand() % 100 / 10.)};*/
 
         input_point2[i] = rand_point2;
-        input_point3[i] = rand_point3;
+        // input_point3[i] = rand_point3;
     }
 
     /** host output for intersection status **/
@@ -66,21 +67,16 @@ TEST(mask_store_cuda, mask_store) {
     const auto& rectangle_mask = store.group<e_rectangle2>()[0];
     const auto& trapezoid_mask = store.group<e_trapezoid2>()[0];
     const auto& ring_mask = store.group<e_ring2>()[0];
-    const auto& cylinder_mask = store.group<e_cylinder3>()[0];
+    const auto& cylinder_mask = store.group<e_cylinder2>()[0];
     const auto& annulus_mask = store.group<e_annulus2>()[0];
 
     /** get host results from is_inside function **/
     for (int i = 0; i < n_points; i++) {
-        output_host[0].push_back(
-            rectangle_mask.is_inside<cartesian2<transform3>>(input_point2[i]));
-        output_host[1].push_back(
-            trapezoid_mask.is_inside<cartesian2<transform3>>(input_point2[i]));
-        output_host[2].push_back(
-            ring_mask.is_inside<cartesian2<transform3>>(input_point2[i]));
-        output_host[3].push_back(
-            cylinder_mask.is_inside<cartesian2<transform3>>(input_point3[i]));
-        output_host[4].push_back(
-            annulus_mask.is_inside<cartesian2<transform3>>(input_point2[i]));
+        output_host[0].push_back(rectangle_mask.is_inside(input_point2[i]));
+        output_host[1].push_back(trapezoid_mask.is_inside(input_point2[i]));
+        output_host[2].push_back(ring_mask.is_inside(input_point2[i]));
+        output_host[3].push_back(cylinder_mask.is_inside(input_point2[i]));
+        output_host[4].push_back(annulus_mask.is_inside(input_point2[i]));
     }
 
     /** Helper object for performing memory copies. **/
@@ -94,11 +90,12 @@ TEST(mask_store_cuda, mask_store) {
     copy.setup(output_buffer);
 
     auto input_point2_data = vecmem::get_data(input_point2);
-    auto input_point3_data = vecmem::get_data(input_point3);
+    // auto input_point3_data = vecmem::get_data(input_point3);
     auto store_data = get_data(store);
 
     /** run the kernel **/
-    mask_test(store_data, input_point2_data, input_point3_data, output_buffer);
+    mask_test(store_data, input_point2_data,
+              /*input_point3_data,*/ output_buffer);
 
     vecmem::jagged_vector<intersection::status> output_device(&mng_mr);
     copy(output_buffer, output_device);
diff --git a/tests/unit_tests/cuda/mask_store_cuda_kernel.cu b/tests/unit_tests/cuda/mask_store_cuda_kernel.cu
index 539804b3a4..6e9ca83176 100644
--- a/tests/unit_tests/cuda/mask_store_cuda_kernel.cu
+++ b/tests/unit_tests/cuda/mask_store_cuda_kernel.cu
@@ -18,7 +18,7 @@ __global__ void mask_test_kernel(
                                trapezoid, ring, cylinder, single, annulus>>
         store_data,
     vecmem::data::vector_view<point2> input_point2_data,
-    vecmem::data::vector_view<point3> input_point3_data,
+    /*vecmem::data::vector_view<point3> input_point3_data,*/
     vecmem::data::jagged_vector_view<intersection::status> output_data) {
 
     /** get mask store **/
@@ -29,29 +29,23 @@ __global__ void mask_test_kernel(
 
     /** get mask objects **/
     vecmem::device_vector<point2> input_point2(input_point2_data);
-    vecmem::device_vector<point3> input_point3(input_point3_data);
+    // vecmem::device_vector<point3> input_point3(input_point3_data);
     vecmem::jagged_device_vector<intersection::status> output_device(
         output_data);
 
     const auto& rectangle_mask = store.group<e_rectangle2>()[0];
     const auto& trapezoid_mask = store.group<e_trapezoid2>()[0];
     const auto& ring_mask = store.group<e_ring2>()[0];
-    const auto& cylinder_mask = store.group<e_cylinder3>()[0];
+    const auto& cylinder_mask = store.group<e_cylinder2>()[0];
     const auto& annulus_mask = store.group<e_annulus2>()[0];
 
     /** get device results from is_inside function **/
     for (int i = 0; i < n_points; i++) {
-
-        output_device[0].push_back(
-            rectangle_mask.is_inside<cartesian2<transform3>>(input_point2[i]));
-        output_device[1].push_back(
-            trapezoid_mask.is_inside<cartesian2<transform3>>(input_point2[i]));
-        output_device[2].push_back(
-            ring_mask.is_inside<cartesian2<transform3>>(input_point2[i]));
-        output_device[3].push_back(
-            cylinder_mask.is_inside<cartesian2<transform3>>(input_point3[i]));
-        output_device[4].push_back(
-            annulus_mask.is_inside<cartesian2<transform3>>(input_point2[i]));
+        output_device[0].push_back(rectangle_mask.is_inside(input_point2[i]));
+        output_device[1].push_back(trapezoid_mask.is_inside(input_point2[i]));
+        output_device[2].push_back(ring_mask.is_inside(input_point2[i]));
+        output_device[3].push_back(cylinder_mask.is_inside(input_point2[i]));
+        output_device[4].push_back(annulus_mask.is_inside(input_point2[i]));
     }
 }
 
@@ -60,15 +54,16 @@ void mask_test(
         thrust::tuple, dvector, mask_ids, rectangle, trapezoid, ring, cylinder,
         single, annulus>>& store_data,
     vecmem::data::vector_view<point2>& input_point2_data,
-    vecmem::data::vector_view<point3>& input_point3_data,
+    /*vecmem::data::vector_view<point3>& input_point3_data,*/
     vecmem::data::jagged_vector_view<intersection::status>& output_data) {
 
     int block_dim = 1;
     int thread_dim = 1;
 
     // run the test kernel
-    mask_test_kernel<<<block_dim, thread_dim>>>(store_data, input_point2_data,
-                                                input_point3_data, output_data);
+    mask_test_kernel<<<block_dim, thread_dim>>>(
+        store_data, input_point2_data,
+        /*input_point3_data,*/ output_data);
 
     // cuda error check
     DETRAY_CUDA_ERROR_CHECK(cudaGetLastError());
diff --git a/tests/unit_tests/cuda/mask_store_cuda_kernel.hpp b/tests/unit_tests/cuda/mask_store_cuda_kernel.hpp
index f0b994cc16..56fd043f5b 100644
--- a/tests/unit_tests/cuda/mask_store_cuda_kernel.hpp
+++ b/tests/unit_tests/cuda/mask_store_cuda_kernel.hpp
@@ -38,12 +38,12 @@ const int n_points = 1000;
 
 namespace detray {
 
-using annulus = annulus2<>;
-using cylinder = cylinder3<>;
-using rectangle = rectangle2<>;
-using ring = ring2<>;
-using single = single3<0>;
-using trapezoid = trapezoid2<>;
+using annulus = mask<annulus2D<>>;
+using cylinder = mask<cylinder2D<>>;
+using rectangle = mask<rectangle2D<>>;
+using ring = mask<ring2D<>>;
+using single = mask<single3D<>>;
+using trapezoid = mask<trapezoid2D<>>;
 
 /** Enumerate different mask types for convenience
  **/
@@ -51,7 +51,7 @@ enum mask_ids : unsigned int {
     e_rectangle2 = 0,
     e_trapezoid2 = 1,
     e_ring2 = 2,
-    e_cylinder3 = 3,
+    e_cylinder2 = 3,
     e_single3 = 4,
     e_annulus2 = 5,
 };
@@ -60,9 +60,9 @@ enum mask_ids : unsigned int {
 void mask_test(
     tuple_vector_container_data<tuple_vector_container<
         thrust::tuple, dvector, mask_ids, rectangle, trapezoid, ring, cylinder,
-        single, annulus> >& store_data,
+        single, annulus>>& store_data,
     vecmem::data::vector_view<point2>& input_point2_data,
-    vecmem::data::vector_view<point3>& input_point3_data,
+    /*vecmem::data::vector_view<point3>& input_point3_data,*/
     vecmem::data::jagged_vector_view<intersection::status>& output_data);
 
 }  // namespace detray
diff --git a/tests/unit_tests/cuda/navigator_cuda.cpp b/tests/unit_tests/cuda/navigator_cuda.cpp
index 2f241cdfda..a42d624aa4 100644
--- a/tests/unit_tests/cuda/navigator_cuda.cpp
+++ b/tests/unit_tests/cuda/navigator_cuda.cpp
@@ -116,7 +116,7 @@ TEST(navigator_cuda, navigator) {
 
     // Create navigator candidates buffer
     auto candidates_buffer =
-        create_candidates_buffer(det, theta_steps * phi_steps, dev_mr);
+        create_candidates_buffer(det, theta_steps * phi_steps, dev_mr, &mng_mr);
     copy.setup(candidates_buffer);
 
     // Run navigator test
diff --git a/tests/unit_tests/cuda/sf_finders_grid_cuda.cpp b/tests/unit_tests/cuda/sf_finders_grid_cuda.cpp
new file mode 100644
index 0000000000..eefdce6222
--- /dev/null
+++ b/tests/unit_tests/cuda/sf_finders_grid_cuda.cpp
@@ -0,0 +1,325 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+// Detray include(s).
+#include "sf_finders_grid_cuda_kernel.hpp"
+
+// VecMem include(s).
+#include <vecmem/memory/cuda/managed_memory_resource.hpp>
+
+// GTest include(s).
+#include <gtest/gtest.h>
+
+// System include(s).
+#include <iostream>
+#include <limits>
+
+using namespace detray;
+
+namespace {
+
+/// Test single entry bin content element by element
+template <typename content_t>
+void test_content(const content_t& bin_content, const content_t& expected) {
+    dindex i = 0;
+    for (const auto& elem : bin_content) {
+        ASSERT_FLOAT_EQ(elem, expected[i++]);
+    }
+}
+
+/// Test collection entries in a bin element by element
+template <typename content_t, typename expected_content_t>
+void test_entry_collection(const content_t& bin_content,
+                           const expected_content_t& expected) {
+
+    // Running indices for the points in the collection and the elements of a
+    // single point3
+    dindex i = 0, j = 0;
+    for (const auto& entry : bin_content) {
+        const auto& expt_entry = expected[i++];
+        j = 0;
+        for (const auto& elem : entry) {
+            ASSERT_FLOAT_EQ(elem, expt_entry[j++]);
+        }
+    }
+}
+
+}  // anonymous namespace
+
+TEST(grids_cuda, grid3_replace_populator) {
+    // memory resource
+    vecmem::cuda::managed_memory_resource mng_mr;
+
+    // Build multi-axis
+    cartesian_3D<host_container_types> axes(mng_mr);
+
+    auto axis_data = axes.m_data.axes_data();
+    auto bin_edges = axes.m_data.edges();
+
+    axis_data->reserve(3);
+    axis_data->insert(
+        axis_data->begin(),
+        {dindex_range{0, 3}, dindex_range{2, 6}, dindex_range{4, 10}});
+    bin_edges->reserve(6);
+    bin_edges->insert(bin_edges->begin(), {-1., 4., 0., 6., -5., 5.});
+
+    // build host grid
+    host_grid3_replace::bin_storage_type bin_data(&mng_mr);
+    bin_data.resize(3 * 6 * 10,
+                    host_grid3_replace::populator_type::init<point3>());
+
+    host_grid3_replace g3(std::move(bin_data), std::move(axes));
+
+    const auto& axis_x = g3.template get_axis<n_axis::label::e_x>();
+    const auto& axis_y = g3.template get_axis<n_axis::label::e_y>();
+    const auto& axis_z = g3.template get_axis<n_axis::label::e_z>();
+
+    auto width_x = axis_x.m_binning.bin_width();
+    auto width_y = axis_y.m_binning.bin_width();
+    auto width_z = axis_z.m_binning.bin_width();
+
+    // pre-check
+    for (std::size_t i_x = 0; i_x < axis_x.nbins(); i_x++) {
+        for (std::size_t i_y = 0; i_y < axis_y.nbins(); i_y++) {
+            for (std::size_t i_z = 0; i_z < axis_z.nbins(); i_z++) {
+                const auto& bin = g3.at({i_x, i_y, i_z});
+                auto invalid_bin =
+                    host_grid3_replace::populator_type::init<point3>();
+                test_content(*bin, invalid_bin.content());
+            }
+        }
+    }
+    // run device side test, which populates the grid
+    grid_replace_test(get_data(g3), axis_x.nbins(), axis_y.nbins(),
+                      axis_z.nbins());
+    // post-check
+    for (std::size_t i_x = 0; i_x < axis_x.nbins(); i_x++) {
+        for (std::size_t i_y = 0; i_y < axis_y.nbins(); i_y++) {
+            for (std::size_t i_z = 0; i_z < axis_z.nbins(); i_z++) {
+                dindex gbin_idx = g3.serializer()(
+                    g3.axes(), detray::n_axis::multi_bin<3>{i_x, i_y, i_z});
+
+                const auto& bin = g3.at(gbin_idx);
+
+                const point3 tp{axis_x.min() + gbin_idx * width_x,
+                                axis_y.min() + gbin_idx * width_y,
+                                axis_z.min() + gbin_idx * width_z};
+
+                test_content(*bin, tp);
+            }
+        }
+    }
+}
+
+TEST(grids_cuda, grid2_replace_populator_ci) {
+
+    vecmem::cuda::managed_memory_resource mng_mr;
+
+    // Build multi-axis
+    polar_ir<host_container_types> axes(mng_mr);
+
+    auto axis_data = axes.m_data.axes_data();
+    auto bin_edges = axes.m_data.edges();
+
+    axis_data->reserve(2);
+    axis_data->insert(axis_data->end(),
+                      {dindex_range{0, 4}, dindex_range{5, 2}});
+    bin_edges->reserve(7);
+    bin_edges->insert(bin_edges->end(), {1., 3., 9., 27., 81., -2., 4.});
+
+    // build host grid
+    host_grid2_replace_ci::bin_storage_type bin_data(&mng_mr);
+    bin_data.resize(2 * 4,
+                    host_grid2_replace_ci::populator_type::init<point3>());
+
+    host_grid2_replace_ci g2(std::move(bin_data), std::move(axes));
+
+    const auto& axis_r = g2.template get_axis<n_axis::label::e_r>();
+    const auto& axis_phi = g2.template get_axis<n_axis::label::e_phi>();
+
+    // pre-check
+    for (std::size_t i_r = 0; i_r < axis_r.nbins(); i_r++) {
+        for (std::size_t i_phi = 0; i_phi < axis_phi.nbins(); i_phi++) {
+            const auto& bin = g2.at({i_r, i_phi});
+            auto invalid_bin =
+                host_grid2_replace_ci::populator_type::init<point3>();
+
+            test_content(*bin, invalid_bin.content());
+        }
+    }
+
+    // run device side test, which populates the grid
+    grid_replace_ci_test(get_data(g2), axis_r.nbins(), axis_phi.nbins());
+
+    // post-check
+    auto width_phi = axis_phi.m_binning.bin_width();
+
+    for (std::size_t i_r = 0; i_r < axis_r.nbins(); i_r++) {
+        for (std::size_t i_phi = 0; i_phi < axis_phi.nbins(); i_phi++) {
+            dindex gbin_idx = g2.serializer()(
+                g2.axes(), detray::n_axis::multi_bin<2>{i_r, i_phi});
+            const auto& bin = g2.at(gbin_idx);
+
+            auto width_r = axis_r.m_binning.bin_width(i_r);
+
+            const point3 tp{axis_r.min() + gbin_idx * width_r,
+                            axis_phi.min() + gbin_idx * width_phi, 0.5};
+
+            test_content(*bin, tp);
+        }
+    }
+}
+
+/*TEST(grids_cuda, grid2_complete_populator) {
+    // memory resource
+    vecmem::cuda::managed_memory_resource mng_mr;
+
+    // Build multi-axis
+    polar<host_container_types> axes(mng_mr);
+
+    auto axis_data = axes.m_data.axes_data();
+    auto bin_edges = axes.m_data.edges();
+
+    axis_data->reserve(2);
+    axis_data->insert(axis_data->begin(),
+                      {dindex_range{0, 3}, dindex_range{2, 7}});
+    bin_edges->reserve(4);
+    bin_edges->insert(bin_edges->begin(), {0., 3., -1, 6.});
+
+    // build host grid
+    const point3 first_tp{3., 3., 3.};
+
+    host_grid2_complete::bin_storage_type bin_data(&mng_mr);
+    bin_data.resize(
+        3 * 7, host_grid2_complete::populator_type::init<point3>(first_tp));
+
+    host_grid2_complete g2(std::move(bin_data), std::move(axes));
+
+    const auto& axis_r = g2.template get_axis<n_axis::label::e_r>();
+    const auto& axis_phi = g2.template get_axis<n_axis::label::e_phi>();
+
+    auto width_r = axis_r.m_binning.bin_width();
+    auto width_phi = axis_phi.m_binning.bin_width();
+
+    // pre-check
+    for (std::size_t i_r = 0; i_r < axis_r.nbins(); i_r++) {
+        for (std::size_t i_phi = 0; i_phi < axis_phi.nbins(); i_phi++) {
+            auto bin = g2.at({i_r, i_phi});
+            auto invalid_bin =
+                host_grid2_complete::populator_type::init<point3>(first_tp);
+
+            test_entry_collection(bin, invalid_bin.view());
+        }
+    }
+
+    // run device side test, which populates the grid
+    grid_complete_test(get_data(g2), axis_r.nbins(), axis_phi.nbins());
+
+    // post-check
+    for (std::size_t i_r = 0; i_r < axis_r.nbins(); i_r++) {
+        for (std::size_t i_phi = 0; i_phi < axis_phi.nbins(); i_phi++) {
+            dindex gbin_idx = g2.serializer()(
+                g2.axes(), detray::n_axis::multi_bin<2>{i_r, i_phi});
+            const auto& bin = g2.at(gbin_idx);
+
+            // Other point with which the bin has been completed
+            const point3 tp{axis_r.min() + gbin_idx * width_r,
+                            axis_phi.min() + gbin_idx * width_phi, 0.5};
+
+            // Go through all points and compare
+            int pt_idx{0};
+            for (const auto& pt : bin) {
+                if (pt_idx == 0) {
+                    EXPECT_EQ(pt, first_tp);
+                } else {
+                    EXPECT_EQ(pt, tp);
+                }
+                pt_idx++;
+            }
+        }
+    }
+}
+
+// Test both the attach population and the const grid reading
+TEST(grids_cuda, grid2_attach_populator) {
+    // memory resource
+    vecmem::cuda::managed_memory_resource mng_mr;
+
+    // Build multi-axis
+    polar<host_container_types> axes(mng_mr);
+
+    auto axis_data = axes.m_data.axes_data();
+    auto bin_edges = axes.m_data.edges();
+
+    axis_data->reserve(2);
+    axis_data->insert(axis_data->begin(),
+                      {dindex_range{0, 2}, dindex_range{2, 65}});
+    bin_edges->reserve(4);
+    bin_edges->insert(bin_edges->begin(), {0., 6., -M_PI, M_PI});
+
+    // build host grid
+    const point3 first_tp{3., 3., 3.};
+    const point3 invalid_tp{0., 0., 0.};
+
+    host_grid2_attach::bin_storage_type bin_data(&mng_mr);
+    bin_data.resize(2 * 65,
+                    host_grid2_attach::populator_type::init<point3>(first_tp));
+
+    host_grid2_attach g2(std::move(bin_data), std::move(axes));
+
+    const auto& axis_r = g2.template get_axis<n_axis::label::e_r>();
+    const auto& axis_phi = g2.template get_axis<n_axis::label::e_phi>();
+
+    auto width_r = axis_r.m_binning.bin_width();
+    auto width_phi = axis_phi.m_binning.bin_width();
+
+    // pre-check
+    for (std::size_t i_r = 0; i_r < axis_r.nbins(); i_r++) {
+        for (std::size_t i_phi = 0; i_phi < axis_phi.nbins(); i_phi++) {
+            auto bin = g2.at({i_r, i_phi});
+            auto invalid_bin =
+                host_grid2_complete::populator_type::init<point3>(first_tp);
+
+            test_entry_collection(bin, invalid_bin.view());
+        }
+    }
+
+    // run device side test, which populates the grid
+    grid_attach_test(get_data(g2), axis_r.nbins(), axis_phi.nbins());
+
+    // post-check
+    for (std::size_t i_r = 0; i_r < axis_r.nbins(); i_r++) {
+        for (std::size_t i_phi = 0; i_phi < axis_phi.nbins(); i_phi++) {
+            dindex gbin_idx = g2.serializer()(
+                g2.axes(), detray::n_axis::multi_bin<2>{i_r, i_phi});
+            const auto& bin = g2.at(gbin_idx);
+
+            // Other point with which the bin has been completed
+            const point3 tp{axis_r.min() + gbin_idx * width_r,
+                            axis_phi.min() + gbin_idx * width_phi, 0.5};
+
+            // Go through all points and compare
+            int pt_idx{0};
+            for (const auto& pt : bin) {
+                if (pt_idx == 0) {
+                    EXPECT_EQ(pt, first_tp);
+                } else if (pt_idx == 1) {
+                    EXPECT_EQ(pt, tp);
+                } else {
+                    EXPECT_EQ(pt, invalid_tp);
+                }
+                pt_idx++;
+            }
+        }
+    }
+
+    // This seems to be undefined behaviour for now
+    //const host_grid2_attach& g2_const = g2;
+    // Read the grid as a const grid of non-const values
+    //grid_attach_read_test(get_data(g2_const), axis_r.nbins(),
+axis_phi.nbins());
+}*/
diff --git a/tests/unit_tests/cuda/sf_finders_grid_cuda_kernel.cu b/tests/unit_tests/cuda/sf_finders_grid_cuda_kernel.cu
new file mode 100644
index 0000000000..1ed4649a94
--- /dev/null
+++ b/tests/unit_tests/cuda/sf_finders_grid_cuda_kernel.cu
@@ -0,0 +1,206 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include <vecmem/containers/device_vector.hpp>
+
+#include "detray/definitions/cuda_definitions.hpp"
+#include "sf_finders_grid_cuda_kernel.hpp"
+
+namespace detray {
+
+//----------------------------------------------------
+//  test function for grid data with replace populator
+//----------------------------------------------------
+
+/// cuda kernel for grid_replace_test
+__global__ void grid_replace_test_kernel(
+    host_grid3_replace::view_type grid_view) {
+    // Let's try building the grid object
+    device_grid3_replace g3_device(grid_view);
+
+    // Fill a test point
+    const auto& axis_x = g3_device.template get_axis<n_axis::label::e_x>();
+    const auto& axis_y = g3_device.template get_axis<n_axis::label::e_y>();
+    const auto& axis_z = g3_device.template get_axis<n_axis::label::e_z>();
+
+    auto width_x = axis_x.m_binning.bin_width();
+    auto width_y = axis_y.m_binning.bin_width();
+    auto width_z = axis_z.m_binning.bin_width();
+
+    dindex gid = g3_device.serializer()(
+        g3_device.axes(),
+        detray::n_axis::multi_bin<3>{threadIdx.x, threadIdx.y, threadIdx.z});
+
+    point3 tp{axis_x.min() + gid * width_x, axis_y.min() + gid * width_y,
+              axis_z.min() + gid * width_z};
+
+    // replace the bin elements
+    g3_device.populate(gid, std::move(tp));
+}
+
+/// grid_replace_test implementation
+void grid_replace_test(host_grid3_replace::view_type grid_view,
+                       std::size_t dim_x, std::size_t dim_y,
+                       std::size_t dim_z) {
+    int block_dim = 1;
+    dim3 thread_dim(dim_x, dim_y, dim_z);
+
+    // run the kernel
+    grid_replace_test_kernel<<<block_dim, thread_dim>>>(grid_view);
+
+    // cuda error check
+    DETRAY_CUDA_ERROR_CHECK(cudaGetLastError());
+    DETRAY_CUDA_ERROR_CHECK(cudaDeviceSynchronize());
+}
+
+/// cuda kernel for grid_replace_ci_test
+__global__ void grid_replace_ci_test_kernel(
+    host_grid2_replace_ci::view_type grid_view) {
+    // Let's try building the grid object
+    device_grid2_replace_ci g2_device(grid_view);
+
+    // Fill a test point
+    const auto& axis_r = g2_device.template get_axis<n_axis::label::e_r>();
+    const auto& axis_phi = g2_device.template get_axis<n_axis::label::e_phi>();
+
+    auto width_r = axis_r.m_binning.bin_width(threadIdx.x);
+    auto width_phi = axis_phi.m_binning.bin_width();
+
+    auto gid = threadIdx.x + threadIdx.y * blockDim.x;
+
+    point3 tp{axis_r.min() + gid * width_r, axis_phi.min() + gid * width_phi,
+              0.5};
+
+    // replace the bin elements
+    g2_device.populate({threadIdx.x, threadIdx.y}, std::move(tp));
+}
+
+// test function for replace populator with circular and irregular axis
+void grid_replace_ci_test(host_grid2_replace_ci::view_type grid_view,
+                          std::size_t dim_x, std::size_t dim_y) {
+    int block_dim = 1;
+    dim3 thread_dim(dim_x, dim_y);
+
+    // run the kernel
+    grid_replace_ci_test_kernel<<<block_dim, thread_dim>>>(grid_view);
+
+    // cuda error check
+    DETRAY_CUDA_ERROR_CHECK(cudaGetLastError());
+    DETRAY_CUDA_ERROR_CHECK(cudaDeviceSynchronize());
+}
+
+//----------------------------------------------------
+// test function for grid data with complete populator
+//----------------------------------------------------
+
+// cuda kernel for grid_complete_test
+/*__global__ void grid_complete_kernel(host_grid2_complete::view_type grid_view)
+{
+
+    // Let's try building the grid object
+    device_grid2_complete g2_device(grid_view);
+
+    // Fill a test point
+    const auto& axis_r = g2_device.template get_axis<n_axis::label::e_r>();
+    const auto& axis_phi = g2_device.template get_axis<n_axis::label::e_phi>();
+
+    auto width_r = axis_r.m_binning.bin_width();
+    auto width_phi = axis_phi.m_binning.bin_width();
+
+    auto gid = threadIdx.x + threadIdx.y * blockDim.x;
+    auto tp = point3{axis_r.min() + gid * width_r,
+                     axis_phi.min() + gid * width_phi, 0.5};
+
+    g2_device.populate({threadIdx.x, threadIdx.y}, std::move(tp));
+}
+
+// grid_complete_test implementation
+void grid_complete_test(host_grid2_complete::view_type grid_view,
+                        std::size_t dim_x, std::size_t dim_y) {
+
+    int block_dim = 1;
+    dim3 thread_dim(dim_x, dim_y);
+
+    // run the kernel
+    grid_complete_kernel<<<block_dim, thread_dim>>>(grid_view);
+
+    // cuda error check
+    DETRAY_CUDA_ERROR_CHECK(cudaGetLastError());
+    DETRAY_CUDA_ERROR_CHECK(cudaDeviceSynchronize());
+}
+
+//--------------------------------------------------
+// test function for grid data with attach populator
+//--------------------------------------------------
+
+// cuda kernel for grid_attach_test
+__global__ void grid_attach_kernel(host_grid2_attach::view_type grid_view) {
+
+    // Let's try building the grid object
+    device_grid2_attach g2_device(grid_view);
+
+    // Fill a test point
+    const auto& axis_r = g2_device.template get_axis<n_axis::label::e_r>();
+    const auto& axis_phi = g2_device.template get_axis<n_axis::label::e_phi>();
+
+    auto width_r = axis_r.m_binning.bin_width();
+    auto width_phi = axis_phi.m_binning.bin_width();
+
+    auto gid = threadIdx.x + threadIdx.y * blockDim.x;
+    auto tp = point3{axis_r.min() + gid * width_r,
+                     axis_phi.min() + gid * width_phi, 0.5};
+
+    g2_device.populate({threadIdx.x, threadIdx.y}, std::move(tp));
+}
+
+// grid_attach_test implementation
+void grid_attach_test(host_grid2_attach::view_type grid_view, std::size_t dim_x,
+                      std::size_t dim_y) {
+
+    int block_dim = 1;
+    dim3 thread_dim(dim_x, dim_y);
+
+    // run the kernel
+    grid_attach_kernel<<<block_dim, thread_dim>>>(grid_view);
+
+    // cuda error check
+    DETRAY_CUDA_ERROR_CHECK(cudaGetLastError());
+    DETRAY_CUDA_ERROR_CHECK(cudaDeviceSynchronize());
+}
+
+//----------------------------------------------------
+// read test function for grid with attach populator
+//----------------------------------------------------
+
+// cuda kernel for attach_read_test
+__global__ void grid_attach_read_kernel(
+    const_host_grid2_attach::view_type grid_view) {
+    // Let's try building the grid object
+    const_device_grid2_attach g2_device(grid_view);
+
+    const auto& bin_content = g2_device.at({threadIdx.x, threadIdx.y});
+
+    for (auto& pt : bin_content) {
+        printf("%f %f %f \n", pt[0], pt[1], pt[2]);
+    }
+}
+
+// grid_attach_read_test implementation
+void grid_attach_read_test(const_host_grid2_attach::view_type grid_view,
+                           std::size_t dim_x, std::size_t dim_y) {
+    int block_dim = 1;
+    dim3 thread_dim(dim_x, dim_y);
+
+    // run the kernel
+    grid_attach_read_kernel<<<block_dim, thread_dim>>>(grid_view);
+
+    // cuda error check
+    DETRAY_CUDA_ERROR_CHECK(cudaGetLastError());
+    DETRAY_CUDA_ERROR_CHECK(cudaDeviceSynchronize());
+}*/
+
+}  // namespace detray
diff --git a/tests/unit_tests/cuda/sf_finders_grid_cuda_kernel.hpp b/tests/unit_tests/cuda/sf_finders_grid_cuda_kernel.hpp
new file mode 100644
index 0000000000..8ee77d318b
--- /dev/null
+++ b/tests/unit_tests/cuda/sf_finders_grid_cuda_kernel.hpp
@@ -0,0 +1,115 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2021 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#if defined(array)
+#include "detray/plugins/algebra/array_definitions.hpp"
+#elif defined(eigen)
+#include "detray/plugins/algebra/eigen_definitions.hpp"
+#elif defined(smatrix)
+#include "detray/plugins/algebra/smatrix_definitions.hpp"
+#elif defined(vc_array)
+#include "detray/plugins/algebra/vc_array_definitions.hpp"
+#endif
+
+// detray core
+#include "detray/masks/masks.hpp"
+#include "detray/surface_finders/grid/axis.hpp"
+#include "detray/surface_finders/grid/grid.hpp"
+#include "detray/surface_finders/grid/grid_builder.hpp"
+#include "detray/surface_finders/grid/populator.hpp"
+#include "detray/surface_finders/grid/serializer.hpp"
+
+#pragma once
+
+namespace {
+
+// type definitions
+using size_type = __plugin::size_type;
+using vector3 = __plugin::vector3<detray::scalar>;
+using point3 = __plugin::point3<detray::scalar>;
+
+}  // namespace
+
+namespace detray {
+
+using namespace n_axis;
+
+static constexpr std::size_t n_points = 3;
+static constexpr bool is_owning = true;
+
+// Coordinate system definitions (all data-owning)
+
+// 3D cartesian coordinate axes with closed bin boundaries and regular binning
+template <typename containers = host_container_types>
+using cartesian_3D =
+    coordinate_axes<cuboid3D::axes<shape::e_closed>, is_owning, containers>;
+
+// 2D polar coordinate axes with closed bin boundaries, irregular binning in r
+// and regular binning in phi
+template <typename containers = host_container_types>
+using polar_ir =
+    coordinate_axes<ring2D<>::axes<shape::e_closed, irregular, regular>,
+                    is_owning, containers>;
+
+// 2D polar coordinate axes with closed bin boundaries and regular binning
+template <typename containers = host_container_types>
+using polar =
+    coordinate_axes<ring2D<>::axes<shape::e_closed>, is_owning, containers>;
+
+// host and device grid definitions
+using host_grid3_replace =
+    grid<cartesian_3D<>, point3, simple_serializer, replacer>;
+
+using device_grid3_replace = grid<cartesian_3D<device_container_types>, point3,
+                                  simple_serializer, replacer>;
+
+using host_grid2_replace_ci =
+    grid<polar_ir<>, point3, simple_serializer, replacer>;
+
+using device_grid2_replace_ci =
+    grid<polar_ir<device_container_types>, point3, simple_serializer, replacer>;
+
+using host_grid2_complete =
+    grid<polar<>, point3, simple_serializer, completer<n_points>>;
+
+using device_grid2_complete = grid<polar<device_container_types>, point3,
+                                   simple_serializer, completer<n_points>>;
+
+using host_grid2_attach =
+    grid<polar<>, point3, simple_serializer, regular_attacher<n_points>>;
+
+using device_grid2_attach = grid<polar<device_container_types>, point3,
+                                 simple_serializer, regular_attacher<n_points>>;
+
+using const_host_grid2_attach =
+    grid<polar<>, const point3, simple_serializer, regular_attacher<n_points>>;
+
+using const_device_grid2_attach =
+    grid<polar<device_container_types>, const point3, simple_serializer,
+         regular_attacher<n_points>>;
+
+/// test function for replace populator
+void grid_replace_test(host_grid3_replace::view_type grid_view,
+                       std::size_t dim_x, std::size_t dim_y, std::size_t dim_z);
+
+/// test function for replace populator with circular and irregular axis
+void grid_replace_ci_test(host_grid2_replace_ci::view_type grid_view,
+                          std::size_t dim_x, std::size_t dim_y);
+
+// test function for complete populator
+void grid_complete_test(host_grid2_complete::view_type grid_view,
+                        std::size_t dim_x, std::size_t dim_y);
+
+// read test function for grid with attach populator
+void grid_attach_test(host_grid2_attach::view_type grid_view, std::size_t dim_x,
+                      std::size_t dim_y);
+
+// read test function for grid with attach populator
+void grid_attach_read_test(const_host_grid2_attach::view_type grid_view,
+                           std::size_t dim_x, std::size_t dim_y);
+
+}  // namespace detray
diff --git a/tests/unit_tests/eigen/CMakeLists.txt b/tests/unit_tests/eigen/CMakeLists.txt
index 7dd1f3b60e..9de27f73e8 100644
--- a/tests/unit_tests/eigen/CMakeLists.txt
+++ b/tests/unit_tests/eigen/CMakeLists.txt
@@ -6,20 +6,47 @@
 
 # Set up all of the "standard" tests.
 detray_add_test( eigen
-   "eigen_actor_chain.cpp" "eigen_annulus2.cpp" "eigen_container.cpp" "eigen_coordinates.cpp"
-   "eigen_core.cpp" "eigen_covariance_engine.cpp"
-   "eigen_cylinder_intersection.cpp" "eigen_cylinder3.cpp" "eigen_detector.cpp"
-   "eigen_geometry_volume_graph.cpp" "eigen_geometry_linking.cpp"
-   "eigen_geometry_navigation.cpp" "eigen_geometry_scan.cpp"
-   "eigen_guided_navigator.cpp" "eigen_helix_trajectory.cpp"
-   "eigen_intersection_kernel.cpp" "eigen_mask_store.cpp" "eigen_materials.cpp"
-   "eigen_navigator.cpp" "eigen_particle_gun.cpp"
-   "eigen_planar_intersection.cpp" "eigen_line_intersection.cpp" "eigen_line.cpp" "eigen_propagator.cpp"
-   "eigen_rectangle2.cpp" "eigen_ring2.cpp" "eigen_single3.cpp"
-   "eigen_stepper.cpp" "eigen_surfaces_finder.cpp"
-   "eigen_telescope_detector.cpp" "eigen_toy_geometry.cpp" "eigen_track.cpp"
-   "eigen_track_generators.cpp" "eigen_transform_store.cpp"
-   "eigen_trapezoid2.cpp" "eigen_unmasked.cpp" "eigen_volume.cpp"
+   "eigen_actor_chain.cpp"
+   "eigen_annulus2D.cpp"
+   "eigen_container.cpp"
+   "eigen_coordinates.cpp"
+   "eigen_core.cpp"
+   "eigen_covariance_engine.cpp"
+   "eigen_cylinder_intersection.cpp" 
+   "eigen_cylinder.cpp"
+   "eigen_detector.cpp"
+   "eigen_geometry_volume_graph.cpp"
+   "eigen_geometry_linking.cpp"
+   "eigen_geometry_navigation.cpp"
+   "eigen_geometry_scan.cpp"
+   "eigen_grid_axis.cpp"
+   "eigen_grid.cpp"
+   "eigen_grid_populator.cpp"
+   "eigen_grid_serializer.cpp"
+   "eigen_guided_navigator.cpp"
+   "eigen_helix_trajectory.cpp"
+   "eigen_intersection_kernel.cpp"
+   "eigen_mask_store.cpp"
+   "eigen_materials.cpp"
+   "eigen_navigator.cpp"
+   "eigen_particle_gun.cpp"
+   "eigen_planar_intersection.cpp"
+   "eigen_line_intersection.cpp"
+   "eigen_line.cpp"
+   "eigen_propagator.cpp"
+   "eigen_rectangle2D.cpp"
+   "eigen_ring2D.cpp"
+   "eigen_single3D.cpp"
+   "eigen_stepper.cpp"
+   "eigen_surfaces_finder.cpp"
+   "eigen_telescope_detector.cpp"
+   "eigen_toy_geometry.cpp"
+   "eigen_track.cpp"
+   "eigen_track_generators.cpp"
+   "eigen_transform_store.cpp"
+   "eigen_trapezoid2D.cpp"
+   "eigen_unmasked.cpp"
+   "eigen_volume.cpp"
    LINK_LIBRARIES GTest::gtest_main detray_tests_common detray::eigen )
 
 # Set up the "conditional" tests.
diff --git a/tests/unit_tests/eigen/eigen_cylinder3.cpp b/tests/unit_tests/eigen/eigen_annulus2D.cpp
similarity index 82%
rename from tests/unit_tests/eigen/eigen_cylinder3.cpp
rename to tests/unit_tests/eigen/eigen_annulus2D.cpp
index 585765a006..c6a4978f0a 100644
--- a/tests/unit_tests/eigen/eigen_cylinder3.cpp
+++ b/tests/unit_tests/eigen/eigen_annulus2D.cpp
@@ -6,4 +6,4 @@
  */
 
 #include "detray/plugins/algebra/eigen_definitions.hpp"
-#include "tests/common/masks_cylinder3.inl"
\ No newline at end of file
+#include "tests/common/masks_annulus2D.inl"
diff --git a/tests/unit_tests/eigen/eigen_single3.cpp b/tests/unit_tests/eigen/eigen_cylinder.cpp
similarity index 83%
rename from tests/unit_tests/eigen/eigen_single3.cpp
rename to tests/unit_tests/eigen/eigen_cylinder.cpp
index 5238a3ce65..de32d7e4d9 100644
--- a/tests/unit_tests/eigen/eigen_single3.cpp
+++ b/tests/unit_tests/eigen/eigen_cylinder.cpp
@@ -6,4 +6,4 @@
  */
 
 #include "detray/plugins/algebra/eigen_definitions.hpp"
-#include "tests/common/masks_single3.inl"
\ No newline at end of file
+#include "tests/common/masks_cylinder.inl"
\ No newline at end of file
diff --git a/tests/unit_tests/eigen/eigen_grid.cpp b/tests/unit_tests/eigen/eigen_grid.cpp
new file mode 100644
index 0000000000..4351ab8d7f
--- /dev/null
+++ b/tests/unit_tests/eigen/eigen_grid.cpp
@@ -0,0 +1,9 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include "detray/plugins/algebra/eigen_definitions.hpp"
+#include "tests/common/grid_grid.inl"
diff --git a/tests/unit_tests/eigen/eigen_grid_axis.cpp b/tests/unit_tests/eigen/eigen_grid_axis.cpp
new file mode 100644
index 0000000000..5cee43ba56
--- /dev/null
+++ b/tests/unit_tests/eigen/eigen_grid_axis.cpp
@@ -0,0 +1,9 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include "detray/plugins/algebra/eigen_definitions.hpp"
+#include "tests/common/grid_axis.inl"
diff --git a/tests/unit_tests/eigen/eigen_grid_populator.cpp b/tests/unit_tests/eigen/eigen_grid_populator.cpp
new file mode 100644
index 0000000000..5326dcead7
--- /dev/null
+++ b/tests/unit_tests/eigen/eigen_grid_populator.cpp
@@ -0,0 +1,9 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include "detray/plugins/algebra/eigen_definitions.hpp"
+#include "tests/common/grid_populator.inl"
diff --git a/tests/unit_tests/eigen/eigen_grid_serializer.cpp b/tests/unit_tests/eigen/eigen_grid_serializer.cpp
new file mode 100644
index 0000000000..5f07c638dc
--- /dev/null
+++ b/tests/unit_tests/eigen/eigen_grid_serializer.cpp
@@ -0,0 +1,9 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include "detray/plugins/algebra/eigen_definitions.hpp"
+#include "tests/common/grid_serializer.inl"
diff --git a/tests/unit_tests/eigen/eigen_rectangle2.cpp b/tests/unit_tests/eigen/eigen_rectangle2D.cpp
similarity index 82%
rename from tests/unit_tests/eigen/eigen_rectangle2.cpp
rename to tests/unit_tests/eigen/eigen_rectangle2D.cpp
index e0bfffa60e..8a8e425c29 100644
--- a/tests/unit_tests/eigen/eigen_rectangle2.cpp
+++ b/tests/unit_tests/eigen/eigen_rectangle2D.cpp
@@ -6,4 +6,4 @@
  */
 
 #include "detray/plugins/algebra/eigen_definitions.hpp"
-#include "tests/common/masks_rectangle2.inl"
\ No newline at end of file
+#include "tests/common/masks_rectangle2D.inl"
\ No newline at end of file
diff --git a/tests/unit_tests/eigen/eigen_ring2.cpp b/tests/unit_tests/eigen/eigen_ring2D.cpp
similarity index 84%
rename from tests/unit_tests/eigen/eigen_ring2.cpp
rename to tests/unit_tests/eigen/eigen_ring2D.cpp
index db9cf71c40..0afa74bff3 100644
--- a/tests/unit_tests/eigen/eigen_ring2.cpp
+++ b/tests/unit_tests/eigen/eigen_ring2D.cpp
@@ -6,4 +6,4 @@
  */
 
 #include "detray/plugins/algebra/eigen_definitions.hpp"
-#include "tests/common/masks_ring2.inl"
\ No newline at end of file
+#include "tests/common/masks_ring2D.inl"
\ No newline at end of file
diff --git a/tests/unit_tests/eigen/eigen_annulus2.cpp b/tests/unit_tests/eigen/eigen_single3D.cpp
similarity index 83%
rename from tests/unit_tests/eigen/eigen_annulus2.cpp
rename to tests/unit_tests/eigen/eigen_single3D.cpp
index 544c7d15b6..673f22d355 100644
--- a/tests/unit_tests/eigen/eigen_annulus2.cpp
+++ b/tests/unit_tests/eigen/eigen_single3D.cpp
@@ -6,4 +6,4 @@
  */
 
 #include "detray/plugins/algebra/eigen_definitions.hpp"
-#include "tests/common/masks_annulus2.inl"
+#include "tests/common/masks_single3D.inl"
\ No newline at end of file
diff --git a/tests/unit_tests/eigen/eigen_trapezoid2.cpp b/tests/unit_tests/eigen/eigen_trapezoid2.cpp
deleted file mode 100644
index f4e7182a3e..0000000000
--- a/tests/unit_tests/eigen/eigen_trapezoid2.cpp
+++ /dev/null
@@ -1,9 +0,0 @@
-/** Detray library, part of the ACTS project (R&D line)
- *
- * (c) 2020 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#include "detray/plugins/algebra/eigen_definitions.hpp"
-#include "tests/common/masks_trapezoid2.inl"
\ No newline at end of file
diff --git a/tests/unit_tests/eigen/eigen_trapezoid2D.cpp b/tests/unit_tests/eigen/eigen_trapezoid2D.cpp
new file mode 100644
index 0000000000..a5df3e2688
--- /dev/null
+++ b/tests/unit_tests/eigen/eigen_trapezoid2D.cpp
@@ -0,0 +1,9 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2020 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include "detray/plugins/algebra/eigen_definitions.hpp"
+#include "tests/common/masks_trapezoid2D.inl"
\ No newline at end of file
diff --git a/tests/unit_tests/smatrix/CMakeLists.txt b/tests/unit_tests/smatrix/CMakeLists.txt
index 48da55964e..36eb63c7e6 100644
--- a/tests/unit_tests/smatrix/CMakeLists.txt
+++ b/tests/unit_tests/smatrix/CMakeLists.txt
@@ -6,21 +6,47 @@
 
 # Set up all of the "standard" tests.
 detray_add_test( smatrix
-   "smatrix_actor_chain.cpp" "smatrix_annulus2.cpp" "smatrix_container.cpp" "smatrix_coordinates.cpp"
-   "smatrix_core.cpp" "smatrix_covariance_engine.cpp"
-   "smatrix_cylinder_intersection.cpp" "smatrix_cylinder3.cpp"
-   "smatrix_detector.cpp" "smatrix_geometry_volume_graph.cpp"
-   "smatrix_geometry_linking.cpp"  "smatrix_geometry_navigation.cpp"
-   "smatrix_geometry_scan.cpp" "smatrix_guided_navigator.cpp"
-   "smatrix_helix_trajectory.cpp" "smatrix_intersection_kernel.cpp"
-   "smatrix_mask_store.cpp" "smatrix_materials.cpp" "smatrix_navigator.cpp"
-   "smatrix_particle_gun.cpp" "smatrix_line_intersection.cpp" "smatrix_line.cpp" "smatrix_planar_intersection.cpp"
-   "smatrix_propagator.cpp" "smatrix_rectangle2.cpp" "smatrix_ring2.cpp"
-   "smatrix_single3.cpp" "smatrix_stepper.cpp" "smatrix_surfaces_finder.cpp"
-   "smatrix_telescope_detector.cpp" "smatrix_toy_geometry.cpp"
-   "smatrix_track.cpp" "smatrix_track_generators.cpp"
-   "smatrix_transform_store.cpp" "smatrix_trapezoid2.cpp"
-   "smatrix_unmasked.cpp" "smatrix_volume.cpp"
+   "smatrix_actor_chain.cpp"
+   "smatrix_annulus2D.cpp"
+   "smatrix_container.cpp"
+   "smatrix_coordinates.cpp"
+   "smatrix_core.cpp" 
+   "smatrix_covariance_engine.cpp"
+   "smatrix_cylinder_intersection.cpp"
+   "smatrix_cylinder.cpp"
+   "smatrix_detector.cpp"
+   "smatrix_geometry_volume_graph.cpp"
+   "smatrix_geometry_linking.cpp"
+   "smatrix_geometry_navigation.cpp"
+   "smatrix_geometry_scan.cpp"
+   "smatrix_grid_axis.cpp"
+   "smatrix_grid.cpp"
+   "smatrix_grid_populator.cpp"
+   "smatrix_grid_serializer.cpp"
+   "smatrix_guided_navigator.cpp"
+   "smatrix_helix_trajectory.cpp"
+   "smatrix_intersection_kernel.cpp"
+   "smatrix_mask_store.cpp"
+   "smatrix_materials.cpp"
+   "smatrix_navigator.cpp"
+   "smatrix_particle_gun.cpp"
+   "smatrix_line_intersection.cpp"
+   "smatrix_line.cpp"
+   "smatrix_planar_intersection.cpp"
+   "smatrix_propagator.cpp"
+   "smatrix_rectangle2D.cpp"
+   "smatrix_ring2D.cpp"
+   "smatrix_single3D.cpp"
+   "smatrix_stepper.cpp" 
+   "smatrix_surfaces_finder.cpp"
+   "smatrix_telescope_detector.cpp"
+   "smatrix_toy_geometry.cpp"
+   "smatrix_track.cpp"
+   "smatrix_track_generators.cpp"
+   "smatrix_transform_store.cpp"
+   "smatrix_trapezoid2D.cpp"
+   "smatrix_unmasked.cpp"
+   "smatrix_volume.cpp"
    LINK_LIBRARIES GTest::gtest_main detray_tests_common detray::smatrix )
 
 # Set up the "conditional" tests.
diff --git a/tests/unit_tests/smatrix/smatrix_cylinder3.cpp b/tests/unit_tests/smatrix/smatrix_annulus2D.cpp
similarity index 83%
rename from tests/unit_tests/smatrix/smatrix_cylinder3.cpp
rename to tests/unit_tests/smatrix/smatrix_annulus2D.cpp
index 3165f58e49..f834ef7b10 100644
--- a/tests/unit_tests/smatrix/smatrix_cylinder3.cpp
+++ b/tests/unit_tests/smatrix/smatrix_annulus2D.cpp
@@ -6,4 +6,4 @@
  */
 
 #include "detray/plugins/algebra/smatrix_definitions.hpp"
-#include "tests/common/masks_cylinder3.inl"
+#include "tests/common/masks_annulus2D.inl"
diff --git a/tests/unit_tests/smatrix/smatrix_annulus2.cpp b/tests/unit_tests/smatrix/smatrix_cylinder.cpp
similarity index 83%
rename from tests/unit_tests/smatrix/smatrix_annulus2.cpp
rename to tests/unit_tests/smatrix/smatrix_cylinder.cpp
index 4add20efaf..a88386cb59 100644
--- a/tests/unit_tests/smatrix/smatrix_annulus2.cpp
+++ b/tests/unit_tests/smatrix/smatrix_cylinder.cpp
@@ -6,4 +6,4 @@
  */
 
 #include "detray/plugins/algebra/smatrix_definitions.hpp"
-#include "tests/common/masks_annulus2.inl"
+#include "tests/common/masks_cylinder.inl"
diff --git a/tests/unit_tests/smatrix/smatrix_grid.cpp b/tests/unit_tests/smatrix/smatrix_grid.cpp
new file mode 100644
index 0000000000..88021e66ca
--- /dev/null
+++ b/tests/unit_tests/smatrix/smatrix_grid.cpp
@@ -0,0 +1,9 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include "detray/plugins/algebra/smatrix_definitions.hpp"
+#include "tests/common/grid_grid.inl"
diff --git a/tests/unit_tests/smatrix/smatrix_grid_axis.cpp b/tests/unit_tests/smatrix/smatrix_grid_axis.cpp
new file mode 100644
index 0000000000..a6147dcf55
--- /dev/null
+++ b/tests/unit_tests/smatrix/smatrix_grid_axis.cpp
@@ -0,0 +1,9 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include "detray/plugins/algebra/smatrix_definitions.hpp"
+#include "tests/common/grid_axis.inl"
diff --git a/tests/unit_tests/smatrix/smatrix_grid_populator.cpp b/tests/unit_tests/smatrix/smatrix_grid_populator.cpp
new file mode 100644
index 0000000000..4d24417158
--- /dev/null
+++ b/tests/unit_tests/smatrix/smatrix_grid_populator.cpp
@@ -0,0 +1,9 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include "detray/plugins/algebra/smatrix_definitions.hpp"
+#include "tests/common/grid_populator.inl"
diff --git a/tests/unit_tests/smatrix/smatrix_grid_serializer.cpp b/tests/unit_tests/smatrix/smatrix_grid_serializer.cpp
new file mode 100644
index 0000000000..4de07e37ac
--- /dev/null
+++ b/tests/unit_tests/smatrix/smatrix_grid_serializer.cpp
@@ -0,0 +1,9 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include "detray/plugins/algebra/smatrix_definitions.hpp"
+#include "tests/common/grid_serializer.inl"
diff --git a/tests/unit_tests/smatrix/smatrix_rectangle2.cpp b/tests/unit_tests/smatrix/smatrix_rectangle2D.cpp
similarity index 82%
rename from tests/unit_tests/smatrix/smatrix_rectangle2.cpp
rename to tests/unit_tests/smatrix/smatrix_rectangle2D.cpp
index dcadeb1c58..c332554684 100644
--- a/tests/unit_tests/smatrix/smatrix_rectangle2.cpp
+++ b/tests/unit_tests/smatrix/smatrix_rectangle2D.cpp
@@ -6,4 +6,4 @@
  */
 
 #include "detray/plugins/algebra/smatrix_definitions.hpp"
-#include "tests/common/masks_rectangle2.inl"
+#include "tests/common/masks_rectangle2D.inl"
diff --git a/tests/unit_tests/smatrix/smatrix_ring2.cpp b/tests/unit_tests/smatrix/smatrix_ring2D.cpp
similarity index 84%
rename from tests/unit_tests/smatrix/smatrix_ring2.cpp
rename to tests/unit_tests/smatrix/smatrix_ring2D.cpp
index 6af7a0db21..5a7d30f525 100644
--- a/tests/unit_tests/smatrix/smatrix_ring2.cpp
+++ b/tests/unit_tests/smatrix/smatrix_ring2D.cpp
@@ -6,4 +6,4 @@
  */
 
 #include "detray/plugins/algebra/smatrix_definitions.hpp"
-#include "tests/common/masks_ring2.inl"
+#include "tests/common/masks_ring2D.inl"
diff --git a/tests/unit_tests/smatrix/smatrix_single3.cpp b/tests/unit_tests/smatrix/smatrix_single3D.cpp
similarity index 83%
rename from tests/unit_tests/smatrix/smatrix_single3.cpp
rename to tests/unit_tests/smatrix/smatrix_single3D.cpp
index d02d59567d..7d2ed844e0 100644
--- a/tests/unit_tests/smatrix/smatrix_single3.cpp
+++ b/tests/unit_tests/smatrix/smatrix_single3D.cpp
@@ -6,4 +6,4 @@
  */
 
 #include "detray/plugins/algebra/smatrix_definitions.hpp"
-#include "tests/common/masks_single3.inl"
+#include "tests/common/masks_single3D.inl"
diff --git a/tests/unit_tests/smatrix/smatrix_trapezoid2.cpp b/tests/unit_tests/smatrix/smatrix_trapezoid2.cpp
deleted file mode 100644
index b9e999b9a5..0000000000
--- a/tests/unit_tests/smatrix/smatrix_trapezoid2.cpp
+++ /dev/null
@@ -1,9 +0,0 @@
-/** Detray library, part of the ACTS project (R&D line)
- *
- * (c) 2020 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#include "detray/plugins/algebra/smatrix_definitions.hpp"
-#include "tests/common/masks_trapezoid2.inl"
diff --git a/tests/unit_tests/smatrix/smatrix_trapezoid2D.cpp b/tests/unit_tests/smatrix/smatrix_trapezoid2D.cpp
new file mode 100644
index 0000000000..13c65482cc
--- /dev/null
+++ b/tests/unit_tests/smatrix/smatrix_trapezoid2D.cpp
@@ -0,0 +1,9 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2020 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include "detray/plugins/algebra/smatrix_definitions.hpp"
+#include "tests/common/masks_trapezoid2D.inl"
diff --git a/tests/unit_tests/vc/CMakeLists.txt b/tests/unit_tests/vc/CMakeLists.txt
index 2ac4cf1727..b4f8be4d89 100644
--- a/tests/unit_tests/vc/CMakeLists.txt
+++ b/tests/unit_tests/vc/CMakeLists.txt
@@ -6,20 +6,47 @@
 
 # Set up all of the "standard" tests.
 detray_add_test( vc_array
-   "vc_array_actor_chain.cpp" "vc_array_annulus2.cpp" "vc_array_container.cpp"  "vc_array_coordinates.cpp" "vc_array_core.cpp" 
-   "vc_array_covariance_engine.cpp" "vc_array_cylinder_intersection.cpp" 
-   "vc_array_cylinder3.cpp" "vc_array_detector.cpp" "vc_array_geometry_volume_graph.cpp"
-   "vc_array_geometry_linking.cpp" "vc_array_geometry_navigation.cpp"
-   "vc_array_geometry_scan.cpp" "vc_array_guided_navigator.cpp"
-   "vc_array_helix_trajectory.cpp" "vc_array_intersection_kernel.cpp" "vc_array_line_intersection.cpp" "vc_array_line.cpp" 
-   "vc_array_mask_store.cpp" "vc_array_materials.cpp" "vc_array_navigator.cpp"
-   "vc_array_particle_gun.cpp" "vc_array_planar_intersection.cpp"
-   "vc_array_propagator.cpp" "vc_array_rectangle2.cpp" "vc_array_ring2.cpp"
-   "vc_array_single3.cpp" "vc_array_stepper.cpp"
-   "vc_array_surfaces_finder.cpp" "vc_array_telescope_detector.cpp"
-   "vc_array_toy_geometry.cpp" "vc_array_track.cpp"
-   "vc_array_track_generators.cpp" "vc_array_transform_store.cpp"
-   "vc_array_trapezoid2.cpp" "vc_array_unmasked.cpp" "vc_array_volume.cpp"
+   "vc_array_actor_chain.cpp"
+   "vc_array_annulus2D.cpp"
+   "vc_array_container.cpp"
+   "vc_array_coordinates.cpp"
+   "vc_array_core.cpp" 
+   "vc_array_covariance_engine.cpp"
+   "vc_array_cylinder_intersection.cpp" 
+   "vc_array_cylinder.cpp"
+   "vc_array_detector.cpp"
+   "vc_array_geometry_volume_graph.cpp"
+   "vc_array_geometry_linking.cpp"
+   "vc_array_geometry_navigation.cpp"
+   "vc_array_geometry_scan.cpp"
+   "vc_array_grid_axis.cpp"
+   "vc_array_grid.cpp"
+   "vc_array_grid_populator.cpp"
+   "vc_array_grid_serializer.cpp"
+   "vc_array_guided_navigator.cpp"
+   "vc_array_helix_trajectory.cpp"
+   "vc_array_intersection_kernel.cpp"
+   "vc_array_line_intersection.cpp"
+   "vc_array_line.cpp"
+   "vc_array_mask_store.cpp" 
+   "vc_array_materials.cpp"
+   "vc_array_navigator.cpp"
+   "vc_array_particle_gun.cpp"
+   "vc_array_planar_intersection.cpp"
+   "vc_array_propagator.cpp"
+   "vc_array_rectangle2D.cpp"
+   "vc_array_ring2D.cpp"
+   "vc_array_single3D.cpp"
+   "vc_array_stepper.cpp"
+   "vc_array_surfaces_finder.cpp"
+   "vc_array_telescope_detector.cpp"
+   "vc_array_toy_geometry.cpp"
+   "vc_array_track.cpp"
+   "vc_array_track_generators.cpp"
+   "vc_array_transform_store.cpp"
+   "vc_array_trapezoid2D.cpp"
+   "vc_array_unmasked.cpp" 
+   "vc_array_volume.cpp"
    LINK_LIBRARIES GTest::gtest_main detray_tests_common detray::vc_array )
 
 # Set up the "conditional" tests.
diff --git a/tests/unit_tests/vc/vc_array_cylinder3.cpp b/tests/unit_tests/vc/vc_array_annulus2D.cpp
similarity index 83%
rename from tests/unit_tests/vc/vc_array_cylinder3.cpp
rename to tests/unit_tests/vc/vc_array_annulus2D.cpp
index db6d80085d..553592e6ce 100644
--- a/tests/unit_tests/vc/vc_array_cylinder3.cpp
+++ b/tests/unit_tests/vc/vc_array_annulus2D.cpp
@@ -6,4 +6,4 @@
  */
 
 #include "detray/plugins/algebra/vc_array_definitions.hpp"
-#include "tests/common/masks_cylinder3.inl"
\ No newline at end of file
+#include "tests/common/masks_annulus2D.inl"
diff --git a/tests/unit_tests/vc/vc_array_single3.cpp b/tests/unit_tests/vc/vc_array_cylinder.cpp
similarity index 83%
rename from tests/unit_tests/vc/vc_array_single3.cpp
rename to tests/unit_tests/vc/vc_array_cylinder.cpp
index 16090e89b4..4e71572690 100644
--- a/tests/unit_tests/vc/vc_array_single3.cpp
+++ b/tests/unit_tests/vc/vc_array_cylinder.cpp
@@ -6,4 +6,4 @@
  */
 
 #include "detray/plugins/algebra/vc_array_definitions.hpp"
-#include "tests/common/masks_single3.inl"
\ No newline at end of file
+#include "tests/common/masks_cylinder.inl"
\ No newline at end of file
diff --git a/tests/unit_tests/vc/vc_array_grid.cpp b/tests/unit_tests/vc/vc_array_grid.cpp
new file mode 100644
index 0000000000..447655a3dd
--- /dev/null
+++ b/tests/unit_tests/vc/vc_array_grid.cpp
@@ -0,0 +1,9 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include "detray/plugins/algebra/vc_array_definitions.hpp"
+#include "tests/common/grid_grid.inl"
diff --git a/tests/unit_tests/vc/vc_array_grid_axis.cpp b/tests/unit_tests/vc/vc_array_grid_axis.cpp
new file mode 100644
index 0000000000..f1486810f0
--- /dev/null
+++ b/tests/unit_tests/vc/vc_array_grid_axis.cpp
@@ -0,0 +1,9 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include "detray/plugins/algebra/vc_array_definitions.hpp"
+#include "tests/common/grid_axis.inl"
diff --git a/tests/unit_tests/vc/vc_array_grid_populator.cpp b/tests/unit_tests/vc/vc_array_grid_populator.cpp
new file mode 100644
index 0000000000..e579a045ea
--- /dev/null
+++ b/tests/unit_tests/vc/vc_array_grid_populator.cpp
@@ -0,0 +1,9 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include "detray/plugins/algebra/vc_array_definitions.hpp"
+#include "tests/common/grid_populator.inl"
diff --git a/tests/unit_tests/vc/vc_array_grid_serializer.cpp b/tests/unit_tests/vc/vc_array_grid_serializer.cpp
new file mode 100644
index 0000000000..a1275a5bf9
--- /dev/null
+++ b/tests/unit_tests/vc/vc_array_grid_serializer.cpp
@@ -0,0 +1,9 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include "detray/plugins/algebra/vc_array_definitions.hpp"
+#include "tests/common/grid_serializer.inl"
diff --git a/tests/unit_tests/vc/vc_array_rectangle2.cpp b/tests/unit_tests/vc/vc_array_rectangle2D.cpp
similarity index 82%
rename from tests/unit_tests/vc/vc_array_rectangle2.cpp
rename to tests/unit_tests/vc/vc_array_rectangle2D.cpp
index 4aa2a8443c..2c68c2bead 100644
--- a/tests/unit_tests/vc/vc_array_rectangle2.cpp
+++ b/tests/unit_tests/vc/vc_array_rectangle2D.cpp
@@ -6,4 +6,4 @@
  */
 
 #include "detray/plugins/algebra/vc_array_definitions.hpp"
-#include "tests/common/masks_rectangle2.inl"
\ No newline at end of file
+#include "tests/common/masks_rectangle2D.inl"
\ No newline at end of file
diff --git a/tests/unit_tests/vc/vc_array_ring2.cpp b/tests/unit_tests/vc/vc_array_ring2D.cpp
similarity index 84%
rename from tests/unit_tests/vc/vc_array_ring2.cpp
rename to tests/unit_tests/vc/vc_array_ring2D.cpp
index 7f1e7f2843..5bf9232c70 100644
--- a/tests/unit_tests/vc/vc_array_ring2.cpp
+++ b/tests/unit_tests/vc/vc_array_ring2D.cpp
@@ -6,4 +6,4 @@
  */
 
 #include "detray/plugins/algebra/vc_array_definitions.hpp"
-#include "tests/common/masks_ring2.inl"
\ No newline at end of file
+#include "tests/common/masks_ring2D.inl"
\ No newline at end of file
diff --git a/tests/unit_tests/vc/vc_array_annulus2.cpp b/tests/unit_tests/vc/vc_array_single3D.cpp
similarity index 83%
rename from tests/unit_tests/vc/vc_array_annulus2.cpp
rename to tests/unit_tests/vc/vc_array_single3D.cpp
index 005afbaf3a..013b6f6c52 100644
--- a/tests/unit_tests/vc/vc_array_annulus2.cpp
+++ b/tests/unit_tests/vc/vc_array_single3D.cpp
@@ -6,4 +6,4 @@
  */
 
 #include "detray/plugins/algebra/vc_array_definitions.hpp"
-#include "tests/common/masks_annulus2.inl"
+#include "tests/common/masks_single3D.inl"
\ No newline at end of file
diff --git a/tests/unit_tests/vc/vc_array_trapezoid2.cpp b/tests/unit_tests/vc/vc_array_trapezoid2.cpp
deleted file mode 100644
index e127297ddc..0000000000
--- a/tests/unit_tests/vc/vc_array_trapezoid2.cpp
+++ /dev/null
@@ -1,9 +0,0 @@
-/** Detray library, part of the ACTS project (R&D line)
- *
- * (c) 2020 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#include "detray/plugins/algebra/vc_array_definitions.hpp"
-#include "tests/common/masks_trapezoid2.inl"
\ No newline at end of file
diff --git a/tests/unit_tests/vc/vc_array_trapezoid2D.cpp b/tests/unit_tests/vc/vc_array_trapezoid2D.cpp
new file mode 100644
index 0000000000..5dfb964f7f
--- /dev/null
+++ b/tests/unit_tests/vc/vc_array_trapezoid2D.cpp
@@ -0,0 +1,9 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2020 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include "detray/plugins/algebra/vc_array_definitions.hpp"
+#include "tests/common/masks_trapezoid2D.inl"
\ No newline at end of file