From 2ce4198ef105ef82fbf37dfd7453c26782b1e175 Mon Sep 17 00:00:00 2001
From: Joana Niermann <joana.niermann@cern.ch>
Date: Fri, 7 Oct 2022 14:12:20 +0200
Subject: [PATCH] Grid implementation that addresses some issues found in the
 local navigation (grid navigation must be possible without reference
 surface). This PR provides:

 - 3D grids
 - Grid local coordinates for a global to local transform
 - Memory serialization: standalone grids and grids in grid collections
 - Implement populators, serializers and unittests, except for
   irregular attach populator.

Due to the 'operator==' not being a __device__ function, the
complete and attach populator unittests cannot pass the CI.

The PR also splits the geometric shape information (cylinder,
rectangle etc) from the navigation linking and boundary values, so
that they can be reused for the grid geometry definition. With that
comes the stringent use of local coordinates in the intersections
and some refactoring (renaming etc).
---
 core/CMakeLists.txt                           |  32 +-
 .../detray/coordinates/cylindrical2.hpp       |   4 +-
 core/include/detray/core/type_registry.hpp    |   3 +-
 .../include/detray/definitions/containers.hpp | 100 +++-
 .../detray/definitions/detail/accessor.hpp    |  41 ++
 core/include/detray/definitions/indexing.hpp  |  28 +-
 core/include/detray/grids/axis.hpp            |  16 +-
 core/include/detray/grids/grid2.hpp           |  10 +-
 core/include/detray/grids/populator.hpp       |   8 +-
 .../concentric_cylinder_intersector.hpp       |  11 +-
 .../intersection/cylinder_intersector.hpp     |  19 +-
 .../detray/intersection/plane_intersector.hpp |   8 +-
 core/include/detray/masks/annulus2.hpp        | 171 -------
 core/include/detray/masks/annulus2D.hpp       | 168 +++++++
 core/include/detray/masks/cuboid3D.hpp        | 108 +++++
 core/include/detray/masks/cylinder2D.hpp      | 111 +++++
 core/include/detray/masks/cylinder3.hpp       | 113 -----
 core/include/detray/masks/cylinder3D.hpp      | 106 +++++
 core/include/detray/masks/line.hpp            | 184 ++++----
 core/include/detray/masks/mask_base.hpp       | 120 -----
 core/include/detray/masks/masks.hpp           | 166 ++++++-
 core/include/detray/masks/rectangle2.hpp      | 104 -----
 core/include/detray/masks/rectangle2D.hpp     |  99 ++++
 core/include/detray/masks/ring2.hpp           | 106 -----
 core/include/detray/masks/ring2D.hpp          | 101 +++++
 core/include/detray/masks/single3.hpp         |  93 ----
 core/include/detray/masks/single3D.hpp        |  97 ++++
 core/include/detray/masks/trapezoid2.hpp      | 113 -----
 core/include/detray/masks/trapezoid2D.hpp     | 109 +++++
 core/include/detray/masks/unmasked.hpp        |  94 ++--
 .../detray/surface_finders/grid/axis.hpp      | 339 ++++++++++++++
 .../grid/detail/axis_binning.hpp              | 298 ++++++++++++
 .../grid/detail/axis_helpers.hpp              | 169 +++++++
 .../grid/detail/axis_shape.hpp                | 272 +++++++++++
 .../grid/detail/grid_helpers.hpp              |  99 ++++
 .../grid/detail/populator_impl.hpp            | 342 ++++++++++++++
 .../grid/detail/serializer_impl.hpp           | 134 ++++++
 .../detray/surface_finders/grid/grid.hpp      | 303 +++++++++++++
 .../surface_finders/grid/grid_builder.hpp     | 130 ++++++
 .../detray/surface_finders/grid/populator.hpp |  68 +++
 .../surface_finders/grid/serializer.hpp       |  11 +
 core/include/detray/tools/generators.hpp      |  49 +-
 core/include/detray/utils/enumerate.hpp       | 112 ++++-
 core/include/detray/utils/invalid_values.hpp  |  41 +-
 core/include/detray/utils/type_traits.hpp     |   4 +-
 .../tests/common/benchmark_find_volume.inl    |   3 -
 .../tests/common/benchmark_intersect_all.inl  |   3 -
 .../common/benchmark_intersect_surfaces.inl   |  22 +-
 .../include/tests/common/benchmark_masks.inl  | 226 ++++-----
 .../include/tests/common/coordinates.inl      |   2 +-
 .../include/tests/common/core_detector.inl    |   7 +-
 .../include/tests/common/core_mask_store.inl  |  34 +-
 .../common/include/tests/common/grid_axis.inl | 420 +++++++++++++++++
 .../common/include/tests/common/grid_grid.inl | 427 ++++++++++++++++++
 .../include/tests/common/grid_populator.inl   | 178 ++++++++
 .../include/tests/common/grid_serializer.inl  | 108 +++++
 .../include/tests/common/masks_annulus2.inl   |  82 ----
 .../include/tests/common/masks_annulus2D.inl  |  65 +++
 .../include/tests/common/masks_cylinder.inl   |  67 +++
 .../include/tests/common/masks_cylinder3.inl  |  52 ---
 .../include/tests/common/masks_line.inl       |  56 ++-
 .../include/tests/common/masks_rectangle2.inl |  43 --
 .../tests/common/masks_rectangle2D.inl        |  38 ++
 .../include/tests/common/masks_ring2.inl      |  51 ---
 .../include/tests/common/masks_ring2D.inl     |  35 ++
 .../include/tests/common/masks_single3.inl    |  93 ----
 .../include/tests/common/masks_single3D.inl   |  76 ++++
 .../include/tests/common/masks_trapezoid2.inl |  45 --
 .../tests/common/masks_trapezoid2D.inl        |  40 ++
 .../include/tests/common/masks_unmasked.inl   |  21 +-
 .../common/include/tests/common/materials.inl |   6 +-
 .../common/include/tests/common/test_core.inl |   6 +-
 .../common/include/tests/common/test_defs.hpp |   6 -
 .../tests/common/test_toy_geometry.inl        |  46 +-
 .../tools/create_telescope_detector.hpp       |   2 +-
 .../common/tools/create_toy_geometry.hpp      |  15 +-
 .../tests/common/tools/detector_metadata.hpp  |  32 +-
 .../helix_cylinder_intersector.hpp            |  21 +-
 .../helix_intersection_kernel.hpp             |  10 +-
 .../intersectors/helix_plane_intersector.hpp  |   7 +-
 .../tests/common/tools/test_surfaces.hpp      |   7 +-
 .../common/tools_cylinder_intersection.inl    |  49 +-
 .../common/tools_intersection_kernel.inl      |  30 +-
 .../tests/common/tools_line_intersection.inl  |  16 +-
 .../common/tools_planar_intersection.inl      |  25 +-
 .../include/tests/common/tools_stepper.inl    |   1 -
 .../include/tests/common/tools_track.inl      |   4 +-
 tests/unit_tests/array/CMakeLists.txt         |  55 ++-
 ...rray_cylinder3.cpp => array_annulus2D.cpp} |   2 +-
 .../{array_single3.cpp => array_cylinder.cpp} |   2 +-
 tests/unit_tests/array/array_grid.cpp         |   9 +
 tests/unit_tests/array/array_grid_axis.cpp    |   9 +
 .../unit_tests/array/array_grid_populator.cpp |   9 +
 .../array/array_grid_serializer.cpp           |   9 +
 ...y_rectangle2.cpp => array_rectangle2D.cpp} |   2 +-
 .../{array_ring2.cpp => array_ring2D.cpp}     |   2 +-
 ...{array_annulus2.cpp => array_single3D.cpp} |   2 +-
 tests/unit_tests/array/array_trapezoid2.cpp   |   9 -
 tests/unit_tests/array/array_trapezoid2D.cpp  |   9 +
 tests/unit_tests/cuda/CMakeLists.txt          |   2 +
 tests/unit_tests/cuda/detector_cuda_kernel.cu |   2 +-
 .../unit_tests/cuda/detector_cuda_kernel.hpp  |   2 +-
 tests/unit_tests/cuda/mask_store_cuda.cpp     |  32 +-
 .../unit_tests/cuda/mask_store_cuda_kernel.cu |  18 +-
 .../cuda/mask_store_cuda_kernel.hpp           |  16 +-
 .../unit_tests/cuda/sf_finders_grid_cuda.cpp  | 325 +++++++++++++
 .../cuda/sf_finders_grid_cuda_kernel.cu       | 206 +++++++++
 .../cuda/sf_finders_grid_cuda_kernel.hpp      | 115 +++++
 tests/unit_tests/eigen/CMakeLists.txt         |  55 ++-
 ...igen_cylinder3.cpp => eigen_annulus2D.cpp} |   2 +-
 .../{eigen_single3.cpp => eigen_cylinder.cpp} |   2 +-
 tests/unit_tests/eigen/eigen_grid.cpp         |   9 +
 tests/unit_tests/eigen/eigen_grid_axis.cpp    |   9 +
 .../unit_tests/eigen/eigen_grid_populator.cpp |   9 +
 .../eigen/eigen_grid_serializer.cpp           |   9 +
 ...n_rectangle2.cpp => eigen_rectangle2D.cpp} |   2 +-
 .../{eigen_ring2.cpp => eigen_ring2D.cpp}     |   2 +-
 ...{eigen_annulus2.cpp => eigen_single3D.cpp} |   2 +-
 tests/unit_tests/eigen/eigen_trapezoid2.cpp   |   9 -
 tests/unit_tests/eigen/eigen_trapezoid2D.cpp  |   9 +
 tests/unit_tests/smatrix/CMakeLists.txt       |  56 ++-
 ...ix_cylinder3.cpp => smatrix_annulus2D.cpp} |   2 +-
 ...trix_annulus2.cpp => smatrix_cylinder.cpp} |   2 +-
 tests/unit_tests/smatrix/smatrix_grid.cpp     |   9 +
 .../unit_tests/smatrix/smatrix_grid_axis.cpp  |   9 +
 .../smatrix/smatrix_grid_populator.cpp        |   9 +
 .../smatrix/smatrix_grid_serializer.cpp       |   9 +
 ...rectangle2.cpp => smatrix_rectangle2D.cpp} |   2 +-
 .../{smatrix_ring2.cpp => smatrix_ring2D.cpp} |   2 +-
 ...atrix_single3.cpp => smatrix_single3D.cpp} |   2 +-
 .../unit_tests/smatrix/smatrix_trapezoid2.cpp |   9 -
 .../smatrix/smatrix_trapezoid2D.cpp           |   9 +
 tests/unit_tests/vc/CMakeLists.txt            |  55 ++-
 ...y_cylinder3.cpp => vc_array_annulus2D.cpp} |   2 +-
 ...rray_single3.cpp => vc_array_cylinder.cpp} |   2 +-
 tests/unit_tests/vc/vc_array_grid.cpp         |   9 +
 tests/unit_tests/vc/vc_array_grid_axis.cpp    |   9 +
 .../unit_tests/vc/vc_array_grid_populator.cpp |   9 +
 .../vc/vc_array_grid_serializer.cpp           |   9 +
 ...ectangle2.cpp => vc_array_rectangle2D.cpp} |   2 +-
 ...vc_array_ring2.cpp => vc_array_ring2D.cpp} |   2 +-
 ...ray_annulus2.cpp => vc_array_single3D.cpp} |   2 +-
 tests/unit_tests/vc/vc_array_trapezoid2.cpp   |   9 -
 tests/unit_tests/vc/vc_array_trapezoid2D.cpp  |   9 +
 144 files changed, 6555 insertions(+), 1931 deletions(-)
 delete mode 100644 core/include/detray/masks/annulus2.hpp
 create mode 100644 core/include/detray/masks/annulus2D.hpp
 create mode 100644 core/include/detray/masks/cuboid3D.hpp
 create mode 100644 core/include/detray/masks/cylinder2D.hpp
 delete mode 100644 core/include/detray/masks/cylinder3.hpp
 create mode 100644 core/include/detray/masks/cylinder3D.hpp
 delete mode 100644 core/include/detray/masks/mask_base.hpp
 delete mode 100644 core/include/detray/masks/rectangle2.hpp
 create mode 100644 core/include/detray/masks/rectangle2D.hpp
 delete mode 100644 core/include/detray/masks/ring2.hpp
 create mode 100644 core/include/detray/masks/ring2D.hpp
 delete mode 100644 core/include/detray/masks/single3.hpp
 create mode 100644 core/include/detray/masks/single3D.hpp
 delete mode 100644 core/include/detray/masks/trapezoid2.hpp
 create mode 100644 core/include/detray/masks/trapezoid2D.hpp
 create mode 100644 core/include/detray/surface_finders/grid/axis.hpp
 create mode 100644 core/include/detray/surface_finders/grid/detail/axis_binning.hpp
 create mode 100644 core/include/detray/surface_finders/grid/detail/axis_helpers.hpp
 create mode 100644 core/include/detray/surface_finders/grid/detail/axis_shape.hpp
 create mode 100644 core/include/detray/surface_finders/grid/detail/grid_helpers.hpp
 create mode 100644 core/include/detray/surface_finders/grid/detail/populator_impl.hpp
 create mode 100644 core/include/detray/surface_finders/grid/detail/serializer_impl.hpp
 create mode 100644 core/include/detray/surface_finders/grid/grid.hpp
 create mode 100644 core/include/detray/surface_finders/grid/grid_builder.hpp
 create mode 100644 core/include/detray/surface_finders/grid/populator.hpp
 create mode 100644 core/include/detray/surface_finders/grid/serializer.hpp
 create mode 100644 tests/common/include/tests/common/grid_axis.inl
 create mode 100644 tests/common/include/tests/common/grid_grid.inl
 create mode 100644 tests/common/include/tests/common/grid_populator.inl
 create mode 100644 tests/common/include/tests/common/grid_serializer.inl
 delete mode 100644 tests/common/include/tests/common/masks_annulus2.inl
 create mode 100644 tests/common/include/tests/common/masks_annulus2D.inl
 create mode 100644 tests/common/include/tests/common/masks_cylinder.inl
 delete mode 100644 tests/common/include/tests/common/masks_cylinder3.inl
 delete mode 100644 tests/common/include/tests/common/masks_rectangle2.inl
 create mode 100644 tests/common/include/tests/common/masks_rectangle2D.inl
 delete mode 100644 tests/common/include/tests/common/masks_ring2.inl
 create mode 100644 tests/common/include/tests/common/masks_ring2D.inl
 delete mode 100644 tests/common/include/tests/common/masks_single3.inl
 create mode 100644 tests/common/include/tests/common/masks_single3D.inl
 delete mode 100644 tests/common/include/tests/common/masks_trapezoid2.inl
 create mode 100644 tests/common/include/tests/common/masks_trapezoid2D.inl
 rename tests/unit_tests/array/{array_cylinder3.cpp => array_annulus2D.cpp} (82%)
 rename tests/unit_tests/array/{array_single3.cpp => array_cylinder.cpp} (83%)
 create mode 100644 tests/unit_tests/array/array_grid.cpp
 create mode 100644 tests/unit_tests/array/array_grid_axis.cpp
 create mode 100644 tests/unit_tests/array/array_grid_populator.cpp
 create mode 100644 tests/unit_tests/array/array_grid_serializer.cpp
 rename tests/unit_tests/array/{array_rectangle2.cpp => array_rectangle2D.cpp} (82%)
 rename tests/unit_tests/array/{array_ring2.cpp => array_ring2D.cpp} (84%)
 rename tests/unit_tests/array/{array_annulus2.cpp => array_single3D.cpp} (83%)
 delete mode 100644 tests/unit_tests/array/array_trapezoid2.cpp
 create mode 100644 tests/unit_tests/array/array_trapezoid2D.cpp
 create mode 100644 tests/unit_tests/cuda/sf_finders_grid_cuda.cpp
 create mode 100644 tests/unit_tests/cuda/sf_finders_grid_cuda_kernel.cu
 create mode 100644 tests/unit_tests/cuda/sf_finders_grid_cuda_kernel.hpp
 rename tests/unit_tests/eigen/{eigen_cylinder3.cpp => eigen_annulus2D.cpp} (82%)
 rename tests/unit_tests/eigen/{eigen_single3.cpp => eigen_cylinder.cpp} (83%)
 create mode 100644 tests/unit_tests/eigen/eigen_grid.cpp
 create mode 100644 tests/unit_tests/eigen/eigen_grid_axis.cpp
 create mode 100644 tests/unit_tests/eigen/eigen_grid_populator.cpp
 create mode 100644 tests/unit_tests/eigen/eigen_grid_serializer.cpp
 rename tests/unit_tests/eigen/{eigen_rectangle2.cpp => eigen_rectangle2D.cpp} (82%)
 rename tests/unit_tests/eigen/{eigen_ring2.cpp => eigen_ring2D.cpp} (84%)
 rename tests/unit_tests/eigen/{eigen_annulus2.cpp => eigen_single3D.cpp} (83%)
 delete mode 100644 tests/unit_tests/eigen/eigen_trapezoid2.cpp
 create mode 100644 tests/unit_tests/eigen/eigen_trapezoid2D.cpp
 rename tests/unit_tests/smatrix/{smatrix_cylinder3.cpp => smatrix_annulus2D.cpp} (83%)
 rename tests/unit_tests/smatrix/{smatrix_annulus2.cpp => smatrix_cylinder.cpp} (83%)
 create mode 100644 tests/unit_tests/smatrix/smatrix_grid.cpp
 create mode 100644 tests/unit_tests/smatrix/smatrix_grid_axis.cpp
 create mode 100644 tests/unit_tests/smatrix/smatrix_grid_populator.cpp
 create mode 100644 tests/unit_tests/smatrix/smatrix_grid_serializer.cpp
 rename tests/unit_tests/smatrix/{smatrix_rectangle2.cpp => smatrix_rectangle2D.cpp} (82%)
 rename tests/unit_tests/smatrix/{smatrix_ring2.cpp => smatrix_ring2D.cpp} (84%)
 rename tests/unit_tests/smatrix/{smatrix_single3.cpp => smatrix_single3D.cpp} (83%)
 delete mode 100644 tests/unit_tests/smatrix/smatrix_trapezoid2.cpp
 create mode 100644 tests/unit_tests/smatrix/smatrix_trapezoid2D.cpp
 rename tests/unit_tests/vc/{vc_array_cylinder3.cpp => vc_array_annulus2D.cpp} (83%)
 rename tests/unit_tests/vc/{vc_array_single3.cpp => vc_array_cylinder.cpp} (83%)
 create mode 100644 tests/unit_tests/vc/vc_array_grid.cpp
 create mode 100644 tests/unit_tests/vc/vc_array_grid_axis.cpp
 create mode 100644 tests/unit_tests/vc/vc_array_grid_populator.cpp
 create mode 100644 tests/unit_tests/vc/vc_array_grid_serializer.cpp
 rename tests/unit_tests/vc/{vc_array_rectangle2.cpp => vc_array_rectangle2D.cpp} (82%)
 rename tests/unit_tests/vc/{vc_array_ring2.cpp => vc_array_ring2D.cpp} (84%)
 rename tests/unit_tests/vc/{vc_array_annulus2.cpp => vc_array_single3D.cpp} (83%)
 delete mode 100644 tests/unit_tests/vc/vc_array_trapezoid2.cpp
 create mode 100644 tests/unit_tests/vc/vc_array_trapezoid2D.cpp

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