diff --git a/core/CMakeLists.txt b/core/CMakeLists.txt
index ad0abc802..c4b6cd25c 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"
@@ -89,6 +89,18 @@ detray_add_library( detray_core core
    "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 6ed134aa9..f08f9fde4 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/type_registry.hpp b/core/include/detray/core/type_registry.hpp
index a20f8c72f..9f0fac72f 100644
--- a/core/include/detray/core/type_registry.hpp
+++ b/core/include/detray/core/type_registry.hpp
@@ -79,6 +79,7 @@ class registry_base<ID, true, registered_types...> {
     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); }
     };
 
@@ -96,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);
diff --git a/core/include/detray/definitions/containers.hpp b/core/include/detray/definitions/containers.hpp
index 1618ca758..57911f5db 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 b63b6dd9d..da05d642f 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 feba7c202..3d4f9d522 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,6 +18,32 @@ dindex constexpr dindex_invalid = std::numeric_limits<dindex>::max();
 using dindex_range = darray<dindex, 2>;
 using dindex_sequence = dvector<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
diff --git a/core/include/detray/grids/axis.hpp b/core/include/detray/grids/axis.hpp
index 9949edd96..cdfd89b88 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 2a51fe24b..4d781309f 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
@@ -64,7 +64,7 @@ class grid2 {
 
     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),
diff --git a/core/include/detray/grids/populator.hpp b/core/include/detray/grids/populator.hpp
index 3ddacb003..f1c5ec670 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 3d7249c7f..e561c2156 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,7 +49,7 @@ 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::local_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,
@@ -56,10 +57,7 @@ struct concentric_cylinder_intersector {
 
         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,9 +105,8 @@ 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.status = mask.is_inside(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;
                 is.link = mask.volume_link();
diff --git a/core/include/detray/intersection/cylinder_intersector.hpp b/core/include/detray/intersection/cylinder_intersector.hpp
index 280066556..04ef8cdcc 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"
@@ -45,7 +46,7 @@ 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::local_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 +54,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);
@@ -82,19 +81,15 @@ 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
+                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) > static_cast<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[0]};
                 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/plane_intersector.hpp b/core/include/detray/intersection/plane_intersector.hpp
index 409bf082d..ea8b4b985 100644
--- a/core/include/detray/intersection/plane_intersector.hpp
+++ b/core/include/detray/intersection/plane_intersector.hpp
@@ -52,8 +52,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 +65,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 4883edaa9..000000000
--- a/core/include/detray/masks/annulus2.hpp
+++ /dev/null
@@ -1,171 +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 000000000..5c151700a
--- /dev/null
+++ b/core/include/detray/masks/annulus2D.hpp
@@ -0,0 +1,168 @@
+/** 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 mask for the stereo annulus geometry 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>;
+    /// Measurement frame
+    template <typename algebra_t>
+    using measurement_frame_type = polar2<algebra_t>; // TODO: focal system
+    /// Local point type (2D)
+    template <typename algebra_t>
+    using loc_point_type = typename local_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 local_frame_type = polar2<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 000000000..40505c9da
--- /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 mask for a full 3D cuboid.
+///
+/// @tparam intersector_t defines how to intersect the underlying surface
+///         geometry
+///
+/// It is defined by the 3 half length and checks whether a point is somewhere
+/// inside the cuboid.
+template <template <typename> class intersector_t = plane_intersector>
+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
+    template <typename algebra_t>
+    using local_frame_type = cartesian3<algebra_t>;
+    /// Measurement frame
+    template <typename algebra_t>
+    using measurement_frame_type = local_frame_type<algebra_t>;
+    /// Local point type (3D)
+    template <typename algebra_t>
+    using loc_point_type = typename local_frame_type<algebra_t>::point3;
+    /// Underlying surface geometry: planar
+    template <typename algebra_t>
+    using intersector_type = intersector_t<algebra_t>;
+
+    /// 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;
+
+        /// Local coordinate frame
+        template <typename algebra_t>
+        using local_frame_type = cartesian3<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 000000000..c36ac9857
--- /dev/null
+++ b/core/include/detray/masks/cylinder2D.hpp
@@ -0,0 +1,111 @@
+/** 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/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 mask for a full 2D cylinder.
+///
+/// @tparam kRadialCheck is a boolean to steer whether the radius compatibility
+///         needs to be checked
+/// @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";
+
+    enum boundaries : std::size_t {
+        e_r = 0,
+        e_n_half_z = 1,
+        e_p_half_z = 2,
+        e_size = 3,
+    };
+
+    /// Local coordinate frame
+    template <typename algebra_t>
+    using local_frame_type = cylindrical2<algebra_t>;
+    /// Local point type (3D)
+    template <typename algebra_t>
+    using loc_point_type = typename local_frame_type<algebra_t>::point2;
+    /// Underlying surface geometry: cylindrical
+    template <typename algebra_t>
+    using intersector_type = intersector_t<algebra_t>;
+
+    /// 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>
+    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>>;
+
+        /// Local coordinate frame
+        template <typename algebra_t>
+        using local_frame_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,
+              bool is_rad_check = kRadialCheck,
+              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 (is_rad_check) {
+            if (std::abs(loc_p[0] / bounds[e_r]) <= scalar_t{M_PI} +
+                tol + 5 * std::numeric_limits<scalar_t>::epsilon()) {
+                return false;
+            }
+        }
+        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 d223a6bef..000000000
--- 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 000000000..3ee038077
--- /dev/null
+++ b/core/include/detray/masks/cylinder3D.hpp
@@ -0,0 +1,106 @@
+/** 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 mask for a full 3D cylinder.
+///
+/// @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 <template <typename> class intersector_t = cylinder_intersector>
+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
+    template <typename algebra_t>
+    using local_frame_type = cylindrical3<algebra_t>;
+    /// Measurement frame
+    template <typename algebra_t>
+    using measurement_frame_type = local_frame_type<algebra_t>;
+    /// Local point type (3D)
+    template <typename algebra_t>
+    using loc_point_type = typename local_frame_type<algebra_t>::point3;
+    /// Underlying surface geometry: cylindrical
+    template <typename algebra_t>
+    using intersector_type = intersector_t<algebra_t>;
+
+    /// 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>>;
+
+        /// Local coordinate frame
+        template <typename algebra_t>
+        using local_frame_type = cylindrical3<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 616b1c9b6..1c17d6558 100644
--- a/core/include/detray/masks/line.hpp
+++ b/core/include/detray/masks/line.hpp
@@ -8,101 +8,121 @@
 #pragma once
 
 // Project include(s).
+#include "detray/coordinates/line2.hpp"
 #include "detray/coordinates/coordinates.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 Mask for a line defined with a line length and its cross section
+///
+/// @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
+    };
+
+    /// How to convert into the local system and back
+    template <typename algebra_t>
+    using local_frame_type = std::conditional_t<kSquareCrossSect, cartesian3<algebra_t>, line2<algebra_t>>;
+    /// Measurement frame
+    template <typename algebra_t>
+    using measurement_frame_type = line2<algebra_t>;
+    /// Local point type (2D)
+    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>;
+    /// Underlying surface geometry: planar
+    template <typename algebra_t>
+    using intersector_type = intersector_t<algebra_t>;
+
+    /// 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;
 
-    /** 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;
+        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 system and back
+        template <typename algebra_t>
+        using local_frame_type = std::conditional_t<kSquareCrossSect, cartesian3<algebra_t>, 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[0] + tol &&
+                    std::abs(loc_p[1]) <= bounds[0] + tol &&
+                    std::abs(loc_p[2]) <= bounds[1] + 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 (getter::perp(loc_p) <= bounds[0] + tol &&
+                    std::abs(loc_p[2]) <= bounds[1] + 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 376ff18e4..000000000
--- a/core/include/detray/masks/mask_base.hpp
+++ /dev/null
@@ -1,120 +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 {
-
-/// @brief Base class for all masks.
-///
-/// Masks are lightweight types that define any special behaviour of different
-/// surfaces geometries: They give the surface class its 'shape'.
-/// A mask defines a local coordinate system on a surface geometry (e.g. a
-/// plane surface or a cylinder surface) and defines the surface's extent in
-/// that geometry. Masks are consequently used to make the inside/outside
-/// decision during an intersection operation.
-/// Masks can be (shared) boundary surfaces for detector volumes and therefore
-/// hold the links to adjacent volumes that are needed during navigation. For
-/// sensitive surfaces those links point to the mother volume.
-///
-/// @note Might contain multiple masks in the future.
-///
-/// @tparam intersector_t the intersection implementation for the surface
-///                       geometry the mask belongs to. Can also be different,
-///                       if the intersection is not done with a straight line.
-/// @tparam locat_t the local coordinate system in which the surface extent is
-///                 defined.
-/// @tparam links_t the type of links that are used to tie detector volumes
-///                 together. Might be multiindex in the future.
-/// @tparam kDIM the number of values needed to define a surfaces extent.
-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:
-    // Make template parameters accessible
-    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), _volume_link(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 mask to be compared with
-    ///
-    /// @returns true if equal
-    DETRAY_HOST_DEVICE
-    bool operator==(const mask_values& rhs) { return (_values == rhs); }
-
-    /// Equality operator
-    ///
-    /// @param rhs is the mask to be compared with
-    ///
-    /// @returns true if equal
-    DETRAY_HOST_DEVICE
-    bool operator==(const mask_base& rhs) {
-        return (_values == rhs._values && _volume_link == rhs._volume_link);
-    }
-
-    /// Access operator - non-const
-    /// @returns the reference to the requested mask value
-    DETRAY_HOST_DEVICE
-    scalar& operator[](std::size_t value_index) { return _values[value_index]; }
-
-    /// Access operator - const
-    /// @returns the reference to the requested mask value
-    DETRAY_HOST_DEVICE
-    scalar operator[](std::size_t value_index) const {
-        return _values[value_index];
-    }
-
-    /// @return the mask values
-    DETRAY_HOST_DEVICE
-    const mask_values& values() const { return _values; }
-
-    /// @return an associated intersector functor
-    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 volume link - const reference
-    DETRAY_HOST_DEVICE
-    auto volume_link() const { return _volume_link; }
-
-    /// @return the volume link - non-const access
-    DETRAY_HOST_DEVICE
-    auto volume_link() { return _volume_link; }
-
-    protected:
-    mask_values _values;
-    links_type _volume_link;
-};
-
-}  // 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 4facdd043..521965584 100644
--- a/core/include/detray/masks/masks.hpp
+++ b/core/include/detray/masks/masks.hpp
@@ -7,11 +7,163 @@
 
 #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>;
+    // 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
+    mask<shape_t, links_t, algebra_t, array_t>& operator=(
+        const mask_values& rhs) {
+        _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 scalar_type& operator[](const std::size_t value_index) { return _values[value_index]; }
+
+    /// Access operator - const
+    ///
+    /// @returns a copy of the member variable
+    DETRAY_HOST_DEVICE
+    constexpr scalar_type operator[](const std::size_t value_index) const {
+        return _values[value_index];
+    }
+
+    /// @returns the boundary values
+    DETRAY_HOST_DEVICE
+    inline constexpr const shape& get_shape() const { 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 loc_point_t to_local_frame(
+        const transform3_t& trf, const point3_t& glob_p, const point3_t& glob_dir = {}) const {
+        return
+            typename shape::template local_frame_type<transform3_t>{}.global_to_local(trf, glob_p, glob_dir);
+    }
+
+    /// @returns the intersection functor for the underlying surface geometry.
+    DETRAY_HOST_DEVICE
+    inline constexpr typename shape::template intersector_type<algebra_t> intersector() const {
+        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
+    // TODO: Use loc_point_type as soon as all shapes are correctly implemented
+    template <typename point_t>
+    DETRAY_HOST_DEVICE intersection::status is_inside(
+        const point_t& loc_p,
+        const scalar_type t = std::numeric_limits<scalar_type>::epsilon()) const {
+
+        return _shape.check_boundaries(_values, loc_p, t)
+                   ? intersection::status::e_inside
+                   : intersection::status::e_outside;
+    }
+
+    /// @returns the boundary values
+    DETRAY_HOST_DEVICE
+    const mask_values& values() const { return _values; }
+
+    /// @returns the volume link - const reference
+    DETRAY_HOST_DEVICE
+    auto volume_link() const { return _volume_link; }
+
+    /// @returns the volume link - non-const access
+    DETRAY_HOST_DEVICE
+    auto volume_link() { return _volume_link; }
+
+    /// @returns a string representation of the mask
+    DETRAY_HOST
+    std::string to_string() const {
+        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 3df451c96..000000000
--- 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 000000000..c5a6c4c8a
--- /dev/null
+++ b/core/include/detray/masks/rectangle2D.hpp
@@ -0,0 +1,99 @@
+/** 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 This is a simple 2-dimensional mask for a regular rectangle
+///
+/// @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,
+    };
+
+    /// How to convert into the local system and back
+    template <typename algebra_t>
+    using local_frame_type = cartesian2<algebra_t>;
+    /// Measurement frame
+    template <typename algebra_t>
+    using measurement_frame_type = local_frame_type<algebra_t>;
+    /// Local point type (2D)
+    template <typename algebra_t>
+    using loc_point_type = typename local_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 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 system and back
+        template <typename algebra_t>
+        using local_frame_type = cartesian2<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 422ce7f20..000000000
--- 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 000000000..35cbb7c2a
--- /dev/null
+++ b/core/include/detray/masks/ring2D.hpp
@@ -0,0 +1,101 @@
+/** 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 {
+
+/// This is a simple 2-dimensional mask for 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,
+    };
+
+    /// How to convert into the local system and back
+    template <typename algebra_t>
+    using local_frame_type = polar2<algebra_t>;
+    /// Measurement frame
+    template <typename algebra_t>
+    using measurement_frame_type = local_frame_type<algebra_t>;
+    /// Local point type (2D)
+    template <typename algebra_t>
+    using loc_point_type = typename local_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;
+
+        /// How to convert into the local system and back
+        template <typename algebra_t>
+        using local_frame_type = polar2<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 681801143..000000000
--- 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 000000000..67cbfc038
--- /dev/null
+++ b/core/include/detray/masks/single3D.hpp
@@ -0,0 +1,97 @@
+/** 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 This is a simple mask 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,
+    };
+
+    /// How to convert into the local system and back
+    template <typename algebra_t>
+    using local_frame_type = cartesian3<algebra_t>;
+    /// Measurement frame
+    template <typename algebra_t>
+    using measurement_frame_type = local_frame_type<algebra_t>;
+    /// Local point type (2D)
+    template <typename algebra_t>
+    using loc_point_type = typename local_frame_type<algebra_t>::point3;
+    /// 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)
+    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 system and back
+        template <typename algebra_t>
+        using local_frame_type = cartesian3<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 9c44e14ae..000000000
--- 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 000000000..41b8209ff
--- /dev/null
+++ b/core/include/detray/masks/trapezoid2D.hpp
@@ -0,0 +1,109 @@
+/** 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 {
+
+/// This is a simple 2-dimensional mask for a regular trapezoid
+///
+/// @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,
+    };
+
+    /// How to convert into the local system and back
+    template <typename algebra_t>
+    using local_frame_type = cartesian2<algebra_t>;
+    /// Measurement frame
+    template <typename algebra_t>
+    using measurement_frame_type = local_frame_type<algebra_t>;
+    /// Local point type (2D)
+    template <typename algebra_t>
+    using loc_point_type = typename local_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 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 system and back
+        template <typename algebra_t>
+        using local_frame_type = cartesian2<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 7484b1052..5474d6fa2 100644
--- a/core/include/detray/masks/unmasked.hpp
+++ b/core/include/detray/masks/unmasked.hpp
@@ -8,57 +8,71 @@
 #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) {}
+    /// How to convert into the local system and back
+    template <typename algebra_t>
+    using local_frame_type = cartesian2<algebra_t>;
+    /// Measurement frame
+    template <typename algebra_t>
+    using measurement_frame_type = local_frame_type<algebra_t>;
+    /// Local point type (2D)
+    template <typename algebra_t>
+    using loc_point_type = typename local_frame_type<algebra_t>::point2;
+    /// Underlying surface geometry: planar
+    template <typename algebra_t>
+    using intersector_type = plane_intersector<algebra_t>;
 
-    /** 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;
-    }
+    /// 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 system and back
+        template <typename algebra_t>
+        using local_frame_type = cartesian2<algebra_t>;
+
+        using types = std::tuple<n_axis::shape_t<e_s, axis_loc0>,
+                                 n_axis::shape_t<e_s, axis_loc1>>;
 
-    /** Transform to a string for output debugging */
-    std::string to_string() const { return "unmasked"; }
+        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/surface_finders/grid/axis.hpp b/core/include/detray/surface_finders/grid/axis.hpp
new file mode 100644
index 000000000..ceafd372a
--- /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 000000000..88ce20c07
--- /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 000000000..77566bf2f
--- /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 000000000..41c509e34
--- /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 000000000..5957f9ccb
--- /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 000000000..c7f342ab1
--- /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 000000000..311d68378
--- /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 000000000..25802bc57
--- /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 000000000..b921bd200
--- /dev/null
+++ b/core/include/detray/surface_finders/grid/grid_builder.hpp
@@ -0,0 +1,130 @@
+/** 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 local_frame_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
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 000000000..4a53838e5
--- /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 000000000..d3d5bce7e
--- /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/tools/generators.hpp b/core/include/detray/tools/generators.hpp
index c47fb1c5a..818333e61 100644
--- a/core/include/detray/tools/generators.hpp
+++ b/core/include/detray/tools/generators.hpp
@@ -40,13 +40,9 @@ static inline dvector<scalar_t> phi_values(scalar_t start_phi, scalar_t end_phi,
  *
  * @return a generated list of vertices
  */
-template <typename point2_t, typename point3_t, typename transform3_t,
-          template <class> typename intersector_t,
-          template <class> typename local_t, typename links_t>
-dvector<point3_t> vertices(
-    const annulus2<transform3_t, intersector_t, local_t, links_t> &annulus_mask,
-    unsigned int lseg) {
-
+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();
@@ -131,13 +127,10 @@ dvector<point3_t> vertices(
  *
  * @return a generated list of vertices
  */
-template <typename point2_t, typename point3_t, typename transform3_t,
-          bool kRadialCheck, template <class> typename intersector_t,
-          template <class> typename local_t, typename links_t>
-dvector<point3_t> vertices(
-    const cylinder3<transform3_t, intersector_t, local_t, links_t, kRadialCheck>
-        & /*cylinder_mask*/,
-    unsigned int /*lseg*/) {
+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*/) {
 
     return {};
 }
@@ -151,13 +144,9 @@ dvector<point3_t> vertices(
  *
  * @return a generated list of vertices
  */
-template <typename point2_t, typename point3_t, typename transform3_t,
-          template <class> typename intersector_t,
-          template <class> typename local_t, typename links_t>
-dvector<point3_t> 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_t lh_lc = {-m_values[0], -m_values[1], 0.};
@@ -180,12 +169,9 @@ dvector<point3_t> vertices(const rectangle2<transform3_t, intersector_t,
  *
  * @return a generated list of vertices
  */
-template <typename point2_t, typename point3_t, typename transform3_t,
-          template <class> typename intersector_t,
-          template <class> typename local_t, typename links_t>
-dvector<point3_t> vertices(
-    const ring2<transform3_t, intersector_t, local_t, links_t> & /*ring_mask*/,
-    unsigned int /*lseg*/) {
+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,12 +184,9 @@ dvector<point3_t> vertices(
  *
  * @return a generated list of vertices
  */
-template <typename point2_t, typename point3_t, typename transform3_t,
-          template <class> typename intersector_t,
-          template <class> typename local_t, typename links_t>
-dvector<point3_t> 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
diff --git a/core/include/detray/utils/enumerate.hpp b/core/include/detray/utils/enumerate.hpp
index ee44ffccf..caaf951bd 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,40 +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
-        if (std::distance(_end, std::end(iterable)) <= 0) {
+        //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); }
@@ -71,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));
     }
 
@@ -79,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.
  *
@@ -207,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());
         }
diff --git a/core/include/detray/utils/invalid_values.hpp b/core/include/detray/utils/invalid_values.hpp
index 846d85a03..04fa39b18 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 588a88cdb..8a510f018 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/tests/common/include/tests/common/benchmark_find_volume.inl b/tests/common/include/tests/common/benchmark_find_volume.inl
index 422214f4d..3f14de4a2 100644
--- a/tests/common/include/tests/common/benchmark_find_volume.inl
+++ b/tests/common/include/tests/common/benchmark_find_volume.inl
@@ -14,7 +14,6 @@
 
 #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;
 
@@ -38,8 +37,6 @@ constexpr std::size_t n_brl_layers{4};
 constexpr std::size_t n_edc_layers{7};
 vecmem::host_memory_resource host_mr;
 auto d = create_toy_geometry(host_mr, n_brl_layers, n_edc_layers);
-// auto [d, name_map] =
-//     read_from_csv<detector_registry::tml_detector>(tml_files, host_mr);
 
 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 d9b55a43c..f1d5b71ee 100644
--- a/tests/common/include/tests/common/benchmark_intersect_all.inl
+++ b/tests/common/include/tests/common/benchmark_intersect_all.inl
@@ -12,7 +12,6 @@
 #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)
@@ -44,8 +43,6 @@ constexpr std::size_t n_brl_layers{4};
 constexpr std::size_t n_edc_layers{7};
 vecmem::host_memory_resource host_mr;
 auto d = create_toy_geometry(host_mr, n_brl_layers, n_edc_layers);
-// auto [d, name_map] =
-//     read_from_csv<detector_registry::tml_detector>(tml_files, host_mr);
 
 using detector_t = decltype(d);
 constexpr auto k_surfaces = detector_t::objects::e_surface;
diff --git a/tests/common/include/tests/common/benchmark_intersect_surfaces.inl b/tests/common/include/tests/common/benchmark_intersect_surfaces.inl
index 0cfd72381..ec33c36ab 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 9e57c6536..f6d01335f 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 db64df2b8..ca8e91d37 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_detector.inl b/tests/common/include/tests/common/core_detector.inl
index dd295138d..81cf14405 100644
--- a/tests/common/include/tests/common/core_detector.inl
+++ b/tests/common/include/tests/common/core_detector.inl
@@ -44,20 +44,19 @@ TEST(detector, detector_kernel) {
     /// Surface 0
     point3 t0{0., 0., 0.};
     trfs.emplace_back(ctx0, t0);
-    masks.template add_value<mask_ids::e_rectangle2>(-3., 3., 0);
+    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.,
-                                                   0);
+    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., 0);
+    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 32a23273a..01f854f88 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/grid_axis.inl b/tests/common/include/tests/common/grid_axis.inl
new file mode 100644
index 000000000..56219d3d8
--- /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 000000000..d2354ec3e
--- /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 000000000..1e8f99712
--- /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 000000000..a30f2fd7d
--- /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 19a53a810..000000000
--- 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 000000000..b471b2313
--- /dev/null
+++ b/tests/common/include/tests/common/masks_annulus2D.inl
@@ -0,0 +1,65 @@
+/** 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/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;
+
+    scalar minR = 7.2;
+    scalar maxR = 12.0;
+    scalar minPhi = 0.74195;
+    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[0], static_cast<scalar>(7.2));
+    ASSERT_FLOAT_EQ(ann2[1], static_cast<scalar>(12.0));
+    ASSERT_FLOAT_EQ(ann2[2], static_cast<scalar>(0.74195));
+    ASSERT_FLOAT_EQ(ann2[3], static_cast<scalar>(1.33970));
+    ASSERT_FLOAT_EQ(ann2[4], static_cast<scalar>(-2.0));
+    ASSERT_FLOAT_EQ(ann2[5], static_cast<scalar>(2.0));
+    ASSERT_FLOAT_EQ(ann2[6], static_cast<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 000000000..fd45ad6e5
--- /dev/null
+++ b/tests/common/include/tests/common/masks_cylinder.inl
@@ -0,0 +1,67 @@
+/** 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/masks.hpp"
+
+using namespace detray;
+using namespace __plugin;
+
+/// This tests the basic functionality of a 2D cylinder
+TEST(mask, cylinder3D) {
+    using point_t = typename mask<cylinder3D<>>::loc_point_t;
+
+    scalar r = 3.;
+    scalar hz = 4.;
+
+    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[0], r);
+    ASSERT_FLOAT_EQ(c[1], -hz);
+    ASSERT_FLOAT_EQ(c[2], 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;
+
+    scalar r = 3.;
+    scalar hz = 4.;
+
+    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<true, cylinder_intersector>> c{0UL, r, -hz, hz};
+
+    ASSERT_FLOAT_EQ(c[0], r);
+    ASSERT_FLOAT_EQ(c[1], -hz);
+    ASSERT_FLOAT_EQ(c[2], 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 1057fc7d8..000000000
--- 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 546129689..b2895e635 100644
--- a/tests/common/include/tests/common/masks_line.inl
+++ b/tests/common/include/tests/common/masks_line.inl
@@ -7,48 +7,56 @@
 
 #include <gtest/gtest.h>
 
-#include "detray/masks/line.hpp"
+#include "detray/intersection/line_intersector.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
+const scalar cell_size{1. * unit_constants::mm};
+const 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[0], static_cast<scalar>(1. * unit_constants::mm));
+    ASSERT_FLOAT_EQ(ln[1], static_cast<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);
     ASSERT_TRUE(ln.is_inside(ln_out1) == intersection::status::e_outside);
-    ASSERT_TRUE(ln.is_inside(ln_out2) == intersection::status::e_outside);
+    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{1., 0., 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[0], static_cast<scalar>(1. * unit_constants::mm));
+    ASSERT_FLOAT_EQ(ln[1], static_cast<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);
     ASSERT_TRUE(ln.is_inside(ln_edge, -1e-5) ==
                 intersection::status::e_outside);
-    ASSERT_TRUE(ln.is_inside(ln_out) == intersection::status::e_outside);
+    ASSERT_TRUE(ln.is_inside(ln_out) == intersection::status::e_outside);*/
 }
\ No newline at end of file
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 656b1626a..000000000
--- 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 000000000..f166e621a
--- /dev/null
+++ b/tests/common/include/tests/common/masks_rectangle2D.inl
@@ -0,0 +1,38 @@
+/** 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/masks.hpp"
+
+using namespace detray;
+using namespace __plugin;
+
+/// 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.};
+
+    scalar hx = 1.;
+    scalar hy = 9.3;
+
+    mask<rectangle2D<>> r2{0UL, hx, hy};
+
+    ASSERT_FLOAT_EQ(r2[0], hx);
+    ASSERT_FLOAT_EQ(r2[1], 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);
+}
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 d2e001827..000000000
--- 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 000000000..43944d54c
--- /dev/null
+++ b/tests/common/include/tests/common/masks_ring2D.inl
@@ -0,0 +1,35 @@
+/** 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/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.};
+
+    const scalar inner_r{0.};
+    const scalar outer_r{3.5};
+
+    mask<ring2D<>> r2{0UL, inner_r, outer_r};
+
+    ASSERT_FLOAT_EQ(r2[0], static_cast<scalar>(0.));
+    ASSERT_FLOAT_EQ(r2[1], 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 8c6eb8410..000000000
--- 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 000000000..84c5bda70
--- /dev/null
+++ b/tests/common/include/tests/common/masks_single3D.inl
@@ -0,0 +1,76 @@
+/** 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/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.};
+
+    const scalar h0{1.};
+    mask<single3D<>> m1_0{0UL, -h0, h0};
+
+    ASSERT_FLOAT_EQ(m1_0[0], -h0);
+    ASSERT_FLOAT_EQ(m1_0[1], 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.};
+
+    const scalar h1{9.3};
+    mask<single3D<1>> m1_1{0UL, -h1, h1};
+
+    ASSERT_FLOAT_EQ(m1_1[0], -h1);
+    ASSERT_FLOAT_EQ(m1_1[1], 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.};
+
+    const scalar h2{2.};
+    mask<single3D<2>> m1_2{0UL, -h2, h2};
+
+    ASSERT_FLOAT_EQ(m1_2[0], -h2);
+    ASSERT_FLOAT_EQ(m1_2[1], 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 b5b24da50..000000000
--- 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 000000000..34225733e
--- /dev/null
+++ b/tests/common/include/tests/common/masks_trapezoid2D.inl
@@ -0,0 +1,40 @@
+/** 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/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};
+
+    scalar hx_miny = 1.;
+    scalar hx_maxy = 3.;
+    scalar hy = 2.;
+    scalar divisor = 1. / (2. * hy);
+
+    mask<trapezoid2D<>> t2{0UL, hx_miny, hx_maxy, hy, divisor};
+
+    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(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 ba9b262a5..2339f2d57 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 0711b589c..e9c05c904 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 1bb1a4cc0..e3aa2e5b8 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 adabc9eeb..bd94f786d 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 f78607d4b..ff5925607 100644
--- a/tests/common/include/tests/common/test_toy_geometry.inl
+++ b/tests/common/include/tests/common/test_toy_geometry.inl
@@ -132,7 +132,7 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     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);
 
@@ -260,19 +260,19 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     // 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},
+                      {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, 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, 15, 16, 17, 18, 19});
 
@@ -310,7 +310,7 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     // 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, leaving_world});
     // disc portals
@@ -337,7 +337,7 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     // 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, leaving_world});
     // disc portals
@@ -373,7 +373,7 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     // 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, leaving_world});
     // disc portals
@@ -399,7 +399,7 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     // 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, leaving_world});
     // disc portals
@@ -435,7 +435,7 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     // 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, leaving_world});
     // disc portals
@@ -461,7 +461,7 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     // 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, leaving_world});
     // disc portals
@@ -502,7 +502,7 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     // cylinder portals
     range = {594, 596};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
-                      range[0], {mask_ids::e_portal_cylinder3, 26},
+                      range[0], {mask_ids::e_portal_cylinder2, 26},
                       {material_ids::e_slab, 594}, portal_mat, {0, 8});
 
     // disc portals
@@ -528,7 +528,7 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     // cylinder portals
     range = {598, 600};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
-                      range[0], {mask_ids::e_portal_cylinder3, 28},
+                      range[0], {mask_ids::e_portal_cylinder2, 28},
                       {material_ids::e_slab, 598}, portal_mat, {7, 9});
     // disc portals
     range = {600, 602};
@@ -563,7 +563,7 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     // cylinder portals
     range = {1050, 1052};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
-                      range[0], {mask_ids::e_portal_cylinder3, 30},
+                      range[0], {mask_ids::e_portal_cylinder2, 30},
                       {material_ids::e_slab, 1050}, portal_mat, {8, 10});
 
     // disc portals
@@ -589,7 +589,7 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     // cylinder portals
     range = {1054, 1056};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
-                      range[0], {mask_ids::e_portal_cylinder3, 32},
+                      range[0], {mask_ids::e_portal_cylinder2, 32},
                       {material_ids::e_slab, 1054}, portal_mat, {9, 11});
     // disc portals
     range = {1056, 1058};
@@ -624,7 +624,7 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     // cylinder portals
     range = {1786, 1788};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
-                      range[0], {mask_ids::e_portal_cylinder3, 34},
+                      range[0], {mask_ids::e_portal_cylinder2, 34},
                       {material_ids::e_slab, 1786}, portal_mat, {10, 12});
 
     // disc portals
@@ -650,7 +650,7 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     // cylinder portals
     range = {1790, 1792};
     test_portal_links(vol_itr->index(), surfaces.begin() + range[0], range,
-                      range[0], {mask_ids::e_portal_cylinder3, 36},
+                      range[0], {mask_ids::e_portal_cylinder2, 36},
                       {material_ids::e_slab, 1790}, portal_mat, {11, 13});
     // disc portals
     range = {1792, 1794};
@@ -685,7 +685,7 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     // 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, leaving_world});
 
@@ -716,7 +716,7 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     // 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, leaving_world});
     // disc portals
@@ -753,7 +753,7 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     // 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, leaving_world});
     // disc portals
@@ -779,7 +779,7 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     // 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, leaving_world});
     // disc portals
@@ -815,7 +815,7 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     // 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, leaving_world});
     // disc portals
@@ -841,7 +841,7 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     // 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, leaving_world});
     // disc portals
@@ -877,7 +877,7 @@ TEST(ALGEBRA_PLUGIN, toy_geometry) {
     // 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, leaving_world});
     // disc portals
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 4e724e15e..bdf92e998 100644
--- a/tests/common/include/tests/common/tools/create_telescope_detector.hpp
+++ b/tests/common/include/tests/common/tools/create_telescope_detector.hpp
@@ -158,7 +158,7 @@ inline void create_telescope(context_t &ctx, track_t &track, stepper_t &stepper,
         } 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_volume_link);
+                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 c108a28f9..c8c3f496b 100644
--- a/tests/common/include/tests/common/tools/create_toy_geometry.hpp
+++ b/tests/common/include/tests/common/tools/create_toy_geometry.hpp
@@ -58,7 +58,7 @@ inline void add_cylinder_surface(
     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)};
@@ -69,7 +69,7 @@ inline void add_cylinder_surface(
 
     // add transform and masks
     transforms.emplace_back(ctx, tsl);
-    masks.template add_value<cylinder_id>(r, min_z, max_z, volume_link);
+    masks.template add_value<cylinder_id>(volume_link, r, min_z, max_z);
 
     // Add material slab
     materials.template add_value<slab_id>(mat, thickness);
@@ -124,7 +124,7 @@ inline void add_disc_surface(
 
     // add transform and mask
     transforms.emplace_back(ctx, tsl);
-    masks.template add_value<disc_id>(min_r, max_r, volume_link);
+    masks.template add_value<disc_id>(volume_link, min_r, max_r);
 
     // Add material slab
     materials.template add_value<slab_id>(mat, thickness);
@@ -288,8 +288,8 @@ inline void create_barrel_modules(context_t &ctx, volume_type &vol,
                               dindex_invalid, false);
 
         // The rectangle bounds for this module
-        masks.template add_value<rectangle_id>(cfg.m_half_x, cfg.m_half_y,
-                                               mask_volume_link);
+        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
@@ -512,8 +512,9 @@ void create_endcap_modules(context_t &ctx, volume_type &vol,
                 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_volume_link);
+                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);
 
diff --git a/tests/common/include/tests/common/tools/detector_metadata.hpp b/tests/common/include/tests/common/tools/detector_metadata.hpp
index c9e3f5b23..670ee8cac 100644
--- a/tests/common/include/tests/common/tools/detector_metadata.hpp
+++ b/tests/common/include/tests/common/tools/detector_metadata.hpp
@@ -26,26 +26,16 @@ struct volume_stats {
     std::size_t n_max_objects_per_volume = 0;
 };
 
-/// volume links: next volume during navigation
+/// 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, volume_link_type>;
-using trapezoid = trapezoid2<__plugin::transform3<detray::scalar>,
-                             plane_intersector, cartesian2, volume_link_type>;
-// @TODO: Use Polar2?
-using annulus = annulus2<__plugin::transform3<detray::scalar>,
-                         plane_intersector, polar2, volume_link_type>;
-using cylinder =
-    cylinder3<__plugin::transform3<detray::scalar>, cylinder_intersector,
-              cylindrical2, volume_link_type>;
-// @TODO: Use Polar2?
-using disc = ring2<__plugin::transform3<detray::scalar>, plane_intersector,
-                   polar2, volume_link_type>;
-using unbounded_plane =
-    unmasked<__plugin::transform3<detray::scalar>, plane_intersector,
-             cartesian2, volume_link_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>;
@@ -68,8 +58,8 @@ struct full_metadata {
         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,
@@ -151,8 +141,8 @@ struct toy_metadata {
     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,
     };
 
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 77ad3ec30..987e55240 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 {
@@ -29,6 +30,7 @@ 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 +57,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 +71,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 +108,16 @@ 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 ac196ee6a..8d7bc8e80 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
@@ -59,9 +59,10 @@ struct helix_intersection_update {
         // 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,8 +74,7 @@ struct helix_intersection_update {
                 }
 
             } else if constexpr (std::is_same_v<
-                                     typename mask_group_t::value_type::
-                                         intersector_type,
+                                     typename mask_t::shape::template intersector_type<transform3_type>,
                                      cylinder_intersector_type>) {
 
                 auto sfi = std::move(helix_cylinder_intersector_type()(
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 3758ca447..983bf145f 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/test_surfaces.hpp b/tests/common/include/tests/common/tools/test_surfaces.hpp
index c906f720a..8255517c5 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 7f5449e14..ac21d689c 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,7 @@ 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 +78,7 @@ 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 +91,10 @@ 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 +126,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 +136,9 @@ 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 ef038a05f..50934083f 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;
 
@@ -84,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>(),
@@ -176,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>(),
diff --git a/tests/common/include/tests/common/tools_line_intersection.inl b/tests/common/include/tests/common/tools_line_intersection.inl
index 9879c0998..62dccc2f2 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,7 @@ 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 0cf76300a..96c415452 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 4d83b0378..41510b13b 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 613c3a012..c3795b50f 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 1e3f7cce3..840bbf20a 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 8eaaeca55..12d12ebb3 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 920e54429..079a4db19 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 000000000..a135d7c1b
--- /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 000000000..2724f4533
--- /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 000000000..f29f06edf
--- /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 000000000..07ea1d9f9
--- /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 90a09e7b3..b1dc859b8 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 f2775a45f..eb141691f 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 6d014d62e..a5da1efbd 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 95a9f3aef..000000000
--- 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 000000000..c9c4c3d27
--- /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 9a7d536cb..cea15f475 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 2dd05c269..a940dd4d8 100644
--- a/tests/unit_tests/cuda/detector_cuda_kernel.cu
+++ b/tests/unit_tests/cuda/detector_cuda_kernel.cu
@@ -64,7 +64,7 @@ __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];
     }
diff --git a/tests/unit_tests/cuda/detector_cuda_kernel.hpp b/tests/unit_tests/cuda/detector_cuda_kernel.hpp
index 56588c4a2..b5ef047b4 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 d27cd3436..49ee09219 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.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{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_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>());
@@ -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_point3[i]));
+        output_host[4].push_back(annulus_mask.is_inside(input_point2[i]));
     }
 
     /** Helper object for performing memory copies. **/
diff --git a/tests/unit_tests/cuda/mask_store_cuda_kernel.cu b/tests/unit_tests/cuda/mask_store_cuda_kernel.cu
index 539804b3a..6998462d0 100644
--- a/tests/unit_tests/cuda/mask_store_cuda_kernel.cu
+++ b/tests/unit_tests/cuda/mask_store_cuda_kernel.cu
@@ -36,22 +36,16 @@ __global__ void mask_test_kernel(
     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_point3[i]));
+        output_device[4].push_back(annulus_mask.is_inside(input_point2[i]));
     }
 }
 
diff --git a/tests/unit_tests/cuda/mask_store_cuda_kernel.hpp b/tests/unit_tests/cuda/mask_store_cuda_kernel.hpp
index f0b994cc1..98d39911e 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,7 +60,7 @@ 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::jagged_vector_view<intersection::status>& output_data);
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 000000000..eefdce622
--- /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 000000000..1ed4649a9
--- /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 000000000..85966713b
--- /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 7dd1f3b60..9de27f73e 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 585765a00..c6a4978f0 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 5238a3ce6..de32d7e4d 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 000000000..4351ab8d7
--- /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 000000000..5cee43ba5
--- /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 000000000..5326dcead
--- /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 000000000..5f07c638d
--- /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 e0bfffa60..8a8e425c2 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 db9cf71c4..0afa74bff 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 544c7d15b..673f22d35 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 f4e7182a3..000000000
--- 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 000000000..a5df3e268
--- /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 48da55964..36eb63c7e 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 3165f58e4..f834ef7b1 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 4add20efa..a88386cb5 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 000000000..88021e66c
--- /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 000000000..a6147dcf5
--- /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 000000000..4d2441715
--- /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 000000000..4de07e37a
--- /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 dcadeb1c5..c33255468 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 6af7a0db2..5a7d30f52 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 d02d59567..7d2ed844e 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 b9e999b9a..000000000
--- 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 000000000..13c65482c
--- /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 2ac4cf172..b4f8be4d8 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 db6d80085..553592e6c 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 16090e89b..4e7157269 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 000000000..447655a3d
--- /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 000000000..f1486810f
--- /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 000000000..e579a045e
--- /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 000000000..a1275a5bf
--- /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 4aa2a8443..2c68c2bea 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 7f1e7f284..5bf9232c7 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 005afbaf3..013b6f6c5 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 e127297dd..000000000
--- 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 000000000..5dfb964f7
--- /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