From d2e46a38f0a13e5abfcfde2c1f7f087356f92782 Mon Sep 17 00:00:00 2001
From: beomki-yeo <beomki.yeo@gmail.com>
Date: Thu, 17 Aug 2023 14:44:53 +0200
Subject: [PATCH 01/29] Refactor measurement ordering

---
 .../include/detray/coordinates/cartesian2.hpp |  5 +++--
 .../detray/coordinates/coordinate_base.hpp    | 12 +++++-----
 .../detray/coordinates/cylindrical2.hpp       |  5 +++--
 core/include/detray/coordinates/line2.hpp     |  7 +++---
 core/include/detray/coordinates/polar2.hpp    |  5 +++--
 core/include/detray/masks/annulus2D.hpp       |  5 +----
 core/include/detray/masks/cylinder2D.hpp      |  5 +----
 core/include/detray/masks/line.hpp            |  5 +----
 core/include/detray/masks/masks.hpp           |  8 ++++---
 core/include/detray/masks/rectangle2D.hpp     |  5 +----
 core/include/detray/masks/ring2D.hpp          |  5 +----
 core/include/detray/masks/single3D.hpp        |  5 +----
 core/include/detray/masks/trapezoid2D.hpp     |  5 +----
 core/include/detray/masks/unbounded.hpp       |  3 ---
 tests/unit_tests/cpu/masks_annulus2D.cpp      |  1 +
 tests/unit_tests/cpu/projection_matrix.cpp    | 22 ++++++++++++-------
 .../validation/src/simulation_validation.cpp  |  8 +++----
 .../include/detray/tutorial/my_square2D.hpp   |  4 ++--
 .../detray/simulation/measurement_smearer.hpp |  5 ++---
 19 files changed, 54 insertions(+), 66 deletions(-)

diff --git a/core/include/detray/coordinates/cartesian2.hpp b/core/include/detray/coordinates/cartesian2.hpp
index a38625750..9c20595cb 100644
--- a/core/include/detray/coordinates/cartesian2.hpp
+++ b/core/include/detray/coordinates/cartesian2.hpp
@@ -158,10 +158,11 @@ struct cartesian2 final : public coordinate_base<cartesian2, transform3_t> {
         // Do nothing
     }
 
-    template <size_type meas_dim, bool normal_order>
+    template <size_type meas_dim>
     DETRAY_HOST_DEVICE inline void unsigned_local(
         matrix_type<meas_dim, e_bound_size> & /*projection_matrix*/,
-        const bound_track_parameters<transform3_t> & /*bound_params*/) {
+        const bound_track_parameters<transform3_t> & /*bound_params*/,
+        const bool /*normal_order*/) {
         // Do nothing
         return;
     }
diff --git a/core/include/detray/coordinates/coordinate_base.hpp b/core/include/detray/coordinates/coordinate_base.hpp
index e5b6dfb8f..5709b1155 100644
--- a/core/include/detray/coordinates/coordinate_base.hpp
+++ b/core/include/detray/coordinates/coordinate_base.hpp
@@ -241,15 +241,15 @@ struct coordinate_base {
     }
 
     /// @returns the projection matrix for measurement
-    template <size_type meas_dim, bool normal_order>
+    template <size_type meas_dim>
     DETRAY_HOST_DEVICE inline matrix_type<meas_dim, e_bound_size>
-    projection_matrix(
-        const bound_track_parameters<transform3_t>& bound_params) {
+    projection_matrix(const bound_track_parameters<transform3_t>& bound_params,
+                      const bool normal_order) {
 
         matrix_type<meas_dim, e_bound_size> proj =
             matrix_operator().template zero<meas_dim, e_bound_size>();
         // For normal ordering
-        if constexpr (normal_order == true) {
+        if (normal_order == true) {
             // For meas_dim == 1, Return:
             // [ 1 0 0 0 0 0 ]
             if constexpr (meas_dim == 1u) {
@@ -279,8 +279,8 @@ struct coordinate_base {
             }
         }
 
-        Derived<transform3_t>().template unsigned_local<meas_dim, normal_order>(
-            proj, bound_params);
+        Derived<transform3_t>().template unsigned_local<meas_dim>(
+            proj, bound_params, normal_order);
 
         return proj;
     }
diff --git a/core/include/detray/coordinates/cylindrical2.hpp b/core/include/detray/coordinates/cylindrical2.hpp
index a3078fea2..7e17b479f 100644
--- a/core/include/detray/coordinates/cylindrical2.hpp
+++ b/core/include/detray/coordinates/cylindrical2.hpp
@@ -201,10 +201,11 @@ struct cylindrical2 : public coordinate_base<cylindrical2, transform3_t> {
         // Do nothing
     }
 
-    template <size_type meas_dim, bool normal_order>
+    template <size_type meas_dim>
     DETRAY_HOST_DEVICE inline void unsigned_local(
         matrix_type<meas_dim, e_bound_size> & /*projection_matrix*/,
-        const bound_track_parameters<transform3_t> & /*bound_params*/) {
+        const bound_track_parameters<transform3_t> & /*bound_params*/,
+        const bool /*normal_order*/) {
         // Do nothing
         return;
     }
diff --git a/core/include/detray/coordinates/line2.hpp b/core/include/detray/coordinates/line2.hpp
index 54eb47c3f..035ba9abe 100644
--- a/core/include/detray/coordinates/line2.hpp
+++ b/core/include/detray/coordinates/line2.hpp
@@ -285,16 +285,17 @@ struct line2 : public coordinate_base<line2, transform3_t> {
             theta_to_free_pos_derivative[2];
     }
 
-    template <size_type meas_dim, bool normal_order>
+    template <size_type meas_dim>
     DETRAY_HOST_DEVICE inline void unsigned_local(
         matrix_type<meas_dim, e_bound_size> &projection_matrix,
-        const bound_track_parameters<transform3_t> &bound_params) {
+        const bound_track_parameters<transform3_t> &bound_params,
+        const bool normal_order) {
 
         const auto bound_local = bound_params.bound_local();
 
         // Change the sign of radial distance if it is negative
         if (bound_local[0] < 0.f) {
-            if constexpr (normal_order == true) {
+            if (normal_order == true) {
                 matrix_operator().element(projection_matrix, 0u, 0u) = -1.f;
             } else {
                 if constexpr (meas_dim == 2u) {
diff --git a/core/include/detray/coordinates/polar2.hpp b/core/include/detray/coordinates/polar2.hpp
index 1bb73b5f4..8233c0c8e 100644
--- a/core/include/detray/coordinates/polar2.hpp
+++ b/core/include/detray/coordinates/polar2.hpp
@@ -211,10 +211,11 @@ struct polar2 : public coordinate_base<polar2, transform3_t> {
         // Do nothing
     }
 
-    template <size_type meas_dim, bool normal_order>
+    template <size_type meas_dim>
     DETRAY_HOST_DEVICE inline void unsigned_local(
         matrix_type<meas_dim, e_bound_size> & /*projection_matrix*/,
-        const bound_track_parameters<transform3_t> & /*bound_params*/) {
+        const bound_track_parameters<transform3_t> & /*bound_params*/,
+        const bool /*normal_order*/) {
         // Do nothing
         return;
     }
diff --git a/core/include/detray/masks/annulus2D.hpp b/core/include/detray/masks/annulus2D.hpp
index fc32309d1..02c6f7372 100644
--- a/core/include/detray/masks/annulus2D.hpp
+++ b/core/include/detray/masks/annulus2D.hpp
@@ -50,7 +50,7 @@ namespace detray {
 /// included (bounds[4], bounds[5]). These are the origin shift in x and y
 /// respectively.
 template <template <typename> class intersector_t = plane_intersector,
-          unsigned int kMeasDim = 1u, bool kNormalOrder = false>
+          unsigned int kMeasDim = 1u>
 class annulus2D {
     public:
     /// The name for this shape
@@ -59,9 +59,6 @@ class annulus2D {
     /// The measurement dimension
     inline static constexpr const unsigned int meas_dim{kMeasDim};
 
-    /// Normal ordering
-    inline static constexpr const bool normal_order{kNormalOrder};
-
     // Measurement dimension check
     static_assert(meas_dim == 1u || meas_dim == 2u,
                   "Only 1D or 2D measurement is allowed");
diff --git a/core/include/detray/masks/cylinder2D.hpp b/core/include/detray/masks/cylinder2D.hpp
index e1024cc78..76979d051 100644
--- a/core/include/detray/masks/cylinder2D.hpp
+++ b/core/include/detray/masks/cylinder2D.hpp
@@ -37,7 +37,7 @@ namespace detray {
 /// 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,
-          unsigned int kMeasDim = 2u, bool kNormalOrder = true>
+          unsigned int kMeasDim = 2u>
 class cylinder2D {
     public:
     /// The name for this shape
@@ -49,9 +49,6 @@ class cylinder2D {
     /// The measurement dimension
     inline static constexpr const unsigned int meas_dim{kMeasDim};
 
-    /// Normal ordering
-    inline static constexpr const bool normal_order{kNormalOrder};
-
     // Measurement dimension check
     static_assert(meas_dim == 1u || meas_dim == 2u,
                   "Only 1D or 2D measurement is allowed");
diff --git a/core/include/detray/masks/line.hpp b/core/include/detray/masks/line.hpp
index b6a5f3e54..66e4d3c46 100644
--- a/core/include/detray/masks/line.hpp
+++ b/core/include/detray/masks/line.hpp
@@ -41,7 +41,7 @@ namespace detray {
 /// in z.
 template <bool kSquareCrossSect = false,
           template <typename> class intersector_t = line_intersector,
-          unsigned int kMeasDim = 1u, bool kNormalOrder = true>
+          unsigned int kMeasDim = 1u>
 class line {
     public:
     /// The name for this shape
@@ -53,9 +53,6 @@ class line {
     /// The measurement dimension
     inline static constexpr const unsigned int meas_dim{kMeasDim};
 
-    /// Normal ordering
-    inline static constexpr const bool normal_order{kNormalOrder};
-
     // Measurement dimension check
     static_assert(meas_dim == 1u || meas_dim == 2u,
                   "Only 1D or 2D measurement is allowed");
diff --git a/core/include/detray/masks/masks.hpp b/core/include/detray/masks/masks.hpp
index 027602509..cce7f39b7 100644
--- a/core/include/detray/masks/masks.hpp
+++ b/core/include/detray/masks/masks.hpp
@@ -65,6 +65,9 @@ class mask {
     using matrix_type = typename algebra_t::template matrix_type<ROWS, COLS>;
     using projection_matrix_type = matrix_type<shape::meas_dim, e_bound_size>;
 
+    // Measurement ordering
+    bool normal_order = true;
+
     /// Default constructor
     constexpr mask() = default;
 
@@ -197,9 +200,8 @@ class mask {
     /// @returns the projection matrix for measurement
     DETRAY_HOST_DEVICE projection_matrix_type projection_matrix(
         const bound_track_parameters<algebra_t>& bound_params) const {
-        return this->local_frame()
-            .template projection_matrix<shape::meas_dim, shape::normal_order>(
-                bound_params);
+        return this->local_frame().template projection_matrix<shape::meas_dim>(
+            bound_params, normal_order);
     }
 
     /// @brief Lower and upper point for minimum axis aligned bounding box.
diff --git a/core/include/detray/masks/rectangle2D.hpp b/core/include/detray/masks/rectangle2D.hpp
index fac195a68..6de045537 100644
--- a/core/include/detray/masks/rectangle2D.hpp
+++ b/core/include/detray/masks/rectangle2D.hpp
@@ -33,7 +33,7 @@ namespace detray {
 ///
 /// It is defined by half length in local0 coordinates bounds[0] and bounds[1]
 template <template <typename> class intersector_t = plane_intersector,
-          unsigned int kMeasDim = 2u, bool kNormalOrder = true>
+          unsigned int kMeasDim = 2u>
 class rectangle2D {
     public:
     /// The name for this shape
@@ -42,9 +42,6 @@ class rectangle2D {
     /// The measurement dimension
     inline static constexpr const unsigned int meas_dim{kMeasDim};
 
-    /// Normal ordering
-    inline static constexpr const bool normal_order{kNormalOrder};
-
     // Measurement dimension check
     static_assert(meas_dim == 1u || meas_dim == 2u,
                   "Only 1D or 2D measurement is allowed");
diff --git a/core/include/detray/masks/ring2D.hpp b/core/include/detray/masks/ring2D.hpp
index 8293788af..5a6a68815 100644
--- a/core/include/detray/masks/ring2D.hpp
+++ b/core/include/detray/masks/ring2D.hpp
@@ -34,7 +34,7 @@ namespace detray {
 /// 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,
-          unsigned int kMeasDim = 2u, bool kNormalOrder = true>
+          unsigned int kMeasDim = 2u>
 class ring2D {
     public:
     /// The name for this shape
@@ -43,9 +43,6 @@ class ring2D {
     /// The measurement dimension
     inline static constexpr const unsigned int meas_dim{kMeasDim};
 
-    /// Normal ordering
-    inline static constexpr const bool normal_order{kNormalOrder};
-
     // Measurement dimension check
     static_assert(meas_dim == 1u || meas_dim == 2u,
                   "Only 1D or 2D measurement is allowed");
diff --git a/core/include/detray/masks/single3D.hpp b/core/include/detray/masks/single3D.hpp
index 5cf810864..0b9550962 100644
--- a/core/include/detray/masks/single3D.hpp
+++ b/core/include/detray/masks/single3D.hpp
@@ -35,7 +35,7 @@ namespace detray {
 /// the local coordinate system
 template <unsigned int kCheckIndex = 0u,
           template <typename> class intersector_t = plane_intersector,
-          unsigned int kMeasDim = 2u, bool kNormalOrder = true>
+          unsigned int kMeasDim = 2u>
 class single3D {
     public:
     /// The name for this shape
@@ -44,9 +44,6 @@ class single3D {
     /// The measurement dimension
     inline static constexpr const unsigned int meas_dim{kMeasDim};
 
-    /// Normal ordering
-    inline static constexpr const bool normal_order{kNormalOrder};
-
     enum boundaries : unsigned int {
         e_lower = 0u,
         e_upper = 1u,
diff --git a/core/include/detray/masks/trapezoid2D.hpp b/core/include/detray/masks/trapezoid2D.hpp
index cb7cb01b7..d5c2c7f3f 100644
--- a/core/include/detray/masks/trapezoid2D.hpp
+++ b/core/include/detray/masks/trapezoid2D.hpp
@@ -36,7 +36,7 @@ namespace detray {
 /// the precomputed value of 1 / (2 * bounds[2]), which avoids
 /// excessive floating point divisions.
 template <template <typename> class intersector_t = plane_intersector,
-          unsigned int kMeasDim = 2u, bool kNormalOrder = true>
+          unsigned int kMeasDim = 2u>
 class trapezoid2D {
     public:
     /// The name for this shape
@@ -45,9 +45,6 @@ class trapezoid2D {
     /// The measurement dimension
     inline static constexpr const unsigned int meas_dim{kMeasDim};
 
-    /// Normal ordering
-    inline static constexpr const bool normal_order{kNormalOrder};
-
     // Measurement dimension check
     static_assert(meas_dim == 1u || meas_dim == 2u,
                   "Only 1D or 2D measurement is allowed");
diff --git a/core/include/detray/masks/unbounded.hpp b/core/include/detray/masks/unbounded.hpp
index d23f036bf..baf8a5b8e 100644
--- a/core/include/detray/masks/unbounded.hpp
+++ b/core/include/detray/masks/unbounded.hpp
@@ -32,9 +32,6 @@ class unbounded {
     /// The measurement dimension
     inline static constexpr const std::size_t meas_dim = shape::meas_dim;
 
-    /// normal ordering
-    inline static constexpr const bool normal_order = shape::normal_order;
-
     /// Local coordinate frame for boundary checks
     template <typename algebra_t>
     using local_frame_type =
diff --git a/tests/unit_tests/cpu/masks_annulus2D.cpp b/tests/unit_tests/cpu/masks_annulus2D.cpp
index d2392d51a..8f6935188 100644
--- a/tests/unit_tests/cpu/masks_annulus2D.cpp
+++ b/tests/unit_tests/cpu/masks_annulus2D.cpp
@@ -44,6 +44,7 @@ GTEST_TEST(detray_masks, annulus2D) {
 
     mask<annulus2D<>> ann2{0u,     minR, maxR,      minPhi,
                            maxPhi, 0.f,  offset[0], offset[1]};
+    ann2.normal_order = false;
 
     ASSERT_NEAR(ann2[annulus2D<>::e_min_r], 7.2f, tol);
     ASSERT_NEAR(ann2[annulus2D<>::e_max_r], 12.0f, tol);
diff --git a/tests/unit_tests/cpu/projection_matrix.cpp b/tests/unit_tests/cpu/projection_matrix.cpp
index 204fa2e16..07dea81d0 100644
--- a/tests/unit_tests/cpu/projection_matrix.cpp
+++ b/tests/unit_tests/cpu/projection_matrix.cpp
@@ -39,7 +39,8 @@ GTEST_TEST(detray_masks, projection_matrix_rectangle) {
     }
 
     // 2D, reverse ordering
-    mask<rectangle2D<plane_intersector, 2u, false>> rec_1{0u, 0.f, 0.f};
+    mask<rectangle2D<plane_intersector, 2u>> rec_1{0u, 0.f, 0.f};
+    rec_1.normal_order = false;
 
     // Check the projection matrix
     // [ 0 1 0 0 0 0 ]
@@ -72,7 +73,8 @@ GTEST_TEST(detray_masks, projection_matrix_rectangle) {
     }
 
     // 1D, reverse ordering
-    mask<rectangle2D<plane_intersector, 1u, false>> rec_3{0u, 0.f, 0.f};
+    mask<rectangle2D<plane_intersector, 1u>> rec_3{0u, 0.f, 0.f};
+    rec_3.normal_order = false;
 
     // Check the projection matrix
     // [ 0 1 0 0 0 0 ]
@@ -94,6 +96,7 @@ TEST(projection_matrix, annulus) {
 
     // 1D reverse ordering
     mask<annulus2D<>> ann_0{0u, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f};
+    ann_0.normal_order = false;
 
     // Check the projection matrix
     // [ 0 1 0 0 0 0 ]
@@ -109,8 +112,8 @@ TEST(projection_matrix, annulus) {
     }
 
     // 1D normal ordering
-    mask<annulus2D<plane_intersector, 1u, true>> ann_1{0u,  0.f, 0.f, 0.f,
-                                                       0.f, 0.f, 0.f, 0.f};
+    mask<annulus2D<plane_intersector, 1u>> ann_1{0u,  0.f, 0.f, 0.f,
+                                                 0.f, 0.f, 0.f, 0.f};
 
     // Check the projection matrix
     // [ 1 0 0 0 0 0 ]
@@ -128,6 +131,7 @@ TEST(projection_matrix, annulus) {
     // 2D reverse ordering
     mask<annulus2D<plane_intersector, 2u>> ann_2{0u,  0.f, 0.f, 0.f,
                                                  0.f, 0.f, 0.f, 0.f};
+    ann_2.normal_order = false;
 
     // Check the projection matrix
     // [ 0 1 0 0 0 0 ]
@@ -144,8 +148,8 @@ TEST(projection_matrix, annulus) {
     }
 
     // 2D normal ordering
-    mask<annulus2D<plane_intersector, 2u, true>> ann_3{0u,  0.f, 0.f, 0.f,
-                                                       0.f, 0.f, 0.f, 0.f};
+    mask<annulus2D<plane_intersector, 2u>> ann_3{0u,  0.f, 0.f, 0.f,
+                                                 0.f, 0.f, 0.f, 0.f};
 
     // Check the projection matrix
     // [ 1 0 0 0 0 0 ]
@@ -185,7 +189,8 @@ TEST(projection_matrix, line) {
     }
 
     // 1D reverse ordering
-    mask<line<false, line_intersector, 1u, false>> ln_1{0u, 0.f, 0.f};
+    mask<line<false, line_intersector, 1u>> ln_1{0u, 0.f, 0.f};
+    ln_1.normal_order = false;
 
     // Check the projection matrix
     // [ 0 1 0 0 0 0 ]
@@ -220,7 +225,8 @@ TEST(projection_matrix, line) {
     }
 
     // 2D reverse ordering
-    mask<line<false, line_intersector, 2u, false>> ln_3{0u, 0.f, 0.f};
+    mask<line<false, line_intersector, 2u>> ln_3{0u, 0.f, 0.f};
+    ln_3.normal_order = false;
 
     // Check the projection matrix
     // [ 0 1 0 0 0 0 ]
diff --git a/tests/validation/src/simulation_validation.cpp b/tests/validation/src/simulation_validation.cpp
index 94dce4468..3e8d63f02 100644
--- a/tests/validation/src/simulation_validation.cpp
+++ b/tests/validation/src/simulation_validation.cpp
@@ -35,16 +35,16 @@ constexpr scalar tol{1e-7f};
 // Test measurement smearer
 GTEST_TEST(detray_simulation, measurement_smearer) {
 
-    const mask<line<false, line_intersector, 1u, true>> ln_1D{
+    const mask<line<false, line_intersector, 1u>> ln_1D{
         0u, 10.f * unit<scalar>::mm, 50.f * unit<scalar>::mm};
 
-    const mask<line<false, line_intersector, 2u, true>> ln_2D{
+    const mask<line<false, line_intersector, 2u>> ln_2D{
         0u, 10.f * unit<scalar>::mm, 50.f * unit<scalar>::mm};
 
-    const mask<rectangle2D<plane_intersector, 1u, true>> re_1D{
+    const mask<rectangle2D<plane_intersector, 1u>> re_1D{
         0u, 10.f * unit<scalar>::mm, 10.f * unit<scalar>::mm};
 
-    const mask<rectangle2D<plane_intersector, 2u, true>> re_2D{
+    const mask<rectangle2D<plane_intersector, 2u>> re_2D{
         0u, 10.f * unit<scalar>::mm, 10.f * unit<scalar>::mm};
 
     bound_track_parameters<transform3> bound_params;
diff --git a/tutorials/include/detray/tutorial/my_square2D.hpp b/tutorials/include/detray/tutorial/my_square2D.hpp
index 2c91bee01..f21642c5c 100644
--- a/tutorials/include/detray/tutorial/my_square2D.hpp
+++ b/tutorials/include/detray/tutorial/my_square2D.hpp
@@ -29,7 +29,7 @@ namespace detray::tutorial {
 /// It is defined by the half length of the square (bounds[0]),
 /// and can be checked with a tolerance in t.
 template <template <typename> class intersector_t = plane_intersector,
-          unsigned int kMeasDim = 2u, bool kNormalOrder = true>
+          unsigned int kMeasDim = 2u>
 class square2D {
     public:
     /// The name for this shape
@@ -39,7 +39,7 @@ class square2D {
     inline static constexpr const unsigned int meas_dim{kMeasDim};
 
     /// Normal ordering
-    inline static constexpr const bool normal_order{kNormalOrder};
+    inline static constexpr const bool normal_order{true};
 
     // Measurement dimension check
     static_assert(meas_dim == 1u || meas_dim == 2u,
diff --git a/utils/include/detray/simulation/measurement_smearer.hpp b/utils/include/detray/simulation/measurement_smearer.hpp
index feb60dca8..28e82467c 100644
--- a/utils/include/detray/simulation/measurement_smearer.hpp
+++ b/utils/include/detray/simulation/measurement_smearer.hpp
@@ -61,8 +61,7 @@ struct measurement_smearer {
             ret[1u] = scalar_type{0.f};
             // Special treatment for line coordinate: we don't allow negative
             // radial distance
-            if (mask_t::shape::name == "line" &&
-                mask_t::shape::normal_order == true) {
+            if (mask_t::shape::name == "line" && mask.normal_order == true) {
                 ret[0u] = std::max(ret[0u], static_cast<scalar_type>(0.f));
             }
 
@@ -74,7 +73,7 @@ struct measurement_smearer {
             // radial distance
             if (mask_t::shape::name == "line") {
 
-                if constexpr (mask_t::shape::normal_order == true) {
+                if (mask.normal_order == true) {
                     ret[0u] = std::max(ret[0u], static_cast<scalar_type>(0.f));
                 } else {
                     ret[1u] = std::max(ret[1u], static_cast<scalar_type>(0.f));

From 2b6276a0266d584e1e13adfcebb6873eb400d666 Mon Sep 17 00:00:00 2001
From: Fred <92879080+fredevb@users.noreply.github.com>
Date: Mon, 21 Aug 2023 13:55:06 +0200
Subject: [PATCH 02/29] feat: visualization of surfaces (#535)

Added conversion from detray surfaces to actsvg proto surfaces/portals. Furthermore, added code for generating proto links to display detray volume links. A few notes regarding the implementation:

Proto Surface Generation (conversion/surface.hpp)
Using the functor in proto/utils/surface_functors.hpp, this converts the different types of detray surfaces on a case by case basis.

Proto Portal Generation (conversion/portal.hpp)
Uses the proto link and proto surface generation code to generate a proto portal.

Proto Link Generation (conversion/link.hpp)
Calculates the start and end point of the arrow to be displayed. This is also done case by case depending on the types of volumes participating in the link (see utils/surface_kernels.hpp).
---
 .../geometry/detail/surface_kernels.hpp       |  16 ++
 core/include/detray/geometry/surface.hpp      |  29 +-
 core/include/detray/masks/cylinder2D.hpp      |   2 +-
 core/include/detray/masks/masks.hpp           |  13 +
 core/include/detray/masks/rectangle2D.hpp     |   2 +-
 core/include/detray/masks/unbounded.hpp       |   8 +-
 core/include/detray/tools/generators.hpp      |   2 +-
 extern/actsvg/CMakeLists.txt                  |   4 +-
 plugins/CMakeLists.txt                        |   1 +
 plugins/svgtools/CMakeLists.txt               |  24 ++
 .../plugins/svgtools/conversion/link.hpp      |  45 +++
 .../plugins/svgtools/conversion/point.hpp     |  25 ++
 .../plugins/svgtools/conversion/portal.hpp    |  40 +++
 .../plugins/svgtools/conversion/surface.hpp   | 186 +++++++++++++
 .../plugins/svgtools/utils/link_utils.hpp     |  63 +++++
 .../plugins/svgtools/utils/mask_utils.hpp     |  43 +++
 .../svgtools/utils/surface_kernels.hpp        | 260 ++++++++++++++++++
 .../plugins/svgtools/utils/volume_utils.hpp   |  26 ++
 .../detray/plugins/svgtools/writer.hpp        |  48 ++++
 tests/unit_tests/CMakeLists.txt               |   1 +
 tests/unit_tests/svgtools/CMakeLists.txt      |  14 +
 tests/unit_tests/svgtools/masks.cpp           |  97 +++++++
 22 files changed, 939 insertions(+), 10 deletions(-)
 create mode 100644 plugins/svgtools/CMakeLists.txt
 create mode 100644 plugins/svgtools/include/detray/plugins/svgtools/conversion/link.hpp
 create mode 100644 plugins/svgtools/include/detray/plugins/svgtools/conversion/point.hpp
 create mode 100644 plugins/svgtools/include/detray/plugins/svgtools/conversion/portal.hpp
 create mode 100644 plugins/svgtools/include/detray/plugins/svgtools/conversion/surface.hpp
 create mode 100644 plugins/svgtools/include/detray/plugins/svgtools/utils/link_utils.hpp
 create mode 100644 plugins/svgtools/include/detray/plugins/svgtools/utils/mask_utils.hpp
 create mode 100644 plugins/svgtools/include/detray/plugins/svgtools/utils/surface_kernels.hpp
 create mode 100644 plugins/svgtools/include/detray/plugins/svgtools/utils/volume_utils.hpp
 create mode 100644 plugins/svgtools/include/detray/plugins/svgtools/writer.hpp
 create mode 100644 tests/unit_tests/svgtools/CMakeLists.txt
 create mode 100644 tests/unit_tests/svgtools/masks.cpp

diff --git a/core/include/detray/geometry/detail/surface_kernels.hpp b/core/include/detray/geometry/detail/surface_kernels.hpp
index 00fe9df9d..860473c0e 100644
--- a/core/include/detray/geometry/detail/surface_kernels.hpp
+++ b/core/include/detray/geometry/detail/surface_kernels.hpp
@@ -13,6 +13,7 @@
 #include "detray/tracks/tracks.hpp"
 
 // System include(s)
+#include <limits>
 #include <ostream>
 
 namespace detray::detail {
@@ -211,6 +212,21 @@ struct surface_kernels {
             return m.local_frame().path_correction(pos, dir, dtds, trf3);
         }
     };
+
+    /// A functor to get the local min bounds.
+    struct local_min_bounds {
+
+        template <typename mask_group_t, typename index_t, typename scalar_t>
+        DETRAY_HOST_DEVICE inline auto operator()(
+            const mask_group_t& mask_group, const index_t& index,
+            const scalar_t env =
+                std::numeric_limits<scalar_t>::epsilon()) const {
+
+            const auto& m = mask_group[index];
+
+            return m.local_min_bounds(env);
+        }
+    };
 };
 
 }  // namespace detray::detail
diff --git a/core/include/detray/geometry/surface.hpp b/core/include/detray/geometry/surface.hpp
index 8a762f557..840f81be3 100644
--- a/core/include/detray/geometry/surface.hpp
+++ b/core/include/detray/geometry/surface.hpp
@@ -89,7 +89,7 @@ class surface {
     DETRAY_HOST_DEVICE
     constexpr auto volume() const -> dindex { return barcode().volume(); }
 
-    /// @returns the index fo the surface in the detector surface lookup
+    /// @returns the index of the surface in the detector surface lookup
     DETRAY_HOST_DEVICE
     constexpr auto index() const -> dindex { return barcode().index(); }
 
@@ -243,6 +243,33 @@ class surface {
                                                              pos, dir, dtds);
     }
 
+    /// @returns the vertices in local frame
+    DETRAY_HOST
+    constexpr auto local_vertices() const {
+        return visit_mask<typename kernels::local_vertices>();
+    }
+
+    /// @returns the vertices in global frame.
+    DETRAY_HOST
+    constexpr auto global_vertices(const context &ctx,
+                                   const vector3 &dir) const {
+        auto vertices = local_vertices();
+        for (size_t i = 0; i < vertices.size(); i++) {
+            vertices[i] = local_to_global(ctx, vertices[i], dir);
+        }
+        return vertices;
+    }
+
+    /// @brief Lower and upper point for minimal axis aligned bounding box.
+    ///
+    /// Computes the min and max vertices in a local cartesian frame.
+    DETRAY_HOST
+    constexpr auto local_min_bounds(
+        const scalar_type env =
+            std::numeric_limits<scalar_type>::epsilon()) const {
+        return visit_mask<typename kernels::local_min_bounds>(env);
+    }
+
     /// Call a functor on the surfaces mask with additional arguments.
     ///
     /// @tparam functor_t the prescription to be applied to the mask
diff --git a/core/include/detray/masks/cylinder2D.hpp b/core/include/detray/masks/cylinder2D.hpp
index e1024cc78..e4e661b5b 100644
--- a/core/include/detray/masks/cylinder2D.hpp
+++ b/core/include/detray/masks/cylinder2D.hpp
@@ -130,7 +130,7 @@ class cylinder2D {
     /// @param bounds the boundary values for this shape
     /// @param env dynamic envelope around the shape
     ///
-    /// @returns and array of coordinates that contains the lower point (first
+    /// @returns an array of coordinates that contains the lower point (first
     /// three values) and the upper point (latter three values) .
     template <typename algebra_t,
               template <typename, std::size_t> class bounds_t,
diff --git a/core/include/detray/masks/masks.hpp b/core/include/detray/masks/masks.hpp
index 027602509..3121119ce 100644
--- a/core/include/detray/masks/masks.hpp
+++ b/core/include/detray/masks/masks.hpp
@@ -220,6 +220,19 @@ class mask {
         return {bounds, std::numeric_limits<unsigned int>::max()};
     }
 
+    /// @brief Calculates the center of the min bounds bounding box.
+    /// @returns The center point in global cartesian coordinates.
+    template <typename transform3_t>
+    auto global_min_bounds_center(const transform3_t& trf) const {
+        const auto m = local_min_bounds();
+        const auto cuboid = m.get_shape();
+        const auto center{0.5f * (point3_t{m[cuboid.e_max_x], m[cuboid.e_max_y],
+                                           m[cuboid.e_max_z]} +
+                                  point3_t{m[cuboid.e_min_x], m[cuboid.e_min_y],
+                                           m[cuboid.e_min_z]})};
+        return trf.point_to_global(center);
+    }
+
     /// @returns true if the mask boundary values are consistent
     DETRAY_HOST
     constexpr bool self_check(std::ostream& os) const {
diff --git a/core/include/detray/masks/rectangle2D.hpp b/core/include/detray/masks/rectangle2D.hpp
index fac195a68..c48795273 100644
--- a/core/include/detray/masks/rectangle2D.hpp
+++ b/core/include/detray/masks/rectangle2D.hpp
@@ -112,7 +112,7 @@ class rectangle2D {
     /// @param bounds the boundary values for this shape
     /// @param env dynamic envelope around the shape
     ///
-    /// @returns and array of coordinates that contains the lower point (first
+    /// @returns an array of coordinates that contains the lower point (first
     /// three values) and the upper point (latter three values) .
     template <typename algebra_t,
               template <typename, std::size_t> class bounds_t,
diff --git a/core/include/detray/masks/unbounded.hpp b/core/include/detray/masks/unbounded.hpp
index d23f036bf..208ea7b49 100644
--- a/core/include/detray/masks/unbounded.hpp
+++ b/core/include/detray/masks/unbounded.hpp
@@ -54,7 +54,7 @@ class unbounded {
     /// @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 bounds_t& /*bounds*/, const point_t& /*loc_p*/,
         const scalar_t /*tol*/) const {
         return true;
     }
@@ -79,7 +79,7 @@ class unbounded {
         typename scalar_t, std::size_t kDIM,
         typename std::enable_if_t<kDIM == boundaries::e_size, bool> = true>
     DETRAY_HOST_DEVICE constexpr darray<scalar_t, 6> local_min_bounds(
-        const bounds_t<scalar_t, kDIM> &bounds,
+        const bounds_t<scalar_t, kDIM>& bounds,
         const scalar_t env = std::numeric_limits<scalar_t>::epsilon()) const {
         return shape{}.template local_min_bounds<algebra_t>(bounds, env);
     }
@@ -95,8 +95,8 @@ class unbounded {
         std::size_t kDIM,
         typename std::enable_if_t<kDIM == boundaries::e_size, bool> = true>
     DETRAY_HOST constexpr bool check_consistency(
-        const bounds_t<scalar_t, kDIM> & /*bounds*/,
-        std::ostream & /*os*/) const {
+        const bounds_t<scalar_t, kDIM>& /*bounds*/,
+        std::ostream& /*os*/) const {
         return true;
     }
 };
diff --git a/core/include/detray/tools/generators.hpp b/core/include/detray/tools/generators.hpp
index f651267ea..7f5d80f4e 100644
--- a/core/include/detray/tools/generators.hpp
+++ b/core/include/detray/tools/generators.hpp
@@ -28,7 +28,7 @@ static inline dvector<scalar_t> phi_values(scalar_t start_phi, scalar_t end_phi,
     values.reserve(lseg + 1u);
     scalar_t step_phi = (end_phi - start_phi) / static_cast<scalar_t>(lseg);
     for (unsigned int istep = 0u; istep <= lseg; ++istep) {
-        values.push_back(start_phi + istep * step_phi);
+        values.push_back(start_phi + static_cast<scalar_t>(istep) * step_phi);
     }
     return values;
 }
diff --git a/extern/actsvg/CMakeLists.txt b/extern/actsvg/CMakeLists.txt
index 89e245bb4..e4d17736c 100644
--- a/extern/actsvg/CMakeLists.txt
+++ b/extern/actsvg/CMakeLists.txt
@@ -19,11 +19,11 @@ message( STATUS "Building actsvg as part of the Detray project" )
 # Declare where to get Actsvg from.
 set( DETRAY_ACTSVG_GIT_REPOSITORY "https://github.com/acts-project/actsvg.git"
    CACHE STRING "Git repository to take actsvg from" )
-set( DETRAY_ACTSVG_GIT_TAG "v0.4.19" CACHE STRING "Version of actsvg to build" )
+set( DETRAY_ACTSVG_GIT_TAG "v0.4.35" CACHE STRING "Version of actsvg to build" )
 mark_as_advanced( DETRAY_ACTSVG_GIT_REPOSITORY DETRAY_ACTSVG_GIT_TAG )
 FetchContent_Declare( actsvg
    GIT_REPOSITORY "${DETRAY_ACTSVG_GIT_REPOSITORY}"
    GIT_TAG "${DETRAY_ACTSVG_GIT_TAG}" )
 
 # Now set up its build.
-FetchContent_MakeAvailable( actsvg )
+FetchContent_MakeAvailable( actsvg )
\ No newline at end of file
diff --git a/plugins/CMakeLists.txt b/plugins/CMakeLists.txt
index 20bd545f0..6b0f2f896 100644
--- a/plugins/CMakeLists.txt
+++ b/plugins/CMakeLists.txt
@@ -6,3 +6,4 @@
 
 # Add all subdirectories.
 add_subdirectory( algebra )
+add_subdirectory( svgtools )
diff --git a/plugins/svgtools/CMakeLists.txt b/plugins/svgtools/CMakeLists.txt
new file mode 100644
index 000000000..03ded5641
--- /dev/null
+++ b/plugins/svgtools/CMakeLists.txt
@@ -0,0 +1,24 @@
+# Detray library, part of the ACTS project (R&D line)
+#
+# (c) 2021-2023 CERN for the benefit of the ACTS project
+#
+# Mozilla Public License Version 2.0
+
+# Let the user know what's happening.
+message(STATUS "Building 'detray::svgtools' component")
+
+include_directories( SYSTEM $<TARGET_PROPERTY:actsvg::meta,INTERFACE_INCLUDE_DIRECTORIES> )
+include_directories( SYSTEM $<TARGET_PROPERTY:actsvg::core,INTERFACE_INCLUDE_DIRECTORIES> )
+
+# Set up the library.
+file( GLOB _detray_svgtools_public_headers
+   RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
+   "include/detray/plugins/svgtools/*.hpp" )
+
+detray_add_library( detray_svgtools svgtools
+   ${_detray_svg_public_headers} )
+target_link_libraries( detray_svgtools
+   INTERFACE detray::core actsvg::core actsvg::meta )
+
+# Clean up.
+unset( _detray_svgtools_public_headers )
\ No newline at end of file
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/conversion/link.hpp b/plugins/svgtools/include/detray/plugins/svgtools/conversion/link.hpp
new file mode 100644
index 000000000..646ed224f
--- /dev/null
+++ b/plugins/svgtools/include/detray/plugins/svgtools/conversion/link.hpp
@@ -0,0 +1,45 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/geometry/surface.hpp"
+#include "detray/plugins/svgtools/conversion/point.hpp"
+#include "detray/plugins/svgtools/utils/link_utils.hpp"
+#include "detray/plugins/svgtools/utils/surface_kernels.hpp"
+
+// Actsvg includes(s)
+#include "actsvg/proto/portal.hpp"
+
+namespace detray::svgtools::conversion {
+
+/// @returns The link calculated using the surface normal vector.
+template <typename point3_container_t, typename detector_t>
+inline auto link(const typename detector_t::geometry_context& context,
+                 const detector_t& detector,
+                 const detray::surface<detector_t>& d_portal) {
+
+    using point3_t = typename point3_container_t::value_type;
+    using p_link_t = typename actsvg::proto::portal<point3_container_t>::link;
+
+    typename detector_t::vector3 dir{};
+
+    // Length of link arrow is currently hardcoded to 3.
+    constexpr double link_length = 3.;
+
+    const auto [start, end] = svgtools::utils::link_points(
+        context, detector, d_portal, dir, link_length);
+
+    p_link_t p_link;
+    p_link._start = svgtools::conversion::point<point3_t>(start);
+    p_link._end = svgtools::conversion::point<point3_t>(end);
+
+    return p_link;
+}
+
+}  // namespace detray::svgtools::conversion
\ No newline at end of file
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/conversion/point.hpp b/plugins/svgtools/include/detray/plugins/svgtools/conversion/point.hpp
new file mode 100644
index 000000000..a9cdceb0d
--- /dev/null
+++ b/plugins/svgtools/include/detray/plugins/svgtools/conversion/point.hpp
@@ -0,0 +1,25 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// System include(s)
+#include <algorithm>
+
+namespace detray::svgtools::conversion {
+
+template <typename ret_point_t, typename arg_point_t>
+inline auto point(const arg_point_t& p) {
+    ret_point_t ret{};
+    const auto n = std::min(ret.size(), p.size());
+    for (std::size_t i = 0; i < n; i++) {
+        ret[i] = static_cast<typename ret_point_t::value_type>(p[i]);
+    }
+    return ret;
+}
+
+}  // namespace detray::svgtools::conversion
\ No newline at end of file
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/conversion/portal.hpp b/plugins/svgtools/include/detray/plugins/svgtools/conversion/portal.hpp
new file mode 100644
index 000000000..f465feebf
--- /dev/null
+++ b/plugins/svgtools/include/detray/plugins/svgtools/conversion/portal.hpp
@@ -0,0 +1,40 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/geometry/surface.hpp"
+#include "detray/plugins/svgtools/conversion/link.hpp"
+#include "detray/plugins/svgtools/conversion/surface.hpp"
+#include "detray/plugins/svgtools/utils/link_utils.hpp"
+
+// Actsvg includes(s)
+#include "actsvg/proto/portal.hpp"
+
+namespace detray::svgtools::conversion {
+
+/// @returns An actsvg proto portal representing the portal.
+/// @note detray portal is_portal() should be true.
+template <typename point3_container_t, typename detector_t>
+auto portal(const typename detector_t::geometry_context& context,
+            const detector_t& detector,
+            const detray::surface<detector_t>& d_portal) {
+    assert(d_portal.is_portal());
+    using p_portal_t = actsvg::proto::portal<point3_container_t>;
+    p_portal_t p_portal;
+    if (svgtools::utils::is_not_world_portal(d_portal)) {
+        p_portal._volume_links = {
+            svgtools::conversion::link<point3_container_t>(context, detector,
+                                                           d_portal)};
+    }
+    p_portal._surface =
+        svgtools::conversion::surface<point3_container_t>(context, d_portal);
+    return p_portal;
+}
+
+}  // namespace detray::svgtools::conversion
\ No newline at end of file
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/conversion/surface.hpp b/plugins/svgtools/include/detray/plugins/svgtools/conversion/surface.hpp
new file mode 100644
index 000000000..d61ee7eb2
--- /dev/null
+++ b/plugins/svgtools/include/detray/plugins/svgtools/conversion/surface.hpp
@@ -0,0 +1,186 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/geometry/surface.hpp"
+#include "detray/plugins/svgtools/conversion/point.hpp"
+#include "detray/plugins/svgtools/utils/mask_utils.hpp"
+
+// Actsvg include(s)
+#include "actsvg/proto/surface.hpp"
+
+// System include(s)
+#include <algorithm>
+#include <iostream>
+#include <iterator>
+
+namespace detray::svgtools::conversion {
+
+/// @brief Sets the measures of the proto surface to be the same as the mask.
+template <typename point3_container_t, typename mask_t>
+inline void set_measures(actsvg::proto::surface<point3_container_t>& p_surface,
+                         const mask_t& m) {
+    using point3_t = typename point3_container_t::value_type;
+    using scalar_t = typename point3_t::value_type;
+    auto cast_scalar = [](const typename mask_t::scalar_type& v) {
+        return static_cast<scalar_t>(v);
+    };
+    std::transform(m.values().cbegin(), m.values().cend(),
+                   std::back_inserter(p_surface._measures), cast_scalar);
+}
+
+/// @brief Sets the vertices of the proto surface to be the same as the mask.
+template <typename point3_container_t, typename transform_t, typename mask_t>
+inline void set_vertices(actsvg::proto::surface<point3_container_t>& p_surface,
+                         const transform_t& transform, const mask_t& m) {
+    using point3_t = typename point3_container_t::value_type;
+    const auto vertices = svgtools::utils::global_vertices(transform, m);
+    std::transform(
+        vertices.cbegin(), vertices.cend(),
+        std::back_inserter(p_surface._vertices),
+        &svgtools::conversion::point<point3_t,
+                                     typename decltype(vertices)::value_type>);
+}
+
+/// @brief Returns the proto surface for a shape.
+/// @note For lines, the thickness is fixed and not determined by the cross
+/// section.
+template <typename point3_container_t, typename transform_t, typename mask_t>
+auto inline surface(const transform_t& transform, const mask_t& m) {
+
+    using p_surface_t = actsvg::proto::surface<point3_container_t>;
+
+    p_surface_t p_surface;
+    p_surface._type = p_surface_t::type::e_polygon;
+    set_measures(p_surface, m);
+    set_vertices(p_surface, transform, m);
+
+    return p_surface;
+}
+
+/// @brief Returns the proto surface for 2D cylinders.
+template <typename point3_container_t, typename transform_t, bool kRadialCheck,
+          template <typename> class intersector_t>
+auto inline surface(const transform_t& transform,
+                    const mask<cylinder2D<kRadialCheck, intersector_t>>& m) {
+    // Rotation is currently not supported.
+    // Furthermore, only translation on z axis is supported.
+
+    using mask_t = mask<cylinder2D<kRadialCheck, intersector_t>>;
+    using shape_t = typename mask_t::shape;
+
+    using point3_t = typename point3_container_t::value_type;
+    using scalar_t = typename point3_t::value_type;
+    using p_surface_t = actsvg::proto::surface<point3_container_t>;
+
+    p_surface_t p_surface;
+
+    const auto r = static_cast<scalar_t>(m[shape_t::e_r]);
+    const auto nhz = static_cast<scalar_t>(m[shape_t::e_n_half_z]);
+    const auto phz = static_cast<scalar_t>(m[shape_t::e_p_half_z]);
+    const auto hz =
+        (phz - nhz) / 2 + static_cast<scalar_t>(transform.translation()[2]);
+
+    p_surface._type = p_surface_t::type::e_cylinder;
+    p_surface._radii = {static_cast<scalar_t>(0), r};
+    p_surface._zparameters = {nhz + hz, hz};
+    set_measures(p_surface, m);
+
+    return p_surface;
+}
+
+/// @brief Returns the proto surface for 2D rings.
+template <typename point3_container_t, typename transform_t>
+auto surface(const transform_t& transform, const mask<ring2D<>>& m) {
+    // Rotation is currently not supported.
+    // Furthermore, only translation on z axis is supported.
+
+    using mask_t = mask<ring2D<>>;
+    using shape_t = typename mask_t::shape;
+
+    using point3_t = typename point3_container_t::value_type;
+    using scalar_t = typename point3_t::value_type;
+    using p_surface_t = actsvg::proto::surface<point3_container_t>;
+
+    p_surface_t p_surface;
+
+    const auto ri = static_cast<scalar_t>(m[shape_t::e_inner_r]);
+    const auto ro = static_cast<scalar_t>(m[shape_t::e_outer_r]);
+    const auto center =
+        svgtools::conversion::point<point3_t>(transform.translation());
+
+    p_surface._type = p_surface_t::type::e_disc;
+    p_surface._radii = {ri, ro};
+    p_surface._zparameters = {center[2], static_cast<scalar_t>(0)};
+    set_measures(p_surface, m);
+
+    return p_surface;
+}
+
+/// @brief Returns the proto surface for 2D annuli.
+template <typename point3_container_t, typename transform_t>
+auto inline surface(const transform_t& transform, const mask<annulus2D<>>& m) {
+    // Rotation is currently not supported.
+    // Furthermore, only translation on z axis is supported.
+
+    using mask_t = mask<annulus2D<>>;
+    using shape_t = typename mask_t::shape;
+
+    using point3_t = typename point3_container_t::value_type;
+    using scalar_t = typename point3_t::value_type;
+    using p_surface_t = actsvg::proto::surface<point3_container_t>;
+
+    p_surface_t p_surface;
+
+    auto ri = static_cast<scalar_t>(m[shape_t::e_min_r]);
+    auto ro = static_cast<scalar_t>(m[shape_t::e_max_r]);
+    auto center =
+        svgtools::conversion::point<point3_t>(transform.translation());
+
+    p_surface._type = p_surface_t::type::e_annulus;
+    p_surface._radii = {ri, ro};
+    p_surface._zparameters = {center[2], static_cast<scalar_t>(0)};
+    set_measures(p_surface, m);
+    set_vertices(p_surface, transform, m);
+
+    return p_surface;
+}
+
+namespace {
+/// @brief A functor to set the proto surfaces type and bounds to be equivalent
+/// to the mask.
+template <typename point3_container_t>
+struct surface_getter {
+    template <typename mask_group_t, typename index_t, typename transform_t>
+    DETRAY_HOST inline auto operator()(const mask_group_t& mask_group,
+                                       const index_t& index,
+                                       const transform_t& transform) const {
+        const auto& m = mask_group[index];
+        return svgtools::conversion::surface<point3_container_t>(transform, m);
+    }
+};
+}  // namespace
+
+/// @brief Calculates the proto surface of a surface.
+///
+/// @param d_surface The detray surface.
+/// @param context The context.
+///
+/// @note The transform is not taken into account for objects such as rings,
+/// cylinders etc (not implemented yet).
+///
+/// @returns An actsvg proto surface representing the surface.
+template <typename point3_container_t, typename detector_t>
+auto surface(const typename detector_t::geometry_context& context,
+             const detray::surface<detector_t>& d_surface) {
+    return d_surface.template visit_mask<surface_getter<point3_container_t>>(
+        d_surface.transform(context));
+}
+
+}  // namespace detray::svgtools::conversion
\ No newline at end of file
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/utils/link_utils.hpp b/plugins/svgtools/include/detray/plugins/svgtools/utils/link_utils.hpp
new file mode 100644
index 000000000..6e1525403
--- /dev/null
+++ b/plugins/svgtools/include/detray/plugins/svgtools/utils/link_utils.hpp
@@ -0,0 +1,63 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/geometry/surface.hpp"
+#include "detray/plugins/svgtools/utils/surface_kernels.hpp"
+#include "detray/utils/invalid_values.hpp"
+
+// System include(s)
+#include <cassert>
+#include <tuple>
+
+namespace detray::svgtools::utils {
+
+/// @brief Checks if the detray surface has a volume link.
+template <typename detector_t>
+inline auto is_not_world_portal(const detray::surface<detector_t>& d_portal) {
+    const auto d_link_idx = d_portal.template visit_mask<link_getter>();
+    return !is_invalid_value(d_link_idx);
+}
+
+/// @note expects that the detray surface has a volume link.
+/// @returns the volume link of the detray surface.
+template <typename detector_t>
+inline auto get_linked_volume(const detector_t& detector,
+                              const detray::surface<detector_t>& d_portal) {
+    assert(is_not_world_portal(d_portal));
+    const auto d_link_idx = d_portal.template visit_mask<link_getter>();
+    return detector.volume_by_index(d_link_idx);
+}
+
+/// @brief Calculates the start and end point of the link.
+/// @note The detray surface must have a volume link.
+/// @returns (start, end).
+template <typename detector_t>
+inline auto link_points(const typename detector_t::geometry_context& context,
+                        const detector_t& detector,
+                        const detray::surface<detector_t>& d_portal,
+                        typename detector_t::vector3 dir,
+                        const double link_length) {
+    assert(is_not_world_portal(d_portal));
+
+    // Calculating the start position:
+    const auto start = d_portal.template visit_mask<link_start_getter>(
+        d_portal.transform(context));
+
+    // Calculating the end position:
+    const auto n =
+        d_portal.normal(context, d_portal.global_to_local(context, start, dir));
+    const auto volume = get_linked_volume(detector, d_portal);
+    const auto end = d_portal.template visit_mask<link_end_getter>(
+        detector, volume, start, n, link_length);
+
+    return std::make_tuple(start, end);
+}
+
+}  // namespace detray::svgtools::utils
\ No newline at end of file
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/utils/mask_utils.hpp b/plugins/svgtools/include/detray/plugins/svgtools/utils/mask_utils.hpp
new file mode 100644
index 000000000..4e0e35f7e
--- /dev/null
+++ b/plugins/svgtools/include/detray/plugins/svgtools/utils/mask_utils.hpp
@@ -0,0 +1,43 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/masks/line.hpp"
+#include "detray/tools/generators.hpp"
+
+// System include(s)
+#include <cmath>
+#include <iostream>
+
+namespace detray::svgtools::utils {
+
+template <typename mask_t>
+inline auto local_vertices(const mask_t& mask) {
+    return vertices<typename mask_t::point2_t, typename mask_t::point3_t>(mask,
+                                                                          10u);
+}
+
+inline auto local_vertices(const mask<line<>>& m) {
+    using point3_t = typename mask<line<>>::point3_t;
+    const auto hz = m[line<>::e_half_z];
+    point3_t p1{0.f, 0.f, -hz};
+    point3_t p2{0.f, 0.f, hz};
+    return dvector<point3_t>{p1, p2};
+}
+
+template <typename transform_t, typename mask_t>
+inline auto global_vertices(const transform_t& transform, const mask_t& mask) {
+    auto ret = local_vertices(mask);
+    for (std::size_t i = 0; i < ret.size(); i++) {
+        ret[i] = transform.point_to_global(ret[i]);
+    }
+    return ret;
+}
+
+}  // namespace detray::svgtools::utils
\ No newline at end of file
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/utils/surface_kernels.hpp b/plugins/svgtools/include/detray/plugins/svgtools/utils/surface_kernels.hpp
new file mode 100644
index 000000000..d98fec5f1
--- /dev/null
+++ b/plugins/svgtools/include/detray/plugins/svgtools/utils/surface_kernels.hpp
@@ -0,0 +1,260 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/definitions/units.hpp"
+#include "detray/geometry/detector_volume.hpp"
+#include "detray/geometry/surface.hpp"
+#include "detray/masks/masks.hpp"
+#include "detray/plugins/svgtools/utils/volume_utils.hpp"
+
+// System include(s)
+#include <cassert>
+#include <optional>
+
+namespace detray::svgtools::utils {
+
+/// @brief Functor to calculate the outermost radius a shape.
+/// If the shape is not defined by a radius, then null option is returned.
+struct outer_radius_getter {
+
+    public:
+    template <typename mask_group_t, typename index_t>
+    DETRAY_HOST inline std::optional<detray::scalar> operator()(
+        const mask_group_t& mask_group, const index_t& index) const {
+        const auto& m = mask_group[index];
+        return outer_radius(m);
+    }
+
+    private:
+    // The remaining shapes do not have an outer radius.
+    template <typename mask_t>
+    std::optional<detray::scalar> inline outer_radius(
+        const mask_t& /*mask*/) const {
+        return std::nullopt;
+    }
+
+    // Calculates the outer radius for rings.
+    auto inline outer_radius(const detray::mask<detray::ring2D<>>& mask) const {
+        return std::optional<detray::scalar>(mask[mask.get_shape().e_outer_r]);
+    }
+
+    // Calculates the outer radius for annuluses.
+    auto inline outer_radius(
+        const detray::mask<detray::annulus2D<>>& mask) const {
+        return std::optional<detray::scalar>(mask[mask.get_shape().e_max_r]);
+    }
+
+    // Calculates the outer radius for cylinders (2D).
+    template <bool kRadialCheck, template <typename> class intersector_t>
+    auto inline outer_radius(
+        const detray::mask<detray::cylinder2D<kRadialCheck, intersector_t>>&
+            mask) const {
+        return std::optional<detray::scalar>(mask[mask.get_shape().e_r]);
+    }
+
+    // Calculates the outer radius for cylinders (3D).
+    auto inline outer_radius(
+        const detray::mask<detray::cylinder3D>& mask) const {
+        return std::optional<detray::scalar>(mask[mask.get_shape().e_max_r]);
+    }
+};
+
+/// @brief Functor to obtain the volume link.
+struct link_getter {
+    template <typename mask_group_t, typename index_t>
+    DETRAY_HOST inline auto operator()(const mask_group_t& mask_group,
+                                       const index_t& index) const {
+        const auto& m = mask_group[index];
+        return m.volume_link();
+    }
+};
+
+/// @brief Functor to calculate a suitable starting point for displaying the
+/// link arrow.
+struct link_start_getter {
+
+    public:
+    template <typename mask_group_t, typename index_t, typename transform_t>
+    DETRAY_HOST inline auto operator()(const mask_group_t& mask_group,
+                                       const index_t& index,
+                                       const transform_t& transform) const {
+        const auto& m = mask_group[index];
+        return link_start(m, transform);
+    }
+
+    private:
+    // Calculates the link starting location of the remaining shapes.
+    template <typename mask_t, typename transform_t>
+    auto inline link_start(const mask_t& mask,
+                           const transform_t& transform) const {
+        return mask.global_min_bounds_center(transform);
+    }
+
+    // Calculates the (optimal) link starting point for rings.
+    template <typename transform_t>
+    auto inline link_start(const detray::mask<detray::ring2D<>>& mask,
+                           const transform_t& transform) const {
+        using mask_t = typename detray::mask<detray::ring2D<>>;
+        using shape_t = typename mask_t::shape;
+        using point3_t = typename mask_t::point3_t;
+        using scalar_t = typename mask_t::scalar_type;
+
+        const scalar_t r{(mask[shape_t::e_inner_r] + mask[shape_t::e_outer_r]) /
+                         2.f};
+        const scalar_t phi{detray::constant<scalar_t>::pi_2};
+        const scalar_t z{0};
+
+        // Polar coordinate system.
+        const typename mask_t::local_frame_type frame{};
+
+        return frame.local_to_global(transform, point3_t{r, phi, z});
+    }
+
+    // Calculates the (optimal) link starting point for annuluses.
+    template <typename transform_t>
+    auto inline link_start(const detray::mask<detray::annulus2D<>>& mask,
+                           const transform_t& transform) const {
+        using mask_t = typename detray::mask<detray::annulus2D<>>;
+        using shape_t = typename mask_t::shape;
+        using point3_t = typename mask_t::point3_t;
+        using scalar_t = typename mask_t::scalar_type;
+
+        const scalar_t r{(mask[shape_t::e_min_r] + mask[shape_t::e_max_r]) /
+                         2.f};
+        const scalar_t phi{mask[shape_t::e_average_phi]};
+        const scalar_t z{0};
+
+        // Polar coordinate system.
+        const typename mask_t::local_frame_type frame{};
+
+        const auto true_center = mask.global_min_bounds_center(transform);
+        const auto rel_point =
+            frame.local_to_global(transform, point3_t{r, phi, z}) -
+            transform.translation();
+        return rel_point + true_center;
+    }
+
+    // Calculates the (optimal) link starting point for cylinders (2D).
+    template <typename transform_t, bool kRadialCheck,
+              template <typename> class intersector_t>
+    auto inline link_start(
+        const detray::mask<detray::cylinder2D<kRadialCheck, intersector_t>>&
+            mask,
+        const transform_t& transform) const {
+        using mask_t = typename detray::mask<
+            detray::cylinder2D<kRadialCheck, intersector_t>>;
+        using shape_t = typename mask_t::shape;
+        using point3_t = typename mask_t::point3_t;
+        using scalar_t = typename mask_t::scalar_type;
+
+        const scalar_t r{mask[shape_t::e_r]};
+        const scalar_t phi{detray::constant<scalar_t>::pi_2};
+        const scalar_t z{0};
+
+        // Cylindrical coordinate system.
+        const typename mask_t::local_frame_type frame{};
+
+        const auto true_center = mask.global_min_bounds_center(transform);
+        const auto rel_point =
+            frame.local_to_global(transform, point3_t{r * phi, z, r}) -
+            transform.translation();
+        return rel_point + true_center;
+    }
+
+    // Calculates the (optimal) link starting point for cylinders (3D).
+    template <typename transform_t>
+    auto inline link_start(const detray::mask<detray::cylinder3D>& mask,
+                           const transform_t& transform) const {
+        using mask_t = typename detray::mask<detray::cylinder3D>;
+        using shape_t = typename mask_t::shape;
+        using point3_t = typename mask_t::point3_t;
+        using scalar_t = typename mask_t::scalar_type;
+
+        const scalar_t r{(mask[shape_t::e_min_r] + mask[shape_t::e_max_r]) /
+                         2.f};
+        const scalar_t phi{
+            (mask[shape_t::e_max_phi] + mask[shape_t::e_max_phi]) / 2.f};
+        const scalar_t z{0};
+
+        // Cylindrical coordinate system.
+        const typename mask_t::local_frame_type frame{};
+
+        const auto true_center = mask.global_min_bounds_center(transform);
+        const auto rel_point =
+            frame.local_to_global(transform, point3_t{r * phi, z, r}) -
+            transform.translation();
+        return rel_point + true_center;
+    }
+};
+
+/// @brief Functor to calculate a suitable end point for displaying the link
+/// arrow.
+struct link_end_getter {
+
+    public:
+    template <typename mask_group_t, typename index_t, typename detector_t,
+              typename point3_t, typename vector3_t, typename scalar_t>
+    DETRAY_HOST inline auto operator()(
+        const mask_group_t& mask_group, const index_t& index,
+        const detector_t& detector,
+        const detray::detector_volume<detector_t>& volume,
+        const point3_t& surface_point, const vector3_t& surface_normal,
+        const scalar_t& link_length) const {
+        const auto& m = mask_group[index];
+        return link_dir(m, detector, volume, surface_point, surface_normal) *
+                   link_length +
+               surface_point;
+    }
+
+    private:
+    /// @brief Calculates the direction of the link for remaining shapes.
+    template <typename detector_t, typename mask_t, typename point3_t,
+              typename vector3_t>
+    inline auto link_dir(const mask_t& /*mask*/, const detector_t& /*detector*/,
+                         const detray::detector_volume<detector_t>& volume,
+                         const point3_t& surface_point,
+                         const vector3_t& surface_normal) const {
+        const auto dir = volume.center() - surface_point;
+        const auto dot_prod = vector::dot(dir, surface_normal);
+        // Should geometrically not happen with a local point 'surface_point'
+        assert(dot_prod != 0.f);
+        typename detector_t::scalar_type sgn =
+            dot_prod > 0.f ? 1.f : (dot_prod < 0.f ? -1.f : 0);
+        return sgn * surface_normal;
+    }
+
+    /// @brief Calculates the direction of the link for cylinders (2D)
+    template <typename detector_t, bool kRadialCheck,
+              template <typename> class intersector_t, typename point3_t,
+              typename vector3_t>
+    inline auto link_dir(
+        const detray::mask<detray::cylinder2D<kRadialCheck, intersector_t>>&
+            mask,
+        const detector_t& detector,
+        const detray::detector_volume<detector_t>& volume,
+        const point3_t& /*surface_point*/,
+        const vector3_t& surface_normal) const {
+        for (const auto& desc :
+             svgtools::utils::surface_lookup(detector, volume)) {
+            const detray::surface surface{detector, desc};
+            if (surface.is_portal()) {
+                if (auto radius =
+                        surface.template visit_mask<outer_radius_getter>()) {
+                    if (*radius > mask[mask.get_shape().e_r]) {
+                        return surface_normal;
+                    }
+                }
+            }
+        }
+        return -1.f * surface_normal;
+    }
+};
+
+}  // namespace detray::svgtools::utils
\ No newline at end of file
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/utils/volume_utils.hpp b/plugins/svgtools/include/detray/plugins/svgtools/utils/volume_utils.hpp
new file mode 100644
index 000000000..9b5bc4e1a
--- /dev/null
+++ b/plugins/svgtools/include/detray/plugins/svgtools/utils/volume_utils.hpp
@@ -0,0 +1,26 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/geometry/detector_volume.hpp"
+
+namespace detray::svgtools::utils {
+/// @return the sub-surfaces of the volume - non-const access
+template <typename detector_t>
+auto surface_lookup(const detector_t& detector,
+                    const detector_volume<detector_t>& d_volume) {
+    typename detector_t::surface_lookup_container descriptors;
+    for (auto desc : detector.surface_lookup()) {
+        if (desc.volume() == d_volume.index()) {
+            descriptors.push_back(desc);
+        }
+    }
+    return descriptors;
+}
+}  // namespace detray::svgtools::utils
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/writer.hpp b/plugins/svgtools/include/detray/plugins/svgtools/writer.hpp
new file mode 100644
index 000000000..f2711fa62
--- /dev/null
+++ b/plugins/svgtools/include/detray/plugins/svgtools/writer.hpp
@@ -0,0 +1,48 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/io/common/detail/file_handle.hpp"
+#include "detray/io/common/detector_writer.hpp"
+
+// Actsvg include(s)
+#include "actsvg/core.hpp"
+
+// System include(s)
+#include <vector>
+
+namespace detray::svgtools {
+
+/// @brief Writes a collection of svgs objects to a single file.
+template <typename container_t>
+inline void write_svg(const std::string& path, const container_t& svgs) {
+    actsvg::svg::file file;
+    for (const actsvg::svg::object& obj : svgs) {
+        file.add_object(obj);
+    }
+    detray::io::detail::file_handle stream{path, "",
+                                           std::ios::out | std::ios::trunc};
+    *stream << file;
+}
+
+/// @brief Writes an svg object to a file.
+/// @note To avoid conflict, the ids of the svg objects must be unique.
+inline void write_svg(const std::string& path, const actsvg::svg::object& svg) {
+    write_svg(path, std::array{svg});
+}
+
+/// @brief Writes an svg objects to a file.
+/// @note To avoid conflict, the ids of the svg objects must be unique.
+inline void write_svg(const std::string& path,
+                      const std::initializer_list<actsvg::svg::object>& svgs) {
+    std::vector<actsvg::svg::object> arg = svgs;
+    write_svg(path, arg);
+}
+
+}  // namespace detray::svgtools
\ No newline at end of file
diff --git a/tests/unit_tests/CMakeLists.txt b/tests/unit_tests/CMakeLists.txt
index 101f1b66f..c913899ac 100644
--- a/tests/unit_tests/CMakeLists.txt
+++ b/tests/unit_tests/CMakeLists.txt
@@ -10,6 +10,7 @@ add_subdirectory( io )
 add_subdirectory( utils )
 add_subdirectory( cpu )
 add_subdirectory( covfie )
+add_subdirectory( svgtools )
 
 # Set up all of the "device" tests.
 if( DETRAY_BUILD_CUDA OR DETRAY_BUILD_SYCL )
diff --git a/tests/unit_tests/svgtools/CMakeLists.txt b/tests/unit_tests/svgtools/CMakeLists.txt
new file mode 100644
index 000000000..c1b7b1a07
--- /dev/null
+++ b/tests/unit_tests/svgtools/CMakeLists.txt
@@ -0,0 +1,14 @@
+# Detray library, part of the ACTS project (R&D line)
+#
+# (c) 2021-2023 CERN for the benefit of the ACTS project
+#
+# Mozilla Public License Version 2.0
+
+# Set up the core tests.
+
+include_directories( SYSTEM $<TARGET_PROPERTY:actsvg::meta,INTERFACE_INCLUDE_DIRECTORIES> )
+include_directories( SYSTEM $<TARGET_PROPERTY:actsvg::core,INTERFACE_INCLUDE_DIRECTORIES> )
+
+detray_add_test( svgtools_masks
+   "masks.cpp"
+   LINK_LIBRARIES GTest::gtest_main detray_tests_common detray::core_array actsvg::core actsvg::meta detray::svgtools)
\ No newline at end of file
diff --git a/tests/unit_tests/svgtools/masks.cpp b/tests/unit_tests/svgtools/masks.cpp
new file mode 100644
index 000000000..fb4b3204b
--- /dev/null
+++ b/tests/unit_tests/svgtools/masks.cpp
@@ -0,0 +1,97 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+// Project include(s)
+#include "detray/masks/masks.hpp"
+
+#include "detray/core/detector.hpp"
+#include "detray/detectors/create_toy_geometry.hpp"
+#include "detray/plugins/svgtools/conversion/surface.hpp"
+#include "detray/plugins/svgtools/writer.hpp"
+
+// Vecmem include(s)
+#include <vecmem/memory/host_memory_resource.hpp>
+
+// Actsvg include(s)
+#include "actsvg/core.hpp"
+#include "actsvg/meta.hpp"
+
+// System include(s)
+#include <array>
+#include <string>
+
+int main(int, char**) {
+
+    // Axes.
+    const auto axes =
+        actsvg::draw::x_y_axes("axes", {-250, 250}, {-250, 250},
+                               actsvg::style::stroke(), "axis1", "axis2");
+
+    using point3 = std::array<actsvg::scalar, 3>;
+    using point3_container = std::vector<point3>;
+
+    using toy_detector_t = detray::detector<detray::toy_metadata<>>;
+    using transform_t = typename toy_detector_t::transform3;
+
+    const typename transform_t::vector3 tr{0.f, 150.f, 0.f};
+    const typename toy_detector_t::transform3 transform(tr);
+    const actsvg::views::x_y view{};
+
+    // e_min_r, e_max_r, e_min_phi_rel, e_max_phi_rel, e_average_phi, e_shift_x,
+    // e_shift_y, e_size
+    detray::mask<detray::annulus2D<>> ann2D{0u,  100.f, 200.f, -1.f,
+                                            1.f, 0.f,   0.f,   100.f};
+    const auto ann2D_proto =
+        detray::svgtools::conversion::surface<point3_container>(transform,
+                                                                ann2D);
+    const auto ann2D_svg = actsvg::display::surface("", ann2D_proto, view);
+    detray::svgtools::write_svg("test_svgtools_annulus2D.svg",
+                                {axes, ann2D_svg});
+
+    // e_r, e_n_half_z, e_p_half_z, e_size
+    detray::mask<detray::cylinder2D<>> cyl2D{0u, 100.f, -10.f, 10.f};
+    const auto cyl2D_proto =
+        detray::svgtools::conversion::surface<point3_container>(transform,
+                                                                cyl2D);
+    const auto cyl2D_svg = actsvg::display::surface("", cyl2D_proto, view);
+    detray::svgtools::write_svg("test_svgtools_cylinder2D.svg",
+                                {axes, cyl2D_svg});
+
+    // e_half_x, e_half_y, e_size
+    detray::mask<detray::rectangle2D<>> rec2D{0u, 100.f, 100.f};
+    const auto rec2D_proto =
+        detray::svgtools::conversion::surface<point3_container>(transform,
+                                                                rec2D);
+    const auto rec2D_svg = actsvg::display::surface("", rec2D_proto, view);
+    detray::svgtools::write_svg("test_svgtools_rectangle2D.svg",
+                                {axes, rec2D_svg});
+
+    // e_inner_r, e_outer_r, e_size
+    detray::mask<detray::ring2D<>> rin2D{0u, 50.f, 100.f};
+    const auto rin2D_proto =
+        detray::svgtools::conversion::surface<point3_container>(transform,
+                                                                rin2D);
+    const auto rin2D_svg = actsvg::display::surface("", rin2D_proto, view);
+    detray::svgtools::write_svg("test_svgtools_ring2D.svg", {axes, rin2D_svg});
+
+    // e_half_length_0, e_half_length_1, e_half_length_2, e_divisor, e_size
+    detray::mask<detray::trapezoid2D<>> tra2D{0u, 100.f, 50.f, 200.f};
+    const auto tra2D_proto =
+        detray::svgtools::conversion::surface<point3_container>(transform,
+                                                                tra2D);
+    const auto tra2D_svg = actsvg::display::surface("", tra2D_proto, view);
+    detray::svgtools::write_svg("test_svgtools_trapezoid2D.svg",
+                                {axes, tra2D_svg});
+
+    // e_cross_section, e_half_z
+    detray::mask<detray::line<>> lin2D{0u, 1.f, 100.f};
+    const auto lin2D_proto =
+        detray::svgtools::conversion::surface<point3_container>(transform,
+                                                                lin2D);
+    const auto lin2D_svg = actsvg::display::surface("", lin2D_proto, view);
+    detray::svgtools::write_svg("test_svgtools_line2D.svg", {axes, lin2D_svg});
+}
\ No newline at end of file

From 03d09bfec597d3c25df3e3d70411ba0b8144fef8 Mon Sep 17 00:00:00 2001
From: beomki-yeo <beomki.yeo@gmail.com>
Date: Tue, 22 Aug 2023 11:17:54 +0200
Subject: [PATCH 03/29] Refactor simulator template parameter

---
 tests/simulation/run_simulation.cpp           |  9 +++++-
 .../validation/src/simulation_validation.cpp  | 23 +++++++++++---
 .../detray/simulation/measurement_smearer.hpp |  1 +
 utils/include/detray/simulation/simulator.hpp | 31 ++++++++++---------
 .../{event_writer.hpp => smearing_writer.hpp} | 20 +++++++-----
 5 files changed, 58 insertions(+), 26 deletions(-)
 rename utils/include/detray/simulation/{event_writer.hpp => smearing_writer.hpp} (90%)

diff --git a/tests/simulation/run_simulation.cpp b/tests/simulation/run_simulation.cpp
index 219034ea9..c1538faea 100644
--- a/tests/simulation/run_simulation.cpp
+++ b/tests/simulation/run_simulation.cpp
@@ -45,8 +45,15 @@ int main() {
     measurement_smearer<transform3> smearer(100.f * unit<scalar>::um,
                                             100.f * unit<scalar>::um);
 
+    using detector_type = decltype(detector);
+    using generator_type = decltype(generator);
+    using writer_type = smearing_writer<measurement_smearer<transform3>>;
+
+    typename writer_type::config writer_cfg{smearer};
+
     std::size_t n_events = 2u;
-    auto sim = simulator(n_events, detector, std::move(generator), smearer);
+    auto sim = simulator<detector_type, generator_type, writer_type>(
+        n_events, detector, std::move(generator), std::move(writer_cfg));
 
     sim.run();
 
diff --git a/tests/validation/src/simulation_validation.cpp b/tests/validation/src/simulation_validation.cpp
index 94dce4468..7b5ed9a19 100644
--- a/tests/validation/src/simulation_validation.cpp
+++ b/tests/validation/src/simulation_validation.cpp
@@ -106,8 +106,16 @@ GTEST_TEST(detray_simulation, toy_geometry_simulation) {
                                             170.f * unit<scalar>::um);
 
     std::size_t n_events{10u};
-    auto sim = simulator(n_events, detector, std::move(generator), smearer,
-                         test::filenames);
+
+    using detector_type = decltype(detector);
+    using generator_type = decltype(generator);
+    using writer_type = smearing_writer<measurement_smearer<transform3>>;
+
+    typename writer_type::config writer_cfg{smearer};
+
+    auto sim = simulator<detector_type, generator_type, writer_type>(
+        n_events, detector, std::move(generator), std::move(writer_cfg),
+        test::filenames);
 
     // Lift step size constraints
     sim.get_config().step_constraint = std::numeric_limits<scalar>::max();
@@ -245,8 +253,15 @@ TEST_P(TelescopeDetectorSimulation, telescope_detector_simulation) {
 
     std::size_t n_events{1000u};
 
-    auto sim = simulator(n_events, detector, std::move(generator), smearer,
-                         test::filenames);
+    using detector_type = decltype(detector);
+    using generator_type = decltype(generator);
+    using writer_type = smearing_writer<measurement_smearer<transform3>>;
+
+    typename writer_type::config writer_cfg{smearer};
+
+    auto sim = simulator<detector_type, generator_type, writer_type>(
+        n_events, detector, std::move(generator), std::move(writer_cfg),
+        test::filenames);
 
     // Lift step size constraints
     sim.get_config().step_constraint = std::numeric_limits<scalar>::max();
diff --git a/utils/include/detray/simulation/measurement_smearer.hpp b/utils/include/detray/simulation/measurement_smearer.hpp
index feb60dca8..be067c20c 100644
--- a/utils/include/detray/simulation/measurement_smearer.hpp
+++ b/utils/include/detray/simulation/measurement_smearer.hpp
@@ -20,6 +20,7 @@ namespace detray {
 template <typename transform3_t>
 struct measurement_smearer {
 
+    using transform3_type = transform3_t;
     using matrix_operator = typename transform3_t::matrix_actor;
     using scalar_type = typename transform3_t::scalar_type;
     using size_type = typename matrix_operator::size_ty;
diff --git a/utils/include/detray/simulation/simulator.hpp b/utils/include/detray/simulation/simulator.hpp
index 866e56642..b1102362a 100644
--- a/utils/include/detray/simulation/simulator.hpp
+++ b/utils/include/detray/simulation/simulator.hpp
@@ -15,8 +15,8 @@
 #include "detray/propagator/navigator.hpp"
 #include "detray/propagator/propagator.hpp"
 #include "detray/propagator/rk_stepper.hpp"
-#include "detray/simulation/event_writer.hpp"
 #include "detray/simulation/random_scatterer.hpp"
+#include "detray/simulation/smearing_writer.hpp"
 
 // System include(s).
 #include <limits>
@@ -24,7 +24,7 @@
 
 namespace detray {
 
-template <typename detector_t, typename track_generator_t, typename smearer_t>
+template <typename detector_t, typename track_generator_t, typename writer_t>
 struct simulator {
 
     using scalar_type = typename detector_t::scalar_type;
@@ -37,9 +37,10 @@ struct simulator {
     using transform3 = typename detector_t::transform3;
     using bfield_type = typename detector_t::bfield_type;
 
-    using actor_chain_type = actor_chain<
-        dtuple, parameter_transporter<transform3>, random_scatterer<transform3>,
-        parameter_resetter<transform3>, event_writer<transform3, smearer_t>>;
+    using actor_chain_type =
+        actor_chain<dtuple, parameter_transporter<transform3>,
+                    random_scatterer<transform3>,
+                    parameter_resetter<transform3>, writer_t>;
 
     using navigator_type = navigator<detector_t>;
     using stepper_type = rk_stepper<typename bfield_type::view_t, transform3,
@@ -48,33 +49,35 @@ struct simulator {
         propagator<stepper_type, navigator_type, actor_chain_type>;
 
     simulator(std::size_t events, const detector_t& det,
-              track_generator_t&& track_gen, smearer_t& smearer,
+              track_generator_t&& track_gen,
+              typename writer_t::config&& writer_cfg,
               const std::string directory = "")
         : m_events(events),
           m_directory(directory),
           m_detector(std::make_unique<detector_t>(det)),
           m_track_generator(
               std::make_unique<track_generator_t>(std::move(track_gen))),
-          m_smearer(smearer) {}
+          m_writer_cfg(writer_cfg) {}
 
     config& get_config() { return m_cfg; }
 
     void run() {
 
         for (std::size_t event_id = 0u; event_id < m_events; event_id++) {
-            typename event_writer<transform3, smearer_t>::state writer(
-                event_id, m_smearer, m_directory);
+
+            typename writer_t::state writer_state(
+                event_id, std::move(m_writer_cfg), m_directory);
 
             // Set random seed
             m_scatterer.set_seed(event_id);
-            writer.set_seed(event_id);
+            writer_state.set_seed(event_id);
 
             auto actor_states =
-                std::tie(m_transporter, m_scatterer, m_resetter, writer);
+                std::tie(m_transporter, m_scatterer, m_resetter, writer_state);
 
             for (auto track : *m_track_generator.get()) {
 
-                writer.write_particle(track);
+                writer_state.write_particle(track);
 
                 typename propagator_type::state propagation(
                     track, m_detector->get_bfield(), *m_detector);
@@ -91,7 +94,7 @@ struct simulator {
                 p.propagate(propagation, actor_states);
 
                 // Increase the particle id
-                writer.particle_id++;
+                writer_state.particle_id++;
             }
         }
     }
@@ -102,7 +105,7 @@ struct simulator {
     std::string m_directory = "";
     std::unique_ptr<detector_t> m_detector;
     std::unique_ptr<track_generator_t> m_track_generator;
-    smearer_t m_smearer;
+    typename writer_t::config m_writer_cfg;
 
     /// Actor states
     typename parameter_transporter<transform3>::state m_transporter{};
diff --git a/utils/include/detray/simulation/event_writer.hpp b/utils/include/detray/simulation/smearing_writer.hpp
similarity index 90%
rename from utils/include/detray/simulation/event_writer.hpp
rename to utils/include/detray/simulation/smearing_writer.hpp
index 844f811e8..f3d3e0d87 100644
--- a/utils/include/detray/simulation/event_writer.hpp
+++ b/utils/include/detray/simulation/smearing_writer.hpp
@@ -24,13 +24,18 @@
 
 namespace detray {
 
-template <typename transform3_t, typename smearer_t>
-struct event_writer : actor {
+template <typename smearer_t>
+struct smearing_writer : actor {
 
-    using scalar_type = typename transform3_t::scalar_type;
+    using transform3_type = typename smearer_t::transform3_type;
+    using scalar_type = typename transform3_type::scalar_type;
+
+    struct config {
+        smearer_t smearer;
+    };
 
     struct state {
-        state(std::size_t event_id, smearer_t& smearer,
+        state(std::size_t event_id, config&& writer_cfg,
               const std::string directory)
             : m_particle_writer(directory + detail::get_event_filename(
                                                 event_id, "-particles.csv")),
@@ -41,7 +46,7 @@ struct event_writer : actor {
               m_meas_hit_id_writer(
                   directory + detail::get_event_filename(
                                   event_id, "-measurement-simhit-map.csv")),
-              m_meas_smearer(smearer) {}
+              m_meas_smearer(writer_cfg.smearer) {}
 
         uint64_t particle_id = 0u;
         particle_writer m_particle_writer;
@@ -53,7 +58,8 @@ struct event_writer : actor {
 
         void set_seed(const uint_fast64_t sd) { m_meas_smearer.set_seed(sd); }
 
-        void write_particle(const free_track_parameters<transform3_t>& track) {
+        void write_particle(
+            const free_track_parameters<transform3_type>& track) {
             csv_particle particle;
             const auto pos = track.pos();
             const auto mom = track.mom();
@@ -77,7 +83,7 @@ struct event_writer : actor {
         template <typename mask_group_t, typename index_t>
         inline std::array<scalar_type, 2> operator()(
             const mask_group_t& mask_group, const index_t& index,
-            const bound_track_parameters<transform3_t>& bound_params,
+            const bound_track_parameters<transform3_type>& bound_params,
             smearer_t& smearer) const {
 
             const auto& mask = mask_group[index];

From 0bcaec5714a94d5e0be93a8a4370dd08497c5620 Mon Sep 17 00:00:00 2001
From: Fred <92879080+fredevb@users.noreply.github.com>
Date: Tue, 22 Aug 2023 13:32:29 +0200
Subject: [PATCH 04/29] feat: visualization of volumes and detectors (#536)

- Added conversion from detray detector volumes to actsvg proto volumes.
- Added class svg_converter to convert detray surfaces, volumes, and detectors to svg (currently supports xy-view and zr-view).
 - Added function write_svg to write the svg object to a file.
 - Added basic surface, portal, volume, and detector styling to make the different objects distinguishable in the visualization.
  - Added tests for converting surfaces, volumes, and detectors.
---
 core/include/detray/masks/masks.hpp           |  10 +-
 .../plugins/svgtools/conversion/volume.hpp    |  78 +++++++++
 .../detray/plugins/svgtools/illustrator.hpp   | 164 ++++++++++++++++++
 .../plugins/svgtools/styling/styling.hpp      | 131 ++++++++++++++
 tests/unit_tests/svgtools/CMakeLists.txt      |  18 +-
 tests/unit_tests/svgtools/detectors.cpp       |  58 +++++++
 tests/unit_tests/svgtools/groups.cpp          |  75 ++++++++
 tests/unit_tests/svgtools/masks.cpp           |   5 +-
 tests/unit_tests/svgtools/surfaces.cpp        |  54 ++++++
 tests/unit_tests/svgtools/volumes.cpp         |  53 ++++++
 10 files changed, 637 insertions(+), 9 deletions(-)
 create mode 100644 plugins/svgtools/include/detray/plugins/svgtools/conversion/volume.hpp
 create mode 100644 plugins/svgtools/include/detray/plugins/svgtools/illustrator.hpp
 create mode 100644 plugins/svgtools/include/detray/plugins/svgtools/styling/styling.hpp
 create mode 100644 tests/unit_tests/svgtools/detectors.cpp
 create mode 100644 tests/unit_tests/svgtools/groups.cpp
 create mode 100644 tests/unit_tests/svgtools/surfaces.cpp
 create mode 100644 tests/unit_tests/svgtools/volumes.cpp

diff --git a/core/include/detray/masks/masks.hpp b/core/include/detray/masks/masks.hpp
index 3121119ce..1bab001a7 100644
--- a/core/include/detray/masks/masks.hpp
+++ b/core/include/detray/masks/masks.hpp
@@ -225,11 +225,11 @@ class mask {
     template <typename transform3_t>
     auto global_min_bounds_center(const transform3_t& trf) const {
         const auto m = local_min_bounds();
-        const auto cuboid = m.get_shape();
-        const auto center{0.5f * (point3_t{m[cuboid.e_max_x], m[cuboid.e_max_y],
-                                           m[cuboid.e_max_z]} +
-                                  point3_t{m[cuboid.e_min_x], m[cuboid.e_min_y],
-                                           m[cuboid.e_min_z]})};
+        const auto center{
+            0.5f * (point3_t{m[cuboid3D<>::e_max_x], m[cuboid3D<>::e_max_y],
+                             m[cuboid3D<>::e_max_z]} +
+                    point3_t{m[cuboid3D<>::e_min_x], m[cuboid3D<>::e_min_y],
+                             m[cuboid3D<>::e_min_z]})};
         return trf.point_to_global(center);
     }
 
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/conversion/volume.hpp b/plugins/svgtools/include/detray/plugins/svgtools/conversion/volume.hpp
new file mode 100644
index 000000000..f46e51a18
--- /dev/null
+++ b/plugins/svgtools/include/detray/plugins/svgtools/conversion/volume.hpp
@@ -0,0 +1,78 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/geometry/detector_volume.hpp"
+#include "detray/plugins/svgtools/conversion/portal.hpp"
+#include "detray/plugins/svgtools/conversion/surface.hpp"
+#include "detray/plugins/svgtools/utils/volume_utils.hpp"
+
+// Actsvg include(s)
+#include "actsvg/proto/portal.hpp"
+#include "actsvg/proto/surface.hpp"
+#include "actsvg/proto/volume.hpp"
+
+// System include(s)
+#include <vector>
+
+namespace detray::svgtools::conversion {
+
+/// @brief Calculates the proto volume of a collection of detray surfaces.
+///
+/// @param context The context.
+/// @param d_surfaces The detray surfaces.
+///
+/// @returns An actsvg proto volume representing the volume.
+template <typename point3_container_t, typename detector_t>
+auto volume(const typename detector_t::geometry_context& context,
+            const detector_t& detector,
+            const std::vector<detray::surface<detector_t>>& d_surfaces) {
+    using p_volume_t = actsvg::proto::volume<point3_container_t>;
+    using p_portal_t = actsvg::proto::portal<point3_container_t>;
+    using p_surface_t = actsvg::proto::surface<point3_container_t>;
+    p_volume_t p_volume;
+    std::vector<p_surface_t> surfaces;
+    std::vector<p_portal_t> portals;
+    for (const auto& item : d_surfaces) {
+        if (item.is_portal()) {
+            auto portal = svgtools::conversion::portal<point3_container_t>(
+                context, detector, item);
+            portals.push_back(portal);
+        } else {
+            auto surface = svgtools::conversion::surface<point3_container_t>(
+                context, item);
+            surfaces.push_back(surface);
+        }
+    }
+    p_volume._v_surfaces = surfaces;
+    p_volume._portals = portals;
+    return p_volume;
+}
+
+/// @brief Calculates the proto volume of a detray volume.
+///
+/// @param context The context.
+/// @param d_volume The detray volume.
+///
+/// @returns An actsvg proto volume representing the volume.
+template <typename point3_container_t, typename detector_t>
+auto volume(const typename detector_t::geometry_context& context,
+            const detector_t& detector,
+            const detray::detector_volume<detector_t>& d_volume) {
+    std::vector<detray::surface<detector_t>> surfaces{};
+    const auto descriptors =
+        svgtools::utils::surface_lookup(detector, d_volume);
+    for (const auto& desc : descriptors) {
+        surfaces.push_back(detray::surface{detector, desc});
+    }
+    return svgtools::conversion::volume<point3_container_t>(context, detector,
+                                                            surfaces);
+}
+
+}  // namespace detray::svgtools::conversion
\ No newline at end of file
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/illustrator.hpp b/plugins/svgtools/include/detray/plugins/svgtools/illustrator.hpp
new file mode 100644
index 000000000..8607a4de5
--- /dev/null
+++ b/plugins/svgtools/include/detray/plugins/svgtools/illustrator.hpp
@@ -0,0 +1,164 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/geometry/surface.hpp"
+#include "detray/io/common/detail/file_handle.hpp"
+#include "detray/io/common/detector_writer.hpp"
+#include "detray/plugins/svgtools/conversion/surface.hpp"
+#include "detray/plugins/svgtools/conversion/volume.hpp"
+#include "detray/plugins/svgtools/styling/styling.hpp"
+#include "detray/plugins/svgtools/utils/volume_utils.hpp"
+#include "detray/utils/ranges.hpp"
+
+// Actsvg include(s)
+#include "actsvg/meta.hpp"
+
+// System include(s)
+#include <array>
+#include <vector>
+
+namespace detray::svgtools {
+
+/// @brief SVG generator for a detector and related entities.
+template <typename detector_t>
+class illustrator {
+
+    public:
+    illustrator() = delete;
+
+    illustrator(const detector_t& detector,
+                const typename detector_t::name_map& name_map)
+        : _detector{detector}, _name_map{name_map} {}
+
+    illustrator(const detector_t& detector,
+                const typename detector_t::name_map& name_map,
+                const styling::style& style)
+        : _detector{detector}, _name_map{name_map}, _style{style} {}
+
+    /// @brief Converts a detray surface in the detector to an actsvg svg.
+    /// @param identification the id of the svg object.
+    /// @param context the geometry context.
+    /// @param index the index of the surface in the detector.
+    /// @param view the display view.
+    /// @returns SVG of the detector's surface.
+    template <typename view_t>
+    inline auto draw_surface(
+        const std::string& identification,
+        const typename detector_t::geometry_context& context,
+        const std::size_t index, const view_t& view) const {
+        const auto surface = detray::surface{
+            _detector,
+            _detector.surface_lookup()[static_cast<detray::dindex>(index)]};
+        if (surface.is_portal()) {
+            auto p_portal = svgtools::conversion::portal<point3_container>(
+                context, _detector, surface);
+            svgtools::styling::apply_style(p_portal, _style);
+            return actsvg::display::portal(identification, p_portal, view);
+        }
+        auto p_surface =
+            svgtools::conversion::surface<point3_container>(context, surface);
+        svgtools::styling::apply_style(p_surface, _style);
+        return actsvg::display::surface(identification, p_surface, view);
+    }
+
+    /// @brief Converts a collection of detray surfaces in the detector to an
+    /// actsvg svg.
+    /// @param identification the id of the svg object.
+    /// @param context the geometry context.
+    /// @param indices the collection of surface indices in the detector to
+    /// convert.
+    /// @param view the display view.
+    /// @returns SVG of the detector's surfaces.
+    template <typename iterator_t, typename view_t>
+    inline auto draw_surfaces(
+        const std::string& identification,
+        const typename detector_t::geometry_context& context,
+        const iterator_t& indices, const view_t& view) const {
+        actsvg::svg::object ret;
+        ret._tag = "g";
+        ret._id = identification;
+        for (const auto index : indices) {
+            const auto svg = draw_surface(
+                identification + "_surface" + std::to_string(index), context,
+                index, view);
+            ret.add_object(svg);
+        }
+        return ret;
+    }
+
+    /// @brief Converts a detray volume in the detector to an actsvg svg.
+    /// @param identification the id of the svg object.
+    /// @param context the geometry context.
+    /// @param index the index of the volume in the detector.
+    /// @param view the display view.
+    /// @returns SVG of the detector's volume.
+    template <typename view_t>
+    inline auto draw_volume(
+        const std::string& identification,
+        const typename detector_t::geometry_context& context,
+        const std::size_t index, const view_t& view) const {
+        const auto volume =
+            _detector.volume_by_index(static_cast<detray::dindex>(index));
+        auto p_volume = svgtools::conversion::volume<point3_container>(
+            context, _detector, volume);
+        svgtools::styling::apply_style(p_volume, _style);
+        return actsvg::display::volume(identification, p_volume, view);
+    }
+
+    /// @brief Converts a collection of detray volumes in the detector to an
+    /// actsvg svg.
+    /// @param identification the id of the svg object.
+    /// @param context the geometry context.
+    /// @param indices the collection of volume indices in the detector to
+    /// convert.
+    /// @param view the display view.
+    /// @returns SVG of the detector's volumes.
+    template <typename iterator_t, typename view_t>
+    inline auto draw_volumes(
+        const std::string& identification,
+        const typename detector_t::geometry_context& context,
+        const iterator_t& indices, const view_t& view) const {
+        actsvg::svg::object ret;
+        ret._tag = "g";
+        ret._id = identification;
+        for (const auto index : indices) {
+            const auto svg =
+                draw_volume(identification + "_volume" + std::to_string(index),
+                            context, index, view);
+            ret.add_object(svg);
+        }
+        return ret;
+    }
+
+    /// @brief Converts a detray detector to an actsvg svg.
+    /// @param identification the id of the svg object.
+    /// @param context the geometry context.
+    /// @param view the display view.
+    /// @returns SVG of the detector.
+    template <typename view_t>
+    inline auto draw_detector(
+        const std::string& identification,
+        const typename detector_t::geometry_context& context,
+        const view_t& view) const {
+        auto indices =
+            detray::views::iota(std::size_t{0u}, _detector.volumes().size());
+        return draw_volumes(identification, context, indices, view);
+    }
+
+    private:
+    using point3 = std::array<actsvg::scalar, 3>;
+    using point3_container = std::vector<point3>;
+
+    const detector_t& _detector;
+    const typename detector_t::name_map& _name_map;
+    const svgtools::styling::style _style = svgtools::styling::default_style;
+};
+
+}  // namespace detray::svgtools
\ No newline at end of file
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/styling/styling.hpp b/plugins/svgtools/include/detray/plugins/svgtools/styling/styling.hpp
new file mode 100644
index 000000000..1e90e6d3d
--- /dev/null
+++ b/plugins/svgtools/include/detray/plugins/svgtools/styling/styling.hpp
@@ -0,0 +1,131 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Actsvg include(s)
+#include "actsvg/core.hpp"
+
+// System include(s)
+#include <cstdlib>
+#include <vector>
+
+namespace detray::svgtools::styling {
+
+struct style {
+    const std::vector<actsvg::style::color> surface_fill_colors;
+    const std::vector<actsvg::style::color> portal_fill_colors;
+    const actsvg::scalar stroke_width;
+    const actsvg::scalar marker_size;
+    const bool hide_links;
+};
+
+namespace colors {
+
+/// @brief Picks a random element in the container.
+template <typename container_t>
+auto pick_random(container_t container) {
+    const auto idx = static_cast<std::size_t>(std::rand()) % container.size();
+    return container[idx];
+}
+
+// Red tones
+constexpr std::array cardinal{167, 51, 63};
+constexpr std::array madder{165, 28, 48};
+constexpr std::array auburn{167, 51, 63};
+constexpr std::array burgundy{116, 18, 29};
+constexpr std::array chocolate_cosmos{88, 12, 31};
+
+// Blue tones
+constexpr std::array celestial_blue{62, 146, 204};
+constexpr std::array lapis_lazulli{42, 98, 143};
+constexpr std::array prussian_blue1{19, 41, 61};
+constexpr std::array prussian_blue2{22, 50, 79};
+constexpr std::array indigo_dye{24, 67, 90};
+
+// Green tones
+constexpr std::array celadon{190, 230, 206};
+constexpr std::array aquamarine1{188, 255, 219};
+constexpr std::array aquamarine2{141, 255, 205};
+constexpr std::array emerald{104, 216, 155};
+constexpr std::array shamrock_green{79, 157, 105};
+
+std::vector<actsvg::style::color> red_theme(const actsvg::scalar opacity) {
+    return {{cardinal, opacity},
+            {madder, opacity},
+            {auburn, opacity},
+            {burgundy, opacity},
+            {chocolate_cosmos, opacity}};
+}
+
+std::vector<actsvg::style::color> blue_theme(const actsvg::scalar opacity) {
+    return {{celestial_blue, opacity},
+            {lapis_lazulli, opacity},
+            {prussian_blue1, opacity},
+            {prussian_blue2, opacity},
+            {indigo_dye, opacity}};
+}
+
+std::vector<actsvg::style::color> green_theme(const actsvg::scalar opacity) {
+    return {{celadon, opacity},
+            {aquamarine1, opacity},
+            {aquamarine2, opacity},
+            {emerald, opacity},
+            {shamrock_green, opacity}};
+}
+
+}  // namespace colors
+
+const style default_style{colors::blue_theme(0.8f), colors::red_theme(0.8f),
+                          1.f, 1.2f, false};
+
+/// @brief Sets the style of the proto surface.
+template <typename point3_container_t>
+void apply_style(actsvg::proto::surface<point3_container_t>& p_surface,
+                 const style& styling) {
+    auto fill_color = colors::pick_random(styling.surface_fill_colors);
+    p_surface._fill = actsvg::style::fill(fill_color);
+    p_surface._stroke = actsvg::style::stroke(fill_color, styling.stroke_width);
+}
+
+/// @brief Sets the style of the proto link.
+template <typename point3_container_t>
+void apply_style(
+    typename actsvg::proto::portal<point3_container_t>::link& p_link,
+    const style& styling) {
+    p_link._end_marker._size = styling.marker_size;
+}
+
+/// @brief Sets the style of the proto portal.
+template <typename point3_container_t>
+void apply_style(actsvg::proto::portal<point3_container_t>& p_portal,
+                 const style& styling) {
+    auto fill_color = colors::pick_random(styling.portal_fill_colors);
+    p_portal._surface._fill = actsvg::style::fill(fill_color);
+    p_portal._surface._stroke =
+        actsvg::style::stroke(fill_color, styling.stroke_width);
+    if (styling.hide_links) {
+        p_portal._volume_links = {};
+    }
+    for (auto& volume_link : p_portal._volume_links) {
+        apply_style<point3_container_t>(volume_link, styling);
+    }
+}
+
+/// @brief Sets the style of the proto volume.
+template <typename point3_container_t>
+void apply_style(actsvg::proto::volume<point3_container_t>& p_volume,
+                 const style& styling) {
+    for (auto& p_surface : p_volume._v_surfaces) {
+        apply_style(p_surface, styling);
+    }
+    for (auto& p_portals : p_volume._portals) {
+        apply_style(p_portals, styling);
+    }
+}
+
+}  // namespace detray::svgtools::styling
\ No newline at end of file
diff --git a/tests/unit_tests/svgtools/CMakeLists.txt b/tests/unit_tests/svgtools/CMakeLists.txt
index c1b7b1a07..8c27e8a51 100644
--- a/tests/unit_tests/svgtools/CMakeLists.txt
+++ b/tests/unit_tests/svgtools/CMakeLists.txt
@@ -11,4 +11,20 @@ include_directories( SYSTEM $<TARGET_PROPERTY:actsvg::core,INTERFACE_INCLUDE_DIR
 
 detray_add_test( svgtools_masks
    "masks.cpp"
-   LINK_LIBRARIES GTest::gtest_main detray_tests_common detray::core_array actsvg::core actsvg::meta detray::svgtools)
\ No newline at end of file
+   LINK_LIBRARIES GTest::gtest_main detray_tests_common detray::core_array actsvg::core actsvg::meta detray::svgtools)
+
+detray_add_test( svgtools_surfaces
+   "surfaces.cpp"
+   LINK_LIBRARIES GTest::gtest_main detray_tests_common detray::core_array actsvg::core actsvg::meta detray::svgtools)
+
+detray_add_test( svgtools_volumes
+   "volumes.cpp"
+   LINK_LIBRARIES GTest::gtest_main detray_tests_common detray::core_array actsvg::core actsvg::meta detray::svgtools)
+
+detray_add_test( svgtools_detectors
+   "detectors.cpp"
+   LINK_LIBRARIES GTest::gtest_main detray_tests_common detray::core_array actsvg::core actsvg::meta detray::svgtools)
+
+detray_add_test( svgtools_groups
+   "groups.cpp"
+   LINK_LIBRARIES GTest::gtest_main detray_tests_common detray::core_array actsvg::core actsvg::meta detray::svgtools)
diff --git a/tests/unit_tests/svgtools/detectors.cpp b/tests/unit_tests/svgtools/detectors.cpp
new file mode 100644
index 000000000..b05f5b83f
--- /dev/null
+++ b/tests/unit_tests/svgtools/detectors.cpp
@@ -0,0 +1,58 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+// Project include(s)
+#include "detray/core/detector.hpp"
+#include "detray/detectors/create_toy_geometry.hpp"
+#include "detray/plugins/svgtools/illustrator.hpp"
+#include "detray/plugins/svgtools/writer.hpp"
+
+// Vecmem include(s)
+#include <vecmem/memory/host_memory_resource.hpp>
+
+// Actsvg include(s)
+#include "actsvg/core.hpp"
+
+// System include(s)
+#include <array>
+#include <string>
+
+int main(int, char**) {
+
+    actsvg::style::stroke stroke_black = actsvg::style::stroke();
+    // x-y axis.
+    auto xy_axis = actsvg::draw::x_y_axes("axes", {-250, 250}, {-250, 250},
+                                          stroke_black, "x", "y");
+    // z-r axis.
+    auto zr_axis = actsvg::draw::x_y_axes("axes", {-250, 250}, {-250, 250},
+                                          stroke_black, "z", "r");
+
+    // Creating the views.
+    const actsvg::views::x_y xy;
+    const actsvg::views::z_r zr;
+
+    // Creating the detector and geomentry context.
+    using toy_detector_t = detray::detector<detray::toy_metadata<>>;
+    vecmem::host_memory_resource host_mr;
+    const auto [det, names] = detray::create_toy_geometry(host_mr, 4, 3);
+    toy_detector_t::geometry_context context{};
+
+    // Creating the svg generator for the detector.
+    detray::svgtools::illustrator il{det, names};
+
+    // Get the svg of the toy detetector in x-y view.
+    const auto svg_xy = il.draw_detector("detector_xy", context, xy);
+    // Write the svg of toy detector.
+    detray::svgtools::write_svg("test_svgtools_detector_xy.svg",
+                                {xy_axis, svg_xy});
+
+    // Get the svg of the toy detetector in z-r view.
+    const auto svg_zr = il.draw_detector("detector_zr", context, zr);
+    // Write the svg of toy detector in z-r view
+    detray::svgtools::write_svg("test_svgtools_detector_zr.svg",
+                                {zr_axis, svg_zr});
+}
\ No newline at end of file
diff --git a/tests/unit_tests/svgtools/groups.cpp b/tests/unit_tests/svgtools/groups.cpp
new file mode 100644
index 000000000..834cb84db
--- /dev/null
+++ b/tests/unit_tests/svgtools/groups.cpp
@@ -0,0 +1,75 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+// Project include(s)
+#include "detray/core/detector.hpp"
+#include "detray/detectors/create_toy_geometry.hpp"
+#include "detray/plugins/svgtools/illustrator.hpp"
+#include "detray/plugins/svgtools/writer.hpp"
+
+// Vecmem include(s)
+#include <vecmem/memory/host_memory_resource.hpp>
+
+// Actsvg include(s)
+#include "actsvg/core.hpp"
+
+// System include(s)
+#include <array>
+#include <string>
+
+int main(int, char**) {
+
+    // Axes.
+    const auto axes = actsvg::draw::x_y_axes("axes", {-250, 250}, {-250, 250},
+                                             actsvg::style::stroke());
+
+    // Creating the views.
+    const actsvg::views::x_y xy;
+    const actsvg::views::z_r zr;
+
+    // Creating the detector and geomentry context.
+    using toy_detector_t = detray::detector<detray::toy_metadata<>>;
+    vecmem::host_memory_resource host_mr;
+    const auto [det, names] = detray::create_toy_geometry(host_mr, 4, 3);
+    toy_detector_t::geometry_context context{};
+
+    // Creating the svg generator for the detector.
+    const detray::svgtools::illustrator il{det, names};
+
+    // Visualisation of a group of surfaces.
+    const std::array surface_group_indices{1UL, 100UL, 10UL, 200UL};
+
+    const auto svg_surface_group_xy = il.draw_surfaces(
+        "my_surface_group1_xy", context, surface_group_indices, xy);
+    detray::svgtools::write_svg("test_svgtools_surface_group_xy.svg",
+                                {axes, svg_surface_group_xy});
+
+    const auto svg_surface_group_zr = il.draw_surfaces(
+        "my_surface_group1_zr", context, surface_group_indices, zr);
+    detray::svgtools::write_svg("test_svgtools_surface_group_zr.svg",
+                                {axes, svg_surface_group_zr});
+
+    // Visualisation of a group of volumes.
+    const std::array volume_group_indices{3UL, 5UL};
+
+    const auto svg_volume_group_xy = il.draw_volumes(
+        "my_volume_group1_xy", context, volume_group_indices, xy);
+    detray::svgtools::write_svg("test_svgtools_volume_group_xy.svg",
+                                {axes, svg_volume_group_xy});
+
+    const auto svg_volume_group_zr = il.draw_volumes(
+        "my_volume_group1_zr", context, volume_group_indices, zr);
+    detray::svgtools::write_svg("test_svgtools_volume_group_zr.svg",
+                                {axes, svg_volume_group_zr});
+
+    // Writing SVGs to a combined file.
+    // NOTE: The all svg object's identification must be unique in the
+    // file!
+    detray::svgtools::write_svg(
+        "test_svgtools_volume_and_surface_group.svg",
+        {axes, svg_surface_group_xy, svg_volume_group_zr});
+}
\ No newline at end of file
diff --git a/tests/unit_tests/svgtools/masks.cpp b/tests/unit_tests/svgtools/masks.cpp
index fb4b3204b..7e45648be 100644
--- a/tests/unit_tests/svgtools/masks.cpp
+++ b/tests/unit_tests/svgtools/masks.cpp
@@ -27,9 +27,8 @@
 int main(int, char**) {
 
     // Axes.
-    const auto axes =
-        actsvg::draw::x_y_axes("axes", {-250, 250}, {-250, 250},
-                               actsvg::style::stroke(), "axis1", "axis2");
+    const auto axes = actsvg::draw::x_y_axes("axes", {-250, 250}, {-250, 250},
+                                             actsvg::style::stroke());
 
     using point3 = std::array<actsvg::scalar, 3>;
     using point3_container = std::vector<point3>;
diff --git a/tests/unit_tests/svgtools/surfaces.cpp b/tests/unit_tests/svgtools/surfaces.cpp
new file mode 100644
index 000000000..dcf560e34
--- /dev/null
+++ b/tests/unit_tests/svgtools/surfaces.cpp
@@ -0,0 +1,54 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+// Project include(s)
+#include "detray/core/detector.hpp"
+#include "detray/detectors/create_toy_geometry.hpp"
+#include "detray/plugins/svgtools/illustrator.hpp"
+#include "detray/plugins/svgtools/writer.hpp"
+
+// Vecmem include(s)
+#include <vecmem/memory/host_memory_resource.hpp>
+
+// Actsvg include(s)
+#include "actsvg/core.hpp"
+
+// System include(s)
+#include <array>
+#include <string>
+
+int main(int, char**) {
+
+    // Axes.
+    const auto axes = actsvg::draw::x_y_axes("axes", {-250, 250}, {-250, 250},
+                                             actsvg::style::stroke());
+
+    // Creating the views.
+    const actsvg::views::x_y xy;
+    const actsvg::views::z_r zr;
+
+    // Creating the detector and geomentry context.
+    using toy_detector_t = detray::detector<detray::toy_metadata<>>;
+    vecmem::host_memory_resource host_mr;
+    const auto [det, names] = detray::create_toy_geometry(host_mr, 4, 3);
+    toy_detector_t::geometry_context context{};
+
+    // Creating the svg generator for the detector.
+    const detray::svgtools::illustrator il{det, names};
+
+    // Indexes of the surfaces in the detector to be visualized.
+    std::array indices{0UL, 1UL, 2UL, 3UL};
+
+    for (std::size_t i : indices) {
+        std::string name = "test_svgtools_surface" + std::to_string(i);
+        // Visualization of portal i:
+        const auto svg_xy = il.draw_surface(name, context, i, xy);
+        detray::svgtools::write_svg(name + "_xy.svg", {axes, svg_xy});
+        const auto svg_zr = il.draw_surface(name, context, i, zr);
+        detray::svgtools::write_svg(name + "_zr.svg", {axes, svg_zr});
+    }
+}
\ No newline at end of file
diff --git a/tests/unit_tests/svgtools/volumes.cpp b/tests/unit_tests/svgtools/volumes.cpp
new file mode 100644
index 000000000..688000345
--- /dev/null
+++ b/tests/unit_tests/svgtools/volumes.cpp
@@ -0,0 +1,53 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+// Project include(s)
+#include "detray/core/detector.hpp"
+#include "detray/detectors/create_toy_geometry.hpp"
+#include "detray/plugins/svgtools/illustrator.hpp"
+#include "detray/plugins/svgtools/writer.hpp"
+
+// Vecmem include(s)
+#include <vecmem/memory/host_memory_resource.hpp>
+
+// Actsvg include(s)
+#include "actsvg/core.hpp"
+
+// System include(s)
+#include <array>
+#include <string>
+
+int main(int, char**) {
+
+    // Axes.
+    const auto axes = actsvg::draw::x_y_axes("axes", {-250, 250}, {-250, 250},
+                                             actsvg::style::stroke());
+
+    // Creating the views.
+    const actsvg::views::x_y xy;
+    const actsvg::views::z_r zr;
+
+    // Creating the detector and geomentry context.
+    using toy_detector_t = detray::detector<detray::toy_metadata<>>;
+    vecmem::host_memory_resource host_mr;
+    const auto [det, names] = detray::create_toy_geometry(host_mr, 4, 3);
+    toy_detector_t::geometry_context context{};
+
+    // Creating the svg generator for the detector.
+    const detray::svgtools::illustrator il{det, names};
+
+    // Indexes of the volumes in the detector to be visualized.
+    std::array indices{0UL, 1UL, 2UL, 3UL};
+    for (std::size_t i : indices) {
+        std::string name = "test_svgtools_volume" + std::to_string(i);
+        // Visualization of volume i:
+        const auto svg_xy = il.draw_volume(name, context, i, xy);
+        detray::svgtools::write_svg(name + "_xy.svg", {axes, svg_xy});
+        const auto svg_zr = il.draw_volume(name, context, i, zr);
+        detray::svgtools::write_svg(name + "_zr.svg", {axes, svg_zr});
+    }
+}
\ No newline at end of file

From 482e70a9ef5b827907356c5e9099012ddc2f9e84 Mon Sep 17 00:00:00 2001
From: beomki-yeo <beomki.yeo@gmail.com>
Date: Tue, 29 Aug 2023 17:46:40 +0200
Subject: [PATCH 05/29] Update algbera plugin version

---
 extern/algebra-plugins/CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/extern/algebra-plugins/CMakeLists.txt b/extern/algebra-plugins/CMakeLists.txt
index 1dd22b2fe..c9c4ba95f 100644
--- a/extern/algebra-plugins/CMakeLists.txt
+++ b/extern/algebra-plugins/CMakeLists.txt
@@ -18,7 +18,7 @@ message(STATUS "Building Algebra Plugins as part of the Detray project")
 
 # Declare where to get Algebra Plugins from.
 set( DETRAY_ALGEBRA_PLUGINS_SOURCE
-   "URL;https://github.com/acts-project/algebra-plugins/archive/refs/tags/v0.20.0.tar.gz;URL_MD5;c28cb43e07c7d4f21a1eb5bf659c7a98"
+   "URL;https://github.com/acts-project/algebra-plugins/archive/refs/tags/v0.21.0.tar.gz;URL_MD5;0fde9e5069c597eb5eccff4c35d0ddd9"
    CACHE STRING "Source for Algebra Plugins, when built as part of this project" )
 mark_as_advanced(DETRAY_ALGEBRA_PLUGINS_SOURCE)
 FetchContent_Declare(AlgebraPlugins ${DETRAY_ALGEBRA_PLUGINS_SOURCE})

From 8e98d8bdb06d64304c9eb0c0a79fad122cda7ffe Mon Sep 17 00:00:00 2001
From: Fred <92879080+fredevb@users.noreply.github.com>
Date: Thu, 31 Aug 2023 17:42:13 +0200
Subject: [PATCH 06/29] feat: visualization of intersection records (#545)

- Added conversion of intersection records to SVG.
- Added new proto types for intersections (i.e., a translation layer from a description of an intersection to SVG object).
- Refactor and added new styling options.
---
 .../conversion/intersection_record.hpp        | 43 ++++++++
 .../plugins/svgtools/conversion/landmark.hpp  | 38 +++++++
 .../plugins/svgtools/conversion/link.hpp      |  2 +-
 .../plugins/svgtools/conversion/point.hpp     |  5 +
 .../detray/plugins/svgtools/illustrator.hpp   | 58 ++++++++---
 .../svgtools/meta/display/geometry.hpp        | 50 ++++++++++
 .../meta/proto/intersection_record.hpp        | 31 ++++++
 .../plugins/svgtools/meta/proto/landmark.hpp  | 27 +++++
 .../plugins/svgtools/styling/styling.hpp      | 99 ++++++++++++++-----
 .../plugins/svgtools/utils/mask_utils.hpp     |  1 +
 tests/unit_tests/CMakeLists.txt               |  2 +-
 tests/unit_tests/svgtools/CMakeLists.txt      |  4 +
 tests/unit_tests/svgtools/intersections.cpp   | 73 ++++++++++++++
 13 files changed, 391 insertions(+), 42 deletions(-)
 create mode 100644 plugins/svgtools/include/detray/plugins/svgtools/conversion/intersection_record.hpp
 create mode 100644 plugins/svgtools/include/detray/plugins/svgtools/conversion/landmark.hpp
 create mode 100644 plugins/svgtools/include/detray/plugins/svgtools/meta/display/geometry.hpp
 create mode 100644 plugins/svgtools/include/detray/plugins/svgtools/meta/proto/intersection_record.hpp
 create mode 100644 plugins/svgtools/include/detray/plugins/svgtools/meta/proto/landmark.hpp
 create mode 100644 tests/unit_tests/svgtools/intersections.cpp

diff --git a/plugins/svgtools/include/detray/plugins/svgtools/conversion/intersection_record.hpp b/plugins/svgtools/include/detray/plugins/svgtools/conversion/intersection_record.hpp
new file mode 100644
index 000000000..870a92afa
--- /dev/null
+++ b/plugins/svgtools/include/detray/plugins/svgtools/conversion/intersection_record.hpp
@@ -0,0 +1,43 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/intersection/intersection.hpp"
+#include "detray/plugins/svgtools/conversion/landmark.hpp"
+#include "detray/plugins/svgtools/meta/proto/intersection_record.hpp"
+
+// System include(s)
+#include <vector>
+
+namespace detray::svgtools::conversion {
+
+/// @returns The proto intersection record of a detray intersection record.
+template <typename point3_t, typename detector_t>
+inline auto intersection_record(
+    const typename detector_t::geometry_context& context,
+    const detector_t& detector,
+    const std::vector<
+        std::pair<detray::dindex,
+                  detray::intersection2D<typename detector_t::surface_type,
+                                         typename detector_t::transform3>>>&
+        intersection_record) {
+    using p_intersection_record_t =
+        svgtools::meta::proto::intersection_record<point3_t>;
+    p_intersection_record_t p_ir;
+    std::vector<typename p_intersection_record_t::landmark_type> landmarks;
+    for (const auto& record : intersection_record) {
+        const auto p_lm = svgtools::conversion::landmark<point3_t>(
+            context, detector, record.second);
+        landmarks.push_back(p_lm);
+    }
+    p_ir._landmarks = landmarks;
+    return p_ir;
+}
+
+}  // namespace detray::svgtools::conversion
\ No newline at end of file
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/conversion/landmark.hpp b/plugins/svgtools/include/detray/plugins/svgtools/conversion/landmark.hpp
new file mode 100644
index 000000000..9932527d6
--- /dev/null
+++ b/plugins/svgtools/include/detray/plugins/svgtools/conversion/landmark.hpp
@@ -0,0 +1,38 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/geometry/surface.hpp"
+#include "detray/intersection/intersection.hpp"
+#include "detray/plugins/svgtools/conversion/point.hpp"
+#include "detray/plugins/svgtools/meta/proto/landmark.hpp"
+
+namespace detray::svgtools::conversion {
+
+/// @returns The proto landmark of a detray intersection.
+template <typename point3_t, typename detector_t>
+inline auto landmark(
+    const typename detector_t::geometry_context& context,
+    const detector_t& detector,
+    const detray::intersection2D<typename detector_t::surface_type,
+                                 typename detector_t::transform3>&
+        d_intersection) {
+    using p_landmark_t = svgtools::meta::proto::landmark<point3_t>;
+
+    const typename detector_t::vector3 dir{};
+    const detray::surface surface{detector, d_intersection.sf_desc};
+    const auto position = svgtools::conversion::point<point3_t>(
+        surface.local_to_global(context, d_intersection.local, dir));
+
+    p_landmark_t p_lm;
+    p_lm._position = position;
+    return p_lm;
+}
+
+}  // namespace detray::svgtools::conversion
\ No newline at end of file
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/conversion/link.hpp b/plugins/svgtools/include/detray/plugins/svgtools/conversion/link.hpp
index 646ed224f..fb8a58866 100644
--- a/plugins/svgtools/include/detray/plugins/svgtools/conversion/link.hpp
+++ b/plugins/svgtools/include/detray/plugins/svgtools/conversion/link.hpp
@@ -18,7 +18,7 @@
 
 namespace detray::svgtools::conversion {
 
-/// @returns The link calculated using the surface normal vector.
+/// @returns The proto link calculated using the surface normal vector.
 template <typename point3_container_t, typename detector_t>
 inline auto link(const typename detector_t::geometry_context& context,
                  const detector_t& detector,
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/conversion/point.hpp b/plugins/svgtools/include/detray/plugins/svgtools/conversion/point.hpp
index a9cdceb0d..d9c0d4f4e 100644
--- a/plugins/svgtools/include/detray/plugins/svgtools/conversion/point.hpp
+++ b/plugins/svgtools/include/detray/plugins/svgtools/conversion/point.hpp
@@ -12,6 +12,11 @@
 
 namespace detray::svgtools::conversion {
 
+/// @brief Converts one type of point to another.
+/// @tparam ret_point_t The type of the point returned
+/// @tparam arg_point_t The type of the point to convert.
+/// @param p The point to convert.
+/// @return The point converted/casted
 template <typename ret_point_t, typename arg_point_t>
 inline auto point(const arg_point_t& p) {
     ret_point_t ret{};
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/illustrator.hpp b/plugins/svgtools/include/detray/plugins/svgtools/illustrator.hpp
index 8607a4de5..f9155780f 100644
--- a/plugins/svgtools/include/detray/plugins/svgtools/illustrator.hpp
+++ b/plugins/svgtools/include/detray/plugins/svgtools/illustrator.hpp
@@ -9,10 +9,11 @@
 
 // Project include(s)
 #include "detray/geometry/surface.hpp"
-#include "detray/io/common/detail/file_handle.hpp"
-#include "detray/io/common/detector_writer.hpp"
+#include "detray/plugins/svgtools/conversion/intersection_record.hpp"
+#include "detray/plugins/svgtools/conversion/landmark.hpp"
 #include "detray/plugins/svgtools/conversion/surface.hpp"
 #include "detray/plugins/svgtools/conversion/volume.hpp"
+#include "detray/plugins/svgtools/meta/display/geometry.hpp"
 #include "detray/plugins/svgtools/styling/styling.hpp"
 #include "detray/plugins/svgtools/utils/volume_utils.hpp"
 #include "detray/utils/ranges.hpp"
@@ -42,12 +43,12 @@ class illustrator {
                 const styling::style& style)
         : _detector{detector}, _name_map{name_map}, _style{style} {}
 
-    /// @brief Converts a detray surface in the detector to an actsvg svg.
+    /// @brief Converts a detray surface in the detector to an svg.
     /// @param identification the id of the svg object.
     /// @param context the geometry context.
     /// @param index the index of the surface in the detector.
     /// @param view the display view.
-    /// @returns SVG of the detector's surface.
+    /// @returns @c actsvg::svg::object of the detector's surface.
     template <typename view_t>
     inline auto draw_surface(
         const std::string& identification,
@@ -59,23 +60,25 @@ class illustrator {
         if (surface.is_portal()) {
             auto p_portal = svgtools::conversion::portal<point3_container>(
                 context, _detector, surface);
-            svgtools::styling::apply_style(p_portal, _style);
+            svgtools::styling::apply_style(p_portal,
+                                           _style._volume_style._portal_style);
             return actsvg::display::portal(identification, p_portal, view);
         }
         auto p_surface =
             svgtools::conversion::surface<point3_container>(context, surface);
-        svgtools::styling::apply_style(p_surface, _style);
+        svgtools::styling::apply_style(p_surface,
+                                       _style._volume_style._surface_style);
         return actsvg::display::surface(identification, p_surface, view);
     }
 
     /// @brief Converts a collection of detray surfaces in the detector to an
-    /// actsvg svg.
+    /// svg.
     /// @param identification the id of the svg object.
     /// @param context the geometry context.
     /// @param indices the collection of surface indices in the detector to
     /// convert.
     /// @param view the display view.
-    /// @returns SVG of the detector's surfaces.
+    /// @returns @c actsvg::svg::object of the detector's surfaces.
     template <typename iterator_t, typename view_t>
     inline auto draw_surfaces(
         const std::string& identification,
@@ -93,12 +96,12 @@ class illustrator {
         return ret;
     }
 
-    /// @brief Converts a detray volume in the detector to an actsvg svg.
+    /// @brief Converts a detray volume in the detector to an svg.
     /// @param identification the id of the svg object.
     /// @param context the geometry context.
     /// @param index the index of the volume in the detector.
     /// @param view the display view.
-    /// @returns SVG of the detector's volume.
+    /// @returns @c actsvg::svg::object of the detector's volume.
     template <typename view_t>
     inline auto draw_volume(
         const std::string& identification,
@@ -108,18 +111,18 @@ class illustrator {
             _detector.volume_by_index(static_cast<detray::dindex>(index));
         auto p_volume = svgtools::conversion::volume<point3_container>(
             context, _detector, volume);
-        svgtools::styling::apply_style(p_volume, _style);
+        svgtools::styling::apply_style(p_volume, _style._volume_style);
         return actsvg::display::volume(identification, p_volume, view);
     }
 
     /// @brief Converts a collection of detray volumes in the detector to an
-    /// actsvg svg.
+    /// svg.
     /// @param identification the id of the svg object.
     /// @param context the geometry context.
     /// @param indices the collection of volume indices in the detector to
     /// convert.
     /// @param view the display view.
-    /// @returns SVG of the detector's volumes.
+    /// @returns @c actsvg::svg::object of the detector's volumes.
     template <typename iterator_t, typename view_t>
     inline auto draw_volumes(
         const std::string& identification,
@@ -137,11 +140,11 @@ class illustrator {
         return ret;
     }
 
-    /// @brief Converts a detray detector to an actsvg svg.
+    /// @brief Converts a detray detector to an svg.
     /// @param identification the id of the svg object.
     /// @param context the geometry context.
     /// @param view the display view.
-    /// @returns SVG of the detector.
+    /// @returns @c actsvg::svg::object of the detector.
     template <typename view_t>
     inline auto draw_detector(
         const std::string& identification,
@@ -152,13 +155,36 @@ class illustrator {
         return draw_volumes(identification, context, indices, view);
     }
 
+    /// @brief Converts an intersection record to an svg.
+    /// @param identification the id of the svg object.
+    /// @param context the geometry context.
+    /// @param intersection_record the intersection record.
+    /// @param view the display view.
+    /// @return @c actsvg::svg::object of the intersectio record.
+    template <typename view_t>
+    inline auto draw_intersections(
+        const std::string& identification,
+        const typename detector_t::geometry_context& context,
+        const std::vector<
+            std::pair<detray::dindex,
+                      detray::intersection2D<typename detector_t::surface_type,
+                                             typename detector_t::transform3>>>&
+            intersection_record,
+        const view_t& view) const {
+        auto p_ir = svgtools::conversion::intersection_record<point3>(
+            context, _detector, intersection_record);
+        svgtools::styling::apply_style(p_ir, _style._intersection_style);
+        return svgtools::meta::display::intersection_record(identification,
+                                                            p_ir, view);
+    }
+
     private:
     using point3 = std::array<actsvg::scalar, 3>;
     using point3_container = std::vector<point3>;
 
     const detector_t& _detector;
     const typename detector_t::name_map& _name_map;
-    const svgtools::styling::style _style = svgtools::styling::default_style;
+    const styling::style _style = styling::style1;
 };
 
 }  // namespace detray::svgtools
\ No newline at end of file
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/meta/display/geometry.hpp b/plugins/svgtools/include/detray/plugins/svgtools/meta/display/geometry.hpp
new file mode 100644
index 000000000..ade9bee7e
--- /dev/null
+++ b/plugins/svgtools/include/detray/plugins/svgtools/meta/display/geometry.hpp
@@ -0,0 +1,50 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project inlude(s)
+#include "detray/plugins/svgtools/meta/proto/intersection_record.hpp"
+#include "detray/plugins/svgtools/meta/proto/landmark.hpp"
+
+// Actsvg include(s)
+#include "actsvg/core.hpp"
+
+// System include(s)
+#include <string>
+#include <vector>
+
+namespace detray::svgtools::meta::display {
+
+/// @brief Converts a proto landmark to a SVG object.
+template <typename point3_t, typename view_t>
+inline auto landmark(const std::string& id,
+                     const svgtools::meta::proto::landmark<point3_t>& lm,
+                     const view_t& view) {
+    const auto point_view = view(std::vector{lm._position})[0];
+    return actsvg::draw::marker(id, point_view, lm._marker);
+}
+
+/// @brief Converts a proto intersection record to a SVG object.
+template <typename point3_t, typename view_t>
+inline auto intersection_record(
+    const std::string& id,
+    const svgtools::meta::proto::intersection_record<point3_t>& ir,
+    const view_t& view) {
+    actsvg::svg::object ret;
+    ret._tag = "g";
+    ret._id = id;
+    for (size_t index = 0; index < ir._landmarks.size(); index++) {
+        const auto lm = ir._landmarks[index];
+        const auto svg = svgtools::meta::display::landmark(
+            id + "_intersection" + std::to_string(index), lm, view);
+        ret.add_object(svg);
+    }
+    return ret;
+}
+
+}  // namespace detray::svgtools::meta::display
\ No newline at end of file
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/meta/proto/intersection_record.hpp b/plugins/svgtools/include/detray/plugins/svgtools/meta/proto/intersection_record.hpp
new file mode 100644
index 000000000..405f95520
--- /dev/null
+++ b/plugins/svgtools/include/detray/plugins/svgtools/meta/proto/intersection_record.hpp
@@ -0,0 +1,31 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project inlude(s)
+#include "detray/plugins/svgtools/meta/proto/landmark.hpp"
+
+// Actsvg include(s)
+#include "actsvg/core.hpp"
+
+// System include(s)
+#include <string>
+#include <vector>
+
+namespace detray::svgtools::meta::proto {
+
+/// @brief A proto intersection record class as a simple translation layer from
+/// a intersection record description.
+template <typename point3_t>
+class intersection_record {
+    public:
+    using landmark_type = svgtools::meta::proto::landmark<point3_t>;
+    std::vector<landmark_type> _landmarks;
+    std::string _name;
+};
+}  // namespace detray::svgtools::meta::proto
\ No newline at end of file
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/meta/proto/landmark.hpp b/plugins/svgtools/include/detray/plugins/svgtools/meta/proto/landmark.hpp
new file mode 100644
index 000000000..b14457379
--- /dev/null
+++ b/plugins/svgtools/include/detray/plugins/svgtools/meta/proto/landmark.hpp
@@ -0,0 +1,27 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Actsvg include(s)
+#include "actsvg/core.hpp"
+
+// System include(s)
+#include <string>
+
+namespace detray::svgtools::meta::proto {
+
+/// @brief A proto landmark class as a simple translation layer from a
+/// description of a point.
+template <typename point3_t>
+class landmark {
+    public:
+    point3_t _position;
+    std::string _name;
+    actsvg::style::marker _marker{"x", 1.};
+};
+}  // namespace detray::svgtools::meta::proto
\ No newline at end of file
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/styling/styling.hpp b/plugins/svgtools/include/detray/plugins/svgtools/styling/styling.hpp
index 1e90e6d3d..774e2c5c7 100644
--- a/plugins/svgtools/include/detray/plugins/svgtools/styling/styling.hpp
+++ b/plugins/svgtools/include/detray/plugins/svgtools/styling/styling.hpp
@@ -9,6 +9,8 @@
 
 // Actsvg include(s)
 #include "actsvg/core.hpp"
+#include "detray/plugins/svgtools/meta/proto/intersection_record.hpp"
+#include "detray/plugins/svgtools/meta/proto/landmark.hpp"
 
 // System include(s)
 #include <cstdlib>
@@ -16,14 +18,6 @@
 
 namespace detray::svgtools::styling {
 
-struct style {
-    const std::vector<actsvg::style::color> surface_fill_colors;
-    const std::vector<actsvg::style::color> portal_fill_colors;
-    const actsvg::scalar stroke_width;
-    const actsvg::scalar marker_size;
-    const bool hide_links;
-};
-
 namespace colors {
 
 /// @brief Picks a random element in the container.
@@ -80,52 +74,109 @@ std::vector<actsvg::style::color> green_theme(const actsvg::scalar opacity) {
 
 }  // namespace colors
 
-const style default_style{colors::blue_theme(0.8f), colors::red_theme(0.8f),
-                          1.f, 1.2f, false};
+struct landmark_style {
+    const std::vector<actsvg::style::color> _fill_colors;
+    const actsvg::scalar _marker_size;
+};
+
+struct surface_style {
+    const std::vector<actsvg::style::color> _fill_colors;
+    const actsvg::scalar _stroke_width;
+};
+
+struct link_style {
+    const actsvg::scalar _marker_size;
+};
+
+struct portal_style {
+    const surface_style _surface_style;
+    const link_style _link_style;
+    const bool _hide_links;
+};
+
+struct volume_style {
+    const surface_style _surface_style;
+    const portal_style _portal_style;
+};
+
+struct style {
+    const volume_style _volume_style;
+    const landmark_style _intersection_style;
+};
+
+const surface_style surface_style1{colors::blue_theme(0.8f), 1.f};
+
+const surface_style surface_style2{colors::red_theme(0.8f), 1.f};
+
+const link_style link_style1{1.2f};
+
+const portal_style portal_style1{surface_style2, link_style1, false};
+
+const volume_style volume_style1{surface_style1, portal_style1};
+
+const landmark_style landmark_style1{colors::green_theme(0.8f), 5.f};
+
+const style style1{volume_style1, landmark_style1};
 
 /// @brief Sets the style of the proto surface.
 template <typename point3_container_t>
 void apply_style(actsvg::proto::surface<point3_container_t>& p_surface,
-                 const style& styling) {
-    auto fill_color = colors::pick_random(styling.surface_fill_colors);
+                 const surface_style& styling) {
+    auto fill_color = colors::pick_random(styling._fill_colors);
     p_surface._fill = actsvg::style::fill(fill_color);
-    p_surface._stroke = actsvg::style::stroke(fill_color, styling.stroke_width);
+    p_surface._stroke =
+        actsvg::style::stroke(fill_color, styling._stroke_width);
 }
 
 /// @brief Sets the style of the proto link.
 template <typename point3_container_t>
 void apply_style(
     typename actsvg::proto::portal<point3_container_t>::link& p_link,
-    const style& styling) {
-    p_link._end_marker._size = styling.marker_size;
+    const link_style& styling) {
+    p_link._end_marker._size = styling._marker_size;
 }
 
 /// @brief Sets the style of the proto portal.
 template <typename point3_container_t>
 void apply_style(actsvg::proto::portal<point3_container_t>& p_portal,
-                 const style& styling) {
-    auto fill_color = colors::pick_random(styling.portal_fill_colors);
+                 const portal_style& styling) {
+    auto fill_color = colors::pick_random(styling._surface_style._fill_colors);
     p_portal._surface._fill = actsvg::style::fill(fill_color);
     p_portal._surface._stroke =
-        actsvg::style::stroke(fill_color, styling.stroke_width);
-    if (styling.hide_links) {
+        actsvg::style::stroke(fill_color, styling._surface_style._stroke_width);
+    if (styling._hide_links) {
         p_portal._volume_links = {};
     }
     for (auto& volume_link : p_portal._volume_links) {
-        apply_style<point3_container_t>(volume_link, styling);
+        apply_style<point3_container_t>(volume_link, styling._link_style);
     }
 }
 
 /// @brief Sets the style of the proto volume.
 template <typename point3_container_t>
 void apply_style(actsvg::proto::volume<point3_container_t>& p_volume,
-                 const style& styling) {
+                 const volume_style& styling) {
     for (auto& p_surface : p_volume._v_surfaces) {
-        apply_style(p_surface, styling);
+        apply_style(p_surface, styling._surface_style);
     }
     for (auto& p_portals : p_volume._portals) {
-        apply_style(p_portals, styling);
+        apply_style(p_portals, styling._portal_style);
+    }
+}
+
+/// @brief Sets the style of the proto intersection record.
+template <typename point3_t>
+void apply_style(
+    meta::proto::intersection_record<point3_t>& p_intersection_record,
+    const landmark_style& styling) {
+    const auto fill_color = colors::pick_random(styling._fill_colors);
+    const auto fill = actsvg::style::fill(fill_color);
+    const auto stroke = actsvg::style::stroke(fill_color, 3.f);
+    const auto marker =
+        actsvg::style::marker{"x", styling._marker_size, fill, stroke};
+    for (auto& p_landmark : p_intersection_record._landmarks) {
+        p_landmark._marker = marker;
     }
 }
 
-}  // namespace detray::svgtools::styling
\ No newline at end of file
+}  // namespace detray::svgtools::styling
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/utils/mask_utils.hpp b/plugins/svgtools/include/detray/plugins/svgtools/utils/mask_utils.hpp
index 4e0e35f7e..489ed7602 100644
--- a/plugins/svgtools/include/detray/plugins/svgtools/utils/mask_utils.hpp
+++ b/plugins/svgtools/include/detray/plugins/svgtools/utils/mask_utils.hpp
@@ -31,6 +31,7 @@ inline auto local_vertices(const mask<line<>>& m) {
     return dvector<point3_t>{p1, p2};
 }
 
+/// @return The global vertices of the mask.
 template <typename transform_t, typename mask_t>
 inline auto global_vertices(const transform_t& transform, const mask_t& mask) {
     auto ret = local_vertices(mask);
diff --git a/tests/unit_tests/CMakeLists.txt b/tests/unit_tests/CMakeLists.txt
index c913899ac..2fb6a65b1 100644
--- a/tests/unit_tests/CMakeLists.txt
+++ b/tests/unit_tests/CMakeLists.txt
@@ -15,4 +15,4 @@ add_subdirectory( svgtools )
 # Set up all of the "device" tests.
 if( DETRAY_BUILD_CUDA OR DETRAY_BUILD_SYCL )
    add_subdirectory( device )
-endif()
\ No newline at end of file
+endif()
diff --git a/tests/unit_tests/svgtools/CMakeLists.txt b/tests/unit_tests/svgtools/CMakeLists.txt
index 8c27e8a51..411978cfb 100644
--- a/tests/unit_tests/svgtools/CMakeLists.txt
+++ b/tests/unit_tests/svgtools/CMakeLists.txt
@@ -28,3 +28,7 @@ detray_add_test( svgtools_detectors
 detray_add_test( svgtools_groups
    "groups.cpp"
    LINK_LIBRARIES GTest::gtest_main detray_tests_common detray::core_array actsvg::core actsvg::meta detray::svgtools)
+
+detray_add_test( svgtools_intersections
+   "intersections.cpp"
+   LINK_LIBRARIES GTest::gtest_main detray_tests_common detray::core_array actsvg::core actsvg::meta detray::svgtools)
diff --git a/tests/unit_tests/svgtools/intersections.cpp b/tests/unit_tests/svgtools/intersections.cpp
new file mode 100644
index 000000000..13e16b9ff
--- /dev/null
+++ b/tests/unit_tests/svgtools/intersections.cpp
@@ -0,0 +1,73 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+// Project include(s)
+#include "detray/core/detector.hpp"
+#include "detray/detectors/create_toy_geometry.hpp"
+#include "detray/intersection/detail/trajectories.hpp"
+#include "detray/plugins/svgtools/illustrator.hpp"
+#include "detray/plugins/svgtools/writer.hpp"
+#include "detray/simulation/event_generator/track_generators.hpp"
+#include "detray/tracks/tracks.hpp"
+#include "tests/common/tools/particle_gun.hpp"
+
+// Vecmem include(s)
+#include <vecmem/memory/host_memory_resource.hpp>
+
+// Actsvg include(s)
+#include "actsvg/core.hpp"
+
+// System include(s)
+#include <array>
+#include <string>
+
+int main(int, char**) {
+
+    // Axes.
+    const auto axes =
+        actsvg::draw::x_y_axes("axes", {-250, 250}, {-250, 250},
+                               actsvg::style::stroke(), "axis1", "axis2");
+
+    // Creating the view.
+    const actsvg::views::z_r view;
+
+    // Creating the detector and geomentry context.
+    using detector_t = detray::detector<detray::toy_metadata<>>;
+    vecmem::host_memory_resource host_mr;
+    const auto [det, names] = detray::create_toy_geometry(host_mr, 4, 3);
+    detector_t::geometry_context context{};
+
+    using transform3_t = typename detector_t::transform3;
+
+    // Svg for the detector.
+    const detray::svgtools::illustrator il{det, names};
+    const auto svg_det = il.draw_detector("detector", context, view);
+
+    // Creating the rays.
+    unsigned int theta_steps{10u};
+    unsigned int phi_steps{10u};
+    const typename detector_t::point3 ori{0.f, 0.f, 100.f};
+
+    std::size_t index = 0;
+    // Iterate through uniformly distributed momentum directions with ray
+    for (const auto test_ray :
+         detray::uniform_track_generator<detray::detail::ray<transform3_t>>(
+             theta_steps, phi_steps, ori)) {
+
+        // Record all intersections and objects along the ray
+        const auto intersection_record =
+            detray::particle_gun::shoot_particle(det, test_ray);
+
+        const std::string name = "record" + std::to_string(index);
+        const auto svg_ir =
+            il.draw_intersections(name, context, intersection_record, view);
+
+        detray::svgtools::write_svg(name + ".svg", {svg_det, svg_ir});
+
+        index++;
+    }
+}
\ No newline at end of file

From fa41ccb075b358ef67743bf159028b12c93b37cb Mon Sep 17 00:00:00 2001
From: beomki-yeo <beomki.yeo@gmail.com>
Date: Wed, 6 Sep 2023 22:17:46 +0200
Subject: [PATCH 07/29] Remove simulation application

---
 tests/CMakeLists.txt                          |   1 -
 tests/simulation/CMakeLists.txt               |   9 -
 tests/simulation/run_simulation.cpp           |  61 ---
 tests/validation/src/CMakeLists.txt           |   6 +-
 .../validation/src/simulation_validation.cpp  | 366 ------------------
 .../detray/simulation/measurement_smearer.hpp |  89 -----
 utils/include/detray/simulation/simulator.hpp | 116 ------
 .../detray/simulation/smearing_writer.hpp     | 158 --------
 8 files changed, 1 insertion(+), 805 deletions(-)
 delete mode 100644 tests/simulation/CMakeLists.txt
 delete mode 100644 tests/simulation/run_simulation.cpp
 delete mode 100644 tests/validation/src/simulation_validation.cpp
 delete mode 100644 utils/include/detray/simulation/measurement_smearer.hpp
 delete mode 100644 utils/include/detray/simulation/simulator.hpp
 delete mode 100644 utils/include/detray/simulation/smearing_writer.hpp

diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index ead715d6c..55271ed75 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -25,6 +25,5 @@ if( DETRAY_BENCHMARKS )
    add_subdirectory( benchmarks )
 endif()
 add_subdirectory( common )
-add_subdirectory( simulation )
 add_subdirectory( unit_tests )
 add_subdirectory( validation )
diff --git a/tests/simulation/CMakeLists.txt b/tests/simulation/CMakeLists.txt
deleted file mode 100644
index fc1dc2cc3..000000000
--- a/tests/simulation/CMakeLists.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-# Detray library, part of the ACTS project (R&D line)
-#
-# (c) 2022-2023 CERN for the benefit of the ACTS project
-#
-# Mozilla Public License Version 2.0
-
-detray_add_executable(run_simulation
-   "run_simulation.cpp"
-   LINK_LIBRARIES detray_tests_common detray::algebra_array )
diff --git a/tests/simulation/run_simulation.cpp b/tests/simulation/run_simulation.cpp
deleted file mode 100644
index c1538faea..000000000
--- a/tests/simulation/run_simulation.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-/** Detray library, part of the ACTS project (R&D line)
- *
- * (c) 2022-2023 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-// Algebra include(s).
-#include "detray/plugins/algebra/array_definitions.hpp"
-
-// Project include(s).
-#include "detray/detectors/create_toy_geometry.hpp"
-#include "detray/simulation/event_generator/track_generators.hpp"
-#include "detray/simulation/simulator.hpp"
-
-// VecMem include(s).
-#include <vecmem/memory/host_memory_resource.hpp>
-
-using namespace detray;
-using transform3 = __plugin::transform3<detray::scalar>;
-
-int main() {
-
-    // Memory resource
-    vecmem::host_memory_resource host_mr;
-
-    // Create B field
-    const vector3 B{0.f, 0.f, 2.f * unit<scalar>::T};
-
-    // Create geometry
-    using b_field_t = decltype(create_toy_geometry(host_mr).first)::bfield_type;
-    const auto [detector, names] = create_toy_geometry(
-        host_mr,
-        b_field_t(b_field_t::backend_t::configuration_t{B[0], B[1], B[2]}));
-
-    // Create track generator
-    constexpr std::size_t theta_steps{4u};
-    constexpr std::size_t phi_steps{4u};
-    const vector3 ori{0.f, 0.f, 0.f};
-    const scalar mom{1.f * unit<scalar>::GeV};
-    auto generator = uniform_track_generator<free_track_parameters<transform3>>(
-        theta_steps, phi_steps, ori, mom);
-
-    // Create smearer
-    measurement_smearer<transform3> smearer(100.f * unit<scalar>::um,
-                                            100.f * unit<scalar>::um);
-
-    using detector_type = decltype(detector);
-    using generator_type = decltype(generator);
-    using writer_type = smearing_writer<measurement_smearer<transform3>>;
-
-    typename writer_type::config writer_cfg{smearer};
-
-    std::size_t n_events = 2u;
-    auto sim = simulator<detector_type, generator_type, writer_type>(
-        n_events, detector, std::move(generator), std::move(writer_cfg));
-
-    sim.run();
-
-    return 0;
-}
diff --git a/tests/validation/src/CMakeLists.txt b/tests/validation/src/CMakeLists.txt
index 02e081e39..ea1c0df72 100644
--- a/tests/validation/src/CMakeLists.txt
+++ b/tests/validation/src/CMakeLists.txt
@@ -21,8 +21,4 @@ detray_add_test(toy_detector
 
 detray_add_test(wire_chamber
                 "wire_chamber_validation.cpp"
-                LINK_LIBRARIES GTest::gtest GTest::gtest_main detray_validation)
-
-detray_add_test(simulation 
-                "simulation_validation.cpp"
-                LINK_LIBRARIES GTest::gtest GTest::gtest_main detray_validation)
+                LINK_LIBRARIES GTest::gtest GTest::gtest_main detray_validation)
\ No newline at end of file
diff --git a/tests/validation/src/simulation_validation.cpp b/tests/validation/src/simulation_validation.cpp
deleted file mode 100644
index 6c88f31af..000000000
--- a/tests/validation/src/simulation_validation.cpp
+++ /dev/null
@@ -1,366 +0,0 @@
-/** Detray library, part of the ACTS project (R&D line)
- *
- * (c) 2022-2023 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-// Project include(s).
-#include "detray/detectors/create_telescope_detector.hpp"
-#include "detray/detectors/create_toy_geometry.hpp"
-#include "detray/geometry/surface.hpp"
-#include "detray/io/common/detail/utils.hpp"
-#include "detray/masks/masks.hpp"
-#include "detray/masks/unbounded.hpp"
-#include "detray/simulation/event_generator/track_generators.hpp"
-#include "detray/simulation/simulator.hpp"
-#include "detray/test/types.hpp"
-#include "detray/tracks/bound_track_parameters.hpp"
-#include "detray/utils/statistics.hpp"
-
-// VecMem include(s).
-#include <vecmem/memory/host_memory_resource.hpp>
-
-// GTest include(s).
-#include <gtest/gtest.h>
-
-// System include(s).
-#include <limits>
-
-using namespace detray;
-using transform3 = test::transform3;
-
-constexpr scalar tol{1e-7f};
-
-// Test measurement smearer
-GTEST_TEST(detray_simulation, measurement_smearer) {
-
-    const mask<line<false, line_intersector, 1u>> ln_1D{
-        0u, 10.f * unit<scalar>::mm, 50.f * unit<scalar>::mm};
-
-    const mask<line<false, line_intersector, 2u>> ln_2D{
-        0u, 10.f * unit<scalar>::mm, 50.f * unit<scalar>::mm};
-
-    const mask<rectangle2D<plane_intersector, 1u>> re_1D{
-        0u, 10.f * unit<scalar>::mm, 10.f * unit<scalar>::mm};
-
-    const mask<rectangle2D<plane_intersector, 2u>> re_2D{
-        0u, 10.f * unit<scalar>::mm, 10.f * unit<scalar>::mm};
-
-    bound_track_parameters<transform3> bound_params;
-    auto& bound_vec = bound_params.vector();
-    getter::element(bound_vec, e_bound_loc0, 0u) = 1.f;
-    getter::element(bound_vec, e_bound_loc1, 0u) = 2.f;
-
-    measurement_smearer<transform3> smearer(0.f, 0.f);
-
-    const auto local_line_1 = smearer(ln_1D, {-3.f, 2.f}, bound_params);
-    ASSERT_NEAR(local_line_1[0], 0.f, tol);
-    // Null for one dimensional measurement
-    ASSERT_NEAR(local_line_1[1], 0.f, tol);
-
-    const auto local_line_2 = smearer(ln_2D, {2.f, -5.f}, bound_params);
-    ASSERT_NEAR(local_line_2[0], 3.f, tol);
-    ASSERT_NEAR(local_line_2[1], -3.f, tol);
-
-    const auto local_rectangle_1 = smearer(re_1D, {-3.f, 2.f}, bound_params);
-    ASSERT_NEAR(local_rectangle_1[0], -2.f, tol);
-    // Null for one dimensional measurement
-    ASSERT_NEAR(local_rectangle_1[1], 0.f, tol);
-
-    const auto local_rectangle_2 = smearer(re_2D, {2.f, -5.f}, bound_params);
-    ASSERT_NEAR(local_rectangle_2[0], 3.f, tol);
-    ASSERT_NEAR(local_rectangle_2[1], -3.f, tol);
-}
-
-GTEST_TEST(detray_simulation, toy_geometry_simulation) {
-
-    // Use deterministic random number generator for testing
-    using normal_gen_t =
-        random_numbers<scalar, std::normal_distribution<scalar>, std::seed_seq>;
-
-    // Create geometry
-    vecmem::host_memory_resource host_mr;
-
-    // Create B field
-    const vector3 B{0.f, 0.f, 2.f * unit<scalar>::T};
-
-    // Create geometry
-    using b_field_t = decltype(create_toy_geometry(host_mr).first)::bfield_type;
-    const auto [detector, names] = create_toy_geometry(
-        host_mr,
-        b_field_t(b_field_t::backend_t::configuration_t{B[0], B[1], B[2]}));
-
-    using geo_cxt_t = typename decltype(detector)::geometry_context;
-    const geo_cxt_t ctx{};
-
-    // Create track generator
-    constexpr unsigned int n_tracks{2500u};
-    const vector3 ori{0.f, 0.f, 0.f};
-    auto generator =
-        random_track_generator<free_track_parameters<transform3>, normal_gen_t>(
-            n_tracks, ori);
-
-    // Create smearer
-    measurement_smearer<transform3> smearer(67.f * unit<scalar>::um,
-                                            170.f * unit<scalar>::um);
-
-    std::size_t n_events{10u};
-
-    using detector_type = decltype(detector);
-    using generator_type = decltype(generator);
-    using writer_type = smearing_writer<measurement_smearer<transform3>>;
-
-    typename writer_type::config writer_cfg{smearer};
-
-    auto sim = simulator<detector_type, generator_type, writer_type>(
-        n_events, detector, std::move(generator), std::move(writer_cfg),
-        test::filenames);
-
-    // Lift step size constraints
-    sim.get_config().step_constraint = std::numeric_limits<scalar>::max();
-
-    // Do the simulation
-    sim.run();
-
-    for (std::size_t i_event = 0u; i_event < n_events; i_event++) {
-
-        std::vector<csv_particle> particles;
-        std::vector<csv_hit> hits;
-        std::vector<csv_measurement> measurements;
-        std::vector<csv_meas_hit_id> meas_hit_ids;
-
-        // Check particle data
-        const auto io_particles_file =
-            test::filenames +
-            detail::get_event_filename(i_event, "-particles.csv");
-        particle_reader preader(io_particles_file);
-
-        csv_particle io_particle;
-        while (preader.read(io_particle)) {
-            particles.push_back(io_particle);
-        }
-
-        ASSERT_EQ(particles.size(), n_tracks);
-
-        // Check hit & measurement data
-        const auto io_hits_file =
-            test::filenames + detail::get_event_filename(i_event, "-hits.csv");
-        hit_reader hreader(
-            io_hits_file,
-            {"particle_id", "geometry_id", "tx", "ty", "tz", "tt", "tpx", "tpy",
-             "tpz", "te", "deltapx", "deltapy", "deltapz", "deltae", "index"});
-
-        csv_hit io_hit;
-        while (hreader.read(io_hit)) {
-            hits.push_back(io_hit);
-        }
-
-        const auto io_measurements_file =
-            test::filenames +
-            detail::get_event_filename(i_event, "-measurements.csv");
-        measurement_reader mreader(
-            io_measurements_file,
-            {"geometry_id", "local_key", "local0", "local1", "phi", "theta",
-             "time", "var_local0", "var_local1", "var_phi", "var_theta",
-             "var_time"});
-
-        csv_measurement io_measurement;
-        while (mreader.read(io_measurement)) {
-            measurements.push_back(io_measurement);
-        }
-
-        const auto io_meas_hit_id_file =
-            test::filenames +
-            detail::get_event_filename(i_event, "-measurement-simhit-map.csv");
-        meas_hit_id_reader meas_hit_id_reader(io_meas_hit_id_file,
-                                              {"measurement_id", "hit_id"});
-        csv_meas_hit_id io_meas_hit_id;
-        while (meas_hit_id_reader.read(io_meas_hit_id)) {
-            meas_hit_ids.push_back(io_meas_hit_id);
-        }
-
-        ASSERT_TRUE(not measurements.empty());
-        ASSERT_EQ(hits.size(), measurements.size());
-        ASSERT_EQ(hits.size(), meas_hit_ids.size());
-
-        // Let's check if measurement smearing works correctly...
-        std::vector<scalar> local0_diff;
-        std::vector<scalar> local1_diff;
-
-        const std::size_t nhits = hits.size();
-        for (std::size_t i = 0u; i < nhits; i++) {
-            const point3 pos{hits[i].tx, hits[i].ty, hits[i].tz};
-            const vector3 mom{hits[i].tpx, hits[i].tpy, hits[i].tpz};
-            const auto truth_local =
-                surface{detector, geometry::barcode(hits[i].geometry_id)}
-                    .global_to_local(ctx, pos, vector::normalize(mom));
-
-            local0_diff.push_back(truth_local[0] - measurements[i].local0);
-            local1_diff.push_back(truth_local[1] - measurements[i].local1);
-
-            ASSERT_EQ(meas_hit_ids[i].hit_id, i);
-            ASSERT_EQ(meas_hit_ids[i].measurement_id, i);
-        }
-
-        const auto var0 = statistics::variance(local0_diff);
-        const auto var1 = statistics::variance(local1_diff);
-
-        EXPECT_NEAR((std::sqrt(var0) - smearer.stddev[0]) / smearer.stddev[0],
-                    0.f, 0.1f);
-        EXPECT_NEAR((std::sqrt(var1) - smearer.stddev[1]) / smearer.stddev[1],
-                    0.f, 0.1f);
-    }
-}
-
-// Test parameters: <initial momentum, theta direction>
-class TelescopeDetectorSimulation
-    : public ::testing::TestWithParam<std::tuple<scalar, scalar>> {};
-
-TEST_P(TelescopeDetectorSimulation, telescope_detector_simulation) {
-
-    // Create geometry
-    vecmem::host_memory_resource host_mr;
-
-    // Build from given module positions
-    std::vector<scalar> positions = {0.f,   50.f,  100.f, 150.f, 200.f, 250.f,
-                                     300.f, 350.f, 400.f, 450.f, 500.f};
-
-    // A thickness larger than 0.1 cm will flip the track direction of low
-    // energy (or non-relativistic) particle due to the large scattering
-    const scalar thickness = 0.005f * unit<scalar>::cm;
-
-    tel_det_config<rectangle2D<>> tel_cfg{1000.f * unit<scalar>::mm,
-                                          1000.f * unit<scalar>::mm};
-    tel_cfg.positions(positions).mat_thickness(thickness);
-
-    const auto [detector, names] = create_telescope_detector(host_mr, tel_cfg);
-
-    // Momentum
-    const scalar mom = std::get<0>(GetParam());
-
-    // Create track generator
-    constexpr unsigned int theta_steps{1u};
-    constexpr unsigned int phi_steps{1u};
-    const vector3 ori{0.f, 0.f, 0.f};
-    const scalar theta = std::get<1>(GetParam());
-    auto generator = uniform_track_generator<free_track_parameters<transform3>>(
-        theta_steps, phi_steps, ori, mom, {theta, theta}, {0.f, 0.f});
-
-    // Create smearer
-    measurement_smearer<transform3> smearer(50.f * unit<scalar>::um,
-                                            50.f * unit<scalar>::um);
-
-    std::size_t n_events{1000u};
-
-    using detector_type = decltype(detector);
-    using generator_type = decltype(generator);
-    using writer_type = smearing_writer<measurement_smearer<transform3>>;
-
-    typename writer_type::config writer_cfg{smearer};
-
-    auto sim = simulator<detector_type, generator_type, writer_type>(
-        n_events, detector, std::move(generator), std::move(writer_cfg),
-        test::filenames);
-
-    // Lift step size constraints
-    sim.get_config().step_constraint = std::numeric_limits<scalar>::max();
-
-    // Run simulation
-    sim.run();
-
-    for (std::size_t i_event{0u}; i_event < n_events; i_event++) {
-
-        std::vector<csv_measurement> measurements;
-
-        const auto io_measurements_file =
-            test::filenames +
-            detail::get_event_filename(i_event, "-measurements.csv");
-        measurement_reader mreader(
-            io_measurements_file,
-            {"geometry_id", "local_key", "local0", "local1", "phi", "theta",
-             "time", "var_local0", "var_local1", "var_phi", "var_theta",
-             "var_time"});
-
-        csv_measurement io_measurement;
-        while (mreader.read(io_measurement)) {
-            measurements.push_back(io_measurement);
-        }
-
-        // Make sure that number of measurements is equal to the number of
-        // physical planes
-        ASSERT_EQ(measurements.size(), positions.size());
-    }
-}
-
-INSTANTIATE_TEST_SUITE_P(
-    Simulation1, TelescopeDetectorSimulation,
-    ::testing::Values(std::make_tuple(0.1f * unit<scalar>::GeV, 0.01f)));
-
-INSTANTIATE_TEST_SUITE_P(
-    Simulation2, TelescopeDetectorSimulation,
-    ::testing::Values(std::make_tuple(1.f * unit<scalar>::GeV, 0.01f)));
-
-INSTANTIATE_TEST_SUITE_P(
-    Simulation3, TelescopeDetectorSimulation,
-    ::testing::Values(std::make_tuple(10.f * unit<scalar>::GeV, 0.01f)));
-
-INSTANTIATE_TEST_SUITE_P(
-    Simulation4, TelescopeDetectorSimulation,
-    ::testing::Values(std::make_tuple(100.f * unit<scalar>::GeV, 0.01f)));
-
-INSTANTIATE_TEST_SUITE_P(
-    Simulation5, TelescopeDetectorSimulation,
-    ::testing::Values(std::make_tuple(0.1f * unit<scalar>::GeV, 0.01f)));
-
-INSTANTIATE_TEST_SUITE_P(
-    Simulation6, TelescopeDetectorSimulation,
-    ::testing::Values(std::make_tuple(1.f * unit<scalar>::GeV, 0.01f)));
-
-INSTANTIATE_TEST_SUITE_P(
-    Simulation7, TelescopeDetectorSimulation,
-    ::testing::Values(std::make_tuple(10.f * unit<scalar>::GeV, 0.01f)));
-
-INSTANTIATE_TEST_SUITE_P(
-    Simulation8, TelescopeDetectorSimulation,
-    ::testing::Values(std::make_tuple(100.f * unit<scalar>::GeV, 0.01f)));
-
-INSTANTIATE_TEST_SUITE_P(
-    Simulation9, TelescopeDetectorSimulation,
-    ::testing::Values(std::make_tuple(0.1f * unit<scalar>::GeV,
-                                      constant<scalar>::pi / 8.f)));
-
-INSTANTIATE_TEST_SUITE_P(
-    Simulation10, TelescopeDetectorSimulation,
-    ::testing::Values(std::make_tuple(1.f * unit<scalar>::GeV,
-                                      constant<scalar>::pi / 8.f)));
-
-INSTANTIATE_TEST_SUITE_P(
-    Simulation11, TelescopeDetectorSimulation,
-    ::testing::Values(std::make_tuple(10.f * unit<scalar>::GeV,
-                                      constant<scalar>::pi / 8.f)));
-
-INSTANTIATE_TEST_SUITE_P(
-    Simulation12, TelescopeDetectorSimulation,
-    ::testing::Values(std::make_tuple(100.f * unit<scalar>::GeV,
-                                      constant<scalar>::pi / 8.f)));
-
-INSTANTIATE_TEST_SUITE_P(
-    Simulation13, TelescopeDetectorSimulation,
-    ::testing::Values(std::make_tuple(0.1f * unit<scalar>::GeV,
-                                      constant<scalar>::pi / 6.f)));
-
-INSTANTIATE_TEST_SUITE_P(
-    Simulation14, TelescopeDetectorSimulation,
-    ::testing::Values(std::make_tuple(1.f * unit<scalar>::GeV,
-                                      constant<scalar>::pi / 6.f)));
-
-INSTANTIATE_TEST_SUITE_P(
-    Simulation15, TelescopeDetectorSimulation,
-    ::testing::Values(std::make_tuple(10.f * unit<scalar>::GeV,
-                                      constant<scalar>::pi / 6.f)));
-
-INSTANTIATE_TEST_SUITE_P(
-    Simulation16, TelescopeDetectorSimulation,
-    ::testing::Values(std::make_tuple(100.f * unit<scalar>::GeV,
-                                      constant<scalar>::pi / 6.f)));
diff --git a/utils/include/detray/simulation/measurement_smearer.hpp b/utils/include/detray/simulation/measurement_smearer.hpp
deleted file mode 100644
index 2653a702f..000000000
--- a/utils/include/detray/simulation/measurement_smearer.hpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/** Detray library, part of the ACTS project (R&D line)
- *
- * (c) 2023 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#pragma once
-
-// Project include(s).
-#include "detray/tracks/bound_track_parameters.hpp"
-
-// System include(s).
-#include <array>
-#include <random>
-#include <string>
-
-namespace detray {
-
-template <typename transform3_t>
-struct measurement_smearer {
-
-    using transform3_type = transform3_t;
-    using matrix_operator = typename transform3_t::matrix_actor;
-    using scalar_type = typename transform3_t::scalar_type;
-    using size_type = typename matrix_operator::size_ty;
-    template <size_type ROWS, size_type COLS>
-    using matrix_type =
-        typename matrix_operator::template matrix_type<ROWS, COLS>;
-
-    measurement_smearer(const scalar_type stddev_local0,
-                        const scalar_type stddev_local1)
-        : stddev({stddev_local0, stddev_local1}) {}
-
-    measurement_smearer(measurement_smearer& smearer)
-        : stddev(smearer.stddev), generator(smearer.generator) {}
-
-    void set_seed(const uint_fast64_t sd) { generator.seed(sd); }
-
-    std::array<scalar_type, 2> stddev;
-    std::random_device rd{};
-    std::mt19937_64 generator{rd()};
-
-    std::array<scalar_type, 2> get_offset() {
-        return {
-            std::normal_distribution<scalar_type>(0.f, stddev[0])(generator),
-            std::normal_distribution<scalar_type>(0.f, stddev[1])(generator)};
-    }
-
-    template <typename mask_t>
-    std::array<scalar_type, 2> operator()(
-        const mask_t& mask, const std::array<scalar_type, 2>& offset,
-        const bound_track_parameters<transform3_t>& bound_params) {
-
-        std::array<scalar_type, 2> ret{0.f, 0.f};
-
-        matrix_type<mask_t::shape::meas_dim, 1u> meas =
-            mask.projection_matrix(bound_params) * bound_params.vector();
-
-        if constexpr (mask_t::shape::meas_dim == 1u) {
-            ret[0u] = matrix_operator().element(meas, 0u, 0u) + offset[0];
-            ret[1u] = scalar_type{0.f};
-            // Special treatment for line coordinate: we don't allow negative
-            // radial distance
-            if (mask_t::shape::name == "line" && mask.normal_order == true) {
-                ret[0u] = std::max(ret[0u], static_cast<scalar_type>(0.f));
-            }
-
-        } else if (mask_t::shape::meas_dim == 2u) {
-            ret[0u] = matrix_operator().element(meas, 0u, 0u) + offset[0];
-            ret[1u] = matrix_operator().element(meas, 1u, 0u) + offset[1];
-
-            // Special treatment for line coordinate: we don't allow negative
-            // radial distance
-            if (mask_t::shape::name == "line") {
-
-                if (mask.normal_order == true) {
-                    ret[0u] = std::max(ret[0u], static_cast<scalar_type>(0.f));
-                } else {
-                    ret[1u] = std::max(ret[1u], static_cast<scalar_type>(0.f));
-                }
-            }
-        }
-
-        return ret;
-    }
-};
-
-}  // namespace detray
\ No newline at end of file
diff --git a/utils/include/detray/simulation/simulator.hpp b/utils/include/detray/simulation/simulator.hpp
deleted file mode 100644
index b1102362a..000000000
--- a/utils/include/detray/simulation/simulator.hpp
+++ /dev/null
@@ -1,116 +0,0 @@
-/** Detray library, part of the ACTS project (R&D line)
- *
- * (c) 2022-2023 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#pragma once
-
-// Project include(s).
-#include "detray/propagator/actor_chain.hpp"
-#include "detray/propagator/actors/aborters.hpp"
-#include "detray/propagator/actors/parameter_resetter.hpp"
-#include "detray/propagator/actors/parameter_transporter.hpp"
-#include "detray/propagator/navigator.hpp"
-#include "detray/propagator/propagator.hpp"
-#include "detray/propagator/rk_stepper.hpp"
-#include "detray/simulation/random_scatterer.hpp"
-#include "detray/simulation/smearing_writer.hpp"
-
-// System include(s).
-#include <limits>
-#include <memory>
-
-namespace detray {
-
-template <typename detector_t, typename track_generator_t, typename writer_t>
-struct simulator {
-
-    using scalar_type = typename detector_t::scalar_type;
-
-    struct config {
-        scalar_type overstep_tolerance{-10.f * detray::unit<scalar_type>::um};
-        scalar_type step_constraint{std::numeric_limits<scalar_type>::max()};
-    };
-
-    using transform3 = typename detector_t::transform3;
-    using bfield_type = typename detector_t::bfield_type;
-
-    using actor_chain_type =
-        actor_chain<dtuple, parameter_transporter<transform3>,
-                    random_scatterer<transform3>,
-                    parameter_resetter<transform3>, writer_t>;
-
-    using navigator_type = navigator<detector_t>;
-    using stepper_type = rk_stepper<typename bfield_type::view_t, transform3,
-                                    constrained_step<>>;
-    using propagator_type =
-        propagator<stepper_type, navigator_type, actor_chain_type>;
-
-    simulator(std::size_t events, const detector_t& det,
-              track_generator_t&& track_gen,
-              typename writer_t::config&& writer_cfg,
-              const std::string directory = "")
-        : m_events(events),
-          m_directory(directory),
-          m_detector(std::make_unique<detector_t>(det)),
-          m_track_generator(
-              std::make_unique<track_generator_t>(std::move(track_gen))),
-          m_writer_cfg(writer_cfg) {}
-
-    config& get_config() { return m_cfg; }
-
-    void run() {
-
-        for (std::size_t event_id = 0u; event_id < m_events; event_id++) {
-
-            typename writer_t::state writer_state(
-                event_id, std::move(m_writer_cfg), m_directory);
-
-            // Set random seed
-            m_scatterer.set_seed(event_id);
-            writer_state.set_seed(event_id);
-
-            auto actor_states =
-                std::tie(m_transporter, m_scatterer, m_resetter, writer_state);
-
-            for (auto track : *m_track_generator.get()) {
-
-                writer_state.write_particle(track);
-
-                typename propagator_type::state propagation(
-                    track, m_detector->get_bfield(), *m_detector);
-
-                propagator_type p({}, {});
-
-                // Set overstep tolerance and stepper constraint
-                propagation._stepping().set_overstep_tolerance(
-                    m_cfg.overstep_tolerance);
-                propagation._stepping.template set_constraint<
-                    detray::step::constraint::e_accuracy>(
-                    m_cfg.step_constraint);
-
-                p.propagate(propagation, actor_states);
-
-                // Increase the particle id
-                writer_state.particle_id++;
-            }
-        }
-    }
-
-    private:
-    config m_cfg;
-    std::size_t m_events{0u};
-    std::string m_directory = "";
-    std::unique_ptr<detector_t> m_detector;
-    std::unique_ptr<track_generator_t> m_track_generator;
-    typename writer_t::config m_writer_cfg;
-
-    /// Actor states
-    typename parameter_transporter<transform3>::state m_transporter{};
-    typename random_scatterer<transform3>::state m_scatterer{};
-    typename parameter_resetter<transform3>::state m_resetter{};
-};
-
-}  // namespace detray
\ No newline at end of file
diff --git a/utils/include/detray/simulation/smearing_writer.hpp b/utils/include/detray/simulation/smearing_writer.hpp
deleted file mode 100644
index f3d3e0d87..000000000
--- a/utils/include/detray/simulation/smearing_writer.hpp
+++ /dev/null
@@ -1,158 +0,0 @@
-/** Detray library, part of the ACTS project (R&D line)
- *
- * (c) 2023 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#pragma once
-
-// Detray core include(s).
-#include "detray/definitions/qualifiers.hpp"
-#include "detray/geometry/barcode.hpp"
-#include "detray/geometry/surface.hpp"
-#include "detray/propagator/base_actor.hpp"
-#include "detray/tracks/bound_track_parameters.hpp"
-#include "detray/tracks/free_track_parameters.hpp"
-
-// Detray I/O include(s).
-#include "detray/io/common/detail/utils.hpp"
-#include "detray/io/csv/csv_io_types.hpp"
-
-// Detray utility include(s).
-#include "detray/simulation/measurement_smearer.hpp"
-
-namespace detray {
-
-template <typename smearer_t>
-struct smearing_writer : actor {
-
-    using transform3_type = typename smearer_t::transform3_type;
-    using scalar_type = typename transform3_type::scalar_type;
-
-    struct config {
-        smearer_t smearer;
-    };
-
-    struct state {
-        state(std::size_t event_id, config&& writer_cfg,
-              const std::string directory)
-            : m_particle_writer(directory + detail::get_event_filename(
-                                                event_id, "-particles.csv")),
-              m_hit_writer(directory +
-                           detail::get_event_filename(event_id, "-hits.csv")),
-              m_meas_writer(directory + detail::get_event_filename(
-                                            event_id, "-measurements.csv")),
-              m_meas_hit_id_writer(
-                  directory + detail::get_event_filename(
-                                  event_id, "-measurement-simhit-map.csv")),
-              m_meas_smearer(writer_cfg.smearer) {}
-
-        uint64_t particle_id = 0u;
-        particle_writer m_particle_writer;
-        hit_writer m_hit_writer;
-        measurement_writer m_meas_writer;
-        meas_hit_id_writer m_meas_hit_id_writer;
-        uint64_t m_hit_count = 0u;
-        smearer_t m_meas_smearer;
-
-        void set_seed(const uint_fast64_t sd) { m_meas_smearer.set_seed(sd); }
-
-        void write_particle(
-            const free_track_parameters<transform3_type>& track) {
-            csv_particle particle;
-            const auto pos = track.pos();
-            const auto mom = track.mom();
-
-            particle.particle_id = particle_id;
-            particle.vx = pos[0];
-            particle.vy = pos[1];
-            particle.vz = pos[2];
-            particle.vt = track.time();
-            particle.px = mom[0];
-            particle.py = mom[1];
-            particle.pz = mom[2];
-            particle.q = track.charge();
-
-            m_particle_writer.append(particle);
-        }
-    };
-
-    struct measurement_kernel {
-
-        template <typename mask_group_t, typename index_t>
-        inline std::array<scalar_type, 2> operator()(
-            const mask_group_t& mask_group, const index_t& index,
-            const bound_track_parameters<transform3_type>& bound_params,
-            smearer_t& smearer) const {
-
-            const auto& mask = mask_group[index];
-
-            return smearer(mask, smearer.get_offset(), bound_params);
-        }
-    };
-
-    template <typename propagator_state_t>
-    void operator()(state& writer_state,
-                    propagator_state_t& propagation) const {
-
-        auto& navigation = propagation._navigation;
-        auto& stepping = propagation._stepping;
-
-        // triggered only for sensitive surfaces
-        if (navigation.is_on_sensitive()) {
-
-            // Write hits
-            csv_hit hit;
-
-            const auto track = stepping();
-            const auto pos = track.pos();
-            const auto mom = track.mom();
-
-            const auto sf = navigation.get_surface();
-
-            hit.particle_id = writer_state.particle_id;
-            hit.geometry_id = sf.barcode().value();
-            hit.tx = pos[0];
-            hit.ty = pos[1];
-            hit.tz = pos[2];
-            hit.tt = track.time();
-            hit.tpx = mom[0];
-            hit.tpy = mom[1];
-            hit.tpz = mom[2];
-
-            writer_state.m_hit_writer.append(hit);
-
-            // Write measurements
-            csv_measurement meas;
-
-            const auto bound_params = stepping._bound_params;
-
-            const auto local = sf.template visit_mask<measurement_kernel>(
-                bound_params, writer_state.m_meas_smearer);
-
-            meas.measurement_id = writer_state.m_hit_count;
-            meas.geometry_id = hit.geometry_id;
-            meas.local_key = "unknown";
-            meas.local0 = local[0];
-            meas.local1 = local[1];
-            auto stddev_0 = writer_state.m_meas_smearer.stddev[0];
-            auto stddev_1 = writer_state.m_meas_smearer.stddev[1];
-            meas.var_local0 = stddev_0 * stddev_0;
-            meas.var_local1 = stddev_1 * stddev_1;
-            meas.phi = bound_params.phi();
-            meas.theta = bound_params.theta();
-            meas.time = bound_params.time();
-
-            writer_state.m_meas_writer.append(meas);
-
-            // Write hit measurement map
-            csv_meas_hit_id meas_hit_id;
-            meas_hit_id.hit_id = writer_state.m_hit_count;
-            meas_hit_id.measurement_id = writer_state.m_hit_count;
-            writer_state.m_meas_hit_id_writer.append(meas_hit_id);
-            writer_state.m_hit_count++;
-        }
-    }
-};
-}  // namespace detray

From 19af0120bdc606ef5c0d8983aa446b3b2def4fc0 Mon Sep 17 00:00:00 2001
From: beomki-yeo <beomki.yeo@gmail.com>
Date: Fri, 8 Sep 2023 14:58:02 +0200
Subject: [PATCH 08/29] Remove measurement property from masks

---
 .../include/detray/coordinates/cartesian2.hpp |  10 -
 .../detray/coordinates/coordinate_base.hpp    |  45 ----
 .../detray/coordinates/cylindrical2.hpp       |  10 -
 core/include/detray/coordinates/line2.hpp     |  22 --
 core/include/detray/coordinates/polar2.hpp    |   9 -
 .../geometry/detail/surface_kernels.hpp       |  11 -
 core/include/detray/geometry/surface.hpp      |   6 -
 core/include/detray/masks/annulus2D.hpp       |  13 +-
 core/include/detray/masks/cuboid3D.hpp        |   3 -
 core/include/detray/masks/cylinder2D.hpp      |  13 +-
 core/include/detray/masks/cylinder3D.hpp      |   3 -
 core/include/detray/masks/line.hpp            |  10 +-
 core/include/detray/masks/masks.hpp           |  15 --
 core/include/detray/masks/rectangle2D.hpp     |  10 +-
 core/include/detray/masks/ring2D.hpp          |  10 +-
 core/include/detray/masks/single3D.hpp        |   6 +-
 core/include/detray/masks/trapezoid2D.hpp     |  10 +-
 core/include/detray/masks/unbounded.hpp       |   3 -
 core/include/detray/masks/unmasked.hpp        |   6 -
 tests/unit_tests/cpu/CMakeLists.txt           |   1 -
 tests/unit_tests/cpu/geometry_surface.cpp     |   3 -
 tests/unit_tests/cpu/masks_annulus2D.cpp      |  14 -
 tests/unit_tests/cpu/masks_cylinder.cpp       |  12 -
 tests/unit_tests/cpu/masks_line.cpp           |  28 --
 tests/unit_tests/cpu/masks_rectangle2D.cpp    |  12 -
 tests/unit_tests/cpu/masks_ring2D.cpp         |  12 -
 tests/unit_tests/cpu/masks_single3D.cpp       |  24 --
 tests/unit_tests/cpu/masks_trapezoid2D.cpp    |  12 -
 tests/unit_tests/cpu/masks_unbounded.cpp      |  13 -
 tests/unit_tests/cpu/masks_unmasked.cpp       |  12 -
 tests/unit_tests/cpu/projection_matrix.cpp    | 246 ------------------
 31 files changed, 7 insertions(+), 597 deletions(-)
 delete mode 100644 tests/unit_tests/cpu/projection_matrix.cpp

diff --git a/core/include/detray/coordinates/cartesian2.hpp b/core/include/detray/coordinates/cartesian2.hpp
index 9c20595cb..52b5479cf 100644
--- a/core/include/detray/coordinates/cartesian2.hpp
+++ b/core/include/detray/coordinates/cartesian2.hpp
@@ -157,16 +157,6 @@ struct cartesian2 final : public coordinate_base<cartesian2, transform3_t> {
         const vector3 & /*dir*/) const {
         // Do nothing
     }
-
-    template <size_type meas_dim>
-    DETRAY_HOST_DEVICE inline void unsigned_local(
-        matrix_type<meas_dim, e_bound_size> & /*projection_matrix*/,
-        const bound_track_parameters<transform3_t> & /*bound_params*/,
-        const bool /*normal_order*/) {
-        // Do nothing
-        return;
-    }
-
 };  // struct cartesian2
 
 }  // namespace detray
diff --git a/core/include/detray/coordinates/coordinate_base.hpp b/core/include/detray/coordinates/coordinate_base.hpp
index 5709b1155..4fb4aa3c3 100644
--- a/core/include/detray/coordinates/coordinate_base.hpp
+++ b/core/include/detray/coordinates/coordinate_base.hpp
@@ -239,51 +239,6 @@ struct coordinate_base {
 
         return derivative * path_derivative;
     }
-
-    /// @returns the projection matrix for measurement
-    template <size_type meas_dim>
-    DETRAY_HOST_DEVICE inline matrix_type<meas_dim, e_bound_size>
-    projection_matrix(const bound_track_parameters<transform3_t>& bound_params,
-                      const bool normal_order) {
-
-        matrix_type<meas_dim, e_bound_size> proj =
-            matrix_operator().template zero<meas_dim, e_bound_size>();
-        // For normal ordering
-        if (normal_order == true) {
-            // For meas_dim == 1, Return:
-            // [ 1 0 0 0 0 0 ]
-            if constexpr (meas_dim == 1u) {
-                matrix_operator().element(proj, 0u, 0u) = 1.f;
-            }
-            // For meas_dim == 2, Return:
-            // [ 1 0 0 0 0 0 ]
-            // [ 0 1 0 0 0 0 ]
-            else if (meas_dim == 2u) {
-                matrix_operator().element(proj, 0u, 0u) = 1.f;
-                matrix_operator().element(proj, 1u, 1u) = 1.f;
-            }
-        }
-        // For reverse ordering
-        else {
-            // For meas_dim == 1, Return:
-            // [ 0 1 0 0 0 0 ]
-            if constexpr (meas_dim == 1u) {
-                matrix_operator().element(proj, 0u, 1u) = 1.f;
-            }
-            // For meas_dim == 2, Return:
-            // [ 0 1 0 0 0 0 ]
-            // [ 1 0 0 0 0 0 ]
-            else if (meas_dim == 2u) {
-                matrix_operator().element(proj, 0u, 1u) = 1.f;
-                matrix_operator().element(proj, 1u, 0u) = 1.f;
-            }
-        }
-
-        Derived<transform3_t>().template unsigned_local<meas_dim>(
-            proj, bound_params, normal_order);
-
-        return proj;
-    }
 };
 
 }  // namespace detray
diff --git a/core/include/detray/coordinates/cylindrical2.hpp b/core/include/detray/coordinates/cylindrical2.hpp
index 7e17b479f..ce7fb2a3c 100644
--- a/core/include/detray/coordinates/cylindrical2.hpp
+++ b/core/include/detray/coordinates/cylindrical2.hpp
@@ -200,16 +200,6 @@ struct cylindrical2 : public coordinate_base<cylindrical2, transform3_t> {
         const vector3 & /*dir*/) const {
         // Do nothing
     }
-
-    template <size_type meas_dim>
-    DETRAY_HOST_DEVICE inline void unsigned_local(
-        matrix_type<meas_dim, e_bound_size> & /*projection_matrix*/,
-        const bound_track_parameters<transform3_t> & /*bound_params*/,
-        const bool /*normal_order*/) {
-        // Do nothing
-        return;
-    }
-
 };  // struct cylindrical2
 
 }  // namespace detray
diff --git a/core/include/detray/coordinates/line2.hpp b/core/include/detray/coordinates/line2.hpp
index 035ba9abe..bf18a0920 100644
--- a/core/include/detray/coordinates/line2.hpp
+++ b/core/include/detray/coordinates/line2.hpp
@@ -284,28 +284,6 @@ struct line2 : public coordinate_base<line2, transform3_t> {
                                   e_bound_theta) =
             theta_to_free_pos_derivative[2];
     }
-
-    template <size_type meas_dim>
-    DETRAY_HOST_DEVICE inline void unsigned_local(
-        matrix_type<meas_dim, e_bound_size> &projection_matrix,
-        const bound_track_parameters<transform3_t> &bound_params,
-        const bool normal_order) {
-
-        const auto bound_local = bound_params.bound_local();
-
-        // Change the sign of radial distance if it is negative
-        if (bound_local[0] < 0.f) {
-            if (normal_order == true) {
-                matrix_operator().element(projection_matrix, 0u, 0u) = -1.f;
-            } else {
-                if constexpr (meas_dim == 2u) {
-                    matrix_operator().element(projection_matrix, 1u, 0u) = -1.f;
-                }
-            }
-        }
-
-        return;
-    }
 };
 
 }  // namespace detray
diff --git a/core/include/detray/coordinates/polar2.hpp b/core/include/detray/coordinates/polar2.hpp
index 8233c0c8e..4808c3c58 100644
--- a/core/include/detray/coordinates/polar2.hpp
+++ b/core/include/detray/coordinates/polar2.hpp
@@ -210,15 +210,6 @@ struct polar2 : public coordinate_base<polar2, transform3_t> {
         const vector3 & /*dir*/) const {
         // Do nothing
     }
-
-    template <size_type meas_dim>
-    DETRAY_HOST_DEVICE inline void unsigned_local(
-        matrix_type<meas_dim, e_bound_size> & /*projection_matrix*/,
-        const bound_track_parameters<transform3_t> & /*bound_params*/,
-        const bool /*normal_order*/) {
-        // Do nothing
-        return;
-    }
 };
 
 }  // namespace detray
diff --git a/core/include/detray/geometry/detail/surface_kernels.hpp b/core/include/detray/geometry/detail/surface_kernels.hpp
index 860473c0e..77ba8cb88 100644
--- a/core/include/detray/geometry/detail/surface_kernels.hpp
+++ b/core/include/detray/geometry/detail/surface_kernels.hpp
@@ -58,17 +58,6 @@ struct surface_kernels {
         }
     };
 
-    /// A functor get the measurement dimension
-    struct meas_dim {
-        template <typename mask_group_t, typename index_t>
-        DETRAY_HOST_DEVICE inline unsigned int operator()(
-            const mask_group_t& /*mask_group*/,
-            const index_t& /*index*/) const {
-
-            return mask_group_t::value_type::shape::meas_dim;
-        }
-    };
-
     /// A functor get the surface normal at a given local/bound position
     struct normal {
         template <typename mask_group_t, typename index_t>
diff --git a/core/include/detray/geometry/surface.hpp b/core/include/detray/geometry/surface.hpp
index 840f81be3..2a2ee1927 100644
--- a/core/include/detray/geometry/surface.hpp
+++ b/core/include/detray/geometry/surface.hpp
@@ -139,12 +139,6 @@ class surface {
         return transform(ctx).translation();
     }
 
-    /// @returns the measurement dimesntion of surface
-    DETRAY_HOST_DEVICE
-    constexpr auto meas_dim() const -> unsigned int {
-        return visit_mask<typename kernels::meas_dim>();
-    }
-
     /// @returns the surface normal in global coordinates at a given bound/local
     /// position @param p
     template <typename point_t = point2,
diff --git a/core/include/detray/masks/annulus2D.hpp b/core/include/detray/masks/annulus2D.hpp
index 02c6f7372..4bfab3dc4 100644
--- a/core/include/detray/masks/annulus2D.hpp
+++ b/core/include/detray/masks/annulus2D.hpp
@@ -30,9 +30,6 @@ namespace detray {
 ///
 /// @tparam intersector_t defines how to intersect the underlying surface
 ///         geometry
-/// @tparam kMeasDim defines the dimension of the measurement
-/// @tparam kNormalOrder true if the index for measurement parameter follows
-/// the local coordinate system
 ///
 /// The stereo annulus is defined in two different(!) polar coordinate systems
 /// that differ by an origin shift. The boundaries are the inner and outer
@@ -49,20 +46,12 @@ namespace detray {
 /// origin from the beam polar system, two additional conversion parameters are
 /// included (bounds[4], bounds[5]). These are the origin shift in x and y
 /// respectively.
-template <template <typename> class intersector_t = plane_intersector,
-          unsigned int kMeasDim = 1u>
+template <template <typename> class intersector_t = plane_intersector>
 class annulus2D {
     public:
     /// The name for this shape
     inline static const std::string name = "(stereo) annulus2D";
 
-    /// The measurement dimension
-    inline static constexpr const unsigned int meas_dim{kMeasDim};
-
-    // Measurement dimension check
-    static_assert(meas_dim == 1u || meas_dim == 2u,
-                  "Only 1D or 2D measurement is allowed");
-
     /// Names for the mask boundary values
     enum boundaries : unsigned int {
         e_min_r = 0u,
diff --git a/core/include/detray/masks/cuboid3D.hpp b/core/include/detray/masks/cuboid3D.hpp
index 22c229f66..b042d9b6d 100644
--- a/core/include/detray/masks/cuboid3D.hpp
+++ b/core/include/detray/masks/cuboid3D.hpp
@@ -33,9 +33,6 @@ class cuboid3D {
     /// The name for this shape
     inline static const std::string name = "cuboid3D";
 
-    /// The measurement dimension (not allowed)
-    inline static constexpr const unsigned int meas_dim{0u};
-
     enum boundaries : unsigned int {
         e_min_x = 0u,
         e_min_y = 1u,
diff --git a/core/include/detray/masks/cylinder2D.hpp b/core/include/detray/masks/cylinder2D.hpp
index 6278c5cd2..bf2986c6d 100644
--- a/core/include/detray/masks/cylinder2D.hpp
+++ b/core/include/detray/masks/cylinder2D.hpp
@@ -30,14 +30,10 @@ namespace detray {
 ///         needs to be checked (changes local coordinate system def.)
 /// @tparam intersector_t defines how to intersect the underlying surface
 ///         geometry
-/// @tparam kMeasDim defines the dimension of the measurement
-/// @tparam kNormalOrder true if the index for measurement parameter follows
-/// the local coordinate system
 ///
 /// 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,
-          unsigned int kMeasDim = 2u>
+          template <typename> class intersector_t = cylinder_intersector>
 class cylinder2D {
     public:
     /// The name for this shape
@@ -46,13 +42,6 @@ class cylinder2D {
     /// Check the radial position in boundary check
     static constexpr bool check_radius = kRadialCheck;
 
-    /// The measurement dimension
-    inline static constexpr const unsigned int meas_dim{kMeasDim};
-
-    // Measurement dimension check
-    static_assert(meas_dim == 1u || meas_dim == 2u,
-                  "Only 1D or 2D measurement is allowed");
-
     enum boundaries : unsigned int {
         e_r = 0u,
         e_n_half_z = 1u,
diff --git a/core/include/detray/masks/cylinder3D.hpp b/core/include/detray/masks/cylinder3D.hpp
index 453dd2ecd..17fef91cc 100644
--- a/core/include/detray/masks/cylinder3D.hpp
+++ b/core/include/detray/masks/cylinder3D.hpp
@@ -31,9 +31,6 @@ class cylinder3D {
     /// The name for this shape
     inline static const std::string name = "cylinder3D";
 
-    /// The measurement dimension (not allowed)
-    inline static constexpr const unsigned int meas_dim{0u};
-
     enum boundaries : unsigned int {
         e_min_r = 0u,
         e_min_phi = 1u,
diff --git a/core/include/detray/masks/line.hpp b/core/include/detray/masks/line.hpp
index 66e4d3c46..28bd5f765 100644
--- a/core/include/detray/masks/line.hpp
+++ b/core/include/detray/masks/line.hpp
@@ -40,8 +40,7 @@ namespace detray {
 /// 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,
-          unsigned int kMeasDim = 1u>
+          template <typename> class intersector_t = line_intersector>
 class line {
     public:
     /// The name for this shape
@@ -50,13 +49,6 @@ class line {
     /// Geometrical cross section of the line
     static constexpr bool square_cross_sect = kSquareCrossSect;
 
-    /// The measurement dimension
-    inline static constexpr const unsigned int meas_dim{kMeasDim};
-
-    // Measurement dimension check
-    static_assert(meas_dim == 1u || meas_dim == 2u,
-                  "Only 1D or 2D measurement is allowed");
-
     enum boundaries : unsigned int {
         e_cross_section = 0u,
         e_half_z = 1u,
diff --git a/core/include/detray/masks/masks.hpp b/core/include/detray/masks/masks.hpp
index f8089ecab..fe0ba6ae8 100644
--- a/core/include/detray/masks/masks.hpp
+++ b/core/include/detray/masks/masks.hpp
@@ -59,14 +59,6 @@ class mask {
     // Linear algebra types
     using point3_t = typename algebra_t::point3;
     using point2_t = typename algebra_t::point2;
-    using matrix_operator = typename algebra_t::matrix_actor;
-    using size_type = typename algebra_t::size_type;
-    template <size_type ROWS, size_type COLS>
-    using matrix_type = typename algebra_t::template matrix_type<ROWS, COLS>;
-    using projection_matrix_type = matrix_type<shape::meas_dim, e_bound_size>;
-
-    // Measurement ordering
-    bool normal_order = true;
 
     /// Default constructor
     constexpr mask() = default;
@@ -197,13 +189,6 @@ class mask {
     DETRAY_HOST_DEVICE
     auto volume_link() -> links_type& { return _volume_link; }
 
-    /// @returns the projection matrix for measurement
-    DETRAY_HOST_DEVICE projection_matrix_type projection_matrix(
-        const bound_track_parameters<algebra_t>& bound_params) const {
-        return this->local_frame().template projection_matrix<shape::meas_dim>(
-            bound_params, normal_order);
-    }
-
     /// @brief Lower and upper point for minimum axis aligned bounding box.
     ///
     /// Computes the min and max vertices in a local 3 dim cartesian frame.
diff --git a/core/include/detray/masks/rectangle2D.hpp b/core/include/detray/masks/rectangle2D.hpp
index 7e3772e37..6120eebca 100644
--- a/core/include/detray/masks/rectangle2D.hpp
+++ b/core/include/detray/masks/rectangle2D.hpp
@@ -32,20 +32,12 @@ namespace detray {
 /// the local coordinate system
 ///
 /// It is defined by half length in local0 coordinates bounds[0] and bounds[1]
-template <template <typename> class intersector_t = plane_intersector,
-          unsigned int kMeasDim = 2u>
+template <template <typename> class intersector_t = plane_intersector>
 class rectangle2D {
     public:
     /// The name for this shape
     inline static const std::string name = "rectangle2D";
 
-    /// The measurement dimension
-    inline static constexpr const unsigned int meas_dim{kMeasDim};
-
-    // Measurement dimension check
-    static_assert(meas_dim == 1u || meas_dim == 2u,
-                  "Only 1D or 2D measurement is allowed");
-
     enum boundaries : unsigned int {
         e_half_x = 0u,
         e_half_y = 1u,
diff --git a/core/include/detray/masks/ring2D.hpp b/core/include/detray/masks/ring2D.hpp
index 5a6a68815..46a2072cb 100644
--- a/core/include/detray/masks/ring2D.hpp
+++ b/core/include/detray/masks/ring2D.hpp
@@ -33,20 +33,12 @@ namespace detray {
 ///
 /// 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,
-          unsigned int kMeasDim = 2u>
+template <template <typename> class intersector_t = plane_intersector>
 class ring2D {
     public:
     /// The name for this shape
     inline static const std::string name = "ring2D";
 
-    /// The measurement dimension
-    inline static constexpr const unsigned int meas_dim{kMeasDim};
-
-    // Measurement dimension check
-    static_assert(meas_dim == 1u || meas_dim == 2u,
-                  "Only 1D or 2D measurement is allowed");
-
     enum boundaries : unsigned int {
         e_inner_r = 0u,
         e_outer_r = 1u,
diff --git a/core/include/detray/masks/single3D.hpp b/core/include/detray/masks/single3D.hpp
index 0b9550962..1d0651cda 100644
--- a/core/include/detray/masks/single3D.hpp
+++ b/core/include/detray/masks/single3D.hpp
@@ -34,16 +34,12 @@ namespace detray {
 /// @tparam kNormalOrder true if the index for measurement parameter follows
 /// the local coordinate system
 template <unsigned int kCheckIndex = 0u,
-          template <typename> class intersector_t = plane_intersector,
-          unsigned int kMeasDim = 2u>
+          template <typename> class intersector_t = plane_intersector>
 class single3D {
     public:
     /// The name for this shape
     inline static const std::string name = "single3D";
 
-    /// The measurement dimension
-    inline static constexpr const unsigned int meas_dim{kMeasDim};
-
     enum boundaries : unsigned int {
         e_lower = 0u,
         e_upper = 1u,
diff --git a/core/include/detray/masks/trapezoid2D.hpp b/core/include/detray/masks/trapezoid2D.hpp
index d5c2c7f3f..c85ef2aec 100644
--- a/core/include/detray/masks/trapezoid2D.hpp
+++ b/core/include/detray/masks/trapezoid2D.hpp
@@ -35,20 +35,12 @@ namespace detray {
 /// 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,
-          unsigned int kMeasDim = 2u>
+template <template <typename> class intersector_t = plane_intersector>
 class trapezoid2D {
     public:
     /// The name for this shape
     inline static const std::string name = "trapezoid2D";
 
-    /// The measurement dimension
-    inline static constexpr const unsigned int meas_dim{kMeasDim};
-
-    // Measurement dimension check
-    static_assert(meas_dim == 1u || meas_dim == 2u,
-                  "Only 1D or 2D measurement is allowed");
-
     enum boundaries : unsigned int {
         e_half_length_0 = 0u,
         e_half_length_1 = 1u,
diff --git a/core/include/detray/masks/unbounded.hpp b/core/include/detray/masks/unbounded.hpp
index cb680ece5..115c67337 100644
--- a/core/include/detray/masks/unbounded.hpp
+++ b/core/include/detray/masks/unbounded.hpp
@@ -29,9 +29,6 @@ class unbounded {
     /// The name for this shape
     inline static const std::string name = "unbounded " + shape::name;
 
-    /// The measurement dimension
-    inline static constexpr const std::size_t meas_dim = shape::meas_dim;
-
     /// Local coordinate frame for boundary checks
     template <typename algebra_t>
     using local_frame_type =
diff --git a/core/include/detray/masks/unmasked.hpp b/core/include/detray/masks/unmasked.hpp
index 68d439860..4349ce604 100644
--- a/core/include/detray/masks/unmasked.hpp
+++ b/core/include/detray/masks/unmasked.hpp
@@ -28,12 +28,6 @@ class unmasked {
     /// The name for this shape
     inline static const std::string name = "unmasked";
 
-    /// The measurement dimension
-    inline static constexpr const unsigned int meas_dim{2u};
-
-    /// normal ordering
-    inline static constexpr const bool normal_order = true;
-
     enum boundaries : unsigned int { e_size = 1u };
 
     /// Local coordinate frame for boundary checks
diff --git a/tests/unit_tests/cpu/CMakeLists.txt b/tests/unit_tests/cpu/CMakeLists.txt
index 277505512..246d60bee 100644
--- a/tests/unit_tests/cpu/CMakeLists.txt
+++ b/tests/unit_tests/cpu/CMakeLists.txt
@@ -48,7 +48,6 @@ macro( detray_add_cpu_test algebra )
       "masks_unmasked.cpp"
       "material_interaction.cpp"
       "materials.cpp"
-      "projection_matrix.cpp"
       "scattering.cpp"
       "sf_finder_brute_force.cpp"
       "test_core.cpp"
diff --git a/tests/unit_tests/cpu/geometry_surface.cpp b/tests/unit_tests/cpu/geometry_surface.cpp
index 5fb40526d..5cc6a033a 100644
--- a/tests/unit_tests/cpu/geometry_surface.cpp
+++ b/tests/unit_tests/cpu/geometry_surface.cpp
@@ -147,7 +147,4 @@ GTEST_TEST(detray_geometry, surface) {
     ASSERT_NEAR(global2[1], glob_pos[1], tol);
     // The bound transform assumes the point is on surface
     ASSERT_NEAR(global2[2], disc_translation[2], tol);
-
-    // WARNING: This should be 0u for portal
-    ASSERT_EQ(disc.meas_dim(), 2u);
 }
diff --git a/tests/unit_tests/cpu/masks_annulus2D.cpp b/tests/unit_tests/cpu/masks_annulus2D.cpp
index 8f6935188..ea5ec855a 100644
--- a/tests/unit_tests/cpu/masks_annulus2D.cpp
+++ b/tests/unit_tests/cpu/masks_annulus2D.cpp
@@ -44,7 +44,6 @@ GTEST_TEST(detray_masks, annulus2D) {
 
     mask<annulus2D<>> ann2{0u,     minR, maxR,      minPhi,
                            maxPhi, 0.f,  offset[0], offset[1]};
-    ann2.normal_order = false;
 
     ASSERT_NEAR(ann2[annulus2D<>::e_min_r], 7.2f, tol);
     ASSERT_NEAR(ann2[annulus2D<>::e_max_r], 12.0f, tol);
@@ -70,19 +69,6 @@ GTEST_TEST(detray_masks, annulus2D) {
     ASSERT_TRUE(ann2.is_inside(toStripFrame(p2_out4), 0.07f) ==
                 intersection::status::e_inside);
 
-    // Dummy bound track parameter
-    bound_track_parameters<transform3_t> bound_params;
-
-    // Check projection matrix
-    const auto proj = ann2.projection_matrix(bound_params);
-    for (unsigned int i = 0u; i < e_bound_size; i++) {
-        if (i == 1u) {
-            ASSERT_EQ(getter::element(proj, 0u, i), 1u);
-        } else {
-            ASSERT_EQ(getter::element(proj, 0u, i), 0u);
-        }
-    }
-
     // Check corner positions
     std::array<scalar, 8> c = ann2.get_shape().corners(ann2.values());
     for (unsigned int i{0u}; i < 8u; i += 2u) {
diff --git a/tests/unit_tests/cpu/masks_cylinder.cpp b/tests/unit_tests/cpu/masks_cylinder.cpp
index e04bef897..763a829c0 100644
--- a/tests/unit_tests/cpu/masks_cylinder.cpp
+++ b/tests/unit_tests/cpu/masks_cylinder.cpp
@@ -44,18 +44,6 @@ GTEST_TEST(detray_masks, cylinder2D) {
     // Dummy bound track parameter
     bound_track_parameters<transform3_t> bound_params;
 
-    // Check projection matrix
-    const auto proj = c.projection_matrix(bound_params);
-    for (unsigned int i = 0u; i < decltype(c)::shape::meas_dim; i++) {
-        for (unsigned int j = 0u; j < e_bound_size; j++) {
-            if (i == j) {
-                ASSERT_EQ(getter::element(proj, i, j), 1u);
-            } else {
-                ASSERT_EQ(getter::element(proj, i, j), 0u);
-            }
-        }
-    }
-
     // Check bounding box
     constexpr scalar envelope{0.01f};
     const auto loc_bounds = c.local_min_bounds(envelope);
diff --git a/tests/unit_tests/cpu/masks_line.cpp b/tests/unit_tests/cpu/masks_line.cpp
index dd4c48118..51cc7735f 100644
--- a/tests/unit_tests/cpu/masks_line.cpp
+++ b/tests/unit_tests/cpu/masks_line.cpp
@@ -50,18 +50,6 @@ GTEST_TEST(detray_masks, line_radial_cross_sect) {
     auto& bound_vec = bound_params.vector();
     getter::element(bound_vec, e_bound_loc0, 0u) = 1.f;
 
-    // Check projection matrix
-    const auto proj = ln.projection_matrix(bound_params);
-    for (unsigned int i = 0u; i < decltype(ln)::shape::meas_dim; i++) {
-        for (unsigned int j = 0u; j < e_bound_size; j++) {
-            if (i == j) {
-                ASSERT_EQ(getter::element(proj, i, j), 1u);
-            } else {
-                ASSERT_EQ(getter::element(proj, i, j), 0u);
-            }
-        }
-    }
-
     // Check bounding box
     constexpr scalar envelope{0.01f};
     const auto loc_bounds = ln.local_min_bounds(envelope);
@@ -100,22 +88,6 @@ GTEST_TEST(detray_masks, line_square_cross_sect) {
     auto& bound_vec = bound_params.vector();
     getter::element(bound_vec, e_bound_loc0, 0u) = -1.f;
 
-    // Check projection matrix
-    const auto proj = ln.projection_matrix(bound_params);
-    for (unsigned int i = 0u; i < decltype(ln)::shape::meas_dim; i++) {
-        for (unsigned int j = 0u; j < e_bound_size; j++) {
-            if (i == j) {
-                if (i == 1) {
-                    ASSERT_EQ(getter::element(proj, i, j), -1.f);
-                } else if (i == 2) {
-                    ASSERT_EQ(getter::element(proj, i, j), 1.f);
-                }
-            } else {
-                ASSERT_EQ(getter::element(proj, i, j), 0u);
-            }
-        }
-    }
-
     // Check bounding box
     constexpr scalar envelope{0.01f};
     const auto loc_bounds = ln.local_min_bounds(envelope);
diff --git a/tests/unit_tests/cpu/masks_rectangle2D.cpp b/tests/unit_tests/cpu/masks_rectangle2D.cpp
index 586e5082b..f1647e27f 100644
--- a/tests/unit_tests/cpu/masks_rectangle2D.cpp
+++ b/tests/unit_tests/cpu/masks_rectangle2D.cpp
@@ -44,18 +44,6 @@ GTEST_TEST(detray_masks, rectangle2D) {
     // Dummy bound track parameter
     bound_track_parameters<transform3_t> bound_params;
 
-    // Check projection matrix
-    const auto proj = r2.projection_matrix(bound_params);
-    for (unsigned int i = 0u; i < decltype(r2)::shape::meas_dim; i++) {
-        for (unsigned int j = 0u; j < e_bound_size; j++) {
-            if (i == j) {
-                ASSERT_EQ(getter::element(proj, i, j), 1u);
-            } else {
-                ASSERT_EQ(getter::element(proj, i, j), 0u);
-            }
-        }
-    }
-
     // Check bounding box
     constexpr scalar envelope{0.01f};
     const auto loc_bounds = r2.local_min_bounds(envelope);
diff --git a/tests/unit_tests/cpu/masks_ring2D.cpp b/tests/unit_tests/cpu/masks_ring2D.cpp
index 0912023f3..195841f31 100644
--- a/tests/unit_tests/cpu/masks_ring2D.cpp
+++ b/tests/unit_tests/cpu/masks_ring2D.cpp
@@ -44,18 +44,6 @@ GTEST_TEST(detray_masks, ring2D) {
     // Dummy bound track parameter
     bound_track_parameters<transform3_t> bound_params;
 
-    // Check projection matrix
-    const auto proj = r2.projection_matrix(bound_params);
-    for (unsigned int i = 0u; i < decltype(r2)::shape::meas_dim; i++) {
-        for (unsigned int j = 0u; j < e_bound_size; j++) {
-            if (i == j) {
-                ASSERT_EQ(getter::element(proj, i, j), 1u);
-            } else {
-                ASSERT_EQ(getter::element(proj, i, j), 0u);
-            }
-        }
-    }
-
     // Check bounding box
     constexpr scalar envelope{0.01f};
     const auto loc_bounds = r2.local_min_bounds(envelope);
diff --git a/tests/unit_tests/cpu/masks_single3D.cpp b/tests/unit_tests/cpu/masks_single3D.cpp
index 1f6ba4c90..5f42026e5 100644
--- a/tests/unit_tests/cpu/masks_single3D.cpp
+++ b/tests/unit_tests/cpu/masks_single3D.cpp
@@ -72,18 +72,6 @@ GTEST_TEST(detray_masks, single3_1) {
     // Dummy bound track parameter
     bound_track_parameters<transform3_t> bound_params;
 
-    // Check projection matrix
-    const auto proj = m1_1.projection_matrix(bound_params);
-    for (unsigned int i = 0u; i < decltype(m1_1)::shape::meas_dim; i++) {
-        for (unsigned int j = 0u; j < e_bound_size; j++) {
-            if (i == j) {
-                ASSERT_EQ(getter::element(proj, i, j), 1u);
-            } else {
-                ASSERT_EQ(getter::element(proj, i, j), 0u);
-            }
-        }
-    }
-
     // Check bounding box
     constexpr scalar envelope{0.01f};
     const auto loc_bounds = m1_1.local_min_bounds(envelope);
@@ -118,18 +106,6 @@ GTEST_TEST(detray_masks, single3_2) {
     // Dummy bound track parameter
     bound_track_parameters<transform3_t> bound_params;
 
-    // Check projection matrix
-    const auto proj = m1_2.projection_matrix(bound_params);
-    for (unsigned int i = 0u; i < decltype(m1_2)::shape::meas_dim; i++) {
-        for (unsigned int j = 0u; j < e_bound_size; j++) {
-            if (i == j) {
-                ASSERT_EQ(getter::element(proj, i, j), 1u);
-            } else {
-                ASSERT_EQ(getter::element(proj, i, j), 0u);
-            }
-        }
-    }
-
     // Check bounding box
     constexpr scalar envelope{0.01f};
     const auto loc_bounds = m1_2.local_min_bounds(envelope);
diff --git a/tests/unit_tests/cpu/masks_trapezoid2D.cpp b/tests/unit_tests/cpu/masks_trapezoid2D.cpp
index f8a6eaa32..c7988977a 100644
--- a/tests/unit_tests/cpu/masks_trapezoid2D.cpp
+++ b/tests/unit_tests/cpu/masks_trapezoid2D.cpp
@@ -47,18 +47,6 @@ GTEST_TEST(detray_masks, trapezoid2D) {
     // Dummy bound track parameter
     bound_track_parameters<transform3_t> bound_params;
 
-    // Check projection matrix
-    const auto proj = t2.projection_matrix(bound_params);
-    for (unsigned int i = 0u; i < decltype(t2)::shape::meas_dim; i++) {
-        for (unsigned int j = 0u; j < e_bound_size; j++) {
-            if (i == j) {
-                ASSERT_EQ(getter::element(proj, i, j), 1u);
-            } else {
-                ASSERT_EQ(getter::element(proj, i, j), 0u);
-            }
-        }
-    }
-
     // Check bounding box
     constexpr scalar envelope{0.01f};
     const auto loc_bounds = t2.local_min_bounds(envelope);
diff --git a/tests/unit_tests/cpu/masks_unbounded.cpp b/tests/unit_tests/cpu/masks_unbounded.cpp
index 984586f70..51d11b539 100644
--- a/tests/unit_tests/cpu/masks_unbounded.cpp
+++ b/tests/unit_tests/cpu/masks_unbounded.cpp
@@ -51,7 +51,6 @@ GTEST_TEST(detray_masks, unbounded) {
 
     // Test static members
     EXPECT_TRUE(unbounded_t::name == "unbounded rectangle2D");
-    EXPECT_TRUE(unbounded_t::meas_dim == 2u);
 
     // Test boundary check
     typename mask<unbounded_t>::point3_t p2 = {0.5f, -9.f, 0.f};
@@ -60,18 +59,6 @@ GTEST_TEST(detray_masks, unbounded) {
     // Dummy bound track parameter
     bound_track_parameters<transform3_t> bound_params;
 
-    // Check projection matrix
-    const auto proj = u.projection_matrix(bound_params);
-    for (unsigned int i = 0u; i < decltype(u)::shape::meas_dim; i++) {
-        for (unsigned int j = 0u; j < e_bound_size; j++) {
-            if (i == j) {
-                ASSERT_EQ(getter::element(proj, i, j), 1u);
-            } else {
-                ASSERT_EQ(getter::element(proj, i, j), 0u);
-            }
-        }
-    }
-
     // Check bounding box
     constexpr scalar envelope{0.01f};
     const auto loc_bounds = u.local_min_bounds(envelope);
diff --git a/tests/unit_tests/cpu/masks_unmasked.cpp b/tests/unit_tests/cpu/masks_unmasked.cpp
index f7722ba4e..179a7c5a8 100644
--- a/tests/unit_tests/cpu/masks_unmasked.cpp
+++ b/tests/unit_tests/cpu/masks_unmasked.cpp
@@ -27,18 +27,6 @@ GTEST_TEST(detray_masks, unmasked) {
     // Dummy bound track parameter
     bound_track_parameters<transform3_t> bound_params;
 
-    // Check projection matrix
-    const auto proj = u.projection_matrix(bound_params);
-    for (unsigned int i = 0u; i < decltype(u)::shape::meas_dim; i++) {
-        for (unsigned int j = 0u; j < e_bound_size; j++) {
-            if (i == j) {
-                ASSERT_EQ(getter::element(proj, i, j), 1u);
-            } else {
-                ASSERT_EQ(getter::element(proj, i, j), 0u);
-            }
-        }
-    }
-
     // Check bounding box
     constexpr scalar envelope{0.01f};
     const auto loc_bounds = u.local_min_bounds(envelope);
diff --git a/tests/unit_tests/cpu/projection_matrix.cpp b/tests/unit_tests/cpu/projection_matrix.cpp
deleted file mode 100644
index 07dea81d0..000000000
--- a/tests/unit_tests/cpu/projection_matrix.cpp
+++ /dev/null
@@ -1,246 +0,0 @@
-/** Detray library, part of the ACTS project
- *
- * (c) 2023 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-// Project include(s).
-#include "detray/masks/masks.hpp"
-#include "detray/test/types.hpp"
-#include "detray/tracks/bound_track_parameters.hpp"
-
-// Google test include(s).
-#include <gtest/gtest.h>
-
-using namespace detray;
-using transform3_t = test::transform3;
-
-/// This tests the basic functionality of projection matrix
-GTEST_TEST(detray_masks, projection_matrix_rectangle) {
-
-    bound_track_parameters<transform3_t> bound_params;
-
-    // 2D, normal ordering
-    mask<rectangle2D<>> rec_0{0u, 0.f, 0.f};
-
-    // Check the projection matrix
-    // [ 1 0 0 0 0 0 ]
-    // [ 0 1 0 0 0 0 ]
-    const auto proj_0 = rec_0.projection_matrix(bound_params);
-    for (unsigned int i = 0u; i < 2u; i++) {
-        for (unsigned int j = 0u; j < e_bound_size; j++) {
-            if (i == j) {
-                ASSERT_EQ(getter::element(proj_0, i, j), 1.f);
-            } else {
-                ASSERT_EQ(getter::element(proj_0, i, j), 0.f);
-            }
-        }
-    }
-
-    // 2D, reverse ordering
-    mask<rectangle2D<plane_intersector, 2u>> rec_1{0u, 0.f, 0.f};
-    rec_1.normal_order = false;
-
-    // Check the projection matrix
-    // [ 0 1 0 0 0 0 ]
-    // [ 1 0 0 0 0 0 ]
-    const auto proj_1 = rec_1.projection_matrix(bound_params);
-    for (unsigned int i = 0u; i < 2u; i++) {
-        for (unsigned int j = 0u; j < e_bound_size; j++) {
-            if ((i == 0 && j == 1) || (i == 1 && j == 0)) {
-                ASSERT_EQ(getter::element(proj_1, i, j), 1.f);
-            } else {
-                ASSERT_EQ(getter::element(proj_1, i, j), 0.f);
-            }
-        }
-    }
-
-    // 1D, normal ordering
-    mask<rectangle2D<plane_intersector, 1u>> rec_2{0u, 0.f, 0.f};
-
-    // Check the projection matrix
-    // [ 1 0 0 0 0 0 ]
-    const auto proj_2 = rec_2.projection_matrix(bound_params);
-    for (unsigned int i = 0u; i < 1u; i++) {
-        for (unsigned int j = 0u; j < e_bound_size; j++) {
-            if (i == j) {
-                ASSERT_EQ(getter::element(proj_2, i, j), 1.f);
-            } else {
-                ASSERT_EQ(getter::element(proj_2, i, j), 0.f);
-            }
-        }
-    }
-
-    // 1D, reverse ordering
-    mask<rectangle2D<plane_intersector, 1u>> rec_3{0u, 0.f, 0.f};
-    rec_3.normal_order = false;
-
-    // Check the projection matrix
-    // [ 0 1 0 0 0 0 ]
-    const auto proj_3 = rec_3.projection_matrix(bound_params);
-    for (unsigned int i = 0u; i < 1u; i++) {
-        for (unsigned int j = 0u; j < e_bound_size; j++) {
-            if (i == 0 && j == 1) {
-                ASSERT_EQ(getter::element(proj_3, i, j), 1.f);
-            } else {
-                ASSERT_EQ(getter::element(proj_3, i, j), 0.f);
-            }
-        }
-    }
-}
-
-TEST(projection_matrix, annulus) {
-
-    bound_track_parameters<transform3_t> bound_params;
-
-    // 1D reverse ordering
-    mask<annulus2D<>> ann_0{0u, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f};
-    ann_0.normal_order = false;
-
-    // Check the projection matrix
-    // [ 0 1 0 0 0 0 ]
-    const auto proj_0 = ann_0.projection_matrix(bound_params);
-    for (unsigned int i = 0u; i < 1u; i++) {
-        for (unsigned int j = 0u; j < e_bound_size; j++) {
-            if (i == 0 && j == 1) {
-                ASSERT_EQ(getter::element(proj_0, i, j), 1.f);
-            } else {
-                ASSERT_EQ(getter::element(proj_0, i, j), 0.f);
-            }
-        }
-    }
-
-    // 1D normal ordering
-    mask<annulus2D<plane_intersector, 1u>> ann_1{0u,  0.f, 0.f, 0.f,
-                                                 0.f, 0.f, 0.f, 0.f};
-
-    // Check the projection matrix
-    // [ 1 0 0 0 0 0 ]
-    const auto proj_1 = ann_1.projection_matrix(bound_params);
-    for (unsigned int i = 0u; i < 1u; i++) {
-        for (unsigned int j = 0u; j < e_bound_size; j++) {
-            if (i == j) {
-                ASSERT_EQ(getter::element(proj_1, i, j), 1.f);
-            } else {
-                ASSERT_EQ(getter::element(proj_1, i, j), 0.f);
-            }
-        }
-    }
-
-    // 2D reverse ordering
-    mask<annulus2D<plane_intersector, 2u>> ann_2{0u,  0.f, 0.f, 0.f,
-                                                 0.f, 0.f, 0.f, 0.f};
-    ann_2.normal_order = false;
-
-    // Check the projection matrix
-    // [ 0 1 0 0 0 0 ]
-    // [ 1 0 0 0 0 0 ]
-    const auto proj_2 = ann_2.projection_matrix(bound_params);
-    for (unsigned int i = 0u; i < 2u; i++) {
-        for (unsigned int j = 0u; j < e_bound_size; j++) {
-            if ((i == 0 && j == 1) || (i == 1 && j == 0)) {
-                ASSERT_EQ(getter::element(proj_2, i, j), 1.f);
-            } else {
-                ASSERT_EQ(getter::element(proj_2, i, j), 0.f);
-            }
-        }
-    }
-
-    // 2D normal ordering
-    mask<annulus2D<plane_intersector, 2u>> ann_3{0u,  0.f, 0.f, 0.f,
-                                                 0.f, 0.f, 0.f, 0.f};
-
-    // Check the projection matrix
-    // [ 1 0 0 0 0 0 ]
-    // [ 0 1 0 0 0 0 ]
-    const auto proj_3 = ann_3.projection_matrix(bound_params);
-    for (unsigned int i = 0u; i < 2u; i++) {
-        for (unsigned int j = 0u; j < e_bound_size; j++) {
-            if (i == j) {
-                ASSERT_EQ(getter::element(proj_3, i, j), 1.f);
-            } else {
-                ASSERT_EQ(getter::element(proj_3, i, j), 0.f);
-            }
-        }
-    }
-}
-
-TEST(projection_matrix, line) {
-
-    bound_track_parameters<transform3_t> bound_params;
-    auto& bound_vec = bound_params.vector();
-    getter::element(bound_vec, e_bound_loc0, 0u) = -1.f;
-
-    // 1D normal ordering
-    mask<line<>> ln_0{0u, 0.f, 0.f};
-
-    // Check the projection matrix
-    // [ -1 0 0 0 0 0 ]
-    const auto proj_0 = ln_0.projection_matrix(bound_params);
-    for (unsigned int i = 0u; i < 1u; i++) {
-        for (unsigned int j = 0u; j < e_bound_size; j++) {
-            if (i == j) {
-                ASSERT_EQ(getter::element(proj_0, i, j), -1.f);
-            } else {
-                ASSERT_EQ(getter::element(proj_0, i, j), 0.f);
-            }
-        }
-    }
-
-    // 1D reverse ordering
-    mask<line<false, line_intersector, 1u>> ln_1{0u, 0.f, 0.f};
-    ln_1.normal_order = false;
-
-    // Check the projection matrix
-    // [ 0 1 0 0 0 0 ]
-    const auto proj_1 = ln_1.projection_matrix(bound_params);
-    for (unsigned int i = 0u; i < 1u; i++) {
-        for (unsigned int j = 0u; j < e_bound_size; j++) {
-            if (i == 0 && j == 1) {
-                ASSERT_EQ(getter::element(proj_1, i, j), 1.f);
-            } else {
-                ASSERT_EQ(getter::element(proj_1, i, j), 0.f);
-            }
-        }
-    }
-
-    // 2D normal ordering
-    mask<line<false, line_intersector, 2u>> ln_2{0u, 0.f, 0.f};
-
-    // Check the projection matrix
-    // [-1 0 0 0 0 0 ]
-    // [ 0 1 0 0 0 0 ]
-    const auto proj_2 = ln_2.projection_matrix(bound_params);
-    for (unsigned int i = 0u; i < 2u; i++) {
-        for (unsigned int j = 0u; j < e_bound_size; j++) {
-            if (i == 0 && j == 0) {
-                ASSERT_EQ(getter::element(proj_2, i, j), -1.f);
-            } else if (i == 1 && j == 1) {
-                ASSERT_EQ(getter::element(proj_2, i, j), 1.f);
-            } else {
-                ASSERT_EQ(getter::element(proj_2, i, j), 0.f);
-            }
-        }
-    }
-
-    // 2D reverse ordering
-    mask<line<false, line_intersector, 2u>> ln_3{0u, 0.f, 0.f};
-    ln_3.normal_order = false;
-
-    // Check the projection matrix
-    // [ 0 1 0 0 0 0 ]
-    // [-1 0 0 0 0 0 ]
-    const auto proj_3 = ln_3.projection_matrix(bound_params);
-    for (unsigned int i = 0u; i < 2u; i++) {
-        for (unsigned int j = 0u; j < e_bound_size; j++) {
-            if (i == 0 && j == 1) {
-                ASSERT_EQ(getter::element(proj_3, i, j), 1.f);
-            } else if (i == 1 && j == 0) {
-                ASSERT_EQ(getter::element(proj_3, i, j), -1.f);
-            } else {
-                ASSERT_EQ(getter::element(proj_3, i, j), 0.f);
-            }
-        }
-    }
-}

From 8761df648bcf07f75e49fd919748d433ada02394 Mon Sep 17 00:00:00 2001
From: beomki-yeo <63090140+beomki-yeo@users.noreply.github.com>
Date: Tue, 19 Sep 2023 15:20:15 +0200
Subject: [PATCH 09/29] Update Detray Version to v43

---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8df533ecb..ae4c97439 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -6,7 +6,7 @@
 
 # Set up the project.
 cmake_minimum_required( VERSION 3.11 )
-project( detray VERSION 0.41.0 LANGUAGES CXX )
+project( detray VERSION 0.43.0 LANGUAGES CXX )
 
 # Set up the used C++ standard(s).
 set( CMAKE_CXX_STANDARD 17 CACHE STRING "The (host) C++ standard to use" )

From a6408da6d5c9010ebf054f0b75c108055bcf9928 Mon Sep 17 00:00:00 2001
From: Joana Niermann <joana.niermann@cern.ch>
Date: Tue, 7 Mar 2023 23:40:11 +0100
Subject: [PATCH 10/29] Add arbitrary bfield types (defined in a dedicated
 header) to the detector with comprehensive testing both for host and device.
 Since the covfie field types for host and device are a bit different, the
 detector and the detector_view had to be templated on the field/backend type,
 so that in the detector view and buffer classes the correct covfie
 constructors are called, which move the data to device. Because this needs a
 special interface for now, the detector has its own versions of the get_data
 and get_buffer functions. To make sure the detector with all the data it
 contains now is not copied, the copy constructor and copy-assignment operator
 were deleted and some downsteam adjustments for this were made in the io and
 simulation packages.

In order to manage the multiplicity of test cases (const bfield/inhomogeneous bfield) the stepper and
propagation unittests were adapted and new ones for the inhomogeneous bfield were added
(note: these can't compare against a helix anymore, since the tracks are no longer helical!).
The device propagation unittests involved a huge amount of duplicate code between the CUDA and
SYCL implementations which was moved into a common propagator test header (mostly the CPU code and
the comparison of the results between host and device). The sycl code that could not be unified
contains the sycl queue wrapper.

The toy detector has a new config struct now, which makes it easier to build different bfield types.
In many cases, the default values of this config are used and new values only set explicitely where
they diverge from the default.

The file handle saw some fixes, too. Mainly for the counting of open files and the correct handling of
empty file names.

A generic bfield reader has been added with a concrete reader implementation for covfie, which can now be
used to read the bfield files into the detector along the detray json data files.

The covfie version was bumped to 0.8.0

In order to make the CI pass, the ODD bfield file was uploaded to the traccc data repository and is
downloaded with the same script in detray now as is used in traccc

Co-authored-by: Stephen Nicholas Swatman <stephen.nicholas.swatman@cern.ch>
Co-authored-by: Guilherme Almeida <g.almeida@cern.ch>
---
 .github/workflows/builds.yml                  |   9 +-
 .gitlab-ci.yml                                |  16 +-
 core/include/detray/core/detector.hpp         | 149 +++++-----
 .../include/detray/core/detector_metadata.hpp |   9 -
 .../detray/definitions/bfield_backends.hpp    |  34 +++
 core/include/detray/propagator/rk_stepper.ipp |   7 +-
 .../include/detray/tools/detector_builder.hpp |  24 +-
 data/detray_data_get_files.sh                 |  97 +++++++
 extern/covfie/CMakeLists.txt                  |   4 +-
 io/include/detray/io/common/bfield_reader.hpp |  90 ++++++
 .../common/detail/detector_components_io.hpp  |  10 +-
 .../detray/io/common/detail/file_handle.hpp   |  89 +++++-
 .../detray/io/common/detector_reader.hpp      |  38 ++-
 .../detray/io/common/detector_writer.hpp      |   6 +-
 .../detray/io/common/geometry_reader.hpp      |  10 +-
 .../io/common/homogeneous_material_reader.hpp |   5 +-
 io/include/detray/io/common/io_interface.hpp  |   4 +-
 io/include/detray/io/json/json_reader.hpp     |  13 +-
 io/include/detray/io/json/json_writer.hpp     |   5 +-
 tests/CMakeLists.txt                          |   1 +
 tests/benchmarks/cpu/find_volume.cpp          |   6 +-
 tests/benchmarks/cpu/intersect_all.cpp        |   6 +-
 .../cuda/benchmark_propagator_cuda.cpp        |  28 +-
 .../cuda/benchmark_propagator_cuda_kernel.cu  |   6 +-
 .../cuda/benchmark_propagator_cuda_kernel.hpp |  15 +-
 .../common/test_base/propagator_test.hpp      | 200 +++++++++++--
 .../tests/common/test_toy_detector.hpp        |   9 +-
 tests/unit_tests/covfie/constant_field.cpp    |   9 +-
 tests/unit_tests/cpu/core_detector.cpp        |   2 +-
 tests/unit_tests/cpu/geometry_surface.cpp     |   2 +-
 .../unit_tests/cpu/geometry_volume_graph.cpp  |   8 +-
 tests/unit_tests/cpu/grid_grid_builder.cpp    |   6 +-
 tests/unit_tests/cpu/io_read_detector.cpp     |  30 ++
 tests/unit_tests/cpu/line_stepper.cpp         |   5 +-
 .../cpu/test_telescope_detector.cpp           |   8 +-
 tests/unit_tests/cpu/test_toy_geometry.cpp    |   5 +-
 .../unit_tests/cpu/tools_guided_navigator.cpp |   4 +-
 .../unit_tests/cpu/tools_material_builder.cpp |   2 +-
 tests/unit_tests/cpu/tools_navigator.cpp      |   6 +-
 tests/unit_tests/cpu/tools_particle_gun.cpp   |  12 +-
 tests/unit_tests/cpu/tools_propagator.cpp     | 221 +++++++++-----
 tests/unit_tests/cpu/tools_stepper.cpp        | 184 +++++++++---
 tests/unit_tests/device/cuda/CMakeLists.txt   |   2 +-
 .../unit_tests/device/cuda/detector_cuda.cpp  |   4 +-
 .../device/cuda/detector_cuda_kernel.cu       |  17 +-
 .../device/cuda/detector_cuda_kernel.hpp      |  26 +-
 .../unit_tests/device/cuda/navigator_cuda.cpp |   5 +-
 .../device/cuda/navigator_cuda_kernel.cu      |   6 +-
 .../device/cuda/navigator_cuda_kernel.hpp     |  13 +-
 .../device/cuda/propagator_cuda.cpp           | 264 ++++++-----------
 .../device/cuda/propagator_cuda_kernel.cu     |  82 ++++--
 .../device/cuda/propagator_cuda_kernel.hpp    | 115 +++++++-
 tests/unit_tests/device/sycl/CMakeLists.txt   |   2 +-
 tests/unit_tests/device/sycl/propagator.sycl  | 274 +++++++-----------
 .../device/sycl/propagator_kernel.hpp         |  25 --
 .../device/sycl/propagator_kernel.sycl        |  95 +++---
 .../device/sycl/propagator_sycl_kernel.hpp    | 114 ++++++++
 tests/unit_tests/io/CMakeLists.txt            |   3 +
 tests/unit_tests/io/io_bfield_reader.cpp      |  81 ++++++
 .../unit_tests/io/io_json_detector_reader.cpp |  17 +-
 .../unit_tests/io/io_json_detector_writer.cpp |   9 +-
 tests/unit_tests/svgtools/detectors.cpp       |   6 +-
 tests/unit_tests/svgtools/groups.cpp          |   6 +-
 tests/unit_tests/svgtools/intersections.cpp   |   6 +-
 tests/unit_tests/svgtools/masks.cpp           |   4 +-
 tests/unit_tests/svgtools/surfaces.cpp        |   6 +-
 tests/unit_tests/svgtools/volumes.cpp         |   6 +-
 .../validation/detail/register_checks.hpp     |   2 +-
 .../src/toy_detector_validation.cpp           |  20 +-
 .../detray/tutorial/detector_metadata.hpp     |   9 -
 .../tutorial/square_surface_generator.hpp     |   6 +-
 .../detector/build_predefined_detectors.cpp   |  16 +-
 .../src/cpu/detector/detector_to_dot.cpp      |   4 +-
 .../cpu/detector/do_it_yourself_detector.cpp  |   5 +-
 .../cpu/detector/read_detector_from_file.cpp  |   4 +-
 .../cpu/propagation/navigation_inspection.cpp |   5 +-
 .../src/device/cuda/detector_construction.cpp |  22 +-
 .../src/device/cuda/detector_construction.cu  |   9 +-
 .../src/device/cuda/detector_construction.hpp |  16 +-
 tutorials/src/device/cuda/propagation.cpp     |  11 +-
 tutorials/src/device/cuda/propagation.hpp     |  18 +-
 .../src/device/cuda/propagation_kernel.cu     |   8 +-
 .../detectors/create_telescope_detector.hpp   |  22 +-
 .../detray/detectors/create_toy_geometry.hpp  | 169 +++++++----
 .../detray/detectors/create_wire_chamber.hpp  |  47 ++-
 .../include/detray/detectors/itk_metadata.hpp |   9 -
 .../detray/detectors/telescope_metadata.hpp   |  11 +-
 .../include/detray/detectors/toy_metadata.hpp |   9 -
 88 files changed, 1939 insertions(+), 1065 deletions(-)
 create mode 100644 core/include/detray/definitions/bfield_backends.hpp
 create mode 100755 data/detray_data_get_files.sh
 create mode 100644 io/include/detray/io/common/bfield_reader.hpp
 create mode 100644 tests/unit_tests/cpu/io_read_detector.cpp
 delete mode 100644 tests/unit_tests/device/sycl/propagator_kernel.hpp
 create mode 100644 tests/unit_tests/device/sycl/propagator_sycl_kernel.hpp
 create mode 100644 tests/unit_tests/io/io_bfield_reader.cpp

diff --git a/.github/workflows/builds.yml b/.github/workflows/builds.yml
index 801b01b4b..46b05ef86 100644
--- a/.github/workflows/builds.yml
+++ b/.github/workflows/builds.yml
@@ -70,10 +70,18 @@ jobs:
       run:
         shell: bash
 
+    # Set the path to the test data files
+    env:
+      DETRAY_DATA_DIRECTORY: ${{ github.workspace }}/data/
+      DETRAY_BFIELD_FILE: ${{ github.workspace }}/data/odd-bfield_v0_8_0.cvf
+
     # The build/test steps to execute.
     steps:
     # Use a standard checkout of the code.
     - uses: actions/checkout@v2
+    # Get the data files for the tests
+    - name: Download data files
+      run: data/detray_data_get_files.sh
     # Run the CMake configuration.
     - name: Configure
       run: |
@@ -137,4 +145,3 @@ jobs:
       run: |
         source ${GITHUB_WORKSPACE}/.github/ci_setup.sh ${{ matrix.PLATFORM.NAME }}
         cmake --build build
-
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 7d6d27dc3..663b35794 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -8,7 +8,7 @@ build_cuda:
   stage: build
   image: ghcr.io/acts-project/ubuntu2004_cuda:v30
   artifacts:
-    paths: 
+    paths:
       - build
   script:
       - git clone $CLONE_URL src
@@ -26,12 +26,18 @@ build_cuda:
 
 
 test_cuda:
+  variables:
+    DETRAY_DATA_DIRECTORY: src/data/
+    DETRAY_BFIELD_FILE: $CI_PROJECT_DIR/src/data/odd-bfield_v0_8_0.cvf
   stage: test
   tags: [docker-gpu-nvidia]
   image: ghcr.io/acts-project/ubuntu2004_cuda:v30
-  needs: 
+  needs:
     - build_cuda
   script:
+    - git clone $CLONE_URL src
+    - git -C src checkout $HEAD_SHA
+    - src/data/detray_data_get_files.sh
     - cd build
     - nvidia-smi
     - ctest --output-on-failure -R ".*cuda.*"
@@ -43,7 +49,7 @@ build_sycl:
   stage: build
   image: "ghcr.io/acts-project/ubuntu2004_oneapi:v30"
   artifacts:
-    paths: 
+    paths:
       - build
   script:
       - git clone $CLONE_URL src
@@ -66,7 +72,7 @@ test_sycl:
   stage: test
   tags: [docker-gpu-nvidia]
   image: "ghcr.io/acts-project/ubuntu2004_oneapi:v30"
-  needs: 
+  needs:
     - build_sycl
   script:
     - git clone $CLONE_URL src
@@ -75,4 +81,4 @@ test_sycl:
     - cd build
     - nvidia-smi
     - ctest --output-on-failure -R ".*sycl.*"
-    - find bin -type f -name "*sycl" -not -name "*text*" -exec {} \;
\ No newline at end of file
+    - find bin -type f -name "*sycl" -not -name "*text*" -exec {} \;
diff --git a/core/include/detray/core/detector.hpp b/core/include/detray/core/detector.hpp
index 9bdd1976a..2c217bf41 100644
--- a/core/include/detray/core/detector.hpp
+++ b/core/include/detray/core/detector.hpp
@@ -11,6 +11,7 @@
 #include "detray/core/detail/container_buffers.hpp"
 #include "detray/core/detail/container_views.hpp"
 #include "detray/core/detector_metadata.hpp"
+#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/containers.hpp"
 #include "detray/definitions/qualifiers.hpp"
 #include "detray/geometry/detail/volume_descriptor.hpp"
@@ -22,9 +23,6 @@
 // Vecmem include(s)
 #include <vecmem/memory/memory_resource.hpp>
 
-// Covfie include(s)
-#include <covfie/core/field.hpp>
-
 // System include(s)
 #include <algorithm>
 #include <map>
@@ -34,8 +32,7 @@
 namespace detray {
 
 /// @brief Forward declaration of a detector view type
-template <typename metadata, template <typename> class bfield_t,
-          typename container_t>
+template <typename device_bfield_bknd_t, typename metadata, typename bfield_t>
 struct detector_view;
 
 /// @brief The detector definition.
@@ -49,7 +46,7 @@ struct detector_view;
 /// @tparam container_t type collection of the underlying containers
 /// @tparam source_link the surface source link
 template <typename metadata_t = default_metadata,
-          template <typename> class bfield_t = covfie::field,
+          typename bfield_t = covfie::field<bfield::const_bknd_t>,
           typename container_t = host_container_types>
 class detector {
 
@@ -58,8 +55,6 @@ class detector {
         detector<metadata_t, bfield_t, container_t>>;
 
     public:
-    using metadata = metadata_t;
-
     /// Algebra types
     /// @TODO: scalar as a template parameter
     using scalar_type = scalar;
@@ -68,9 +63,9 @@ class detector {
     using vector3 = __plugin::vector3<scalar_type>;
     using point2 = __plugin::point2<scalar_type>;
 
-    using bfield_backend_type = typename metadata::bfield_backend_t;
+    using metadata = metadata_t;
 
-    using bfield_type = bfield_t<bfield_backend_type>;
+    using bfield_type = bfield_t;
 
     /// Raw container types
     template <typename T, std::size_t N>
@@ -133,18 +128,22 @@ class detector {
     using volume_finder =
         typename metadata::template volume_finder<container_t>;
 
+    // TODO: Remove
+    template <typename device_bfield_t>
     using detector_view_type =
-        detector_view<metadata, covfie::field, host_container_types>;
+        detector_view<device_bfield_t, metadata, bfield_t>;
 
+    // TODO: rename back to 'view_type' etc, once covfie is wrapped in the
+    // container view/buffer formalism
     /// Detector view types
-    using view_type = dmulti_view<
+    using view_t = dmulti_view<
         dvector_view<volume_type>, typename transform_container::view_type,
         typename mask_container::view_type,
         typename material_container::view_type,
         typename surface_container::view_type, dvector_view<surface_type>,
         typename volume_finder::view_type>;
 
-    using const_view_type =
+    using const_view_t =
         dmulti_view<dvector_view<const volume_type>,
                     typename transform_container::const_view_type,
                     typename mask_container::const_view_type,
@@ -154,7 +153,7 @@ class detector {
                     typename volume_finder::const_view_type>;
 
     /// Detector buffer types
-    using buffer_type = dmulti_buffer<
+    using buffer_t = dmulti_buffer<
         dvector_buffer<volume_type>, typename transform_container::buffer_type,
         typename mask_container::buffer_type,
         typename material_container::buffer_type,
@@ -162,11 +161,17 @@ class detector {
         typename volume_finder::buffer_type>;
 
     detector() = delete;
+    // The detector holds a lot of data and should never be copied
+    detector(const detector &) = delete;
+    detector &operator=(const detector &) = delete;
+    detector(detector &&) = default;
 
     /// Allowed costructor
+    /// @{
+    /// Default construction
     /// @param resource memory resource for the allocation of members
     DETRAY_HOST
-    detector(vecmem::memory_resource &resource, bfield_type &&field)
+    explicit detector(vecmem::memory_resource &resource)
         : _volumes(&resource),
           _transforms(resource),
           _masks(resource),
@@ -175,12 +180,12 @@ class detector {
           _surface_lookup(&resource),
           _volume_finder(resource),
           _resource(&resource),
-          _bfield(field) {}
+          _bfield() {}
 
-    /// Constructor with simplified constant-zero B-field
-    /// @param resource memory resource for the allocation of members
+    /// @param resource memory resource for the allocation of members and
+    /// externally provided magnetic field @param field
     DETRAY_HOST
-    explicit detector(vecmem::memory_resource &resource)
+    detector(vecmem::memory_resource &resource, bfield_type &&field)
         : _volumes(&resource),
           _transforms(resource),
           _masks(resource),
@@ -189,8 +194,7 @@ class detector {
           _surface_lookup(&resource),
           _volume_finder(resource),
           _resource(&resource),
-          _bfield(typename bfield_type::backend_t::configuration_t{0.f, 0.f,
-                                                                   0.f}) {}
+          _bfield(std::move(field)) {}
 
     /// Constructor with detector_data
     template <typename detector_data_type,
@@ -208,6 +212,7 @@ class detector {
           _volume_finder(
               detray::detail::get<6>(det_data._detector_data.m_view)),
           _bfield(det_data._bfield_view) {}
+    /// @}
 
     /// Add a new volume and retrieve a reference to it.
     ///
@@ -537,6 +542,12 @@ class detector {
         return *std::max_element(n_candidates.begin(), n_candidates.end());
     }
 
+    /// @brief Add a bfield to the detector
+    DETRAY_HOST
+    void set_bfield(bfield_type &&field) {
+        _bfield = std::forward<bfield_type>(field);
+    }
+
     DETRAY_HOST_DEVICE
     inline const bfield_type &get_bfield() const { return _bfield; }
 
@@ -612,12 +623,14 @@ class detector {
     bfield_type _bfield;
 };
 
-/// @brief A static inplementation of detector data for device
-template <typename metadata, template <typename> class bfield_t,
-          typename container_t>
+/// @brief The detector data buffer
+///
+/// Contains the buffers for all detector components plus the covfie device
+/// field type, which is being copied to device when this type gets constructed
+template <typename device_bfield_bknd_t, typename metadata_t, typename bfield_t>
 struct detector_buffer {
 
-    using detector_type = detector<metadata, bfield_t, container_t>;
+    using detector_type = detector<metadata_t, bfield_t, host_container_types>;
 
     /// Automatic buffer creation with the given parameters
     detector_buffer(detector_type &det, vecmem::memory_resource &mr,
@@ -639,11 +652,11 @@ struct detector_buffer {
                                               cpy_type, buff_type),
                            detray::get_buffer(det.volume_search_grid(), mr, cpy,
                                               cpy_type, buff_type)),
-          _bfield_view(det.get_bfield()) {}
+          _bfield(det.get_bfield()) {}
 
     /// Buffers were created manually
     detector_buffer(
-        detector<metadata, bfield_t, container_t> &det,
+        const detector_type &det,
         detail::get_buffer_t<typename detector_type::volume_container>
             &&vol_buffer,
         typename detector_type::transform_container::buffer_type &&trf_buffer,
@@ -657,41 +670,22 @@ struct detector_buffer {
                            std::move(msk_buffer), std::move(mat_buffer),
                            std::move(sf_buffer), std::move(sf_lkp_buffer),
                            std::move(vgrd_buffer)),
-          _bfield_view(det.get_bfield()) {}
+          _bfield(det.get_bfield()) {}
 
     /// Buffers for the vecemem types
-    typename detector_type::buffer_type _detector_buffer;
-    /// Covfie field
-    typename detector_type::bfield_type::view_t _bfield_view;
+    typename detector_type::buffer_t _detector_buffer;
+    /// Covfie device field
+    covfie::field<device_bfield_bknd_t> _bfield;
 };
 
-// Deduction guide to construct a detector buffer type more conveniently
-template <typename metadata, template <typename> class bfield_t,
-          typename container_t>
-detector_buffer(
-    detector<metadata, bfield_t, container_t> &,
-    detail::get_buffer_t<typename detector<metadata, bfield_t,
-                                           container_t>::volume_container> &&,
-    typename detector<metadata, bfield_t,
-                      container_t>::transform_container::buffer_type &&,
-    typename detector<metadata, bfield_t,
-                      container_t>::mask_container::buffer_type &&,
-    typename detector<metadata, bfield_t,
-                      container_t>::material_container::buffer_type &&,
-    typename detector<metadata, bfield_t,
-                      container_t>::surface_container::buffer_type &&,
-    typename detector<metadata, bfield_t, container_t>::surface_lookup_container
-        &&,
-    typename detector<metadata, bfield_t,
-                      container_t>::volume_finder::buffer_type &&)
-    -> detector_buffer<metadata, bfield_t, container_t>;
-
-/// @brief A static inplementation of detector data for device
-template <typename metadata, template <typename> class bfield_t,
-          typename container_t>
+/// @brief The detector view
+///
+/// Contains the views for all detector components, including the device view
+/// of the bfield
+template <typename device_bfield_bknd_t, typename metadata_t, typename bfield_t>
 struct detector_view {
 
-    using detector_type = detector<metadata, bfield_t, container_t>;
+    using detector_type = detector<metadata_t, bfield_t, host_container_types>;
 
     detector_view(detector_type &det)
         : _detector_data(detray::get_data(det.volumes()),
@@ -703,49 +697,48 @@ struct detector_view {
                          detray::get_data(det.volume_search_grid())),
           _bfield_view(det.get_bfield()) {}
 
-    detector_view(detector_buffer<metadata, bfield_t, container_t> &det_buff)
+    detector_view(
+        detector_buffer<device_bfield_bknd_t, metadata_t, bfield_t> &det_buff)
         : _detector_data(detray::get_data(det_buff._detector_buffer)),
-          _bfield_view(det_buff._bfield_view) {}
+          _bfield_view(det_buff._bfield) {}
 
     /// Views for the vecmem types
-    typename detector_type::view_type _detector_data;
+    typename detector_type::view_t _detector_data;
     /// Covfie field view
-    typename detector_type::bfield_type::view_t _bfield_view;
+    covfie::field_view<device_bfield_bknd_t> _bfield_view;
 };
 
-/// Stand-alone function that @returns the detector data for transfer to
+/// Stand-alone function that @returns the detector view for transfer to
 /// device.
 ///
 /// @param detector the detector to be tranferred
-template <typename metadata, template <typename> class bfield_t,
-          typename container_t>
-inline detector_view<metadata, bfield_t, container_t> get_data(
-    detector<metadata, bfield_t, container_t> &det) {
+template <typename device_bfield_bknd_t, typename metadata_t, typename bfield_t>
+inline detector_view<device_bfield_bknd_t, metadata_t, bfield_t> get_data(
+    detector<metadata_t, bfield_t, host_container_types> &det) {
     return {det};
 }
 
-/// Stand-alone function that @returns the detector data for transfer to
+/// Stand-alone function that @returns the detector buffer for transfer to
 /// device.
 ///
-/// @param detector the detector to be tranferred
-template <typename metadata, template <typename> class bfield_t,
-          typename container_t>
-inline detector_buffer<metadata, bfield_t, container_t> get_buffer(
-    detector<metadata, bfield_t, container_t> &det, vecmem::memory_resource &mr,
-    vecmem::copy &cpy, detray::copy cpy_type = detray::copy::sync,
+/// @param detector the detector to be transferred
+template <typename device_bfield_bknd_t, typename metadata_t, typename bfield_t>
+inline detector_buffer<device_bfield_bknd_t, metadata_t, bfield_t> get_buffer(
+    detector<metadata_t, bfield_t, host_container_types> &det,
+    vecmem::memory_resource &mr, vecmem::copy &cpy,
+    detray::copy cpy_type = detray::copy::sync,
     vecmem::data::buffer_type buff_type =
         vecmem::data::buffer_type::fixed_size) {
     return {det, mr, cpy, cpy_type, buff_type};
 }
 
-/// Stand-alone function that @returns the detector data for transfer to
+/// Stand-alone function that @returns the detector view for transfer to
 /// device.
 ///
-/// @param detector the detector to be tranferred
-template <typename metadata, template <typename> class bfield_t,
-          typename container_t>
-inline detector_view<metadata, bfield_t, container_t> get_data(
-    detector_buffer<metadata, bfield_t, container_t> &det_buff) {
+/// @param detector the detector to be transferred
+template <typename device_bfield_bknd_t, typename metadata_t, typename bfield_t>
+inline detector_view<device_bfield_bknd_t, metadata_t, bfield_t> get_data(
+    detector_buffer<device_bfield_bknd_t, metadata_t, bfield_t> &det_buff) {
     return {det_buff};
 }
 
diff --git a/core/include/detray/core/detector_metadata.hpp b/core/include/detray/core/detector_metadata.hpp
index 24593db5e..da5140f80 100644
--- a/core/include/detray/core/detector_metadata.hpp
+++ b/core/include/detray/core/detector_metadata.hpp
@@ -24,10 +24,6 @@
 #include "detray/surface_finders/accelerator_grid.hpp"
 #include "detray/surface_finders/brute_force_finder.hpp"
 
-// Covfie include(s)
-#include <covfie/core/backend/primitive/constant.hpp>
-#include <covfie/core/vector.hpp>
-
 namespace detray {
 
 /// Assembles the detector type. This metatdata contains all available types
@@ -121,11 +117,6 @@ struct default_metadata {
 
     /// @}
 
-    // @TODO: Switch to inhomogenous b-field
-    using bfield_backend_t =
-        covfie::backend::constant<covfie::vector::vector_d<scalar, 3>,
-                                  covfie::vector::vector_d<scalar, 3>>;
-
     /// How to store coordinate transform matrices
     template <template <typename...> class vector_t = dvector>
     using transform_store = single_store<__plugin::transform3<detray::scalar>,
diff --git a/core/include/detray/definitions/bfield_backends.hpp b/core/include/detray/definitions/bfield_backends.hpp
new file mode 100644
index 000000000..10abb8b16
--- /dev/null
+++ b/core/include/detray/definitions/bfield_backends.hpp
@@ -0,0 +1,34 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/definitions/algebra.hpp"
+
+// Covfie include(s)
+#include <covfie/core/backend/primitive/constant.hpp>
+#include <covfie/core/backend/transformer/affine.hpp>
+#include <covfie/core/backend/transformer/nearest_neighbour.hpp>
+#include <covfie/core/backend/transformer/strided.hpp>
+#include <covfie/core/field.hpp>
+#include <covfie/core/field_view.hpp>
+
+namespace detray::bfield {
+
+// Constant bfield (host and device)
+using const_bknd_t =
+    covfie::backend::constant<covfie::vector::vector_d<scalar, 3>,
+                              covfie::vector::vector_d<scalar, 3>>;
+
+// Inhomogeneous field (host)
+using inhom_bknd_t = covfie::backend::affine<
+    covfie::backend::nearest_neighbour<covfie::backend::strided<
+        covfie::vector::ulong3,
+        covfie::backend::array<covfie::vector::vector_d<scalar, 3>>>>>;
+
+}  // namespace detray::bfield
diff --git a/core/include/detray/propagator/rk_stepper.ipp b/core/include/detray/propagator/rk_stepper.ipp
index 07ecbe946..36f2678b6 100644
--- a/core/include/detray/propagator/rk_stepper.ipp
+++ b/core/include/detray/propagator/rk_stepper.ipp
@@ -173,9 +173,10 @@ bool detray::rk_stepper<magnetic_field_t, transform3_t, constraint_t, policy_t,
     scalar error_estimate{0.f};
 
     // First Runge-Kutta point
-    const vector3 spos = stepping().pos();
+    const vector3 pos = stepping().pos();
+    const vector3 dir = stepping().dir();
     const typename magnetic_field_t::output_t bvec =
-        magnetic_field.at(spos[0], spos[1], spos[2]);
+        magnetic_field.at(pos[0], pos[1], pos[2]);
     sd.b_first[0] = bvec[0];
     sd.b_first[1] = bvec[1];
     sd.b_first[2] = bvec[2];
@@ -186,8 +187,6 @@ bool detray::rk_stepper<magnetic_field_t, transform3_t, constraint_t, policy_t,
         // State the square and half of the step size
         const scalar h2{h * h};
         const scalar half_h{h * 0.5f};
-        auto pos = stepping().pos();
-        auto dir = stepping().dir();
 
         // Second Runge-Kutta point
         const vector3 pos1 = pos + half_h * dir + h2 * 0.125f * sd.k1;
diff --git a/core/include/detray/tools/detector_builder.hpp b/core/include/detray/tools/detector_builder.hpp
index 05b3e3fff..6528c25c1 100644
--- a/core/include/detray/tools/detector_builder.hpp
+++ b/core/include/detray/tools/detector_builder.hpp
@@ -10,6 +10,7 @@
 // Project include(s).
 #include "detray/core/detector.hpp"
 #include "detray/core/detector_metadata.hpp"
+#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/geometry.hpp"
 #include "detray/tools/grid_factory.hpp"
 #include "detray/tools/volume_builder.hpp"
@@ -19,9 +20,6 @@
 // Vecmem include(s)
 #include <vecmem/memory/memory_resource.hpp>
 
-// Covfie include(s)
-#include <covfie/core/field.hpp>
-
 // System include(s)
 #include <memory>
 #include <vector>
@@ -35,12 +33,13 @@ namespace detray {
 ///                          geometry data
 /// @tparam volume_data_t the data structure that hold the volume builders
 template <typename metadata = default_metadata,
+          typename bfield_bknd_t = bfield::const_bknd_t,
           template <typename> class volume_builder_t = volume_builder,
           template <typename...> class volume_data_t = std::vector>
 class detector_builder {
     public:
     using detector_type =
-        detector<metadata, covfie::field, host_container_types>;
+        detector<metadata, covfie::field<bfield_bknd_t>, host_container_types>;
 
     /// Empty detector builder
     detector_builder() = default;
@@ -80,16 +79,15 @@ class detector_builder {
     /// Assembles the final detector from the volumes builders and allocates
     /// the detector containers with the memory resource @param resource
     DETRAY_HOST
-    auto build(vecmem::memory_resource& resource,
-               typename detector_type::bfield_type&& field) -> detector_type {
+    auto build(vecmem::memory_resource& resource) -> detector_type {
 
-        detector_type det{
-            resource, std::forward<typename detector_type::bfield_type>(field)};
+        detector_type det{resource};
 
         for (auto& vol_builder : m_volumes) {
             vol_builder->build(det);
         }
 
+        det.set_bfield(std::move(m_bfield));
         det.set_volume_finder(std::move(m_vol_finder));
 
         // TODO: Add sorting, data deduplication etc. here later...
@@ -100,12 +98,8 @@ class detector_builder {
     /// Assembles the detector, without a magnetic field
     // TODO: Remove, won't work for non-constant bfields
     DETRAY_HOST
-    auto build(vecmem::memory_resource& resource) -> detector_type {
-        using bfield_bknd_t = typename detector_type::bfield_type::backend_t;
-
-        return build(resource, typename detector_type::bfield_type(
-                                   typename bfield_bknd_t::configuration_t{
-                                       0.f, 0.f, 0.f}));
+    void set_bfield(typename detector_type::bfield_type&& field) {
+        m_bfield = std::forward<typename detector_type::bfield_type>(field);
     }
 
     /// Put the volumes into a search data structure
@@ -139,6 +133,8 @@ class detector_builder {
         m_volumes{};
     /// Data structure to find volumes
     typename detector_type::volume_finder m_vol_finder{};
+    /// The detector bfield
+    typename detector_type::bfield_type m_bfield;
 };
 
 }  // namespace detray
diff --git a/data/detray_data_get_files.sh b/data/detray_data_get_files.sh
new file mode 100755
index 000000000..2a2f22b18
--- /dev/null
+++ b/data/detray_data_get_files.sh
@@ -0,0 +1,97 @@
+#!/bin/bash
+#
+# (c) 2023 CERN for the benefit of the ACTS project
+#
+# Mozilla Public License Version 2.0
+#
+# Script downloading the detray data file(s) through HTTPS, and unpacking them.
+#
+
+# Stop on errors.
+set -e
+set -o pipefail
+
+# Function printing the usage information for the script.
+usage() {
+   echo "Script downloading/unpacking data TGZ/MD5 files"
+   echo ""
+   echo "Usage: detray_data_get_files.sh [options]"
+   echo ""
+   echo "Options:"
+   echo "  -f <filename>        Name of the data file, without its extension"
+   echo "  -d <webDirectory>    Directory holding the data and MD5 files"
+   echo "  -o <dataDirectory>   Main data directory"
+   echo "  -c <cmakeExecutable> CMake executable to use in the script"
+   echo "  -w <curlExecutable>  Curl executable to use in the script"
+   echo ""
+}
+
+# Default script arguments.
+DETRAY_DATA_NAME=${DETRAY_DATA_NAME:-"detray-data-v1"}
+DETRAY_WEB_DIRECTORY=${DETRAY_WEB_DIRECTORY:-"https://acts.web.cern.ch/traccc/data"}
+DETRAY_DATA_DIRECTORY=${DETRAY_DATA_DIRECTORY:-$(cd $(dirname "${BASH_SOURCE[0]}") && pwd)}
+DETRAY_CMAKE_EXECUTABLE=${DETRAY_CMAKE_EXECUTABLE:-cmake}
+DETRAY_CURL_EXECUTABLE=${DETRAY_CURL_EXECUTABLE:-curl}
+
+# Parse the command line argument(s).
+while getopts ":f:d:o:c:wh" opt; do
+   case $opt in
+      f)
+         DETRAY_DATA_NAME=$OPTARG
+         ;;
+      d)
+         DETRAY_WEB_DIRECTORY=$OPTARG
+         ;;
+      o)
+         DETRAY_DATA_DIRECTORY=$OPTARG
+         ;;
+      c)
+         DETRAY_CMAKE_EXECUTABLE=$OPTARG
+         ;;
+      w)
+         DETRAY_CURL_EXECUTABLE=$OPTARG
+         ;;
+      h)
+         usage
+         exit 0
+         ;;
+      :)
+         echo "Argument -$OPTARG requires a parameter!"
+         usage
+         exit 1
+         ;;
+      ?)
+         echo "Unknown argument: -$OPTARG"
+         usage
+         exit 1
+         ;;
+   esac
+done
+
+# Go into the target directory.
+cd "${DETRAY_DATA_DIRECTORY}"
+
+# Download the TGZ and MD5 files.
+"${DETRAY_CURL_EXECUTABLE}" --retry 5 --retry-delay 10 \
+   --output "${DETRAY_DATA_NAME}.tar.gz"               \
+   "${DETRAY_WEB_DIRECTORY}/${DETRAY_DATA_NAME}.tar.gz"
+"${DETRAY_CURL_EXECUTABLE}" --retry 5 --retry-delay 10 \
+   --output "${DETRAY_DATA_NAME}.md5"                  \
+   "${DETRAY_WEB_DIRECTORY}/${DETRAY_DATA_NAME}.md5"
+
+# Verify that the download succeeded.
+"${DETRAY_CMAKE_EXECUTABLE}" -E md5sum "${DETRAY_DATA_NAME}.tar.gz" > \
+   "${DETRAY_DATA_NAME}.md5-test"
+"${DETRAY_CMAKE_EXECUTABLE}" -E compare_files "${DETRAY_DATA_NAME}.md5" \
+   "${DETRAY_DATA_NAME}.md5-test"
+
+# Extract the data files.
+"${DETRAY_CMAKE_EXECUTABLE}" -E tar xf "${DETRAY_DATA_NAME}.tar.gz"
+
+# Clean up.
+"${DETRAY_CMAKE_EXECUTABLE}" -E remove "${DETRAY_DATA_NAME}.tar.gz" \
+   "${DETRAY_DATA_NAME}.md5" "${DETRAY_DATA_NAME}.md5-test"
+
+# Leave the user with a message.
+"${DETRAY_CMAKE_EXECUTABLE}" -E echo \
+   "Files from ${DETRAY_DATA_NAME} unpacked under '${DETRAY_DATA_DIRECTORY}'"
diff --git a/extern/covfie/CMakeLists.txt b/extern/covfie/CMakeLists.txt
index 463166d1a..c43476f33 100644
--- a/extern/covfie/CMakeLists.txt
+++ b/extern/covfie/CMakeLists.txt
@@ -18,7 +18,7 @@ message( STATUS "Fetching covfie as part of the Detray project" )
 
 # Declare where to get covfie from.
 set( DETRAY_COVFIE_SOURCE
-   "URL;https://github.com/acts-project/covfie/archive/refs/tags/v0.5.0.tar.gz;URL_MD5;e6683f6eb34b6156f8ac90facc7e538e"
+   "URL;https://github.com/acts-project/covfie/archive/refs/tags/v0.8.0.tar.gz;URL_MD5;b29a452aa529ee1b170650a15c591ce8"
    CACHE STRING "Source for covfie, when built as part of this project" )
 mark_as_advanced( DETRAY_COVFIE_SOURCE )
 FetchContent_Declare( covfie ${DETRAY_COVFIE_SOURCE} )
@@ -29,7 +29,7 @@ set( COVFIE_BUILD_TESTS OFF CACHE BOOL "Build covfie tests")
 set( COVFIE_BUILD_BENCHMARKS OFF CACHE BOOL "Build covfie benchmarks")
 
 set( COVFIE_PLATFORM_CPU ON CACHE BOOL "Enable covfie CPU platform")
-set( COVFIE_PLATFORM_CUDA ON CACHE BOOL "Enable covfie CUDA platform")
+set( COVFIE_PLATFORM_CUDA ${DETRAY_BUILD_CUDA} CACHE BOOL "Enable covfie CUDA platform")
 
 set( COVFIE_REQUIRE_CXX20 OFF CACHE BOOL "Enable covfie C++20 requirement")
 set( COVFIE_QUIET ON CACHE BOOL "Quiet covfie feature warnings")
diff --git a/io/include/detray/io/common/bfield_reader.hpp b/io/include/detray/io/common/bfield_reader.hpp
new file mode 100644
index 000000000..64831c365
--- /dev/null
+++ b/io/include/detray/io/common/bfield_reader.hpp
@@ -0,0 +1,90 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/io/common/detail/file_handle.hpp"
+#include "detray/io/common/io_interface.hpp"
+
+// Covfie include(s)
+#include <covfie/core/utility/binary_io.hpp>
+
+// System include(s)
+#include <ios>
+#include <string>
+
+namespace detray {
+
+/// @brief Function that reads the first 4 bytes of a potential bfield file and
+/// checks that it contains data for a covfie field
+inline bool check_covfie_file(const std::string& file_name) {
+
+    // Open binary file
+    io::detail::file_handle file{file_name,
+                                 std::ios_base::in | std::ios_base::binary};
+
+    // See "covfie/lib/core/utility/binary_io.hpp"
+    std::uint32_t hdr = covfie::utility::read_binary<std::uint32_t>(*file);
+
+    // Compare to magic bytes
+    return (hdr == covfie::utility::MAGIC_HEADER);
+}
+
+/// @brief Reader that constructs a covfie field from file input
+template <class detector_t>
+class covfie_file_reader : public reader_interface<detector_t> {
+
+    using base_type = reader_interface<detector_t>;
+
+    protected:
+    /// Tag the reader as magnetic field reader
+    inline static const std::string tag = "bfield";
+
+    public:
+    /// Same constructors for this class as for base_type
+    using base_type::base_type;
+
+    /// Covfie constructs the field directly from the input stream in
+    /// @param file
+    auto deserialize(io::detail::file_handle& file) const {
+        return typename detector_t::bfield_type(*file);
+    }
+};
+
+/// @brief Generic magnetic field reader
+template <class detector_t, template <class> class reader_t>
+class bfield_reader final : public reader_t<detector_t> {
+
+    using base_reader = reader_t<detector_t>;
+
+    public:
+    /// Default file ending for covfie input
+    bfield_reader() : base_reader{".cvf"} {}
+
+    /// Read from file with given extension @param ext
+    bfield_reader(const std::string& ext) : base_reader{ext} {}
+
+    /// Reads the geometry from file with the given name
+    virtual void read(
+        detector_builder<typename detector_t::metadata,
+                         typename detector_t::bfield_type::backend_t,
+                         volume_builder>& det_builder,
+        typename detector_t::name_map&, const std::string& file_name) override {
+
+        io::detail::file_handle file{file_name,
+                                     std::ios_base::binary | std::ios_base::in};
+
+        det_builder.set_bfield(base_reader::deserialize(file));
+    }
+};
+
+/// Read a covfie field from file and add it to a detray detector
+template <typename detector_t>
+using covfie_reader = bfield_reader<detector_t, covfie_file_reader>;
+
+}  // namespace detray
diff --git a/io/include/detray/io/common/detail/detector_components_io.hpp b/io/include/detray/io/common/detail/detector_components_io.hpp
index 8c917fffb..16a7978b8 100644
--- a/io/include/detray/io/common/detail/detector_components_io.hpp
+++ b/io/include/detray/io/common/detail/detector_components_io.hpp
@@ -63,7 +63,7 @@ class detector_component_writers final {
 
         // Call the write method on all optional writers
         std::for_each(m_writers.begin(), m_writers.end(),
-                      [det, names, mode](writer_ptr_t& writer) {
+                      [&det, &names, mode](writer_ptr_t& writer) {
                           writer->write(det, names, mode);
                       });
     }
@@ -107,9 +107,11 @@ class detector_component_readers final {
 
     /// Reads the full detector into @param det by calling the readers, while
     /// using the name map @param names for to write the volume names.
-    virtual void read(detector_builder<typename detector_t::metadata,
-                                       volume_builder>& det_builder,
-                      typename detector_t::name_map& names) {
+    virtual void read(
+        detector_builder<typename detector_t::metadata,
+                         typename detector_t::bfield_type::backend_t,
+                         volume_builder>& det_builder,
+        typename detector_t::name_map& names) {
 
         // We have to at least read a geometry
         assert(m_readers.size() != 0u &&
diff --git a/io/include/detray/io/common/detail/file_handle.hpp b/io/include/detray/io/common/detail/file_handle.hpp
index 57f1813b8..ddccbeb32 100644
--- a/io/include/detray/io/common/detail/file_handle.hpp
+++ b/io/include/detray/io/common/detail/file_handle.hpp
@@ -13,6 +13,7 @@
 #include <filesystem>
 #include <fstream>
 #include <ios>
+#include <iostream>
 #include <limits>
 #include <stdexcept>
 #include <string>
@@ -23,7 +24,19 @@ enum class format { json = 0u };
 
 namespace detail {
 
-/// Wrapper around a file stream
+/// @brief Wrapper around a file stream
+///
+/// Performs some checks and offers some convenience functionality:
+/// - In out mode w.o. file replacement: Checks if file exists and automatically
+///   finds a new filename in case it does.
+/// - In in mode: Checks for empty file names and whether the file exists
+/// - Enforces a limit on the number of files that can be written/opened
+/// - Checks whether a file was opened correctly
+/// - Closes the stream when the handle goes out of scope and checks whether
+///   anything went wrong during the IO operations
+///
+/// @note Not thread safe.
+/// @note Can throw exceptions during construction.
 class file_handle final {
 
     public:
@@ -42,41 +55,74 @@ class file_handle final {
     file_handle(const std::string& name, const std::string& extension,
                 std::ios_base::openmode mode = std::ios_base::in |
                                                std::ios_base::out) {
-        // Default name
-        std::string file_stem{name.empty() ? "detray_" + std::to_string(n_files)
-                                           : name};
+        // File name
+        std::string file_stem{name};
+
+        // Pure output mode without replacement of file: Check if name is taken
+        // and modify it if necessary
+        if (mode == std::ios_base::out or
+            (mode == (std::ios_base::out | std::ios_base::binary))) {
+            // Default name for output
+            file_stem =
+                name.empty() ? "detray_" + std::to_string(n_files) : name;
 
-        // Check if name is taken and modify it if necessary
-        if (mode == std::ios_base::out) {
             std::filesystem::path file_path{file_stem + extension};
-            std::size_t n_trials{1u};
+            std::size_t n_trials{2u};
             while (std::filesystem::exists(file_path)) {
                 file_stem = get_alternate_file_stem(file_stem, n_trials);
                 file_path = std::filesystem::path{file_stem + extension};
                 ++n_trials;
+
                 // The maximum here is arbitrary
                 if (n_trials >= 10000u) {
-                    throw std::runtime_error("Too many versions of file exist");
+                    throw std::runtime_error(
+                        "Too many versions of file exist: " + file_stem +
+                        extension);
                 }
             }
+            // Pure input mode: Check if file name makes sense and file exists
+        } else if ((mode == std::ios_base::in) or
+                   (mode == (std::ios_base::in | std::ios_base::binary))) {
+            if (file_stem.empty()) {
+                throw std::invalid_argument("File name empty");
+            }
+
+            std::filesystem::path file_path{file_stem + extension};
+            if (not std::filesystem::exists(file_path)) {
+                throw std::invalid_argument(
+                    "Could not open file: File does not exist: " + file_stem +
+                    extension);
+            }
+        } else if (file_stem.empty()) {
+            std::cout << "WARNING: Empty file name" << std::endl;
         }
 
         // Count the new file
+        const std::string file_name{file_stem + extension};
         ++n_files;
         ++n_open_files;
-        assert(n_files < std::numeric_limits<std::uint_least16_t>::max());
-        assert(n_open_files < 1000u);
+        if (n_files >= std::numeric_limits<std::uint_least16_t>::max()) {
+            throw std::runtime_error(
+                "Could not open file: Too many files written: " + file_name);
+        } else if (n_open_files >= 1000u) {
+            throw std::runtime_error(
+                "Could not open file: Too many files currently open: " +
+                file_name);
+        }
 
         // Open file
-        m_stream.open(file_stem + extension, mode);
+        m_stream.open(file_name, mode);
 
         if (!m_stream.is_open()) {
-            throw std::runtime_error("Could not open file");
+            throw std::runtime_error("Could not open file: " + file_name);
         }
     }
 
     /// Destructor closes the file
     ~file_handle() {
+        if (m_stream.bad()) {
+            std::cout << "ERROR: Could not read from/write to file";
+        }
         m_stream.close();
         --n_open_files;
     }
@@ -88,12 +134,23 @@ class file_handle final {
     /// @returns alternate file stem upon collision
     std::string get_alternate_file_stem(std::string& stem,
                                         const std::size_t n) {
-        // File stem already come with a number, simply update it
-        if (n > 1u) {
-            stem.replace(stem.size() - 1u, 1, std::to_string(n));
+        const std::string delim{"_"};
+
+        // File stem already comes with a number, simply update it
+        if (n > 2u) {
+            std::size_t pos{stem.rfind(delim)};
+            if (pos == std::string::npos or (pos + 1 == stem.size())) {
+                throw std::runtime_error("Malformed file name");
+            }
+
+            // Leave the delimeter where it is and replace the file number
+            ++pos;
+            stem.replace(pos, stem.size() - pos, std::to_string(n));
+
             return stem;
         }
-        return stem + "_" + std::to_string(n);
+
+        return stem + delim + std::to_string(n);
     }
 
     /// Output file handle
diff --git a/io/include/detray/io/common/detector_reader.hpp b/io/include/detray/io/common/detector_reader.hpp
index 3119cbf05..b2cb7273a 100644
--- a/io/include/detray/io/common/detector_reader.hpp
+++ b/io/include/detray/io/common/detector_reader.hpp
@@ -8,6 +8,7 @@
 #pragma once
 
 // Project include(s)
+#include "detray/io/common/bfield_reader.hpp"
 #include "detray/io/common/detail/detector_components_io.hpp"
 #include "detray/io/common/detail/type_traits.hpp"
 #include "detray/io/json/json_reader.hpp"
@@ -47,9 +48,9 @@ struct detector_reader_config {
     bool do_check() const { return m_do_check; }
     template <typename const_bfield_bknd_t>
     auto bfield() const {
-        return covfie::field<const_bfield_bknd_t>(
+        return covfie::field<const_bfield_bknd_t>(covfie::make_parameter_pack(
             typename const_bfield_bknd_t::configuration_t{
-                m_bfield_vec[0], m_bfield_vec[1], m_bfield_vec[2]});
+                m_bfield_vec[0], m_bfield_vec[1], m_bfield_vec[2]}));
     }
     /// @}
 
@@ -103,6 +104,14 @@ auto assemble_reader(const io::detector_reader_config& cfg) {
                                             header.tag +
                                             "' in input file: " + file_name);
             }
+        } else if (extension == ".cvf" and check_covfie_file(file_name)) {
+            // This is the file type covfie uses
+            if constexpr (not std::is_same_v<
+                              typename detector_t::bfield_type::backend_t,
+                              bfield::const_bknd_t>) {
+                std::cout << "Adding an inhom bfield reader" << std::endl;
+                readers.template add<covfie_reader>(file_name);
+            }
         } else {
             throw std::runtime_error("Unsupported file format '" + extension +
                                      "' for input file: " + file_name);
@@ -129,27 +138,30 @@ template <class detector_t,
           template <typename> class volume_builder_t = volume_builder>
 auto read_detector(vecmem::memory_resource& resc,
                    const detector_reader_config& cfg) {
-    // Map the volue names to their indices
+
+    using bfield_bknd_t = typename detector_t::bfield_type::backend_t;
+
+    // Map the volume names to their indices
     typename detector_t::name_map names{};
 
-    detector_builder<typename detector_t::metadata, volume_builder_t>
+    detector_builder<typename detector_t::metadata, bfield_bknd_t,
+                     volume_builder_t>
         det_builder;
 
-    // Find all required the readers
+    // Find all required readers
     auto [reader, det_name] = detray::detail::assemble_reader<detector_t>(cfg);
 
+    // Add a constant b-field (no bfield reader is added in this case)
+    if constexpr (std::is_same_v<bfield_bknd_t, bfield::const_bknd_t>) {
+        det_builder.set_bfield(cfg.template bfield<bfield_bknd_t>());
+    }
+
+    // Read the data
     names.emplace(0u, std::move(det_name));
     reader.read(det_builder, names);
 
-    // TODO: Remove once bfield reader is available
-    using scalar_t = typename detector_t::scalar_type;
-    using const_bfield_bknd_t =
-        covfie::backend::constant<covfie::vector::vector_d<scalar_t, 3>,
-                                  covfie::vector::vector_d<scalar_t, 3>>;
-
     // Build and return the detector
-    auto det =
-        det_builder.build(resc, cfg.template bfield<const_bfield_bknd_t>());
+    auto det = det_builder.build(resc);
 
     if (cfg.do_check()) {
         detray::detail::check_consistency(det);
diff --git a/io/include/detray/io/common/detector_writer.hpp b/io/include/detray/io/common/detector_writer.hpp
index d151fe579..97b82b7d3 100644
--- a/io/include/detray/io/common/detector_writer.hpp
+++ b/io/include/detray/io/common/detector_writer.hpp
@@ -112,8 +112,10 @@ template <class detector_t>
 void write_detector(detector_t& det, const typename detector_t::name_map& names,
                     const detector_writer_config& cfg) {
     // How to open the file
-    auto mode = cfg.m_replace ? (std::ios_base::out | std::ios_base::trunc)
-                              : std::ios_base::out;
+    const std::ios_base::openmode out_mode{std::ios_base::out |
+                                           std::ios_base::binary};
+    auto mode = cfg.m_replace ? (out_mode | std::ios_base::trunc) : out_mode;
+
     // Get the writer
     auto writer = detray::detail::assemble_writer<detector_t>(cfg);
     writer.write(det, names, mode);
diff --git a/io/include/detray/io/common/geometry_reader.hpp b/io/include/detray/io/common/geometry_reader.hpp
index 1fc662a4a..e70daea21 100644
--- a/io/include/detray/io/common/geometry_reader.hpp
+++ b/io/include/detray/io/common/geometry_reader.hpp
@@ -69,10 +69,12 @@ class geometry_reader : public reader_interface<detector_t> {
     protected:
     /// Deserialize a detector @param det from its io payload @param det_data
     /// and add the volume names to @param name_map
-    static void deserialize(detector_builder<typename detector_t::metadata,
-                                             volume_builder>& det_builder,
-                            typename detector_t::name_map& name_map,
-                            const detector_payload& det_data) {
+    static void deserialize(
+        detector_builder<typename detector_t::metadata,
+                         typename detector_t::bfield_type::backend_t,
+                         volume_builder>& det_builder,
+        typename detector_t::name_map& name_map,
+        const detector_payload& det_data) {
 
         // @todo Add volume grid
 
diff --git a/io/include/detray/io/common/homogeneous_material_reader.hpp b/io/include/detray/io/common/homogeneous_material_reader.hpp
index 4e0d8815a..3a9c8c34c 100644
--- a/io/include/detray/io/common/homogeneous_material_reader.hpp
+++ b/io/include/detray/io/common/homogeneous_material_reader.hpp
@@ -46,8 +46,9 @@ class homogeneous_material_reader : public reader_interface<detector_t> {
     /// Deserialize the detector material @param det_mat_data from its IO
     /// payload
     static void deserialize(
-        detector_builder<typename detector_t::metadata, volume_builder>&
-            det_builder,
+        detector_builder<typename detector_t::metadata,
+                         typename detector_t::bfield_type::backend_t,
+                         volume_builder>& det_builder,
         typename detector_t::name_map& /*name_map*/,
         const detector_homogeneous_material_payload& det_mat_data) {
         using mat_types = typename detector_t::material_container::value_types;
diff --git a/io/include/detray/io/common/io_interface.hpp b/io/include/detray/io/common/io_interface.hpp
index 218fb4da8..318f6b028 100644
--- a/io/include/detray/io/common/io_interface.hpp
+++ b/io/include/detray/io/common/io_interface.hpp
@@ -37,7 +37,9 @@ class reader_interface {
     /// does not keep the volume names, the name map is also passed and
     /// filled.
     virtual void read(
-        detector_builder<typename detector_t::metadata, volume_builder>&,
+        detector_builder<typename detector_t::metadata,
+                         typename detector_t::bfield_type::backend_t,
+                         volume_builder>&,
         typename detector_t::name_map&, const std::string&) = 0;
 
     protected:
diff --git a/io/include/detray/io/json/json_reader.hpp b/io/include/detray/io/json/json_reader.hpp
index 7a6ff126a..832c4864a 100644
--- a/io/include/detray/io/json/json_reader.hpp
+++ b/io/include/detray/io/json/json_reader.hpp
@@ -66,13 +66,16 @@ class json_reader final : public common_reader_t<detector_t> {
     json_reader() : base_reader(".json") {}
 
     /// Writes the geometry to file with a given name
-    virtual void read(detector_builder<typename detector_t::metadata,
-                                       volume_builder>& det_builder,
-                      typename detector_t::name_map& name_map,
-                      const std::string& file_name) override {
+    virtual void read(
+        detector_builder<typename detector_t::metadata,
+                         typename detector_t::bfield_type::backend_t,
+                         volume_builder>& det_builder,
+        typename detector_t::name_map& name_map,
+        const std::string& file_name) override {
 
         // Read json from file
-        io::detail::file_handle file{file_name};
+        io::detail::file_handle file{file_name,
+                                     std::ios_base::in | std::ios_base::binary};
         nlohmann::json in_json;
         *file >> in_json;
 
diff --git a/io/include/detray/io/json/json_writer.hpp b/io/include/detray/io/json/json_writer.hpp
index 632e03137..e1dd56e86 100644
--- a/io/include/detray/io/json/json_writer.hpp
+++ b/io/include/detray/io/json/json_writer.hpp
@@ -47,7 +47,10 @@ class json_writer final : public common_writer_t<detector_t> {
                               const std::ios_base::openmode mode) override {
         // Assert output stream
         assert(((mode == std::ios_base::out) or
-                (mode == (std::ios_base::out | std::ios_base::trunc))) &&
+                (mode == (std::ios_base::out | std::ios_base::binary)) or
+                (mode == (std::ios_base::out | std::ios_base::trunc)) or
+                (mode == (std::ios_base::out | std::ios_base::trunc |
+                          std::ios_base::binary))) &&
                "Illegal file mode for json writer");
 
         // By convention the name of the detector is the first element
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 55271ed75..63600fa1f 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -7,6 +7,7 @@
 # Set the common C++ flags.
 include( detray-compiler-options-cpp )
 include_directories( SYSTEM $<TARGET_PROPERTY:dfelibs::dfelibs,INTERFACE_INCLUDE_DIRECTORIES> )
+include_directories( SYSTEM $<TARGET_PROPERTY:covfie::core,INTERFACE_INCLUDE_DIRECTORIES> )
 
 # Set up a test library, which the "new style" benchmarks and tests could use.
 file( GLOB _detray_test_headers
diff --git a/tests/benchmarks/cpu/find_volume.cpp b/tests/benchmarks/cpu/find_volume.cpp
index 818773c38..573749c7d 100644
--- a/tests/benchmarks/cpu/find_volume.cpp
+++ b/tests/benchmarks/cpu/find_volume.cpp
@@ -29,10 +29,10 @@ void BM_FIND_VOLUMES(benchmark::State &state) {
     return;
 
     // Detector configuration
-    static constexpr unsigned int n_brl_layers{4u};
-    static constexpr unsigned int n_edc_layers{7u};
     vecmem::host_memory_resource host_mr;
-    auto [d, names] = create_toy_geometry(host_mr, n_brl_layers, n_edc_layers);
+    toy_det_config toy_cfg{};
+    toy_cfg.n_edc_layers(7u);
+    auto [d, names] = create_toy_geometry(host_mr, toy_cfg);
 
     static const unsigned int itest = 10000u;
 
diff --git a/tests/benchmarks/cpu/intersect_all.cpp b/tests/benchmarks/cpu/intersect_all.cpp
index 1ee8ad4c8..8e2fcc37a 100644
--- a/tests/benchmarks/cpu/intersect_all.cpp
+++ b/tests/benchmarks/cpu/intersect_all.cpp
@@ -36,10 +36,10 @@ void BM_INTERSECT_ALL(benchmark::State &state) {
     static const unsigned int phi_steps{100u};
 
     // Detector configuration
-    static constexpr std::size_t n_brl_layers{4u};
-    static constexpr std::size_t n_edc_layers{7u};
     vecmem::host_memory_resource host_mr;
-    auto [d, names] = create_toy_geometry(host_mr, n_brl_layers, n_edc_layers);
+    toy_det_config toy_cfg{};
+    toy_cfg.n_edc_layers(7u);
+    auto [d, names] = create_toy_geometry(host_mr, toy_cfg);
 
     using detector_t = decltype(d);
     detector_t::geometry_context geo_context;
diff --git a/tests/benchmarks/cuda/benchmark_propagator_cuda.cpp b/tests/benchmarks/cuda/benchmark_propagator_cuda.cpp
index bd035a5cd..522a22119 100644
--- a/tests/benchmarks/cuda/benchmark_propagator_cuda.cpp
+++ b/tests/benchmarks/cuda/benchmark_propagator_cuda.cpp
@@ -5,16 +5,18 @@
  * Mozilla Public License Version 2.0
  */
 
-#include <benchmark/benchmark.h>
+// Project include(s)
+#include "benchmark_propagator_cuda_kernel.hpp"
+#include "detray/simulation/event_generator/track_generators.hpp"
 
-#include <covfie/core/field.hpp>
+// Vecmem include(s)
 #include <vecmem/memory/binary_page_memory_resource.hpp>
 #include <vecmem/memory/cuda/device_memory_resource.hpp>
 #include <vecmem/memory/cuda/managed_memory_resource.hpp>
+#include <vecmem/utils/cuda/copy.hpp>
 
-#include "benchmark_propagator_cuda_kernel.hpp"
-#include "detray/simulation/event_generator/track_generators.hpp"
-#include "vecmem/utils/cuda/copy.hpp"
+// Google include(s).
+#include <benchmark/benchmark.h>
 
 using namespace detray;
 
@@ -25,8 +27,7 @@ vecmem::cuda::device_memory_resource dev_mr;
 vecmem::binary_page_memory_resource bp_mng_mr(mng_mr);
 
 // detector configuration
-constexpr std::size_t n_brl_layers{4u};
-constexpr std::size_t n_edc_layers{7u};
+toy_det_config toy_cfg{4u, 7u};
 
 void fill_tracks(vecmem::vector<free_track_parameters<transform3>> &tracks,
                  const std::size_t theta_steps, const std::size_t phi_steps) {
@@ -45,11 +46,8 @@ template <propagate_option opt>
 static void BM_PROPAGATOR_CPU(benchmark::State &state) {
 
     // Create the toy geometry
-    auto [det, names] = create_toy_geometry<host_container_types>(
-        host_mr,
-        field_type(field_type::backend_t::configuration_t{
-            0.f, 0.f, 2.f * unit<scalar>::T}),
-        n_brl_layers, n_edc_layers);
+    auto [det, names] =
+        create_toy_geometry<field_type::backend_t>(host_mr, toy_cfg);
 
     // Create RK stepper
     rk_stepper_type s;
@@ -106,11 +104,11 @@ template <propagate_option opt>
 static void BM_PROPAGATOR_CUDA(benchmark::State &state) {
 
     // Create the toy geometry
-    auto [det, names] = create_toy_geometry<host_container_types>(
-        bp_mng_mr, n_brl_layers, n_edc_layers);
+    auto [det, names] =
+        create_toy_geometry<field_type::backend_t>(bp_mng_mr, toy_cfg);
 
     // Get detector data
-    auto det_data = get_data(det);
+    auto det_data = detray::get_data<field_type::backend_t>(det);
 
     // vecmem copy helper object
     vecmem::cuda::copy copy;
diff --git a/tests/benchmarks/cuda/benchmark_propagator_cuda_kernel.cu b/tests/benchmarks/cuda/benchmark_propagator_cuda_kernel.cu
index b12cb1934..c852ba9a5 100644
--- a/tests/benchmarks/cuda/benchmark_propagator_cuda_kernel.cu
+++ b/tests/benchmarks/cuda/benchmark_propagator_cuda_kernel.cu
@@ -11,7 +11,8 @@
 namespace detray {
 
 __global__ void __launch_bounds__(256, 4) propagator_benchmark_kernel(
-    typename detector_host_type::detector_view_type det_data,
+    typename detector_host_type::detector_view_type<bfield::const_bknd_t>
+        det_data,
     vecmem::data::vector_view<free_track_parameters<transform3>> tracks_data,
     vecmem::data::jagged_vector_view<intersection_t> candidates_data,
     const propagate_option opt) {
@@ -56,7 +57,8 @@ __global__ void __launch_bounds__(256, 4) propagator_benchmark_kernel(
 }
 
 void propagator_benchmark(
-    typename detector_host_type::detector_view_type det_data,
+    typename detector_host_type::detector_view_type<bfield::const_bknd_t>
+        det_data,
     vecmem::data::vector_view<free_track_parameters<transform3>>& tracks_data,
     vecmem::data::jagged_vector_view<intersection_t>& candidates_data,
     const propagate_option opt) {
diff --git a/tests/benchmarks/cuda/benchmark_propagator_cuda_kernel.hpp b/tests/benchmarks/cuda/benchmark_propagator_cuda_kernel.hpp
index 39fbdea06..7d631ef4d 100644
--- a/tests/benchmarks/cuda/benchmark_propagator_cuda_kernel.hpp
+++ b/tests/benchmarks/cuda/benchmark_propagator_cuda_kernel.hpp
@@ -7,10 +7,9 @@
 
 #pragma once
 
-#include <covfie/core/field.hpp>
-#include <covfie/core/field_view.hpp>
-
+// Project include(s)
 #include "detray/definitions/algebra.hpp"
+#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/units.hpp"
 #include "detray/detectors/create_toy_geometry.hpp"
 #include "detray/propagator/actor_chain.hpp"
@@ -27,10 +26,13 @@
 using namespace detray;
 
 using transform3 = __plugin::transform3<scalar>;
+
 using detector_host_type =
-    detector<toy_metadata<>, covfie::field, host_container_types>;
+    detector<toy_metadata, covfie::field<bfield::const_bknd_t>,
+             host_container_types>;
 using detector_device_type =
-    detector<toy_metadata<>, covfie::field_view, device_container_types>;
+    detector<toy_metadata, covfie::field_view<bfield::const_bknd_t>,
+             device_container_types>;
 
 using intersection_t =
     intersection2D<typename detector_device_type::surface_type, transform3>;
@@ -56,7 +58,8 @@ namespace detray {
 
 /// test function for propagator with single state
 void propagator_benchmark(
-    typename detector_host_type::detector_view_type det_data,
+    typename detector_host_type::detector_view_type<bfield::const_bknd_t>
+        det_data,
     vecmem::data::vector_view<free_track_parameters<transform3>>& tracks_data,
     vecmem::data::jagged_vector_view<intersection_t>& candidates_data,
     const propagate_option opt);
diff --git a/tests/common/include/tests/common/test_base/propagator_test.hpp b/tests/common/include/tests/common/test_base/propagator_test.hpp
index faf13cdc6..70be60af0 100644
--- a/tests/common/include/tests/common/test_base/propagator_test.hpp
+++ b/tests/common/include/tests/common/test_base/propagator_test.hpp
@@ -9,6 +9,7 @@
 
 // Project include(s).
 #include "detray/definitions/algebra.hpp"
+#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/units.hpp"
 #include "detray/detectors/create_toy_geometry.hpp"
 #include "detray/propagator/actor_chain.hpp"
@@ -23,40 +24,48 @@
 #include "detray/simulation/event_generator/track_generators.hpp"
 #include "detray/tracks/tracks.hpp"
 
-// Covfie include(s).
-#include <covfie/core/field.hpp>
-#include <covfie/core/field_view.hpp>
+// Vecmem include(s)
+#include <vecmem/memory/memory_resource.hpp>
 
 // GTest include(s).
 #include <gtest/gtest.h>
 
+// System include(s)
+#include <tuple>
+
 namespace detray {
 
-// Type declarations
-using transform3 = __plugin::transform3<scalar>;
-using detector_host_type =
-    detector<toy_metadata<>, covfie::field, host_container_types>;
-using detector_device_type =
-    detector<toy_metadata<>, covfie::field_view, device_container_types>;
+// Host detector type
+template <typename bfield_bknd_t>
+using detector_host_t =
+    detector<toy_metadata, covfie::field<bfield_bknd_t>, host_container_types>;
 
-using intersection_t =
-    intersection2D<typename detector_device_type::surface_type, transform3>;
+// Device detector type using views
+template <typename bfield_bknd_t>
+using detector_device_t =
+    detector<toy_metadata, covfie::field_view<bfield_bknd_t>,
+             device_container_types>;
 
-using navigator_host_type = navigator<detector_host_type>;
-using navigator_device_type = navigator<detector_device_type>;
+// These types are identical in host and device code for all bfield types
+using transform3 = typename detector_host_t<bfield::const_bknd_t>::transform3;
+using vector3_t = typename transform3::vector3;
+using matrix_operator = standard_matrix_operator<scalar>;
+using track_t = free_track_parameters<transform3>;
+using free_matrix = typename track_t::covariance_type;
 
-using constraints_t = constrained_step<>;
-using field_type = detector_host_type::bfield_type;
-using rk_stepper_type =
-    rk_stepper<field_type::view_t, transform3, constraints_t>;
+// Navigator
+template <typename detector_t>
+using navigator_t = navigator<detector_t>;
+template <typename detector_t>
+using intersection_t = typename navigator_t<detector_t>::intersection_type;
 
-using matrix_operator = standard_matrix_operator<scalar>;
-using free_track_parameters_type = free_track_parameters<transform3>;
-using free_matrix = typename free_track_parameters_type::covariance_type;
+// Stepper
+using constraints_t = constrained_step<>;
+template <typename bfield_view_t>
+using rk_stepper_t = rk_stepper<bfield_view_t, transform3, constraints_t>;
 
 // Detector configuration
-constexpr std::size_t n_brl_layers{4u};
-constexpr std::size_t n_edc_layers{3u};
+toy_det_config toy_cfg{};
 
 // Geomery navigation configurations
 constexpr unsigned int theta_steps{10u};
@@ -79,14 +88,14 @@ struct track_inspector : actor {
               _jac_transports(&resource) {}
 
         DETRAY_HOST_DEVICE
-        state(vector_t<scalar> path_lengths, vector_t<vector3> positions,
+        state(vector_t<scalar> path_lengths, vector_t<vector3_t> positions,
               vector_t<free_matrix> jac_transports)
             : _path_lengths(path_lengths),
               _positions(positions),
               _jac_transports(jac_transports) {}
 
         vector_t<scalar> _path_lengths;
-        vector_t<vector3> _positions;
+        vector_t<vector3_t> _positions;
         vector_t<free_matrix> _jac_transports;
     };
 
@@ -108,7 +117,7 @@ struct track_inspector : actor {
     }
 };
 
-// Assemble propagator type
+// Assemble actor chain type
 using inspector_host_t = track_inspector<vecmem::vector>;
 using inspector_device_t = track_inspector<vecmem::device_vector>;
 using actor_chain_host_t =
@@ -121,9 +130,142 @@ using actor_chain_device_t =
                 parameter_transporter<transform3>,
                 pointwise_material_interactor<transform3>,
                 parameter_resetter<transform3>>;
-using propagator_host_type =
-    propagator<rk_stepper_type, navigator_host_type, actor_chain_host_t>;
-using propagator_device_type =
-    propagator<rk_stepper_type, navigator_device_type, actor_chain_device_t>;
+
+/// Precompute the tracks
+inline vecmem::vector<track_t> generate_tracks(
+    vecmem::memory_resource *mr, const unsigned int ts = theta_steps,
+    const unsigned int ps = phi_steps) {
+
+    // Track collection
+    vecmem::vector<track_t> tracks(mr);
+
+    // Set origin position of tracks
+    const point3 ori{0.f, 0.f, 0.f};
+    const scalar p_mag{10.f * unit<scalar>::GeV};
+
+    // Iterate through uniformly distributed momentum directions
+    for (auto track : uniform_track_generator<track_t>(
+             ts, ps, ori, p_mag, {0.01f, constant<scalar>::pi},
+             {-constant<scalar>::pi, constant<scalar>::pi})) {
+        track.set_overstep_tolerance(overstep_tolerance);
+
+        // Put it into vector of trajectories
+        tracks.push_back(track);
+    }
+
+    return tracks;
+}
+
+/// Test function for propagator on the host
+template <typename bfield_bknd_t>
+inline auto run_propagation_host(vecmem::memory_resource *mr,
+                                 const detector_host_t<bfield_bknd_t> &det,
+                                 const vecmem::vector<track_t> &tracks)
+    -> std::tuple<vecmem::jagged_vector<scalar>,
+                  vecmem::jagged_vector<vector3_t>,
+                  vecmem::jagged_vector<free_matrix>> {
+
+    // Construct propagator from stepper and navigator
+    auto stepr = rk_stepper_t<
+        typename detector_host_t<bfield_bknd_t>::bfield_type::view_t>{};
+    auto nav = navigator_t<detector_host_t<bfield_bknd_t>>{};
+
+    using propagator_host_t =
+        propagator<decltype(stepr), decltype(nav), actor_chain_host_t>;
+    propagator_host_t p(std::move(stepr), std::move(nav));
+
+    // Create vector for track recording
+    vecmem::jagged_vector<scalar> host_path_lengths(mr);
+    vecmem::jagged_vector<vector3_t> host_positions(mr);
+    vecmem::jagged_vector<free_matrix> host_jac_transports(mr);
+
+    for (const auto &trk : tracks) {
+
+        // Create the propagator state
+        inspector_host_t::state insp_state{*mr};
+        pathlimit_aborter::state pathlimit_state{path_limit};
+        parameter_transporter<transform3>::state transporter_state{};
+        pointwise_material_interactor<transform3>::state interactor_state{};
+        parameter_resetter<transform3>::state resetter_state{};
+        auto actor_states =
+            detray::tie(insp_state, pathlimit_state, transporter_state,
+                        interactor_state, resetter_state);
+
+        typename propagator_host_t::state state(trk, det.get_bfield(), det);
+
+        state._stepping.template set_constraint<step::constraint::e_accuracy>(
+            constrainted_step_size);
+
+        state._stepping.set_tolerance(rk_tolerance);
+
+        // Run propagation
+        p.propagate(state, actor_states);
+
+        // Record the step information
+        host_path_lengths.push_back(insp_state._path_lengths);
+        host_positions.push_back(insp_state._positions);
+        host_jac_transports.push_back(insp_state._jac_transports);
+    }
+
+    return std::make_tuple(std::move(host_path_lengths),
+                           std::move(host_positions),
+                           std::move(host_jac_transports));
+}
+
+/// Compare the results between host and device propagation
+inline void compare_propagation_results(
+    const vecmem::jagged_vector<vector3_t> &host_positions,
+    const vecmem::jagged_vector<vector3_t> &device_positions,
+    const vecmem::jagged_vector<scalar> &host_path_lengths,
+    const vecmem::jagged_vector<scalar> &device_path_lengths,
+    const vecmem::jagged_vector<free_matrix> &host_jac_transports,
+    const vecmem::jagged_vector<free_matrix> &device_jac_transports) {
+
+    // Compare the positions and pathlengths
+    for (unsigned int i = 0u; i < host_positions.size(); i++) {
+        ASSERT_TRUE(host_positions[i].size() > 0);
+
+        for (unsigned int j = 0u; j < host_positions[i].size(); j++) {
+
+            scalar host_pl = host_path_lengths[i][j];
+            scalar device_pl = device_path_lengths[i][j];
+
+            ASSERT_EQ(host_positions[i].size(), device_positions[i].size());
+            ASSERT_NEAR(host_pl, device_pl, host_pl * is_close);
+
+            const vector3_t &host_pos = host_positions[i][j];
+            const vector3_t &device_pos = device_positions[i][j];
+
+            auto relative_error =
+                static_cast<point3>(1. / host_pl * (host_pos - device_pos));
+
+            ASSERT_NEAR(getter::norm(relative_error), 0.f, is_close);
+        }
+    }
+
+    // Compare the Jacobians
+    for (unsigned int i = 0u; i < host_jac_transports.size(); i++) {
+        for (unsigned int j = 0u; j < host_jac_transports[i].size(); j++) {
+
+            const free_matrix &host_J = host_jac_transports[i][j];
+            const free_matrix &device_J = device_jac_transports[i][j];
+
+            scalar pl = host_path_lengths[i][j];
+
+            for (std::size_t row = 0u; row < e_free_size; row++) {
+                for (std::size_t col = 0u; col < e_free_size; col++) {
+
+                    scalar host_val =
+                        matrix_operator().element(host_J, row, col);
+
+                    scalar device_val =
+                        matrix_operator().element(device_J, row, col);
+
+                    ASSERT_NEAR((host_val - device_val) / pl, 0.f, is_close);
+                }
+            }
+        }
+    }
+}
 
 }  // namespace detray
diff --git a/tests/common/include/tests/common/test_toy_detector.hpp b/tests/common/include/tests/common/test_toy_detector.hpp
index 3b756ad17..75e90905f 100644
--- a/tests/common/include/tests/common/test_toy_detector.hpp
+++ b/tests/common/include/tests/common/test_toy_detector.hpp
@@ -51,10 +51,13 @@ inline void test_finder(const acc_t& finder, const dindex volume_index,
     }
 }
 
-inline bool test_toy_detector(const detector<toy_metadata<>>& toy_det,
-                              const detector<toy_metadata<>>::name_map& names) {
+inline bool test_toy_detector(
+    const detector<toy_metadata, covfie::field<bfield::const_bknd_t>>& toy_det,
+    const detector<toy_metadata, covfie::field<bfield::const_bknd_t>>::name_map&
+        names) {
 
-    using detector_t = detector<toy_metadata<>>;
+    using detector_t =
+        detector<toy_metadata, covfie::field<bfield::const_bknd_t>>;
     using geo_obj_ids = typename detector_t::geo_obj_ids;
     using volume_t = typename detector_t::volume_type;
     using nav_link_t = typename detector_t::surface_type::navigation_link;
diff --git a/tests/unit_tests/covfie/constant_field.cpp b/tests/unit_tests/covfie/constant_field.cpp
index 40673b4bc..4867c1b0b 100644
--- a/tests/unit_tests/covfie/constant_field.cpp
+++ b/tests/unit_tests/covfie/constant_field.cpp
@@ -20,7 +20,8 @@ TEST(Covfie, ConstantField1D) {
         covfie::field<covfie::backend::constant<covfie::vector::float1,
                                                 covfie::vector::float1>>;
 
-    field_t f(field_t::backend_t::configuration_t{2.f});
+    field_t f(
+        covfie::make_parameter_pack(field_t::backend_t::configuration_t{2.f}));
     field_t::view_t v(f);
 
     for (float x = -100.f; x <= 100.f; x += 1.f) {
@@ -33,7 +34,8 @@ TEST(Covfie, ConstantField2D) {
         covfie::field<covfie::backend::constant<covfie::vector::float2,
                                                 covfie::vector::float2>>;
 
-    field_t f(field_t::backend_t::configuration_t{2.f, 5.f});
+    field_t f(covfie::make_parameter_pack(
+        field_t::backend_t::configuration_t{2.f, 5.f}));
     field_t::view_t v(f);
 
     for (float x = -100.f; x <= 100.f; x += 1.f) {
@@ -49,7 +51,8 @@ TEST(Covfie, ConstantField3D) {
         covfie::field<covfie::backend::constant<covfie::vector::float3,
                                                 covfie::vector::float3>>;
 
-    field_t f(field_t::backend_t::configuration_t{2.f, 5.f, -4.f});
+    field_t f(covfie::make_parameter_pack(
+        field_t::backend_t::configuration_t{2.f, 5.f, -4.f}));
     field_t::view_t v(f);
 
     for (float x = -10.f; x <= 10.f; x += 1.f) {
diff --git a/tests/unit_tests/cpu/core_detector.cpp b/tests/unit_tests/cpu/core_detector.cpp
index 19490d019..5074b8f97 100644
--- a/tests/unit_tests/cpu/core_detector.cpp
+++ b/tests/unit_tests/cpu/core_detector.cpp
@@ -705,7 +705,7 @@ GTEST_TEST(detray_tools, detector_builder) {
     // detector builder
     auto geo_ctx = typename detector_t::geometry_context{};
 
-    detector_builder<default_metadata, volume_builder> det_builder{};
+    detector_builder<default_metadata> det_builder{};
 
     //
     // first volume builder
diff --git a/tests/unit_tests/cpu/geometry_surface.cpp b/tests/unit_tests/cpu/geometry_surface.cpp
index 5cc6a033a..03d5a5181 100644
--- a/tests/unit_tests/cpu/geometry_surface.cpp
+++ b/tests/unit_tests/cpu/geometry_surface.cpp
@@ -85,7 +85,7 @@ GTEST_TEST(detray_geometry, surface) {
 
     using namespace detray;
 
-    using detector_t = detector<toy_metadata<>>;
+    using detector_t = detector<toy_metadata>;
 
     using point2_t = surface<detector_t>::point2;
     using point3_t = surface<detector_t>::point3;
diff --git a/tests/unit_tests/cpu/geometry_volume_graph.cpp b/tests/unit_tests/cpu/geometry_volume_graph.cpp
index 6a556ca95..d9dae5b23 100644
--- a/tests/unit_tests/cpu/geometry_volume_graph.cpp
+++ b/tests/unit_tests/cpu/geometry_volume_graph.cpp
@@ -21,11 +21,11 @@ GTEST_TEST(detray_geometry, volume_graph) {
 
     vecmem::host_memory_resource host_mr;
 
-    unsigned int n_brl_layers{4u};
-    unsigned int n_edc_layers{1u};
+    toy_det_config toy_cfg{};
+    toy_cfg.n_edc_layers(1u);
+
+    auto [det, names] = create_toy_geometry(host_mr, toy_cfg);
 
-    auto [det, names] =
-        create_toy_geometry(host_mr, n_brl_layers, n_edc_layers);
     using detector_t = decltype(det);
 
     /// Prints linking information for every node when visited
diff --git a/tests/unit_tests/cpu/grid_grid_builder.cpp b/tests/unit_tests/cpu/grid_grid_builder.cpp
index 8d83bcf06..1156d00d4 100644
--- a/tests/unit_tests/cpu/grid_grid_builder.cpp
+++ b/tests/unit_tests/cpu/grid_grid_builder.cpp
@@ -9,6 +9,7 @@
 
 // Detray include(s)
 #include "detray/core/detector.hpp"
+#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/indexing.hpp"
 #include "detray/detectors/toy_metadata.hpp"
 #include "detray/masks/masks.hpp"
@@ -35,7 +36,7 @@ using vector3 = test::vector3;
 
 test::transform3 Identity{};
 
-using test_detector_t = detector<toy_metadata<>>;
+using test_detector_t = detector<toy_metadata>;
 
 }  // anonymous namespace
 
@@ -267,9 +268,10 @@ GTEST_TEST(detray_tools, decorator_grid_builder) {
     EXPECT_EQ(vol.id(), volume_id::e_cylinder);
 
     // only the portals are referenced through the volume
-    typename toy_metadata<>::object_link_type sf_range{};
+    typename toy_metadata::object_link_type sf_range{};
     sf_range[0] = {acc_ids::e_default, 0u};
     sf_range[1] = {acc_ids::e_cylinder2_grid, 0u};
+
     // toy detector makes no distinction between the surface types
     EXPECT_EQ(vol.template link<geo_obj_id::e_portal>(),
               sf_range[geo_obj_id::e_portal]);
diff --git a/tests/unit_tests/cpu/io_read_detector.cpp b/tests/unit_tests/cpu/io_read_detector.cpp
new file mode 100644
index 000000000..80e3c6eb1
--- /dev/null
+++ b/tests/unit_tests/cpu/io_read_detector.cpp
@@ -0,0 +1,30 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2021-2022 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#include <gtest/gtest.h>
+
+#include <iostream>
+#include <map>
+#include <string>
+#include <vecmem/memory/host_memory_resource.hpp>
+
+#include "detray/core/detector.hpp"
+#include "detray/detectors/toy_metadata.hpp"
+#include "detray/test/types.hpp"
+#include "tests/common/tools/read_geometry.hpp"
+
+// This tests the construction of a detector class
+GTEST_TEST(detray_tools, read_detector) {
+    vecmem::host_memory_resource host_mr;
+    using namespace detray;
+
+    /*auto [d, name_map] =
+        read_from_csv<detector_registry::tml_detector,
+        covfie::field<bfield::const_bknd_t>>(tml_files, host_mr);
+
+    std::cout << d.to_string(name_map) << std::endl;*/
+}
diff --git a/tests/unit_tests/cpu/line_stepper.cpp b/tests/unit_tests/cpu/line_stepper.cpp
index 4432572db..7bdeff45e 100644
--- a/tests/unit_tests/cpu/line_stepper.cpp
+++ b/tests/unit_tests/cpu/line_stepper.cpp
@@ -8,6 +8,7 @@
 // Project include(s).
 #include "detray/propagator/line_stepper.hpp"
 
+#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/units.hpp"
 #include "detray/detectors/create_telescope_detector.hpp"
 #include "detray/masks/masks.hpp"
@@ -19,10 +20,6 @@
 #include "detray/propagator/propagator.hpp"
 #include "detray/test/types.hpp"
 
-// Covfie include(s).
-#include <covfie/core/field.hpp>
-#include <covfie/core/field_view.hpp>
-
 // Vecmem include(s).
 #include <vecmem/memory/host_memory_resource.hpp>
 
diff --git a/tests/unit_tests/cpu/test_telescope_detector.cpp b/tests/unit_tests/cpu/test_telescope_detector.cpp
index e1f973248..fdea0a10b 100644
--- a/tests/unit_tests/cpu/test_telescope_detector.cpp
+++ b/tests/unit_tests/cpu/test_telescope_detector.cpp
@@ -85,10 +85,10 @@ GTEST_TEST(detray_detectors, telescope_detector) {
     // B-fields
     vector3 B_z{0.f, 0.f, 1.f * unit<scalar>::T};
     vector3 B_x{1.f * unit<scalar>::T, 0.f, 0.f};
-    b_field_t b_field_z{
-        b_field_t::backend_t::configuration_t{B_z[0], B_z[1], B_z[2]}};
-    b_field_t b_field_x{
-        b_field_t::backend_t::configuration_t{B_x[0], B_x[1], B_x[2]}};
+    b_field_t b_field_z{covfie::make_parameter_pack(
+        b_field_t::backend_t::configuration_t{B_z[0], B_z[1], B_z[2]})};
+    b_field_t b_field_x{covfie::make_parameter_pack(
+        b_field_t::backend_t::configuration_t{B_x[0], B_x[1], B_x[2]})};
 
     // steppers
     rk_stepper_t rk_stepper_z;
diff --git a/tests/unit_tests/cpu/test_toy_geometry.cpp b/tests/unit_tests/cpu/test_toy_geometry.cpp
index bebca3fc5..7c535f8f1 100644
--- a/tests/unit_tests/cpu/test_toy_geometry.cpp
+++ b/tests/unit_tests/cpu/test_toy_geometry.cpp
@@ -22,11 +22,8 @@ using namespace detray;
 GTEST_TEST(detray_detectors, toy_geometry) {
 
     vecmem::host_memory_resource host_mr;
-    constexpr std::size_t n_brl_layers{4u};
-    constexpr std::size_t n_edc_layers{3u};
 
-    const auto [toy_det, names] =
-        create_toy_geometry(host_mr, n_brl_layers, n_edc_layers);
+    const auto [toy_det, names] = create_toy_geometry(host_mr);
 
     EXPECT_TRUE(test_toy_detector(toy_det, names));
 }
diff --git a/tests/unit_tests/cpu/tools_guided_navigator.cpp b/tests/unit_tests/cpu/tools_guided_navigator.cpp
index 42f5719ad..88ab9e685 100644
--- a/tests/unit_tests/cpu/tools_guided_navigator.cpp
+++ b/tests/unit_tests/cpu/tools_guided_navigator.cpp
@@ -67,8 +67,8 @@ GTEST_TEST(detray_propagator, guided_navigator) {
     const vector3 mom{0.f, 0.f, 1.f};
     free_track_parameters<transform3_t> track(pos, 0.f, mom, -1.f);
     const vector3 B{0.f, 0.f, 1.f * unit<scalar>::T};
-    const b_field_t b_field(
-        b_field_t::backend_t::configuration_t{B[0], B[1], B[2]});
+    const b_field_t b_field(covfie::make_parameter_pack(
+        b_field_t::backend_t::configuration_t{B[0], B[1], B[2]}));
 
     // Actors
     pathlimit_aborter::state pathlimit{200.f * unit<scalar>::cm};
diff --git a/tests/unit_tests/cpu/tools_material_builder.cpp b/tests/unit_tests/cpu/tools_material_builder.cpp
index d9469d72d..3f6afd257 100644
--- a/tests/unit_tests/cpu/tools_material_builder.cpp
+++ b/tests/unit_tests/cpu/tools_material_builder.cpp
@@ -232,7 +232,7 @@ GTEST_TEST(detray_tools, detector_builder_with_material) {
     using material_id = typename detector_t::materials::id;
 
     // detector builder
-    detector_builder<default_metadata, volume_builder> det_builder{};
+    detector_builder<default_metadata> det_builder{};
 
     // Vanilla volume builder
     auto vbuilder = det_builder.new_volume(volume_id::e_cuboid);
diff --git a/tests/unit_tests/cpu/tools_navigator.cpp b/tests/unit_tests/cpu/tools_navigator.cpp
index 1c45bdd8b..a0ca75fb9 100644
--- a/tests/unit_tests/cpu/tools_navigator.cpp
+++ b/tests/unit_tests/cpu/tools_navigator.cpp
@@ -118,10 +118,8 @@ GTEST_TEST(detray_navigator, toy_geometry) {
     /// Tolerance for tests
     constexpr double tol{0.01};
 
-    unsigned int n_brl_layers{4u};
-    unsigned int n_edc_layers{3u};
-    auto [toy_det, names] =
-        create_toy_geometry(host_mr, n_brl_layers, n_edc_layers);
+    auto [toy_det, names] = create_toy_geometry(host_mr);
+
     using detector_t = decltype(toy_det);
     using inspector_t = navigation::print_inspector;
     using navigator_t = navigator<detector_t, inspector_t>;
diff --git a/tests/unit_tests/cpu/tools_particle_gun.cpp b/tests/unit_tests/cpu/tools_particle_gun.cpp
index e25860479..d2b014126 100644
--- a/tests/unit_tests/cpu/tools_particle_gun.cpp
+++ b/tests/unit_tests/cpu/tools_particle_gun.cpp
@@ -30,9 +30,16 @@ constexpr const scalar tol{1e-3f};
 /// without B-field
 GTEST_TEST(detray_tools, particle_gun) {
 
+    // Simulate straight line track
+    const vector3 B{0.f * unit<scalar>::T, 0.f * unit<scalar>::T,
+                    tol * unit<scalar>::T};
+
     // Build the geometry
     vecmem::host_memory_resource host_mr;
-    auto [toy_det, names] = create_toy_geometry(host_mr);
+    toy_det_config toy_cfg{};
+    toy_cfg.bfield_vec(B);
+
+    auto [toy_det, names] = create_toy_geometry(host_mr, toy_cfg);
 
     unsigned int theta_steps{50u};
     unsigned int phi_steps{50u};
@@ -55,9 +62,6 @@ GTEST_TEST(detray_tools, particle_gun) {
         expected.push_back(intersection_record);
     }
 
-    // Simulate straight line track
-    const vector3 B{0.f * unit<scalar>::T, 0.f * unit<scalar>::T,
-                    tol * unit<scalar>::T};
     // Iterate through uniformly distributed momentum directions with helix
     std::size_t n_tracks{0u};
     for (const auto track :
diff --git a/tests/unit_tests/cpu/tools_propagator.cpp b/tests/unit_tests/cpu/tools_propagator.cpp
index 7f51562df..ff3ed2038 100644
--- a/tests/unit_tests/cpu/tools_propagator.cpp
+++ b/tests/unit_tests/cpu/tools_propagator.cpp
@@ -6,6 +6,7 @@
  */
 
 // Project include(s)
+#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/units.hpp"
 #include "detray/detectors/create_toy_geometry.hpp"
 #include "detray/geometry/surface.hpp"
@@ -44,7 +45,7 @@ struct helix_inspector : actor {
 
     /// Keeps the state of a helix gun to calculate track positions
     struct state {
-        // navigation status for every step
+        /// navigation status for every step
         std::vector<navigation::status> _nav_status;
     };
 
@@ -89,7 +90,7 @@ struct helix_inspector : actor {
         const auto bvec =
             stepping._magnetic_field.at(last_pos[0], last_pos[1], last_pos[2]);
         const vector3 b{bvec[0], bvec[1], bvec[2]};
-        // const auto b = stepping._magnetic_field->get_field(last_pos, {});
+
         detail::helix<transform3> hlx(free_params, &b);
 
         const auto true_pos = hlx(stepping._s);
@@ -136,45 +137,53 @@ GTEST_TEST(detray_propagator, propagator_line_stepper) {
         << state._navigation.inspector().to_string() << std::endl;
 }
 
-class PropagatorWithRkStepper : public ::testing::TestWithParam<
-                                    std::tuple<test::vector3, scalar, scalar>> {
-};
-
-/// Test propagation in a magnetic field using a Runge-Kutta stepper
-TEST_P(PropagatorWithRkStepper, propagator_rk_stepper) {
+/// Fixture for Runge-Kutta Propagation
+class PropagatorWithRkStepper
+    : public ::testing::TestWithParam<
+          std::tuple<scalar, scalar, __plugin::vector3<scalar>>> {
 
-    // geomery navigation configurations
-    constexpr std::size_t theta_steps{50u};
-    constexpr std::size_t phi_steps{50u};
+    public:
+    /// Set the test environment up
+    virtual void SetUp() {
+        overstep_tol = std::get<0>(GetParam());
+        step_constr = std::get<1>(GetParam());
+    }
 
-    // Set origin position of tracks
-    const point3 ori{0.f, 0.f, 0.f};
-    constexpr scalar mom{10.f * unit<scalar>::GeV};
+    /// Clean up
+    virtual void TearDown() {}
 
-    // detector configuration
-    constexpr std::size_t n_brl_layers{4u};
-    constexpr std::size_t n_edc_layers{7u};
+    protected:
+    /// Detector configuration
     vecmem::host_memory_resource host_mr;
+    toy_det_config toy_cfg{4u, 7u};
+
+    /// Track generator configuration
+    unsigned int theta_steps{50u};
+    unsigned int phi_steps{50u};
+    point3 ori{0.f, 0.f, 0.f};
+    scalar mom{10.f * unit<scalar>::GeV};
 
-    // Construct the constant magnetic field.
-    using b_field_t =
-        decltype(create_toy_geometry(host_mr, n_brl_layers, n_edc_layers)
-                     .first)::bfield_type;
-    const vector3 B = std::get<0>(GetParam());
+    /// Stepper configuration
+    scalar overstep_tol, step_constr;
+};
+
+/// Test propagation in a constant magnetic field using a Runge-Kutta stepper
+TEST_P(PropagatorWithRkStepper, rk4_propagator_const_bfield) {
+
+    // Constant magnetic field type
+    using bfield_t = covfie::field<bfield::const_bknd_t>;
 
-    const auto [d, names] = create_toy_geometry(
-        host_mr,
-        b_field_t(b_field_t::backend_t::configuration_t{B[0], B[1], B[2]}),
-        n_brl_layers, n_edc_layers);
+    // Toy detector
+    using detector_t = detector<toy_metadata, bfield_t>;
 
-    // Create the navigator
-    // using navigator_t = navigator<decltype(d), navigation::print_inspector>;
-    using navigator_t = navigator<decltype(d)>;
+    // Runge-Kutta propagation
+    using navigator_t = navigator<detector_t /*, navigation::print_inspector*/>;
     using track_t = free_track_parameters<transform3>;
     using constraints_t = constrained_step<>;
     using policy_t = stepper_default_policy;
     using stepper_t =
-        rk_stepper<b_field_t::view_t, transform3, constraints_t, policy_t>;
+        rk_stepper<bfield_t::view_t, transform3, constraints_t, policy_t>;
+    // Include helix actor to check track position/covariance
     using actor_chain_t =
         actor_chain<dtuple, helix_inspector, propagation::print_inspector,
                     pathlimit_aborter, parameter_transporter<transform3>,
@@ -182,9 +191,9 @@ TEST_P(PropagatorWithRkStepper, propagator_rk_stepper) {
                     parameter_resetter<transform3>>;
     using propagator_t = propagator<stepper_t, navigator_t, actor_chain_t>;
 
-    // Test parameters
-    const scalar overstep_tol = std::get<1>(GetParam());
-    const scalar step_constr = std::get<2>(GetParam());
+    // Build detector and magnetic field
+    toy_cfg.bfield_vec(std::get<2>(GetParam()));
+    const auto [det, names] = create_toy_geometry(host_mr, toy_cfg);
 
     // Propagator is built from the stepper and navigator
     propagator_t p(stepper_t{}, navigator_t{});
@@ -220,8 +229,8 @@ TEST_P(PropagatorWithRkStepper, propagator_rk_stepper) {
             transporter_state, interactor_state, resetter_state);
 
         // Init propagator states
-        propagator_t::state state(track, d.get_bfield(), d);
-        propagator_t::state lim_state(lim_track, d.get_bfield(), d);
+        propagator_t::state state(track, det.get_bfield(), det);
+        propagator_t::state lim_state(lim_track, det.get_bfield(), det);
 
         // Set step constraints
         state._stepping.template set_constraint<step::constraint::e_accuracy>(
@@ -257,37 +266,119 @@ TEST_P(PropagatorWithRkStepper, propagator_rk_stepper) {
     }
 }
 
-// Realistic case
-INSTANTIATE_TEST_SUITE_P(
-    PropagatorValidation1, PropagatorWithRkStepper,
-    ::testing::Values(std::make_tuple(test::vector3{0.f * unit<scalar>::T,
-                                                    0.f * unit<scalar>::T,
-                                                    2.f * unit<scalar>::T},
-                                      -7.f * unit<scalar>::um,
-                                      std::numeric_limits<scalar>::max())));
+/// Test propagation in an inhomogenous magnetic field using a Runge-Kutta
+/// stepper
+TEST_P(PropagatorWithRkStepper, rk4_propagator_inhom_bfield) {
 
-// Add some restrictions for more frequent navigation updates in the cases of
-// non-z-aligned B-fields
-INSTANTIATE_TEST_SUITE_P(
-    PropagatorValidation2, PropagatorWithRkStepper,
-    ::testing::Values(std::make_tuple(test::vector3{0.f * unit<scalar>::T,
-                                                    1.f * unit<scalar>::T,
-                                                    1.f * unit<scalar>::T},
-                                      -10.f * unit<scalar>::um,
-                                      5.f * unit<scalar>::mm)));
+    // Magnetic field map using nearest neightbor interpolation
+    using bfield_t = covfie::field<bfield::inhom_bknd_t>;
 
-INSTANTIATE_TEST_SUITE_P(
-    PropagatorValidation3, PropagatorWithRkStepper,
-    ::testing::Values(std::make_tuple(test::vector3{1.f * unit<scalar>::T,
-                                                    0.f * unit<scalar>::T,
-                                                    1.f * unit<scalar>::T},
-                                      -10.f * unit<scalar>::um,
-                                      5.f * unit<scalar>::mm)));
+    // Toy detector
+    using detector_t = detector<toy_metadata, bfield_t>;
 
+    // Runge-Kutta propagation
+    using navigator_t = navigator<detector_t /*, navigation::print_inspector*/>;
+    using track_t = free_track_parameters<transform3>;
+    using constraints_t = constrained_step<>;
+    using policy_t = stepper_default_policy;
+    using stepper_t =
+        rk_stepper<bfield_t::view_t, transform3, constraints_t, policy_t>;
+    // Include helix actor to check track position/covariance
+    using actor_chain_t =
+        actor_chain<dtuple, propagation::print_inspector, pathlimit_aborter,
+                    parameter_transporter<transform3>,
+                    pointwise_material_interactor<transform3>,
+                    parameter_resetter<transform3>>;
+    using propagator_t = propagator<stepper_t, navigator_t, actor_chain_t>;
+
+    // Build detector and magnetic field
+    const auto [det, names] =
+        create_toy_geometry<bfield::inhom_bknd_t>(host_mr, toy_cfg);
+    // Propagator is built from the stepper and navigator
+    propagator_t p(stepper_t{}, navigator_t{});
+
+    // Iterate through uniformly distributed momentum directions
+    for (auto track :
+         uniform_track_generator<track_t>(theta_steps, phi_steps, ori, mom)) {
+        // Genrate second track state used for propagation with pathlimit
+        track_t lim_track(track);
+
+        track.set_overstep_tolerance(overstep_tol);
+        lim_track.set_overstep_tolerance(overstep_tol);
+
+        // Build actor states: the helix inspector can be shared
+        propagation::print_inspector::state print_insp_state{};
+        propagation::print_inspector::state lim_print_insp_state{};
+        pathlimit_aborter::state unlimted_aborter_state{};
+        pathlimit_aborter::state pathlimit_aborter_state{path_limit};
+        parameter_transporter<transform3>::state transporter_state{};
+        pointwise_material_interactor<transform3>::state interactor_state{};
+        parameter_resetter<transform3>::state resetter_state{};
+
+        // Create actor states tuples
+        auto actor_states =
+            std::tie(print_insp_state, unlimted_aborter_state,
+                     transporter_state, interactor_state, resetter_state);
+        auto lim_actor_states =
+            std::tie(lim_print_insp_state, pathlimit_aborter_state,
+                     transporter_state, interactor_state, resetter_state);
+
+        // Init propagator states
+        propagator_t::state state(track, det.get_bfield(), det);
+        propagator_t::state lim_state(lim_track, det.get_bfield(), det);
+
+        // Set step constraints
+        state._stepping.template set_constraint<step::constraint::e_accuracy>(
+            step_constr);
+        lim_state._stepping
+            .template set_constraint<step::constraint::e_accuracy>(step_constr);
+
+        // Propagate the entire detector
+        ASSERT_TRUE(p.propagate(state, actor_states))
+            << print_insp_state.to_string() << std::endl;
+        //<< state._navigation.inspector().to_string() << std::endl;
+
+        // Propagate with path limit
+        ASSERT_NEAR(pathlimit_aborter_state.path_limit(), path_limit, tol);
+        ASSERT_FALSE(p.propagate(lim_state, lim_actor_states))
+            << lim_print_insp_state.to_string() << std::endl;
+        //<< lim_state._navigation.inspector().to_string() << std::endl;
+
+        ASSERT_TRUE(lim_state._stepping.path_length() <
+                    std::abs(path_limit) + tol)
+            << "path length: " << lim_state._stepping.path_length()
+            << ", path limit: " << path_limit << std::endl;
+        //<< state._navigation.inspector().to_string() << std::endl;
+    }
+}
+
+// No step size constraint
 INSTANTIATE_TEST_SUITE_P(
-    PropagatorValidation4, PropagatorWithRkStepper,
-    ::testing::Values(std::make_tuple(test::vector3{1.f * unit<scalar>::T,
-                                                    1.f * unit<scalar>::T,
-                                                    1.f * unit<scalar>::T},
-                                      -10.f * unit<scalar>::um,
-                                      5.f * unit<scalar>::mm)));
+    PropagationValidation1, PropagatorWithRkStepper,
+    ::testing::Values(std::make_tuple(
+        -0.05f * unit<scalar>::mm, std::numeric_limits<scalar>::max(),
+        __plugin::vector3<scalar>{0.f * unit<scalar>::T, 0.f * unit<scalar>::T,
+                                  2.f * unit<scalar>::T})));
+
+// Add some restrictions for more frequent navigation updates in the cases of
+// non-z-aligned B-fields
+INSTANTIATE_TEST_SUITE_P(PropagationValidation2, PropagatorWithRkStepper,
+                         ::testing::Values(std::make_tuple(
+                             -10.f * unit<scalar>::um, 5.f * unit<scalar>::mm,
+                             __plugin::vector3<scalar>{
+                                 0.f * unit<scalar>::T, 1.f * unit<scalar>::T,
+                                 1.f * unit<scalar>::T})));
+
+INSTANTIATE_TEST_SUITE_P(PropagationValidation3, PropagatorWithRkStepper,
+                         ::testing::Values(std::make_tuple(
+                             -10.f * unit<scalar>::um, 5.f * unit<scalar>::mm,
+                             __plugin::vector3<scalar>{
+                                 1.f * unit<scalar>::T, 0.f * unit<scalar>::T,
+                                 1.f * unit<scalar>::T})));
+
+INSTANTIATE_TEST_SUITE_P(PropagationValidation4, PropagatorWithRkStepper,
+                         ::testing::Values(std::make_tuple(
+                             -10.f * unit<scalar>::um, 5.f * unit<scalar>::mm,
+                             __plugin::vector3<scalar>{
+                                 1.f * unit<scalar>::T, 1.f * unit<scalar>::T,
+                                 1.f * unit<scalar>::T})));
diff --git a/tests/unit_tests/cpu/tools_stepper.cpp b/tests/unit_tests/cpu/tools_stepper.cpp
index 3c98b39a3..55b9acfbb 100644
--- a/tests/unit_tests/cpu/tools_stepper.cpp
+++ b/tests/unit_tests/cpu/tools_stepper.cpp
@@ -6,9 +6,11 @@
  */
 
 // detray include(s)
+#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/units.hpp"
 #include "detray/geometry/surface.hpp"
 #include "detray/intersection/detail/trajectories.hpp"
+#include "detray/io/common/detail/file_handle.hpp"
 #include "detray/propagator/line_stepper.hpp"
 #include "detray/propagator/rk_stepper.hpp"
 #include "detray/simulation/event_generator/track_generators.hpp"
@@ -18,28 +20,36 @@
 // google-test include(s)
 #include <gtest/gtest.h>
 
-// covfie include(s)
-#include <covfie/core/backend/primitive/constant.hpp>
-#include <covfie/core/field.hpp>
-#include <covfie/core/field_view.hpp>
-#include <covfie/core/vector.hpp>
-
 using namespace detray;
 using vector2 = test::vector2;
 using vector3 = test::vector3;
 using point3 = test::point3;
 using transform3 = test::transform3;
 using matrix_operator = standard_matrix_operator<scalar>;
-using mag_field_t = covfie::field<covfie::backend::constant<
-    covfie::vector::vector_d<scalar, 3>, covfie::vector::vector_d<scalar, 3>>>;
-using rk_stepper_t = rk_stepper<mag_field_t::view_t, transform3>;
+
+/// Runge-Kutta stepper
+template <typename bfield_t>
+using rk_stepper_t = rk_stepper<typename bfield_t::view_t, transform3>;
+template <typename bfield_t>
 using crk_stepper_t =
-    rk_stepper<mag_field_t::view_t, transform3, constrained_step<>>;
+    rk_stepper<typename bfield_t::view_t, transform3, constrained_step<>>;
 
 namespace {
 
 constexpr scalar tol{1e-3f};
 
+template <typename bfield_t>
+inline bfield_t load_field() {
+    detray::io::detail::file_handle file(
+        !std::getenv("DETRAY_BFIELD_FILE") ? ""
+                                           : std::getenv("DETRAY_BFIELD_FILE"),
+        std::ios_base::binary | std::ios_base::in);
+
+    bfield_t field(*file);
+
+    return field;
+}
+
 // dummy navigation struct
 struct nav_state {
     scalar operator()() const { return _step_size; }
@@ -139,24 +149,27 @@ GTEST_TEST(detray_propagator, line_stepper) {
 GTEST_TEST(detray_propagator, rk_stepper) {
     using namespace step;
 
-    // RK stepper configurations
-    constexpr unsigned int theta_steps = 100u;
-    constexpr unsigned int phi_steps = 100u;
-    constexpr unsigned int rk_steps = 100u;
-
     // Constant magnetic field
+    using bfield_t = covfie::field<bfield::const_bknd_t>;
+
     vector3 B{1.f * unit<scalar>::T, 1.f * unit<scalar>::T,
               1.f * unit<scalar>::T};
-    mag_field_t mag_field(
-        typename mag_field_t::backend_t::configuration_t{B[0], B[1], B[2]});
+    bfield_t hom_bfield(covfie::make_parameter_pack(
+        typename bfield_t::backend_t::configuration_t{B[0], B[1], B[2]}));
 
     // RK stepper
-    rk_stepper_t rk_stepper;
-    crk_stepper_t crk_stepper;
+    rk_stepper_t<bfield_t> rk_stepper;
+    crk_stepper_t<bfield_t> crk_stepper;
 
-    // Set origin position of tracks
+    // RK stepper configurations
+    constexpr unsigned int rk_steps = 100u;
+    constexpr scalar stepsize_constr{0.5f * unit<scalar>::mm};
+
+    // Track generator configuration
     const point3 ori{0.f, 0.f, 0.f};
     const scalar p_mag{10.f * unit<scalar>::GeV};
+    constexpr unsigned int theta_steps = 100u;
+    constexpr unsigned int phi_steps = 100u;
 
     // Iterate through uniformly distributed momentum directions
     for (auto track :
@@ -165,47 +178,51 @@ GTEST_TEST(detray_propagator, rk_stepper) {
         // Generate track state used for propagation with constrained step size
         free_track_parameters c_track(track);
 
-        // helix gun
+        // helix trajectory
         detail::helix helix(track, &B);
 
         // RK Stepping into forward direction
-        prop_state<rk_stepper_t::state, nav_state> propagation{
-            rk_stepper_t::state{track, mag_field}, nav_state{}};
-        prop_state<crk_stepper_t::state, nav_state> c_propagation{
-            crk_stepper_t::state{c_track, mag_field}, nav_state{}};
+        prop_state<rk_stepper_t<bfield_t>::state, nav_state> propagation{
+            rk_stepper_t<bfield_t>::state{track, hom_bfield}, nav_state{}};
+        prop_state<crk_stepper_t<bfield_t>::state, nav_state> c_propagation{
+            crk_stepper_t<bfield_t>::state{c_track, hom_bfield}, nav_state{}};
 
-        rk_stepper_t::state &rk_state = propagation._stepping;
-        crk_stepper_t::state &crk_state = c_propagation._stepping;
+        rk_stepper_t<bfield_t>::state &rk_state = propagation._stepping;
+        crk_stepper_t<bfield_t>::state &crk_state = c_propagation._stepping;
 
-        // Retrieve one of the navigation states
+        // Retrieve the navigation states
         nav_state &n_state = propagation._navigation;
         nav_state &cn_state = c_propagation._navigation;
 
-        crk_state.template set_constraint<constraint::e_user>(0.5f *
-                                                              unit<scalar>::mm);
-        n_state._step_size = 1.f * unit<scalar>::mm;
-        cn_state._step_size = 1.f * unit<scalar>::mm;
+        // Set step size constraint to half the nominal step size =>
+        // crk_stepper will need twice as many steps
+        crk_state.template set_constraint<constraint::e_user>(stepsize_constr);
         ASSERT_NEAR(crk_state.constraints().template size<>(),
                     0.5f * unit<scalar>::mm, tol);
 
+        // Reset step size in the navigation state to a positive value
+        n_state._step_size = 1.f * unit<scalar>::mm;
+        cn_state._step_size = 1.f * unit<scalar>::mm;
         for (unsigned int i_s = 0u; i_s < rk_steps; i_s++) {
             rk_stepper.step(propagation);
             crk_stepper.step(c_propagation);
             crk_stepper.step(c_propagation);
         }
 
-        // get relative error by dividing error with path length
+        // Check that both steppers arrive at the same point
+        // Get relative error by dividing error with path length
         ASSERT_NEAR(rk_state.path_length(), crk_state.path_length(), tol);
         ASSERT_NEAR(getter::norm(rk_state().pos() - crk_state().pos()) /
                         rk_state.path_length(),
                     0.f, tol);
 
+        // Check that the stepper position lies on the truth helix
         const auto helix_pos = helix(rk_state.path_length());
         const auto forward_pos = rk_state().pos();
         const point3 forward_relative_error{(1.f / rk_state.path_length()) *
                                             (forward_pos - helix_pos)};
 
-        // Make sure that relative error is smaller than epsion
+        // Make sure that relative error is smaller than the tolerance
         EXPECT_NEAR(getter::norm(forward_relative_error), 0.f, tol);
 
         // Roll the same track back to the origin
@@ -219,16 +236,105 @@ GTEST_TEST(detray_propagator, rk_stepper) {
             crk_stepper.step(c_propagation);
         }
 
-        ASSERT_NEAR(rk_state.path_length(), crk_state.path_length(), tol);
+        // Should arrive back at track origin, where path length is zero
+        ASSERT_NEAR(rk_state.path_length(), 0.f, tol);
+        ASSERT_NEAR(crk_state.path_length(), 0.f, tol);
+
+        const point3 backward_relative_error{1.f / (2.f * path_length) *
+                                             (rk_state().pos() - ori)};
+        // Make sure that relative error is smaller than the tolerance
+        EXPECT_NEAR(getter::norm(backward_relative_error), 0.f, tol);
+
+        // The constrained stepper should be at the same position now
         ASSERT_NEAR(getter::norm(rk_state().pos() - crk_state().pos()) /
                         (2.f * path_length),
                     0.f, tol);
+    }
+}
 
-        const auto backward_pos = rk_state().pos();
-        const point3 backward_relative_error{1.f / (2.f * path_length) *
-                                             (backward_pos - ori)};
+/// This tests the base functionality of the Runge-Kutta stepper in an
+/// in-homogeneous magnetic field, read from file
+TEST(detray_propagator, rk_stepper_inhomogeneous_bfield) {
+    using namespace step;
+
+    using bfield_t = covfie::field<bfield::inhom_bknd_t>;
+
+    // Read the magnetic field map
+    bfield_t inhom_bfield(load_field<bfield_t>());
+
+    // RK stepper
+    rk_stepper_t<bfield_t> rk_stepper;
+    crk_stepper_t<bfield_t> crk_stepper;
+
+    // RK stepper configurations
+    constexpr unsigned int rk_steps = 100u;
+    constexpr scalar stepsize_constr{0.5f * unit<scalar>::mm};
+
+    // Track generator configuration
+    const point3 ori{0.f, 0.f, 0.f};
+    const scalar p_mag{10.f * unit<scalar>::GeV};
+    constexpr unsigned int theta_steps = 100u;
+    constexpr unsigned int phi_steps = 100u;
 
-        // Make sure that relative error is smaller than epsion
+    // Iterate through uniformly distributed momentum directions
+    for (auto track :
+         uniform_track_generator<free_track_parameters<transform3>>(
+             theta_steps, phi_steps, ori, p_mag)) {
+        // Generate track state used for propagation with constrained step size
+        free_track_parameters c_track(track);
+
+        // RK Stepping into forward direction
+        prop_state<rk_stepper_t<bfield_t>::state, nav_state> propagation{
+            rk_stepper_t<bfield_t>::state{track, inhom_bfield}, nav_state{}};
+        prop_state<crk_stepper_t<bfield_t>::state, nav_state> c_propagation{
+            crk_stepper_t<bfield_t>::state{c_track, inhom_bfield}, nav_state{}};
+
+        rk_stepper_t<bfield_t>::state &rk_state = propagation._stepping;
+        crk_stepper_t<bfield_t>::state &crk_state = c_propagation._stepping;
+
+        // Retrieve the navigation states
+        nav_state &n_state = propagation._navigation;
+        nav_state &cn_state = c_propagation._navigation;
+
+        crk_state.template set_constraint<constraint::e_user>(stepsize_constr);
+        ASSERT_NEAR(crk_state.constraints().template size<>(),
+                    0.5f * unit<scalar>::mm, tol);
+
+        n_state._step_size = 1.f * unit<scalar>::mm;
+        cn_state._step_size = 1.f * unit<scalar>::mm;
+        for (unsigned int i_s = 0u; i_s < rk_steps; i_s++) {
+            rk_stepper.step(propagation);
+            crk_stepper.step(c_propagation);
+            crk_stepper.step(c_propagation);
+        }
+
+        // Make sure the steppers moved
+        const scalar path_length{rk_state.path_length()};
+        ASSERT_TRUE(path_length > 0.f);
+        ASSERT_TRUE(crk_state.path_length() > 0.f);
+
+        // Roll the same track back to the origin
+        // Use the same path length, since there is no overstepping
+        n_state._step_size *= -unit<scalar>::mm;
+        cn_state._step_size *= -unit<scalar>::mm;
+        for (unsigned int i_s = 0u; i_s < rk_steps; i_s++) {
+            rk_stepper.step(propagation);
+            crk_stepper.step(c_propagation);
+            crk_stepper.step(c_propagation);
+        }
+
+        // Should arrive back at track origin, where path length is zero
+        ASSERT_NEAR(rk_state.path_length(), 0.f, tol);
+        ASSERT_NEAR(crk_state.path_length(), 0.f, tol);
+
+        const point3 backward_relative_error{1.f / (2.f * path_length) *
+                                             (rk_state().pos() - ori)};
+        // Make sure that relative error is smaller than the tolerance
         EXPECT_NEAR(getter::norm(backward_relative_error), 0.f, tol);
+
+        // The constrained stepper should be at the same position now
+        ASSERT_NEAR(getter::norm(rk_state().pos() - crk_state().pos()) /
+                        (2.f * path_length),
+                    0.f, tol);
     }
 }
diff --git a/tests/unit_tests/device/cuda/CMakeLists.txt b/tests/unit_tests/device/cuda/CMakeLists.txt
index 33cc9a8fe..486976dc1 100644
--- a/tests/unit_tests/device/cuda/CMakeLists.txt
+++ b/tests/unit_tests/device/cuda/CMakeLists.txt
@@ -46,7 +46,7 @@ foreach(algebra ${algebras})
       "propagator_cuda.cpp" "propagator_cuda_kernel.hpp"
       "propagator_cuda_kernel.cu"
       LINK_LIBRARIES GTest::gtest_main vecmem::cuda detray_tests_common
-      detray::algebra_${algebra})
+                     covfie::cuda detray::algebra_${algebra})
    target_compile_definitions(detray_test_${algebra}_cuda
       PRIVATE ${algebra}=${algebra})
 endforeach()
diff --git a/tests/unit_tests/device/cuda/detector_cuda.cpp b/tests/unit_tests/device/cuda/detector_cuda.cpp
index 1a553c018..98ee47cb4 100644
--- a/tests/unit_tests/device/cuda/detector_cuda.cpp
+++ b/tests/unit_tests/device/cuda/detector_cuda.cpp
@@ -29,7 +29,7 @@ TEST(detector_cuda, detector) {
     vecmem::cuda::managed_memory_resource mng_mr;
 
     // create toy geometry
-    auto [toy_det, names] = create_toy_geometry<host_container_types>(mng_mr);
+    auto [toy_det, names] = create_toy_geometry(mng_mr);
 
     auto ctx0 = typename detector_host_t::geometry_context();
 
@@ -53,7 +53,7 @@ TEST(detector_cuda, detector) {
     vecmem::vector<cylinder_t> cylinders_device(cylinders_host.size(), &mng_mr);
 
     // get data object for toy detector
-    auto toy_det_data = get_data(toy_det);
+    auto toy_det_data = detray::get_data<bfield::const_bknd_t>(toy_det);
 
     // get data object for device outputs
     auto volumes_data = vecmem::get_data(volumes_device);
diff --git a/tests/unit_tests/device/cuda/detector_cuda_kernel.cu b/tests/unit_tests/device/cuda/detector_cuda_kernel.cu
index d2ff369aa..14e993071 100644
--- a/tests/unit_tests/device/cuda/detector_cuda_kernel.cu
+++ b/tests/unit_tests/device/cuda/detector_cuda_kernel.cu
@@ -12,7 +12,7 @@ namespace detray {
 
 // cuda kernel to copy sub-detector objects
 __global__ void detector_test_kernel(
-    typename detector_host_t::detector_view_type det_data,
+    typename detector_host_t::detector_view_type<bfield::const_bknd_t> det_data,
     vecmem::data::vector_view<volume_t> volumes_data,
     vecmem::data::vector_view<surface_t> surfaces_data,
     vecmem::data::vector_view<transform3_t> transforms_data,
@@ -84,13 +84,14 @@ __global__ void detector_test_kernel(
 }
 
 /// implementation of the test function for detector
-void detector_test(typename detector_host_t::detector_view_type det_data,
-                   vecmem::data::vector_view<volume_t> volumes_data,
-                   vecmem::data::vector_view<surface_t> surfaces_data,
-                   vecmem::data::vector_view<transform3_t> transforms_data,
-                   vecmem::data::vector_view<rectangle_t> rectangles_data,
-                   vecmem::data::vector_view<disc_t> discs_data,
-                   vecmem::data::vector_view<cylinder_t> cylinders_data) {
+void detector_test(
+    typename detector_host_t::detector_view_type<bfield::const_bknd_t> det_data,
+    vecmem::data::vector_view<volume_t> volumes_data,
+    vecmem::data::vector_view<surface_t> surfaces_data,
+    vecmem::data::vector_view<transform3_t> transforms_data,
+    vecmem::data::vector_view<rectangle_t> rectangles_data,
+    vecmem::data::vector_view<disc_t> discs_data,
+    vecmem::data::vector_view<cylinder_t> cylinders_data) {
 
     constexpr int block_dim = 1u;
     constexpr int thread_dim = 1u;
diff --git a/tests/unit_tests/device/cuda/detector_cuda_kernel.hpp b/tests/unit_tests/device/cuda/detector_cuda_kernel.hpp
index 5801d9f97..503d4b1f9 100644
--- a/tests/unit_tests/device/cuda/detector_cuda_kernel.hpp
+++ b/tests/unit_tests/device/cuda/detector_cuda_kernel.hpp
@@ -7,10 +7,10 @@
 
 #pragma once
 
-#include <thrust/tuple.h>
-
+// Projetc include(s)
 #include "detray/core/detector.hpp"
 #include "detray/definitions/algebra.hpp"
+#include "detray/definitions/bfield_backends.hpp"
 #include "detray/detectors/toy_metadata.hpp"
 #include "detray/utils/ranges.hpp"
 
@@ -21,9 +21,12 @@ namespace detray {
 
 // some useful type declarations
 using detector_host_t =
-    detector<toy_metadata<>, covfie::field, host_container_types>;
+    detector<toy_metadata, covfie::field<bfield::const_bknd_t>,
+             host_container_types>;
 using detector_device_t =
-    detector<toy_metadata<>, covfie::field_view, device_container_types>;
+    detector<toy_metadata, covfie::field_view<bfield::const_bknd_t>,
+             device_container_types>;
+
 using volume_t = typename detector_host_t::volume_type;
 using surface_t = typename detector_host_t::surface_type;
 using transform3_t = typename detector_host_t::transform3;
@@ -38,12 +41,13 @@ using disc_t = typename mask_defs::template get_type<disc_id>::type;
 using cylinder_t = typename mask_defs::template get_type<cylinder_id>::type;
 
 /// declaration of a test function for detector
-void detector_test(typename detector_host_t::detector_view_type det_data,
-                   vecmem::data::vector_view<volume_t> volumes_data,
-                   vecmem::data::vector_view<surface_t> surfaces_data,
-                   vecmem::data::vector_view<transform3_t> transforms_data,
-                   vecmem::data::vector_view<rectangle_t> rectangles_data,
-                   vecmem::data::vector_view<disc_t> discs_data,
-                   vecmem::data::vector_view<cylinder_t> cylinders_data);
+void detector_test(
+    typename detector_host_t::detector_view_type<bfield::const_bknd_t> det_data,
+    vecmem::data::vector_view<volume_t> volumes_data,
+    vecmem::data::vector_view<surface_t> surfaces_data,
+    vecmem::data::vector_view<transform3_t> transforms_data,
+    vecmem::data::vector_view<rectangle_t> rectangles_data,
+    vecmem::data::vector_view<disc_t> discs_data,
+    vecmem::data::vector_view<cylinder_t> cylinders_data);
 
 }  // namespace detray
diff --git a/tests/unit_tests/device/cuda/navigator_cuda.cpp b/tests/unit_tests/device/cuda/navigator_cuda.cpp
index e27ebf823..6597e0038 100644
--- a/tests/unit_tests/device/cuda/navigator_cuda.cpp
+++ b/tests/unit_tests/device/cuda/navigator_cuda.cpp
@@ -23,8 +23,7 @@ TEST(navigator_cuda, navigator) {
     vecmem::cuda::device_memory_resource dev_mr;
 
     // Create detector
-    auto [det, names] = create_toy_geometry<host_container_types>(
-        mng_mr, n_brl_layers, n_edc_layers);
+    auto [det, names] = create_toy_geometry(mng_mr);
 
     // Create navigator
     navigator_host_t nav;
@@ -106,7 +105,7 @@ TEST(navigator_cuda, navigator) {
     copy.setup(position_records_buffer);
 
     // Get detector data
-    auto det_data = get_data(det);
+    auto det_data = detray::get_data<bfield::const_bknd_t>(det);
 
     // Get tracks data
     auto tracks_data = vecmem::get_data(tracks_device);
diff --git a/tests/unit_tests/device/cuda/navigator_cuda_kernel.cu b/tests/unit_tests/device/cuda/navigator_cuda_kernel.cu
index 4491f58eb..d21255785 100644
--- a/tests/unit_tests/device/cuda/navigator_cuda_kernel.cu
+++ b/tests/unit_tests/device/cuda/navigator_cuda_kernel.cu
@@ -11,7 +11,7 @@
 namespace detray {
 
 __global__ void navigator_test_kernel(
-    typename detector_host_t::detector_view_type det_data,
+    typename detector_host_t::detector_view_type<bfield::const_bknd_t> det_data,
     vecmem::data::vector_view<free_track_parameters<transform3>> tracks_data,
     vecmem::data::jagged_vector_view<intersection_t> candidates_data,
     vecmem::data::jagged_vector_view<dindex> volume_records_data,
@@ -63,7 +63,7 @@ __global__ void navigator_test_kernel(
 }
 
 void navigator_test(
-    typename detector_host_t::detector_view_type det_data,
+    typename detector_host_t::detector_view_type<bfield::const_bknd_t> det_data,
     vecmem::data::vector_view<free_track_parameters<transform3>>& tracks_data,
     vecmem::data::jagged_vector_view<intersection_t>& candidates_data,
     vecmem::data::jagged_vector_view<dindex>& volume_records_data,
@@ -82,4 +82,4 @@ void navigator_test(
     DETRAY_CUDA_ERROR_CHECK(cudaDeviceSynchronize());
 }
 
-}  // namespace detray
\ No newline at end of file
+}  // namespace detray
diff --git a/tests/unit_tests/device/cuda/navigator_cuda_kernel.hpp b/tests/unit_tests/device/cuda/navigator_cuda_kernel.hpp
index a4d3a6eae..2adeb8e9e 100644
--- a/tests/unit_tests/device/cuda/navigator_cuda_kernel.hpp
+++ b/tests/unit_tests/device/cuda/navigator_cuda_kernel.hpp
@@ -7,10 +7,9 @@
 
 #pragma once
 
-#include <covfie/core/field.hpp>
-#include <covfie/core/field_view.hpp>
-
+// Project include(s)
 #include "detray/definitions/algebra.hpp"
+#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/units.hpp"
 #include "detray/detectors/create_toy_geometry.hpp"
 #include "detray/propagator/line_stepper.hpp"
@@ -23,9 +22,11 @@ using transform3 = __plugin::transform3<scalar>;
 
 // some useful type declarations
 using detector_host_t =
-    detector<toy_metadata<>, covfie::field, host_container_types>;
+    detector<toy_metadata, covfie::field<bfield::const_bknd_t>,
+             host_container_types>;
 using detector_device_t =
-    detector<toy_metadata<>, covfie::field_view, device_container_types>;
+    detector<toy_metadata, covfie::field_view<bfield::const_bknd_t>,
+             device_container_types>;
 
 using intersection_t =
     intersection2D<typename detector_device_t::surface_type, transform3>;
@@ -59,7 +60,7 @@ namespace detray {
 
 /// test function for navigator with single state
 void navigator_test(
-    typename detector_host_t::detector_view_type det_data,
+    typename detector_host_t::detector_view_type<bfield::const_bknd_t> det_data,
     vecmem::data::vector_view<free_track_parameters<transform3>>& tracks_data,
     vecmem::data::jagged_vector_view<intersection_t>& candidates_data,
     vecmem::data::jagged_vector_view<dindex>& volume_records_data,
diff --git a/tests/unit_tests/device/cuda/propagator_cuda.cpp b/tests/unit_tests/device/cuda/propagator_cuda.cpp
index 51d91b306..e3337df8f 100644
--- a/tests/unit_tests/device/cuda/propagator_cuda.cpp
+++ b/tests/unit_tests/device/cuda/propagator_cuda.cpp
@@ -1,214 +1,124 @@
 /** Detray library, part of the ACTS project (R&D line)
  *
- * (c) 2022 CERN for the benefit of the ACTS project
+ * (c) 2022-2023 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
 
-#include <gtest/gtest.h>
+// Project include(s)
+#include "propagator_cuda_kernel.hpp"
 
+// Vecmem include(s)
 #include <vecmem/memory/cuda/device_memory_resource.hpp>
 #include <vecmem/memory/cuda/managed_memory_resource.hpp>
+#include <vecmem/memory/host_memory_resource.hpp>
+#include <vecmem/utils/cuda/copy.hpp>
 
-#include "propagator_cuda_kernel.hpp"
-#include "vecmem/utils/cuda/copy.hpp"
+// GTest include
+#include <gtest/gtest.h>
 
 using namespace detray;
 
-class CudaPropagatorWithRkStepper
-    : public ::testing::TestWithParam<__plugin::vector3<scalar>> {};
-
-TEST_P(CudaPropagatorWithRkStepper, propagator) {
+class CudaPropConstBFieldMng : public ::testing::TestWithParam<vector3_t> {};
 
-    // Helper object for performing memory copies.
-    vecmem::copy copy;
+TEST_P(CudaPropConstBFieldMng, propagator) {
 
     // VecMem memory resource(s)
     vecmem::cuda::managed_memory_resource mng_mr;
 
     // Set the magnetic field
-    const vector3 B = GetParam();
+    const vector3_t B = GetParam();
 
     // Create the toy geometry
-    auto [det, names] = create_toy_geometry<host_container_types>(
-        mng_mr,
-        field_type(field_type::backend_t::configuration_t{B[0], B[1], B[2]}),
-        n_brl_layers, n_edc_layers);
-
-    // Create the vector of initial track parameters
-    vecmem::vector<free_track_parameters<transform3>> tracks_host(&mng_mr);
-    vecmem::vector<free_track_parameters<transform3>> tracks_device(&mng_mr);
-
-    // Set origin position of tracks
-    const point3 ori{0.f, 0.f, 0.f};
-    const scalar p_mag{10.f * unit<scalar>::GeV};
-
-    // Iterate through uniformly distributed momentum directions
-    for (auto track :
-         uniform_track_generator<free_track_parameters<transform3>>(
-             theta_steps, phi_steps, ori, p_mag, {0.01f, constant<scalar>::pi},
-             {-constant<scalar>::pi, constant<scalar>::pi})) {
-        track.set_overstep_tolerance(overstep_tolerance);
-
-        // Put it into vector of trajectories
-        tracks_host.push_back(track);
-        tracks_device.push_back(track);
-    }
-
-    /**
-     * Host propagation
-     */
-
-    // Create RK stepper
-    rk_stepper_type s;
-    // Create navigator
-    navigator_host_type n;
-    // Create propagator
-    propagator_host_type p(std::move(s), std::move(n));
-
-    // Create vector for track recording
-    vecmem::jagged_vector<scalar> host_path_lengths(&mng_mr);
-    vecmem::jagged_vector<vector3> host_positions(&mng_mr);
-    vecmem::jagged_vector<free_matrix> host_jac_transports(&mng_mr);
-
-    for (const auto& trk : tracks_host) {
-
-        // Create the propagator state
-        inspector_host_t::state insp_state{mng_mr};
-        pathlimit_aborter::state pathlimit_state{path_limit};
-        parameter_transporter<transform3>::state transporter_state{};
-        pointwise_material_interactor<transform3>::state interactor_state{};
-        parameter_resetter<transform3>::state resetter_state{};
-        auto actor_states =
-            ::detray::tie(insp_state, pathlimit_state, transporter_state,
-                          interactor_state, resetter_state);
-
-        propagator_host_type::state state(trk, det.get_bfield(), det);
-
-        state._stepping.template set_constraint<step::constraint::e_accuracy>(
-            constrainted_step_size);
-
-        state._stepping.set_tolerance(rk_tolerance);
-
-        // Run propagation
-        p.propagate(state, actor_states);
-
-        // Record the step information
-        host_path_lengths.push_back(insp_state._path_lengths);
-        host_positions.push_back(insp_state._positions);
-        host_jac_transports.push_back(insp_state._jac_transports);
-    }
-
-    /**
-     * Device propagation
-     */
-
-    // Get detector data
-    auto det_data = get_data(det);
-
-    // Get tracks data
-    auto tracks_data = vecmem::get_data(tracks_device);
-
-    // Create navigator candidates buffer
-    auto candidates_buffer =
-        create_candidates_buffer(det, theta_steps * phi_steps, mng_mr);
-    copy.setup(candidates_buffer);
-
-    // Create vector buffer for track recording
-    std::vector<std::size_t> capacities;
-    capacities.reserve(theta_steps * phi_steps);
-    for (auto& r : host_positions) {
-        capacities.push_back(r.size());
-    }
-
-    vecmem::data::jagged_vector_buffer<scalar> path_lengths_buffer(
-        capacities, mng_mr, nullptr, vecmem::data::buffer_type::resizable);
-    vecmem::data::jagged_vector_buffer<vector3> positions_buffer(
-        capacities, mng_mr, nullptr, vecmem::data::buffer_type::resizable);
-    vecmem::data::jagged_vector_buffer<free_matrix> jac_transports_buffer(
-        capacities, mng_mr, nullptr, vecmem::data::buffer_type::resizable);
-
-    copy.setup(path_lengths_buffer);
-    copy.setup(positions_buffer);
-    copy.setup(jac_transports_buffer);
-
-    // Run the propagator test for GPU device
-    propagator_test(det_data, tracks_data, candidates_buffer,
-                    path_lengths_buffer, positions_buffer,
-                    jac_transports_buffer);
-
-    vecmem::jagged_vector<scalar> device_path_lengths(&mng_mr);
-    vecmem::jagged_vector<vector3> device_positions(&mng_mr);
-    vecmem::jagged_vector<free_matrix> device_jac_transports(&mng_mr);
-
-    copy(path_lengths_buffer, device_path_lengths);
-    copy(positions_buffer, device_positions);
-    copy(jac_transports_buffer, device_jac_transports);
+    toy_cfg.bfield_vec(B);
+    auto [det, names] = create_toy_geometry(mng_mr, toy_cfg);
 
-    // Compare the positions
-    for (unsigned int i = 0; i < host_positions.size(); i++) {
-        ASSERT_TRUE(host_positions[i].size() > 0);
+    run_propagation_test<bfield::const_bknd_t>(
+        &mng_mr, det, detray::get_data<bfield::const_bknd_t>(det));
+}
 
-        for (unsigned int j = 0; j < host_positions[i].size(); j++) {
+class CudaPropConstBFieldCpy : public ::testing::TestWithParam<vector3_t> {};
 
-            auto host_pl = host_path_lengths[i][j];
-            auto device_pl = device_path_lengths[i][j];
+TEST_P(CudaPropConstBFieldCpy, propagator) {
 
-            // ASSERT_NEAR((host_pl - device_pl) / host_pl, 0, is_close);
+    // VecMem memory resource(s)
+    vecmem::host_memory_resource host_mr;
+    vecmem::cuda::managed_memory_resource mng_mr;
+    vecmem::cuda::device_memory_resource dev_mr;
 
-            ASSERT_EQ(host_positions[i].size(), device_positions[i].size());
-            ASSERT_NEAR(host_pl, device_pl, host_pl * is_close);
+    vecmem::cuda::copy cuda_cpy;
 
-            auto& host_pos = host_positions[i][j];
-            auto& device_pos = device_positions[i][j];
+    // Set the magnetic field
+    const vector3_t B = GetParam();
 
-            auto relative_error =
-                static_cast<point3>(1. / host_pl * (host_pos - device_pos));
+    // Create the toy geometry
+    toy_cfg.bfield_vec(B);
+    auto [det, names] = create_toy_geometry(host_mr, toy_cfg);
 
-            ASSERT_NEAR(getter::norm(relative_error), 0, is_close);
-        }
-    }
+    auto det_buff =
+        detray::get_buffer<bfield::const_bknd_t>(det, dev_mr, cuda_cpy);
 
-    // Compare the jacobian transports
-    for (unsigned int i = 0; i < host_jac_transports.size(); i++) {
-        for (unsigned int j = 0; j < host_jac_transports[i].size(); j++) {
+    run_propagation_test<bfield::const_bknd_t>(&mng_mr, det,
+                                               detray::get_data(det_buff));
+}
 
-            auto& host_J = host_jac_transports[i][j];
-            auto& device_J = device_jac_transports[i][j];
+INSTANTIATE_TEST_SUITE_P(CudaPropagatorValidation1, CudaPropConstBFieldMng,
+                         ::testing::Values(vector3_t{0. * unit<scalar>::T,
+                                                     0. * unit<scalar>::T,
+                                                     2. * unit<scalar>::T}));
+
+INSTANTIATE_TEST_SUITE_P(CudaPropagatorValidation2, CudaPropConstBFieldMng,
+                         ::testing::Values(vector3_t{0. * unit<scalar>::T,
+                                                     1. * unit<scalar>::T,
+                                                     1. * unit<scalar>::T}));
+
+INSTANTIATE_TEST_SUITE_P(CudaPropagatorValidation3, CudaPropConstBFieldMng,
+                         ::testing::Values(vector3_t{1. * unit<scalar>::T,
+                                                     0. * unit<scalar>::T,
+                                                     1. * unit<scalar>::T}));
+
+INSTANTIATE_TEST_SUITE_P(CudaPropagatorValidation4, CudaPropConstBFieldMng,
+                         ::testing::Values(vector3_t{1. * unit<scalar>::T,
+                                                     1. * unit<scalar>::T,
+                                                     1. * unit<scalar>::T}));
+
+INSTANTIATE_TEST_SUITE_P(CudaPropagatorValidation5, CudaPropConstBFieldCpy,
+                         ::testing::Values(vector3_t{0. * unit<scalar>::T,
+                                                     0. * unit<scalar>::T,
+                                                     2. * unit<scalar>::T}));
+
+INSTANTIATE_TEST_SUITE_P(CudaPropagatorValidation6, CudaPropConstBFieldCpy,
+                         ::testing::Values(vector3_t{0. * unit<scalar>::T,
+                                                     1. * unit<scalar>::T,
+                                                     1. * unit<scalar>::T}));
+
+INSTANTIATE_TEST_SUITE_P(CudaPropagatorValidation7, CudaPropConstBFieldCpy,
+                         ::testing::Values(vector3_t{1. * unit<scalar>::T,
+                                                     0. * unit<scalar>::T,
+                                                     1. * unit<scalar>::T}));
+
+INSTANTIATE_TEST_SUITE_P(CudaPropagatorValidation8, CudaPropConstBFieldCpy,
+                         ::testing::Values(vector3_t{1. * unit<scalar>::T,
+                                                     1. * unit<scalar>::T,
+                                                     1. * unit<scalar>::T}));
+
+/// This tests the device propagation in an inhomogenepus magnetic field
+TEST(CudaPropagatorValidation10, inhomogeneous_bfield_cpy) {
 
-            auto pl = host_path_lengths[i][j];
+    // VecMem memory resource(s)
+    vecmem::host_memory_resource host_mr;
+    vecmem::cuda::managed_memory_resource mng_mr;
+    vecmem::cuda::device_memory_resource dev_mr;
 
-            for (std::size_t row = 0; row < e_free_size; row++) {
-                for (std::size_t col = 0; col < e_free_size; col++) {
+    vecmem::cuda::copy cuda_cpy;
 
-                    auto host_val = matrix_operator().element(host_J, row, col);
+    // Create the toy geometry with inhomogeneous bfield from file
+    auto [det, names] =
+        create_toy_geometry<bfield::inhom_bknd_t>(host_mr, toy_cfg);
 
-                    auto device_val =
-                        matrix_operator().element(device_J, row, col);
+    auto det_buff =
+        detray::get_buffer<bfield::cuda::inhom_bknd_t>(det, dev_mr, cuda_cpy);
 
-                    ASSERT_NEAR((host_val - device_val) / pl, 0, is_close);
-                }
-            }
-        }
-    }
+    run_propagation_test<bfield::cuda::inhom_bknd_t>(
+        &mng_mr, det, detray::get_data(det_buff));
 }
-
-INSTANTIATE_TEST_SUITE_P(CudaPropagatorValidation1, CudaPropagatorWithRkStepper,
-                         ::testing::Values(__plugin::vector3<scalar>{
-                             0. * unit<scalar>::T, 0. * unit<scalar>::T,
-                             2. * unit<scalar>::T}));
-
-INSTANTIATE_TEST_SUITE_P(CudaPropagatorValidation2, CudaPropagatorWithRkStepper,
-                         ::testing::Values(__plugin::vector3<scalar>{
-                             0. * unit<scalar>::T, 1. * unit<scalar>::T,
-                             1. * unit<scalar>::T}));
-
-INSTANTIATE_TEST_SUITE_P(CudaPropagatorValidation3, CudaPropagatorWithRkStepper,
-                         ::testing::Values(__plugin::vector3<scalar>{
-                             1. * unit<scalar>::T, 0. * unit<scalar>::T,
-                             1. * unit<scalar>::T}));
-
-INSTANTIATE_TEST_SUITE_P(CudaPropagatorValidation4, CudaPropagatorWithRkStepper,
-                         ::testing::Values(__plugin::vector3<scalar>{
-                             1. * unit<scalar>::T, 1. * unit<scalar>::T,
-                             1. * unit<scalar>::T}));
diff --git a/tests/unit_tests/device/cuda/propagator_cuda_kernel.cu b/tests/unit_tests/device/cuda/propagator_cuda_kernel.cu
index 3bd347410..a8bd87997 100644
--- a/tests/unit_tests/device/cuda/propagator_cuda_kernel.cu
+++ b/tests/unit_tests/device/cuda/propagator_cuda_kernel.cu
@@ -1,6 +1,6 @@
 /** Detray library, part of the ACTS project (R&D line)
  *
- * (c) 2022 CERN for the benefit of the ACTS project
+ * (c) 2022-2023 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -10,22 +10,24 @@
 
 namespace detray {
 
+template <typename bfield_bknd_t, typename detector_t>
 __global__ void propagator_test_kernel(
-    typename detector_host_type::detector_view_type det_data,
-    vecmem::data::vector_view<free_track_parameters<transform3>> tracks_data,
-    vecmem::data::jagged_vector_view<intersection_t> candidates_data,
+    typename detector_t::template detector_view_type<bfield_bknd_t> det_data,
+    vecmem::data::vector_view<track_t> tracks_data,
+    vecmem::data::jagged_vector_view<intersection_t<detector_t>>
+        candidates_data,
     vecmem::data::jagged_vector_view<scalar> path_lengths_data,
-    vecmem::data::jagged_vector_view<vector3> positions_data,
+    vecmem::data::jagged_vector_view<vector3_t> positions_data,
     vecmem::data::jagged_vector_view<free_matrix> jac_transports_data) {
 
     int gid = threadIdx.x + blockIdx.x * blockDim.x;
 
-    detector_device_type det(det_data);
-    vecmem::device_vector<free_track_parameters<transform3>> tracks(
-        tracks_data);
-    vecmem::jagged_device_vector<intersection_t> candidates(candidates_data);
+    detector_device_t<bfield_bknd_t> det(det_data);
+    vecmem::device_vector<track_t> tracks(tracks_data);
+    vecmem::jagged_device_vector<intersection_t<detector_t>> candidates(
+        candidates_data);
     vecmem::jagged_device_vector<scalar> path_lengths(path_lengths_data);
-    vecmem::jagged_device_vector<vector3> positions(positions_data);
+    vecmem::jagged_device_vector<vector3_t> positions(positions_data);
     vecmem::jagged_device_vector<free_matrix> jac_transports(
         jac_transports_data);
 
@@ -33,16 +35,14 @@ __global__ void propagator_test_kernel(
         return;
     }
 
-    detector_device_type::bfield_type B_field = det.get_bfield();
-
-    // Create RK stepper
-    rk_stepper_type s;
-
-    // Create navigator
-    navigator_device_type n;
+    auto stepr =
+        rk_stepper_t<typename detector_device_t<bfield_bknd_t>::bfield_type>{};
+    auto nav = navigator_t<detector_device_t<bfield_bknd_t>>{};
 
     // Create propagator
-    propagator_device_type p(std::move(s), std::move(n));
+    using propagator_device_t =
+        propagator<decltype(stepr), decltype(nav), actor_chain_device_t>;
+    propagator_device_t p(std::move(stepr), std::move(nav));
 
     // Create actor states
     inspector_device_t::state insp_state(
@@ -57,8 +57,8 @@ __global__ void propagator_test_kernel(
         ::detray::tie(insp_state, aborter_state, transporter_state,
                       interactor_state, resetter_state);
     // Create the propagator state
-    propagator_device_type::state state(tracks[gid], B_field, det,
-                                        candidates.at(gid));
+    typename propagator_device_t::state state(tracks[gid], det.get_bfield(),
+                                              det, candidates.at(gid));
 
     state._stepping.set_tolerance(rk_tolerance);
 
@@ -69,25 +69,53 @@ __global__ void propagator_test_kernel(
     p.propagate(state, actor_states);
 }
 
+/// Launch the device kernel
+template <typename bfield_bknd_t, typename detector_t>
 void propagator_test(
-    typename detector_host_type::detector_view_type det_data,
-    vecmem::data::vector_view<free_track_parameters<transform3>>& tracks_data,
-    vecmem::data::jagged_vector_view<intersection_t>& candidates_data,
+    typename detector_t::template detector_view_type<bfield_bknd_t> det_view,
+    vecmem::data::vector_view<track_t>& tracks_data,
+    vecmem::data::jagged_vector_view<intersection_t<detector_t>>&
+        candidates_data,
     vecmem::data::jagged_vector_view<scalar>& path_lengths_data,
-    vecmem::data::jagged_vector_view<vector3>& positions_data,
+    vecmem::data::jagged_vector_view<vector3_t>& positions_data,
     vecmem::data::jagged_vector_view<free_matrix>& jac_transports_data) {
 
     constexpr int thread_dim = 2 * WARP_SIZE;
     constexpr int block_dim = theta_steps * phi_steps / thread_dim + 1;
 
     // run the test kernel
-    propagator_test_kernel<<<block_dim, thread_dim>>>(
-        det_data, tracks_data, candidates_data, path_lengths_data,
-        positions_data, jac_transports_data);
+    propagator_test_kernel<bfield_bknd_t, detector_t>
+        <<<block_dim, thread_dim>>>(det_view, tracks_data, candidates_data,
+                                    path_lengths_data, positions_data,
+                                    jac_transports_data);
 
     // cuda error check
     DETRAY_CUDA_ERROR_CHECK(cudaGetLastError());
     DETRAY_CUDA_ERROR_CHECK(cudaDeviceSynchronize());
 }
 
+/// Explicit instantiation for a constant magnetic field
+template void
+propagator_test<bfield::const_bknd_t, detector_host_t<bfield::const_bknd_t>>(
+    detector_host_t<bfield::const_bknd_t>::template detector_view_type<
+        bfield::const_bknd_t>,
+    vecmem::data::vector_view<track_t>&,
+    vecmem::data::jagged_vector_view<
+        intersection_t<detector_host_t<bfield::const_bknd_t>>>&,
+    vecmem::data::jagged_vector_view<scalar>&,
+    vecmem::data::jagged_vector_view<vector3_t>&,
+    vecmem::data::jagged_vector_view<free_matrix>&);
+
+/// Explicit instantiation for an inhomogeneous magnetic field
+template void propagator_test<bfield::cuda::inhom_bknd_t,
+                              detector_host_t<bfield::inhom_bknd_t>>(
+    detector_host_t<bfield::inhom_bknd_t>::template detector_view_type<
+        bfield::cuda::inhom_bknd_t>,
+    vecmem::data::vector_view<track_t>&,
+    vecmem::data::jagged_vector_view<
+        intersection_t<detector_host_t<bfield::inhom_bknd_t>>>&,
+    vecmem::data::jagged_vector_view<scalar>&,
+    vecmem::data::jagged_vector_view<vector3_t>&,
+    vecmem::data::jagged_vector_view<free_matrix>&);
+
 }  // namespace detray
diff --git a/tests/unit_tests/device/cuda/propagator_cuda_kernel.hpp b/tests/unit_tests/device/cuda/propagator_cuda_kernel.hpp
index 03c9f1cde..718684df3 100644
--- a/tests/unit_tests/device/cuda/propagator_cuda_kernel.hpp
+++ b/tests/unit_tests/device/cuda/propagator_cuda_kernel.hpp
@@ -9,15 +9,116 @@
 
 #include "tests/common/test_base/propagator_test.hpp"
 
+// Vecmem include(s)
+#include <vecmem/memory/memory_resource.hpp>
+#include <vecmem/utils/cuda/copy.hpp>
+
+// Covfie include(s)
+#include <covfie/cuda/backend/primitive/cuda_device_array.hpp>
+
 namespace detray {
 
-/// test function for propagator with single state
+namespace bfield::cuda {
+
+// Inhomogeneous field (cuda)
+using inhom_bknd_t = covfie::backend::affine<
+    covfie::backend::nearest_neighbour<covfie::backend::strided<
+        covfie::vector::ulong3, covfie::backend::cuda_device_array<
+                                    covfie::vector::vector_d<scalar, 3>>>>>;
+
+}  // namespace bfield::cuda
+
+/// Launch the propagation test kernel
+template <typename bfield_bknd_t, typename detector_t>
 void propagator_test(
-    typename detector_host_type::detector_view_type det_data,
-    vecmem::data::vector_view<free_track_parameters<transform3>> &tracks_data,
-    vecmem::data::jagged_vector_view<intersection_t> &candidates_data,
-    vecmem::data::jagged_vector_view<scalar> &path_lengths_data,
-    vecmem::data::jagged_vector_view<vector3> &positions_data,
-    vecmem::data::jagged_vector_view<free_matrix> &jac_transports_data);
+    typename detector_t::template detector_view_type<bfield_bknd_t>,
+    vecmem::data::vector_view<track_t> &,
+    vecmem::data::jagged_vector_view<intersection_t<detector_t>> &,
+    vecmem::data::jagged_vector_view<scalar> &,
+    vecmem::data::jagged_vector_view<vector3_t> &,
+    vecmem::data::jagged_vector_view<free_matrix> &);
+
+/// Test function for propagator on the device
+template <typename bfield_bknd_t, typename detector_t>
+inline auto run_propagation_device(
+    vecmem::memory_resource *mr, detector_t &det,
+    typename detector_t::template detector_view_type<bfield_bknd_t> det_view,
+    dvector<track_t> &tracks,
+    const vecmem::jagged_vector<vector3_t> &host_positions)
+    -> std::tuple<vecmem::jagged_vector<scalar>,
+                  vecmem::jagged_vector<vector3_t>,
+                  vecmem::jagged_vector<free_matrix>> {
+
+    // Helper object for performing memory copies.
+    vecmem::copy copy;
+
+    // Get tracks data
+    auto tracks_data = vecmem::get_data(tracks);
+
+    // Create navigator candidates buffer
+    auto candidates_buffer =
+        create_candidates_buffer(det, theta_steps * phi_steps, *mr);
+    copy.setup(candidates_buffer);
+
+    // Create vector buffer for track recording
+    std::vector<std::size_t> sizes(theta_steps * phi_steps, 0);
+    std::vector<std::size_t> capacities;
+    for (auto &r : host_positions) {
+        capacities.push_back(r.size());
+    }
+
+    vecmem::data::jagged_vector_buffer<scalar> path_lengths_buffer(
+        capacities, *mr, nullptr, vecmem::data::buffer_type::resizable);
+    vecmem::data::jagged_vector_buffer<vector3_t> positions_buffer(
+        capacities, *mr, nullptr, vecmem::data::buffer_type::resizable);
+    vecmem::data::jagged_vector_buffer<free_matrix> jac_transports_buffer(
+        capacities, *mr, nullptr, vecmem::data::buffer_type::resizable);
+
+    copy.setup(path_lengths_buffer);
+    copy.setup(positions_buffer);
+    copy.setup(jac_transports_buffer);
+
+    // Run the propagator test for GPU device
+    propagator_test<bfield_bknd_t, detector_t>(
+        det_view, tracks_data, candidates_buffer, path_lengths_buffer,
+        positions_buffer, jac_transports_buffer);
+
+    vecmem::jagged_vector<scalar> device_path_lengths(mr);
+    vecmem::jagged_vector<vector3_t> device_positions(mr);
+    vecmem::jagged_vector<free_matrix> device_jac_transports(mr);
+
+    copy(path_lengths_buffer, device_path_lengths);
+    copy(positions_buffer, device_positions);
+    copy(jac_transports_buffer, device_jac_transports);
+
+    return std::make_tuple(std::move(device_path_lengths),
+                           std::move(device_positions),
+                           std::move(device_jac_transports));
+}
+
+/// Test chain for the propagator
+template <typename bfield_bknd_t, typename detector_t>
+inline auto run_propagation_test(
+    vecmem::memory_resource *mr, detector_t &det,
+    typename detector_t::template detector_view_type<bfield_bknd_t> det_view) {
+
+    // Create the vector of initial track parameterizations
+    auto tracks_host = generate_tracks(mr);
+    vecmem::vector<track_t> tracks_device(tracks_host, mr);
+
+    // Host propagation
+    auto &&[host_path_lengths, host_positions, host_jac_transports] =
+        run_propagation_host(mr, det, tracks_host);
+
+    // Device propagation (device backend specific implementation)
+    auto &&[device_path_lengths, device_positions, device_jac_transports] =
+        run_propagation_device<bfield_bknd_t>(mr, det, det_view, tracks_device,
+                                              host_positions);
+
+    // Check the results
+    compare_propagation_results(host_positions, device_positions,
+                                host_path_lengths, device_path_lengths,
+                                host_jac_transports, device_jac_transports);
+}
 
 }  // namespace detray
diff --git a/tests/unit_tests/device/sycl/CMakeLists.txt b/tests/unit_tests/device/sycl/CMakeLists.txt
index 71a0bb8b5..4e62c7614 100644
--- a/tests/unit_tests/device/sycl/CMakeLists.txt
+++ b/tests/unit_tests/device/sycl/CMakeLists.txt
@@ -17,7 +17,7 @@ set(algebras "array")
 foreach(algebra ${algebras})
    # Unit tests for the selected algebra.
    detray_add_test(${algebra}_sycl
-      "propagator.sycl" "propagator_kernel.hpp"
+      "propagator.sycl" "propagator_sycl_kernel.hpp"
       "propagator_kernel.sycl"
       LINK_LIBRARIES GTest::gtest_main vecmem::sycl detray_tests_common
       detray::algebra_${algebra})
diff --git a/tests/unit_tests/device/sycl/propagator.sycl b/tests/unit_tests/device/sycl/propagator.sycl
index 254cde436..05c0bd5bd 100644
--- a/tests/unit_tests/device/sycl/propagator.sycl
+++ b/tests/unit_tests/device/sycl/propagator.sycl
@@ -5,13 +5,17 @@
  * Mozilla Public License Version 2.0
  */
 
-#include <gtest/gtest.h>
+// Project include(s)
+#include "propagator_sycl_kernel.hpp"
 
+// Vecmem include(s)
+#include <vecmem/memory/host_memory_resource.hpp>
 #include <vecmem/memory/sycl/device_memory_resource.hpp>
 #include <vecmem/memory/sycl/shared_memory_resource.hpp>
+#include <vecmem/utils/sycl/copy.hpp>
 
-#include "propagator_kernel.hpp"
-#include "vecmem/utils/sycl/copy.hpp"
+// GTest include
+#include <gtest/gtest.h>
 
 using namespace detray;
 
@@ -26,20 +30,15 @@ auto handle_async_error = [](::sycl::exception_list elist) {
         }
     }
 };
+class SyclPropConstBFieldMng : public ::testing::TestWithParam<vector3_t> {};
 
-class SyclPropagatorWithRkStepper
-    : public ::testing::TestWithParam<__plugin::vector3<scalar>> {};
-
-TEST_P(SyclPropagatorWithRkStepper, propagator) {
+TEST_P(SyclPropConstBFieldMng, propagator) {
 
     // Creating SYCL queue object
     ::sycl::queue q(handle_async_error);
-    std::cout << "Running Seeding on device: "
+    std::cout << "Running constant bfield propagation on device (mng mem): "
               << q.get_device().get_info<::sycl::info::device::name>() << "\n";
 
-    // Helper object for performing memory copies.
-    vecmem::copy copy;
-
     // VecMem memory resource(s)
     vecmem::sycl::shared_memory_resource shared_mr;
 
@@ -47,186 +46,107 @@ TEST_P(SyclPropagatorWithRkStepper, propagator) {
     const vector3 B = GetParam();
 
     // Create the toy geometry
-    auto [det, names] = create_toy_geometry<host_container_types>(
-        shared_mr,
-        field_type(field_type::backend_t::configuration_t{B[0], B[1], B[2]}),
-        n_brl_layers, n_edc_layers);
-
-    // Create the vector of initial track parameters
-    vecmem::vector<free_track_parameters<transform3>> tracks_host(&shared_mr);
-    vecmem::vector<free_track_parameters<transform3>> tracks_device(&shared_mr);
-
-    // Set origin position of tracks
-    const point3 ori{0., 0., 0.};
-    const scalar p_mag{10. * unit<scalar>::GeV};
-
-    // Iterate through uniformly distributed momentum directions
-    for (auto track :
-         uniform_track_generator<free_track_parameters<transform3>>(
-             theta_steps, phi_steps, ori, p_mag, {0.01, M_PI}, {-M_PI, M_PI})) {
-        track.set_overstep_tolerance(overstep_tolerance);
-
-        // Put it into vector of trajectories
-        tracks_host.push_back(track);
-        tracks_device.push_back(track);
-    }
-
-    /**
-     * Host propagation
-     */
-
-    // Create RK stepper
-    rk_stepper_type s;
-    // Create navigator
-    navigator_host_type n;
-    // Create propagator
-    propagator_host_type p(std::move(s), std::move(n));
-
-    // Create vector for track recording
-    vecmem::jagged_vector<scalar> host_path_lengths(&shared_mr);
-    vecmem::jagged_vector<vector3> host_positions(&shared_mr);
-    vecmem::jagged_vector<free_matrix> host_jac_transports(&shared_mr);
-
-    for (const auto& trk : tracks_host) {
-
-        // Create the propagator state
-        inspector_host_t::state insp_state{shared_mr};
-        pathlimit_aborter::state pathlimit_state{path_limit};
-        parameter_transporter<transform3>::state transporter_state{};
-        pointwise_material_interactor<transform3>::state interactor_state{};
-        parameter_resetter<transform3>::state resetter_state{};
-        auto actor_states =
-            ::detray::tie(insp_state, pathlimit_state, transporter_state,
-                          interactor_state, resetter_state);
-
-        propagator_host_type::state state(trk, det.get_bfield(), det);
-
-        state._stepping.template set_constraint<step::constraint::e_accuracy>(
-            constrainted_step_size);
-
-        state._stepping.set_tolerance(rk_tolerance);
-
-        // Run propagation
-        p.propagate(state, actor_states);
-
-        // Record the step information
-        host_path_lengths.push_back(insp_state._path_lengths);
-        host_positions.push_back(insp_state._positions);
-        host_jac_transports.push_back(insp_state._jac_transports);
-    }
-
-    /**
-     * Device propagation
-     */
-
-    // Get detector data
-    auto det_data = get_data(det);
-
-    // Get tracks data
-    auto tracks_data = vecmem::get_data(tracks_device);
-
-    // Create navigator candidates buffer
-    auto candidates_buffer =
-        create_candidates_buffer(det, theta_steps * phi_steps, shared_mr);
-    copy.setup(candidates_buffer);
-
-    // Create vector buffer for track recording
-    std::vector<std::size_t> capacities;
-    capacities.reserve(theta_steps * phi_steps);
-    for (auto& r : host_positions) {
-        capacities.push_back(r.size());
-    }
-
-    vecmem::data::jagged_vector_buffer<scalar> path_lengths_buffer(
-        capacities, shared_mr, nullptr, vecmem::data::buffer_type::resizable);
-    vecmem::data::jagged_vector_buffer<vector3> positions_buffer(
-        capacities, shared_mr, nullptr, vecmem::data::buffer_type::resizable);
-    vecmem::data::jagged_vector_buffer<free_matrix> jac_transports_buffer(
-        capacities, shared_mr, nullptr, vecmem::data::buffer_type::resizable);
-
-    copy.setup(path_lengths_buffer);
-    copy.setup(positions_buffer);
-    copy.setup(jac_transports_buffer);
+    toy_cfg.bfield_vec(B);
+    auto [det, names] = create_toy_geometry(shared_mr, toy_cfg);
 
-    detray::sycl::queue_wrapper queue(&q);
-
-    // Run the propagator test for GPU device
-
-    propagator_test(det_data, tracks_data, candidates_buffer,
-                    path_lengths_buffer, positions_buffer,
-                    jac_transports_buffer, queue);
+    run_propagation_test<bfield::const_bknd_t>(
+        &shared_mr, &q, det, detray::get_data<bfield::const_bknd_t>(det));
+}
 
-    vecmem::jagged_vector<scalar> device_path_lengths(&shared_mr);
-    vecmem::jagged_vector<vector3> device_positions(&shared_mr);
-    vecmem::jagged_vector<free_matrix> device_jac_transports(&shared_mr);
+class SyclPropConstBFieldCpy : public ::testing::TestWithParam<vector3_t> {};
 
-    copy(path_lengths_buffer, device_path_lengths);
-    copy(positions_buffer, device_positions);
-    copy(jac_transports_buffer, device_jac_transports);
+TEST_P(SyclPropConstBFieldCpy, propagator) {
 
-    // Compare the positions
-    for (unsigned int i = 0; i < host_positions.size(); i++) {
-        ASSERT_TRUE(host_positions[i].size() > 0);
-        for (unsigned int j = 0; j < host_positions[i].size(); j++) {
+    // Creating SYCL queue object
+    ::sycl::queue q(handle_async_error);
+    std::cout << "Running constant bfield propagation on device (cpy): "
+              << q.get_device().get_info<::sycl::info::device::name>() << "\n";
 
-            auto host_pl = host_path_lengths[i][j];
-            auto device_pl = device_path_lengths[i][j];
+    // VecMem memory resource(s)
+    vecmem::host_memory_resource host_mr;
+    vecmem::sycl::shared_memory_resource shared_mr;
+    vecmem::sycl::device_memory_resource dev_mr;
 
-            // ASSERT_NEAR((host_pl - device_pl) / host_pl, 0, is_close);
+    vecmem::sycl::queue_wrapper q_wrapper(&q);
+    vecmem::sycl::copy sycl_cpy(q_wrapper);
 
-            ASSERT_EQ(host_positions[i].size(), device_positions[i].size());
-            ASSERT_NEAR(host_pl, device_pl, host_pl * is_close);
+    // Set the magnetic field
+    const vector3 B = GetParam();
 
-            auto& host_pos = host_positions[i][j];
-            auto& device_pos = device_positions[i][j];
+    // Create the toy geometry
+    toy_cfg.bfield_vec(B);
+    auto [det, names] = create_toy_geometry(host_mr, toy_cfg);
 
-            auto relative_error =
-                static_cast<point3>(1. / host_pl * (host_pos - device_pos));
+    auto det_buff =
+        detray::get_buffer<bfield::const_bknd_t>(det, dev_mr, sycl_cpy);
 
-            ASSERT_NEAR(getter::norm(relative_error), 0, is_close);
-        }
-    }
-
-    // Compare the jacobian transports
-    for (unsigned int i = 0; i < host_jac_transports.size(); i++) {
-        for (unsigned int j = 0; j < host_jac_transports[i].size(); j++) {
+    run_propagation_test<bfield::const_bknd_t>(&shared_mr, &q, det,
+                                               detray::get_data(det_buff));
+}
 
-            auto& host_J = host_jac_transports[i][j];
-            auto& device_J = device_jac_transports[i][j];
+INSTANTIATE_TEST_SUITE_P(SyclPropagatorValidation1, SyclPropConstBFieldMng,
+                         ::testing::Values(vector3_t{0. * unit<scalar>::T,
+                                                     0. * unit<scalar>::T,
+                                                     2. * unit<scalar>::T}));
+
+INSTANTIATE_TEST_SUITE_P(SyclPropagatorValidation2, SyclPropConstBFieldMng,
+                         ::testing::Values(vector3_t{0. * unit<scalar>::T,
+                                                     1. * unit<scalar>::T,
+                                                     1. * unit<scalar>::T}));
+
+INSTANTIATE_TEST_SUITE_P(SyclPropagatorValidation3, SyclPropConstBFieldMng,
+                         ::testing::Values(vector3_t{1. * unit<scalar>::T,
+                                                     0. * unit<scalar>::T,
+                                                     1. * unit<scalar>::T}));
+
+INSTANTIATE_TEST_SUITE_P(SyclPropagatorValidation4, SyclPropConstBFieldMng,
+                         ::testing::Values(vector3_t{1. * unit<scalar>::T,
+                                                     1. * unit<scalar>::T,
+                                                     1. * unit<scalar>::T}));
+
+INSTANTIATE_TEST_SUITE_P(SyclPropagatorValidation5, SyclPropConstBFieldCpy,
+                         ::testing::Values(vector3_t{0. * unit<scalar>::T,
+                                                     0. * unit<scalar>::T,
+                                                     2. * unit<scalar>::T}));
+
+INSTANTIATE_TEST_SUITE_P(SyclPropagatorValidation6, SyclPropConstBFieldCpy,
+                         ::testing::Values(vector3_t{0. * unit<scalar>::T,
+                                                     1. * unit<scalar>::T,
+                                                     1. * unit<scalar>::T}));
+
+INSTANTIATE_TEST_SUITE_P(SyclPropagatorValidation7, SyclPropConstBFieldCpy,
+                         ::testing::Values(vector3_t{1. * unit<scalar>::T,
+                                                     0. * unit<scalar>::T,
+                                                     1. * unit<scalar>::T}));
+
+INSTANTIATE_TEST_SUITE_P(SyclPropagatorValidation8, SyclPropConstBFieldCpy,
+                         ::testing::Values(vector3_t{1. * unit<scalar>::T,
+                                                     1. * unit<scalar>::T,
+                                                     1. * unit<scalar>::T}));
+
+/// This tests the device propagation in an inhomogenepus magnetic field
+/*
+TEST(SyclPropagatorValidation10, inhomogeneous_bfield_cpy) {
 
-            auto pl = host_path_lengths[i][j];
+    // Creating SYCL queue object
+    ::sycl::queue q(handle_async_error);
+    std::cout << "Running inhom bfield propagation on device (cpy): "
+              << q.get_device().get_info<::sycl::info::device::name>() << "\n";
 
-            for (std::size_t row = 0; row < e_free_size; row++) {
-                for (std::size_t col = 0; col < e_free_size; col++) {
+    // VecMem memory resource(s)
+    vecmem::host_memory_resource host_mr;
+    vecmem::sycl::shared_memory_resource shared_mr;
+    vecmem::sycl::device_memory_resource dev_mr;
 
-                    auto host_val = matrix_operator().element(host_J, row, col);
+    vecmem::sycl::copy sycl_cpy;
 
-                    auto device_val =
-                        matrix_operator().element(device_J, row, col);
+    // Create the toy geometry with inhomogeneous bfield from file
+    auto [det, names] = create_toy_geometry<bfield::inhom_bknd_t>(
+        shared_mr, toy_cfg);
 
-                    ASSERT_NEAR((host_val - device_val) / pl, 0, is_close);
-                }
-            }
-        }
-    }
-}
+    auto det_buff = detray::get_buffer<bfield::sycl::inhom_bknd_t>(det, dev_mr,
+sycl_cpy);
 
-INSTANTIATE_TEST_SUITE_P(SyclPropagatorValidation1, SyclPropagatorWithRkStepper,
-                         ::testing::Values(__plugin::vector3<scalar>{
-                             0. * unit<scalar>::T, 0. * unit<scalar>::T,
-                             2. * unit<scalar>::T}));
-
-INSTANTIATE_TEST_SUITE_P(SyclPropagatorValidation2, SyclPropagatorWithRkStepper,
-                         ::testing::Values(__plugin::vector3<scalar>{
-                             0. * unit<scalar>::T, 1. * unit<scalar>::T,
-                             1. * unit<scalar>::T}));
-
-INSTANTIATE_TEST_SUITE_P(SyclPropagatorValidation3, SyclPropagatorWithRkStepper,
-                         ::testing::Values(__plugin::vector3<scalar>{
-                             1. * unit<scalar>::T, 0. * unit<scalar>::T,
-                             1. * unit<scalar>::T}));
-
-INSTANTIATE_TEST_SUITE_P(SyclPropagatorValidation4, SyclPropagatorWithRkStepper,
-                         ::testing::Values(__plugin::vector3<scalar>{
-                             1. * unit<scalar>::T, 1. * unit<scalar>::T,
-                             1. * unit<scalar>::T}));
+    run_propagation_test<bfield::sycl::inhom_bknd_t>(&mng_mr, &q, det,
+detray::get_data(det_buff));
+}*/
diff --git a/tests/unit_tests/device/sycl/propagator_kernel.hpp b/tests/unit_tests/device/sycl/propagator_kernel.hpp
deleted file mode 100644
index 59f6fd2f3..000000000
--- a/tests/unit_tests/device/sycl/propagator_kernel.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-/** Detray library, part of the ACTS project (R&D line)
- *
- * (c) 2023 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#pragma once
-
-#include "queue_wrapper.hpp"
-#include "tests/common/test_base/propagator_test.hpp"
-
-namespace detray {
-
-/// test function for propagator with single state
-void propagator_test(
-    typename detector_host_type::detector_view_type det_data,
-    vecmem::data::vector_view<free_track_parameters<transform3>> &tracks_data,
-    vecmem::data::jagged_vector_view<intersection_t> &candidates_data,
-    vecmem::data::jagged_vector_view<scalar> &path_lengths_data,
-    vecmem::data::jagged_vector_view<vector3> &positions_data,
-    vecmem::data::jagged_vector_view<free_matrix> &jac_transports_data,
-    sycl::queue_wrapper queue);
-
-}  // namespace detray
diff --git a/tests/unit_tests/device/sycl/propagator_kernel.sycl b/tests/unit_tests/device/sycl/propagator_kernel.sycl
index 982ce1668..22dec4175 100644
--- a/tests/unit_tests/device/sycl/propagator_kernel.sycl
+++ b/tests/unit_tests/device/sycl/propagator_kernel.sycl
@@ -5,22 +5,21 @@
  * Mozilla Public License Version 2.0
  */
 
-#include "propagator_kernel.hpp"
+#include "propagator_sycl_kernel.hpp"
+#include "tests/common/test_base/propagator_test.hpp"
 
 namespace detray {
 
-namespace kernels {
-class propagate;
-}  // namespace kernels
-
-/// test function for propagator with single state
+/// Test function for propagator
+template <typename bfield_bknd_t, typename detector_t>
 void propagator_test(
-    typename detector_host_type::detector_view_type det_data,
-    vecmem::data::vector_view<free_track_parameters<transform3>> &tracks_data,
-    vecmem::data::jagged_vector_view<intersection_t> &candidates_data,
-    vecmem::data::jagged_vector_view<scalar> &path_lengths_data,
-    vecmem::data::jagged_vector_view<vector3> &positions_data,
-    vecmem::data::jagged_vector_view<free_matrix> &jac_transports_data,
+    typename detector_t::template detector_view_type<bfield_bknd_t> det_data,
+    vecmem::data::vector_view<track_t>& tracks_data,
+    vecmem::data::jagged_vector_view<intersection_t<detector_t>>&
+        candidates_data,
+    vecmem::data::jagged_vector_view<scalar>& path_lengths_data,
+    vecmem::data::jagged_vector_view<vector3_t>& positions_data,
+    vecmem::data::jagged_vector_view<free_matrix>& jac_transports_data,
     detray::sycl::queue_wrapper queue) {
 
     unsigned int localSize = 64;
@@ -30,21 +29,17 @@ void propagator_test(
     const auto ndrange = ::sycl::nd_range<1>{::sycl::range<1>(num * localSize),
                                              ::sycl::range<1>(localSize)};
 
-    reinterpret_cast<::sycl::queue *>(queue.queue())
-        ->submit([&](::sycl::handler &h) {
-            h.parallel_for<kernels::propagate>(ndrange, [det_data, tracks_data,
-                                                         candidates_data,
-                                                         path_lengths_data,
-                                                         positions_data,
-                                                         jac_transports_data](
-                                                            ::sycl::nd_item<1>
-                                                                item) {
-                detector_device_type det(det_data);
-
-                vecmem::device_vector<free_track_parameters<transform3>> tracks(
-                    tracks_data);
-                vecmem::jagged_device_vector<intersection_t> candidates(
-                    candidates_data);
+    reinterpret_cast<::sycl::queue*>(queue.queue())
+        ->submit([&](::sycl::handler& h) {
+            h.parallel_for(ndrange, [det_data, tracks_data, candidates_data,
+                                     path_lengths_data, positions_data,
+                                     jac_transports_data](
+                                        ::sycl::nd_item<1> item) {
+                detector_device_t<bfield_bknd_t> dev_det(det_data);
+
+                vecmem::device_vector<track_t> tracks(tracks_data);
+                vecmem::jagged_device_vector<intersection_t<detector_t>>
+                    candidates(candidates_data);
                 vecmem::jagged_device_vector<scalar> path_lengths(
                     path_lengths_data);
                 vecmem::jagged_device_vector<vector3> positions(positions_data);
@@ -57,16 +52,15 @@ void propagator_test(
                     return;
                 }
 
-                detector_device_type::bfield_type B_field = det.get_bfield();
-
-                // Create RK stepper
-                rk_stepper_type s;
-
-                // Create navigator
-                navigator_device_type n;
+                auto stepr = rk_stepper_t<
+                    typename detector_device_t<bfield_bknd_t>::bfield_type>{};
+                auto nav = navigator_t<detector_device_t<bfield_bknd_t>>{};
 
                 // Create propagator
-                propagator_device_type p(std::move(s), std::move(n));
+                using propagator_device_t =
+                    propagator<decltype(stepr), decltype(nav),
+                               actor_chain_device_t>;
+                propagator_device_t p(std::move(stepr), std::move(nav));
 
                 // Create actor states
                 inspector_device_t::state insp_state(path_lengths.at(gid),
@@ -83,8 +77,9 @@ void propagator_test(
                     ::detray::tie(insp_state, aborter_state, transporter_state,
                                   interactor_state, resetter_state);
                 // Create the propagator state
-                propagator_device_type::state state(tracks[gid], B_field, det,
-                                                    candidates.at(gid));
+                typename propagator_device_t::state state(
+                    tracks[gid], dev_det.get_bfield(), dev_det,
+                    candidates.at(gid));
 
                 state._stepping.set_tolerance(rk_tolerance);
 
@@ -98,4 +93,30 @@ void propagator_test(
         .wait_and_throw();
 }
 
+/// Explicit instantiation for a constant magnetic field
+template void
+propagator_test<bfield::const_bknd_t, detector_host_t<bfield::const_bknd_t>>(
+    detector_host_t<bfield::const_bknd_t>::template detector_view_type<
+        bfield::const_bknd_t>,
+    vecmem::data::vector_view<track_t>&,
+    vecmem::data::jagged_vector_view<
+        intersection_t<detector_host_t<bfield::const_bknd_t>>>&,
+    vecmem::data::jagged_vector_view<scalar>&,
+    vecmem::data::jagged_vector_view<vector3_t>&,
+    vecmem::data::jagged_vector_view<free_matrix>&,
+    detray::sycl::queue_wrapper);
+
+/// Explicit instantiation for an inhomogeneous magnetic field
+/*template void propagator_test<bfield::sycl::inhom_bknd_t,
+                              detector_host_t<bfield::inhom_bknd_t>>(
+    detector_host_t<bfield::inhom_bknd_t>::detector_view_type<
+        bfield::sycl::inhom_bknd_t>,
+    vecmem::data::vector_view<track_t>&,
+    vecmem::data::jagged_vector_view<
+        intersection_t<detector_host_t<bfield::inhom_bknd_t>>>&,
+    vecmem::data::jagged_vector_view<scalar>&,
+    vecmem::data::jagged_vector_view<vector3_t>&,
+    vecmem::data::jagged_vector_view<free_matrix>&,
+    detray::sycl::queue_wrapper);*/
+
 }  // namespace detray
diff --git a/tests/unit_tests/device/sycl/propagator_sycl_kernel.hpp b/tests/unit_tests/device/sycl/propagator_sycl_kernel.hpp
new file mode 100644
index 000000000..cedc4db9a
--- /dev/null
+++ b/tests/unit_tests/device/sycl/propagator_sycl_kernel.hpp
@@ -0,0 +1,114 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "queue_wrapper.hpp"
+#include "tests/common/test_base/propagator_test.hpp"
+
+// Vecmem include(s)
+#include "vecmem/utils/sycl/copy.hpp"
+
+namespace detray {
+
+/// Launch the propagation test kernel
+template <typename bfield_bknd_t, typename detector_t>
+void propagator_test(
+    typename detector_t::template detector_view_type<bfield_bknd_t>,
+    vecmem::data::vector_view<track_t> &,
+    vecmem::data::jagged_vector_view<intersection_t<detector_t>> &,
+    vecmem::data::jagged_vector_view<scalar> &,
+    vecmem::data::jagged_vector_view<vector3_t> &,
+    vecmem::data::jagged_vector_view<free_matrix> &, sycl::queue_wrapper);
+
+/// test function for propagator on the device
+template <typename bfield_bknd_t, typename detector_t>
+inline auto run_propagation_device(
+    vecmem::memory_resource *mr, detector_t &det,
+    typename detector_t::template detector_view_type<bfield_bknd_t> det_view,
+    sycl::queue_wrapper queue, dvector<track_t> &tracks,
+    const vecmem::jagged_vector<vector3_t> &host_positions)
+    -> std::tuple<vecmem::jagged_vector<scalar>,
+                  vecmem::jagged_vector<vector3_t>,
+                  vecmem::jagged_vector<free_matrix>> {
+
+    // Helper object for performing memory copies.
+    vecmem::copy copy;
+
+    // Get tracks data
+    auto tracks_data = vecmem::get_data(tracks);
+
+    // Create navigator candidates buffer
+    auto candidates_buffer =
+        create_candidates_buffer(det, theta_steps * phi_steps, *mr);
+    copy.setup(candidates_buffer);
+
+    // Create vector buffer for track recording
+    std::vector<std::size_t> sizes(theta_steps * phi_steps, 0);
+    std::vector<std::size_t> capacities;
+    for (auto &r : host_positions) {
+        capacities.push_back(r.size());
+    }
+
+    vecmem::data::jagged_vector_buffer<scalar> path_lengths_buffer(
+        capacities, *mr, nullptr, vecmem::data::buffer_type::resizable);
+    vecmem::data::jagged_vector_buffer<vector3_t> positions_buffer(
+        capacities, *mr, nullptr, vecmem::data::buffer_type::resizable);
+    vecmem::data::jagged_vector_buffer<free_matrix> jac_transports_buffer(
+        capacities, *mr, nullptr, vecmem::data::buffer_type::resizable);
+
+    copy.setup(path_lengths_buffer);
+    copy.setup(positions_buffer);
+    copy.setup(jac_transports_buffer);
+
+    // Run the propagator test for GPU device
+    propagator_test<bfield_bknd_t, detector_t>(
+        det_view, tracks_data, candidates_buffer, path_lengths_buffer,
+        positions_buffer, jac_transports_buffer, queue);
+
+    vecmem::jagged_vector<scalar> device_path_lengths(mr);
+    vecmem::jagged_vector<vector3_t> device_positions(mr);
+    vecmem::jagged_vector<free_matrix> device_jac_transports(mr);
+
+    copy(path_lengths_buffer, device_path_lengths);
+    copy(positions_buffer, device_positions);
+    copy(jac_transports_buffer, device_jac_transports);
+
+    return std::make_tuple(std::move(device_path_lengths),
+                           std::move(device_positions),
+                           std::move(device_jac_transports));
+}
+
+/// Test chain for the propagator
+template <typename bfield_bknd_t, typename detector_t>
+inline auto run_propagation_test(
+    vecmem::memory_resource *mr, ::sycl::queue *q, detector_t &det,
+    typename detector_t::template detector_view_type<bfield_bknd_t> det_view) {
+
+    // Create the vector of initial track parameterizations
+    auto tracks_host = generate_tracks(mr);
+    vecmem::vector<track_t> tracks_device(tracks_host, mr);
+
+    // Host propagation
+    auto &&[host_path_lengths, host_positions, host_jac_transports] =
+        run_propagation_host(mr, det, tracks_host);
+
+    // Device propagation
+    detray::sycl::queue_wrapper queue(q);
+
+    auto &&[device_path_lengths, device_positions, device_jac_transports] =
+        run_propagation_device<bfield_bknd_t>(mr, det, det_view, queue,
+                                              tracks_device, host_positions);
+
+    // Check the results
+    compare_propagation_results(host_positions, device_positions,
+                                host_path_lengths, device_path_lengths,
+                                host_jac_transports, device_jac_transports);
+}
+
+}  // namespace detray
diff --git a/tests/unit_tests/io/CMakeLists.txt b/tests/unit_tests/io/CMakeLists.txt
index d12af50fb..60e0e1a6f 100644
--- a/tests/unit_tests/io/CMakeLists.txt
+++ b/tests/unit_tests/io/CMakeLists.txt
@@ -15,3 +15,6 @@ detray_add_test( io_reader
     "io_json_detector_reader.cpp"
     LINK_LIBRARIES GTest::gtest_main vecmem::core detray::core_array
     detray::io_array detray::test detray_tests_common detray::utils_array)
+detray_add_test( io_bfield_reader
+   "io_bfield_reader.cpp"
+   LINK_LIBRARIES GTest::gtest_main detray::core_array detray::io_array detray::utils_array covfie::core vecmem::core )
diff --git a/tests/unit_tests/io/io_bfield_reader.cpp b/tests/unit_tests/io/io_bfield_reader.cpp
new file mode 100644
index 000000000..d1a7b3c09
--- /dev/null
+++ b/tests/unit_tests/io/io_bfield_reader.cpp
@@ -0,0 +1,81 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+// Project include(s)
+#include "detray/definitions/algebra.hpp"
+#include "detray/definitions/bfield_backends.hpp"
+#include "detray/detectors/create_toy_geometry.hpp"
+#include "detray/io/common/bfield_reader.hpp"
+#include "detray/io/common/detector_reader.hpp"
+
+// Vecmem include(s)
+#include <vecmem/memory/host_memory_resource.hpp>
+
+// GTest include(s)
+#include <gtest/gtest.h>
+
+#include <iostream>
+
+using namespace detray;
+
+/// Test the reading of a magnetic field from file
+TEST(io, bfield_reader) {
+
+    // Magnetic field map using nearest neightbor interpolation
+    using bfield_t = covfie::field<bfield::inhom_bknd_t>;
+
+    // Toy detector
+    using detector_t = detector<toy_metadata, bfield_t>;
+
+    // Empty volume name map
+    typename detector_t::name_map volume_name_map = {{0u, "toy_detector"}};
+
+    // Toy detector with inhomogeneous bfield
+    vecmem::host_memory_resource host_mr;
+    detector_builder<toy_metadata, bfield::inhom_bknd_t> toy_builder;
+
+    // Read the bfield from file into the detector
+    covfie_reader<detector_t> bf_reader;
+    bf_reader.read(toy_builder, volume_name_map,
+                   !std::getenv("DETRAY_BFIELD_FILE")
+                       ? ""
+                       : std::getenv("DETRAY_BFIELD_FILE"));
+    auto det = toy_builder.build(host_mr);
+
+    // Test the field
+    const bfield_t& bf = det.get_bfield();
+    bfield_t::view_t bv(bf);
+
+    auto field_strength = [&bv](float x, float y, float z) {
+        return std::sqrt(std::pow(bv.at(x, y, z)[0], 2) +
+                         std::pow(bv.at(x, y, z)[1], 2) +
+                         std::pow(bv.at(x, y, z)[2], 2));
+    };
+
+    // Sample some field strengths
+    constexpr scalar tol{1e-7f};
+    float x = -5000.0f, y = 3200.0f, z = -7700.0f;
+    ASSERT_NEAR(field_strength(x, y, z), 0.668426511f * unit<scalar>::T, tol);
+    x = -2400.0f, y = 7500.0f, z = 6500.0f;
+    ASSERT_NEAR(field_strength(x, y, z), 0.597449579f * unit<scalar>::T, tol);
+    x = -1000.0f, y = -4300.0f, z = 2700.0f;
+    ASSERT_NEAR(field_strength(x, y, z), 0.41904773f * unit<scalar>::T, tol);
+    x = 6100.0f, y = 4800.0f, z = -4300.0f;
+    ASSERT_NEAR(field_strength(x, y, z), 0.439638488f * unit<scalar>::T, tol);
+    x = -7800.0f, y = -8400.0f, z = 9000.0f;
+    ASSERT_NEAR(field_strength(x, y, z), 0.061408468f * unit<scalar>::T, tol);
+    x = 6900.0f, y = -8800.0f, z = -4900.0f;
+    ASSERT_NEAR(field_strength(x, y, z), 0.087212384f * unit<scalar>::T, tol);
+    x = -9600.0f, y = 8600.0f, z = 3000.0f;
+    ASSERT_NEAR(field_strength(x, y, z), 0.026944387f * unit<scalar>::T, tol);
+    x = 6400.0f, y = -3200.0f, z = -6400.0f;
+    ASSERT_NEAR(field_strength(x, y, z), 0.629775357f * unit<scalar>::T, tol);
+    x = 200.0f, y = -4000.0f, z = 1700.0f;
+    ASSERT_NEAR(field_strength(x, y, z), 0.004898979f * unit<scalar>::T, tol);
+    x = 400.0f, y = -7100.0f, z = -11700.0f;
+    ASSERT_NEAR(field_strength(x, y, z), 0.293974489f * unit<scalar>::T, tol);
+}
diff --git a/tests/unit_tests/io/io_json_detector_reader.cpp b/tests/unit_tests/io/io_json_detector_reader.cpp
index 03db52fac..0e816149f 100644
--- a/tests/unit_tests/io/io_json_detector_reader.cpp
+++ b/tests/unit_tests/io/io_json_detector_reader.cpp
@@ -30,7 +30,7 @@ using namespace detray;
 /// Test the reading and writing of a toy detector geometry
 TEST(io, json_toy_geometry) {
 
-    using detector_t = detector<toy_metadata<>>;
+    using detector_t = detector<toy_metadata>;
 
     // Toy detector
     vecmem::host_memory_resource host_mr;
@@ -39,13 +39,13 @@ TEST(io, json_toy_geometry) {
     // Write the detector
     json_geometry_writer<detector_t> geo_writer;
     auto file_name = geo_writer.write(
-        toy_det, names, std::ios_base::out | std::ios_base::trunc);
+        toy_det, names, std::ios::out | std::ios::binary | std::ios::trunc);
 
     // Empty volume name map to be filled
     typename detector_t::name_map volume_name_map = {{0u, "toy_detector"}};
 
     // Read the detector back in
-    detector_builder<toy_metadata<>, volume_builder> toy_builder;
+    detector_builder<toy_metadata> toy_builder;
     json_geometry_reader<detector_t> geo_reader;
     geo_reader.read(toy_builder, volume_name_map, file_name);
     auto det = toy_builder.build(host_mr);
@@ -81,11 +81,13 @@ TEST(io, json_toy_geometry) {
 /// Test the reading and writing of a toy detector geometry
 TEST(io, json_toy_detector_reader) {
 
-    using detector_t = detector<toy_metadata<>>;
+    using detector_t =
+        detector<toy_metadata, covfie::field<bfield::inhom_bknd_t>>;
 
     // Toy detector
     vecmem::host_memory_resource host_mr;
-    const auto [toy_det, toy_names] = create_toy_geometry(host_mr);
+    toy_det_config toy_cfg{};
+    const auto [toy_det, toy_names] = create_toy_geometry(host_mr, toy_cfg);
 
     auto writer_cfg = io::detector_writer_config{}
                           .format(io::format::json)
@@ -95,12 +97,13 @@ TEST(io, json_toy_detector_reader) {
     // Read the detector back in
     io::detector_reader_config reader_cfg{};
     reader_cfg.add_file("toy_detector_geometry.json")
-        .add_file("toy_detector_homogeneous_material.json");
+        .add_file("toy_detector_homogeneous_material.json")
+        .add_file(toy_cfg.bfield_file());
 
     const auto [det, names] =
         io::read_detector<detector_t>(host_mr, reader_cfg);
 
-    EXPECT_TRUE(test_toy_detector(det, names));
+    // EXPECT_TRUE(test_toy_detector(det, names));
 }
 
 /// Test the reading and writing of a wire chamber
diff --git a/tests/unit_tests/io/io_json_detector_writer.cpp b/tests/unit_tests/io/io_json_detector_writer.cpp
index 6a798584c..1735e15ee 100644
--- a/tests/unit_tests/io/io_json_detector_writer.cpp
+++ b/tests/unit_tests/io/io_json_detector_writer.cpp
@@ -55,7 +55,7 @@ TEST(io, json_telescope_geometry_writer) {
         create_telescope_detector(host_mr, tel_cfg.positions(positions));
 
     json_geometry_writer<detector_t> geo_writer;
-    geo_writer.write(det, names, std::ios_base::out);
+    geo_writer.write(det, names, std::ios::out | std::ios::binary);
 }
 
 /// Test the writing of the toy detector material to json
@@ -70,20 +70,21 @@ TEST(io, json_telescope_material_writer) {
         create_telescope_detector(host_mr, tel_cfg.positions(positions));
 
     json_homogeneous_material_writer<detector_t> mat_writer;
-    mat_writer.write(det, names, std::ios_base::out);
+    mat_writer.write(det, names, std::ios::out | std::ios::binary);
 }
 
 /// Test the writing of the toy detector grids to json
 TEST(io, json_toy_grid_writer) {
 
-    using detector_t = detector<toy_metadata<>>;
+    using detector_t = detector<toy_metadata>;
 
     // Toy detector
     vecmem::host_memory_resource host_mr;
     auto [det, names] = create_toy_geometry(host_mr);
 
     json_grid_writer<detector_t> grid_writer;
-    grid_writer.write(det, names, std::ios_base::out | std::ios_base::trunc);
+    grid_writer.write(det, names,
+                      std::ios::out | std::ios::binary | std::ios::trunc);
 }
 
 /// Test the writing of the entire toy detector to json
diff --git a/tests/unit_tests/svgtools/detectors.cpp b/tests/unit_tests/svgtools/detectors.cpp
index b05f5b83f..67b7e1d43 100644
--- a/tests/unit_tests/svgtools/detectors.cpp
+++ b/tests/unit_tests/svgtools/detectors.cpp
@@ -36,9 +36,9 @@ int main(int, char**) {
     const actsvg::views::z_r zr;
 
     // Creating the detector and geomentry context.
-    using toy_detector_t = detray::detector<detray::toy_metadata<>>;
+    using toy_detector_t = detray::detector<detray::toy_metadata>;
     vecmem::host_memory_resource host_mr;
-    const auto [det, names] = detray::create_toy_geometry(host_mr, 4, 3);
+    const auto [det, names] = detray::create_toy_geometry(host_mr);
     toy_detector_t::geometry_context context{};
 
     // Creating the svg generator for the detector.
@@ -55,4 +55,4 @@ int main(int, char**) {
     // Write the svg of toy detector in z-r view
     detray::svgtools::write_svg("test_svgtools_detector_zr.svg",
                                 {zr_axis, svg_zr});
-}
\ No newline at end of file
+}
diff --git a/tests/unit_tests/svgtools/groups.cpp b/tests/unit_tests/svgtools/groups.cpp
index 834cb84db..b540f945b 100644
--- a/tests/unit_tests/svgtools/groups.cpp
+++ b/tests/unit_tests/svgtools/groups.cpp
@@ -32,9 +32,9 @@ int main(int, char**) {
     const actsvg::views::z_r zr;
 
     // Creating the detector and geomentry context.
-    using toy_detector_t = detray::detector<detray::toy_metadata<>>;
+    using toy_detector_t = detray::detector<detray::toy_metadata>;
     vecmem::host_memory_resource host_mr;
-    const auto [det, names] = detray::create_toy_geometry(host_mr, 4, 3);
+    const auto [det, names] = detray::create_toy_geometry(host_mr);
     toy_detector_t::geometry_context context{};
 
     // Creating the svg generator for the detector.
@@ -72,4 +72,4 @@ int main(int, char**) {
     detray::svgtools::write_svg(
         "test_svgtools_volume_and_surface_group.svg",
         {axes, svg_surface_group_xy, svg_volume_group_zr});
-}
\ No newline at end of file
+}
diff --git a/tests/unit_tests/svgtools/intersections.cpp b/tests/unit_tests/svgtools/intersections.cpp
index 13e16b9ff..3d086ac7c 100644
--- a/tests/unit_tests/svgtools/intersections.cpp
+++ b/tests/unit_tests/svgtools/intersections.cpp
@@ -36,9 +36,9 @@ int main(int, char**) {
     const actsvg::views::z_r view;
 
     // Creating the detector and geomentry context.
-    using detector_t = detray::detector<detray::toy_metadata<>>;
+    using detector_t = detray::detector<detray::toy_metadata>;
     vecmem::host_memory_resource host_mr;
-    const auto [det, names] = detray::create_toy_geometry(host_mr, 4, 3);
+    const auto [det, names] = detray::create_toy_geometry(host_mr);
     detector_t::geometry_context context{};
 
     using transform3_t = typename detector_t::transform3;
@@ -70,4 +70,4 @@ int main(int, char**) {
 
         index++;
     }
-}
\ No newline at end of file
+}
diff --git a/tests/unit_tests/svgtools/masks.cpp b/tests/unit_tests/svgtools/masks.cpp
index 7e45648be..7b1d1b635 100644
--- a/tests/unit_tests/svgtools/masks.cpp
+++ b/tests/unit_tests/svgtools/masks.cpp
@@ -33,7 +33,7 @@ int main(int, char**) {
     using point3 = std::array<actsvg::scalar, 3>;
     using point3_container = std::vector<point3>;
 
-    using toy_detector_t = detray::detector<detray::toy_metadata<>>;
+    using toy_detector_t = detray::detector<detray::toy_metadata>;
     using transform_t = typename toy_detector_t::transform3;
 
     const typename transform_t::vector3 tr{0.f, 150.f, 0.f};
@@ -93,4 +93,4 @@ int main(int, char**) {
                                                                 lin2D);
     const auto lin2D_svg = actsvg::display::surface("", lin2D_proto, view);
     detray::svgtools::write_svg("test_svgtools_line2D.svg", {axes, lin2D_svg});
-}
\ No newline at end of file
+}
diff --git a/tests/unit_tests/svgtools/surfaces.cpp b/tests/unit_tests/svgtools/surfaces.cpp
index dcf560e34..b0be55ca9 100644
--- a/tests/unit_tests/svgtools/surfaces.cpp
+++ b/tests/unit_tests/svgtools/surfaces.cpp
@@ -32,9 +32,9 @@ int main(int, char**) {
     const actsvg::views::z_r zr;
 
     // Creating the detector and geomentry context.
-    using toy_detector_t = detray::detector<detray::toy_metadata<>>;
+    using toy_detector_t = detray::detector<detray::toy_metadata>;
     vecmem::host_memory_resource host_mr;
-    const auto [det, names] = detray::create_toy_geometry(host_mr, 4, 3);
+    const auto [det, names] = detray::create_toy_geometry(host_mr);
     toy_detector_t::geometry_context context{};
 
     // Creating the svg generator for the detector.
@@ -51,4 +51,4 @@ int main(int, char**) {
         const auto svg_zr = il.draw_surface(name, context, i, zr);
         detray::svgtools::write_svg(name + "_zr.svg", {axes, svg_zr});
     }
-}
\ No newline at end of file
+}
diff --git a/tests/unit_tests/svgtools/volumes.cpp b/tests/unit_tests/svgtools/volumes.cpp
index 688000345..4c5050f28 100644
--- a/tests/unit_tests/svgtools/volumes.cpp
+++ b/tests/unit_tests/svgtools/volumes.cpp
@@ -32,9 +32,9 @@ int main(int, char**) {
     const actsvg::views::z_r zr;
 
     // Creating the detector and geomentry context.
-    using toy_detector_t = detray::detector<detray::toy_metadata<>>;
+    using toy_detector_t = detray::detector<detray::toy_metadata>;
     vecmem::host_memory_resource host_mr;
-    const auto [det, names] = detray::create_toy_geometry(host_mr, 4, 3);
+    const auto [det, names] = detray::create_toy_geometry(host_mr);
     toy_detector_t::geometry_context context{};
 
     // Creating the svg generator for the detector.
@@ -50,4 +50,4 @@ int main(int, char**) {
         const auto svg_zr = il.draw_volume(name, context, i, zr);
         detray::svgtools::write_svg(name + "_zr.svg", {axes, svg_zr});
     }
-}
\ No newline at end of file
+}
diff --git a/tests/validation/include/detray/validation/detail/register_checks.hpp b/tests/validation/include/detray/validation/detail/register_checks.hpp
index 40519c054..30cebae5f 100644
--- a/tests/validation/include/detray/validation/detail/register_checks.hpp
+++ b/tests/validation/include/detray/validation/detail/register_checks.hpp
@@ -20,7 +20,7 @@ void register_checks(const detector_t &det,
     ::testing::RegisterTest(
         "detray_validation", cfg.name().c_str(), nullptr, cfg.name().c_str(),
         __FILE__, __LINE__,
-        [=]() -> typename check_t<detector_t>::fixture_type * {
+        [&]() -> typename check_t<detector_t>::fixture_type * {
             return new check_t<detector_t>(det, vol_names, cfg);
         });
 }
diff --git a/tests/validation/src/toy_detector_validation.cpp b/tests/validation/src/toy_detector_validation.cpp
index 2063b8b78..47b1f53b0 100644
--- a/tests/validation/src/toy_detector_validation.cpp
+++ b/tests/validation/src/toy_detector_validation.cpp
@@ -31,21 +31,17 @@ int main(int argc, char **argv) {
     //
     // Toy detector configuration
     //
-    constexpr std::size_t n_brl_layers{4u};
-    constexpr std::size_t n_edc_layers{7u};
-    vecmem::host_memory_resource host_mr;
+    toy_det_config toy_cfg{};
+    toy_cfg.n_brl_layers(4u).n_edc_layers(7u);
+    toy_cfg.bfield_vec(
+        {0.f * unit<scalar>::T, 0.f * unit<scalar>::T, 2.f * unit<scalar>::T});
 
-    using toy_detector_t = detector<toy_metadata<>>;
-    using b_field_t = toy_detector_t::bfield_type;
+    using toy_detector_t = detector<toy_metadata>;
     using scalar_t = typename toy_detector_t::scalar_type;
 
-    const toy_detector_t::vector3 B{
-        0.f * unit<scalar>::T, 0.f * unit<scalar>::T, 2.f * unit<scalar>::T};
-
-    const auto [toy_det, toy_names] = create_toy_geometry(
-        host_mr,
-        b_field_t(b_field_t::backend_t::configuration_t{B[0], B[1], B[2]}),
-        n_brl_layers, n_edc_layers);
+    // Build the geometry
+    vecmem::host_memory_resource host_mr;
+    auto [toy_det, toy_names] = create_toy_geometry(host_mr, toy_cfg);
 
     // General data consistency of the detector
     consistency_check<toy_detector_t>::config cfg_cons{};
diff --git a/tutorials/include/detray/tutorial/detector_metadata.hpp b/tutorials/include/detray/tutorial/detector_metadata.hpp
index 4c22cc790..13aee548c 100644
--- a/tutorials/include/detray/tutorial/detector_metadata.hpp
+++ b/tutorials/include/detray/tutorial/detector_metadata.hpp
@@ -24,10 +24,6 @@
 // New geometric shape type
 #include "my_square2D.hpp"
 
-// Covfie include(s)
-#include <covfie/core/backend/primitive/constant.hpp>
-#include <covfie/core/vector.hpp>
-
 /// This example defines a detray geometry type for a detector with cuboid
 /// volumes that constain a new surface shape (squares), trapezoids and
 /// rectangles for the volume boundary surfaces (portals).
@@ -70,11 +66,6 @@ using slab = material_slab<detray::scalar>;
 /// box.
 struct my_metadata {
 
-    /// Constant B-field
-    using bfield_backend_t =
-        covfie::backend::constant<covfie::vector::vector_d<scalar, 3>,
-                                  covfie::vector::vector_d<scalar, 3>>;
-
     /// How to index the constituent objects in a volume
     /// If they share the same index value here, they will be added into the
     /// same acceleration data structure in every respective volume
diff --git a/tutorials/include/detray/tutorial/square_surface_generator.hpp b/tutorials/include/detray/tutorial/square_surface_generator.hpp
index 128dba99c..715b5a636 100644
--- a/tutorials/include/detray/tutorial/square_surface_generator.hpp
+++ b/tutorials/include/detray/tutorial/square_surface_generator.hpp
@@ -25,10 +25,12 @@ namespace detray::tutorial {
 
 /// @brief Generates a sequence of square surfaces for the example detector
 class square_surface_generator final
-    : public surface_factory_interface<detector<tutorial::my_metadata>> {
+    : public surface_factory_interface<detector<
+          tutorial::my_metadata, covfie::field<bfield::const_bknd_t>>> {
 
     public:
-    using detector_t = detector<tutorial::my_metadata>;
+    using detector_t =
+        detector<tutorial::my_metadata, covfie::field<bfield::const_bknd_t>>;
     using scalar_t = typename detector_t::scalar_type;
 
     /// Generate @param n square surfaces with half length @param hl .
diff --git a/tutorials/src/cpu/detector/build_predefined_detectors.cpp b/tutorials/src/cpu/detector/build_predefined_detectors.cpp
index 20fac37e5..008e0366e 100644
--- a/tutorials/src/cpu/detector/build_predefined_detectors.cpp
+++ b/tutorials/src/cpu/detector/build_predefined_detectors.cpp
@@ -6,6 +6,7 @@
  */
 
 // Project include(s)
+#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/units.hpp"
 #include "detray/detectors/create_telescope_detector.hpp"
 #include "detray/detectors/create_toy_geometry.hpp"
@@ -40,23 +41,24 @@ int main(int argc, char** argv) {
     //
     // Toy detector
     //
-
+    detray::toy_det_config toy_cfg{};
     // Number of barrel layers (0 - 4)
-    unsigned int n_brl_layers{4u};
+    toy_cfg.n_brl_layers(4u);
     // Number of endcap layers on either side (0 - 7)
     // Note: The detector must be configured with 4 barrel layers to be able to
     // add any encap layers
-    unsigned int n_edc_layers{1u};
+    toy_cfg.n_edc_layers(1u);
 
     // Read toy detector config from commandline, if it was given
     if (argc == 3) {
-        n_brl_layers = static_cast<unsigned int>(std::abs(std::atoi(argv[1])));
-        n_edc_layers = static_cast<unsigned int>(std::abs(std::atoi(argv[2])));
+        toy_cfg.n_brl_layers(
+            static_cast<unsigned int>(std::abs(std::atoi(argv[1]))));
+        toy_cfg.n_edc_layers(
+            static_cast<unsigned int>(std::abs(std::atoi(argv[2]))));
     }
 
     // Fill the detector
-    const auto [toy_det, names] =
-        detray::create_toy_geometry(host_mr, n_brl_layers, n_edc_layers);
+    const auto [toy_det, names] = detray::create_toy_geometry(host_mr, toy_cfg);
 
     // Print the volume graph of the toy detector
     std::cout << "\nToy detector:\n"
diff --git a/tutorials/src/cpu/detector/detector_to_dot.cpp b/tutorials/src/cpu/detector/detector_to_dot.cpp
index 543a4bc75..fecb0e68c 100644
--- a/tutorials/src/cpu/detector/detector_to_dot.cpp
+++ b/tutorials/src/cpu/detector/detector_to_dot.cpp
@@ -34,8 +34,8 @@ int main(int argc, char** argv) {
         throw std::runtime_error("Please specify an input file name!");
     }
 
-    // Read a toy detector
-    using detector_t = detray::detector<detray::toy_metadata<>>;
+    // Read a toy detector with constant bfield (default)
+    using detector_t = detray::detector<detray::toy_metadata>;
 
     // Create an empty detector to be filled
     vecmem::host_memory_resource host_mr;
diff --git a/tutorials/src/cpu/detector/do_it_yourself_detector.cpp b/tutorials/src/cpu/detector/do_it_yourself_detector.cpp
index 8e8b77111..5d1104cab 100644
--- a/tutorials/src/cpu/detector/do_it_yourself_detector.cpp
+++ b/tutorials/src/cpu/detector/do_it_yourself_detector.cpp
@@ -7,6 +7,7 @@
 
 // Project include(s)
 #include "detray/core/detector.hpp"
+#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/geometry.hpp"
 #include "detray/definitions/units.hpp"
 #include "detray/detectors/create_toy_geometry.hpp"
@@ -31,7 +32,9 @@
 int main() {
 
     // The new detector type
-    using detector_t = detray::detector<detray::tutorial::my_metadata>;
+    using detector_t =
+        detray::detector<detray::tutorial::my_metadata,
+                         covfie::field<detray::bfield::const_bknd_t>>;
 
     // First, create an empty detector in in host memory to be filled
     vecmem::host_memory_resource host_mr;
diff --git a/tutorials/src/cpu/detector/read_detector_from_file.cpp b/tutorials/src/cpu/detector/read_detector_from_file.cpp
index fdea91501..b457e2e75 100644
--- a/tutorials/src/cpu/detector/read_detector_from_file.cpp
+++ b/tutorials/src/cpu/detector/read_detector_from_file.cpp
@@ -34,8 +34,8 @@ int main(int argc, char** argv) {
         throw std::runtime_error("Please specify an input file name!");
     }
 
-    // Read a toy detector
-    using detector_t = detray::detector<detray::toy_metadata<>>;
+    // Read a toy detector with constant bfield (default)
+    using detector_t = detray::detector<detray::toy_metadata>;
 
     // Create an empty detector to be filled
     vecmem::host_memory_resource host_mr;
diff --git a/tutorials/src/cpu/propagation/navigation_inspection.cpp b/tutorials/src/cpu/propagation/navigation_inspection.cpp
index 4617ea768..0420fe5eb 100644
--- a/tutorials/src/cpu/propagation/navigation_inspection.cpp
+++ b/tutorials/src/cpu/propagation/navigation_inspection.cpp
@@ -6,6 +6,7 @@
  */
 
 // Project include(s)
+#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/units.hpp"
 #include "detray/detectors/create_toy_geometry.hpp"
 #include "detray/intersection/detail/trajectories.hpp"  // ray
@@ -31,7 +32,9 @@
 /// of the encountered surfaces (using the navigation inspectors)
 int main() {
     // Toy detector
-    using toy_detector_t = detray::detector<detray::toy_metadata<>>;
+    using toy_detector_t =
+        detray::detector<detray::toy_metadata,
+                         covfie::field<detray::bfield::const_bknd_t>>;
 
     /// Type that holds the intersection information
     using intersection_t =
diff --git a/tutorials/src/device/cuda/detector_construction.cpp b/tutorials/src/device/cuda/detector_construction.cpp
index daa17c67e..6bb1a9f26 100644
--- a/tutorials/src/device/cuda/detector_construction.cpp
+++ b/tutorials/src/device/cuda/detector_construction.cpp
@@ -36,7 +36,7 @@ int main() {
     auto [det_mng, names_mng] = detray::create_toy_geometry(mng_mr);
 
     // Get the view onto the detector data directly
-    auto det_mng_data = detray::get_data(det_mng);
+    auto det_mng_data = detray::get_data<detray::bfield::const_bknd_t>(det_mng);
 
     // Pass the view and call the kernel
     std::cout << "Using CUDA unified memory:" << std::endl;
@@ -50,16 +50,17 @@ int main() {
     auto [det_host, names_host] = detray::create_toy_geometry(host_mr);
 
     // Copy the detector data to device (synchronous copy, fixed size buffers)
-    auto det_fixed_buff = detray::get_buffer(det_host, dev_mr, cuda_cpy);
+    auto det_fixed_buff = detray::get_buffer<detray::bfield::const_bknd_t>(
+        det_host, dev_mr, cuda_cpy);
 
     // Get the detector view from the buffer and call the kernel
     std::cout << "\nSynchronous copy, fixed size buffers:" << std::endl;
     detray::tutorial::print(detray::get_data(det_fixed_buff));
 
     // Copy the data to device in resizable buffers (synchronous copy)
-    auto det_resz_buff =
-        detray::get_buffer(det_host, dev_mr, cuda_cpy, detray::copy::sync,
-                           vecmem::data::buffer_type::resizable);
+    auto det_resz_buff = detray::get_buffer<detray::bfield::const_bknd_t>(
+        det_host, dev_mr, cuda_cpy, detray::copy::sync,
+        vecmem::data::buffer_type::resizable);
 
     std::cout << "\nSynchronous copy, resizable buffers:" << std::endl;
     detray::tutorial::print(detray::get_data(det_resz_buff));
@@ -93,10 +94,13 @@ int main() {
                                          vecmem::data::buffer_type::fixed_size);
 
     // Assemble the detector buffer
-    auto det_custom_buff = detray::detector_buffer(
-        det_host, std::move(vol_buff), std::move(trf_buff), std::move(msk_buff),
-        std::move(mat_buff), std::move(sf_buff), std::move(sf_lkp_buff),
-        std::move(vgrid_buff));
+    auto det_custom_buff =
+        detray::detector_buffer<detray::bfield::const_bknd_t,
+                                detray::toy_metadata,
+                                covfie::field<detray::bfield::const_bknd_t>>(
+            det_host, std::move(vol_buff), std::move(trf_buff),
+            std::move(msk_buff), std::move(mat_buff), std::move(sf_buff),
+            std::move(sf_lkp_buff), std::move(vgrid_buff));
 
     std::cout << "\nCustom buffer setup:" << std::endl;
     detray::tutorial::print(detray::get_data(det_custom_buff));
diff --git a/tutorials/src/device/cuda/detector_construction.cu b/tutorials/src/device/cuda/detector_construction.cu
index efab22e99..9fc07fe03 100644
--- a/tutorials/src/device/cuda/detector_construction.cu
+++ b/tutorials/src/device/cuda/detector_construction.cu
@@ -12,7 +12,9 @@ namespace detray::tutorial {
 
 /// Kernel that runs the entire propagation loop
 __global__ void print_kernel(
-    typename detray::tutorial::detector_host_t::detector_view_type det_data) {
+    typename detray::tutorial::detector_host_t::detector_view_type<
+        bfield::const_bknd_t>
+        det_data) {
 
     int gid = threadIdx.x + blockIdx.x * blockDim.x;
 
@@ -41,8 +43,9 @@ __global__ void print_kernel(
            det.surface_store().get<acc_id::e_cylinder2_grid>().size());
 }
 
-void print(
-    typename detray::tutorial::detector_host_t::detector_view_type det_data) {
+void print(typename detray::tutorial::detector_host_t::detector_view_type<
+           bfield::const_bknd_t>
+               det_data) {
 
     // run the tutorial kernel
     print_kernel<<<1, 1>>>(det_data);
diff --git a/tutorials/src/device/cuda/detector_construction.hpp b/tutorials/src/device/cuda/detector_construction.hpp
index e6ba68f78..f3c8147d4 100644
--- a/tutorials/src/device/cuda/detector_construction.hpp
+++ b/tutorials/src/device/cuda/detector_construction.hpp
@@ -8,26 +8,26 @@
 #pragma once
 
 // Project include(s).
+#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/units.hpp"
 #include "detray/detectors/create_toy_geometry.hpp"
 #include "detray/tutorial/types.hpp"
 
-// Covfie include(s).
-#include <covfie/core/field.hpp>
-#include <covfie/core/field_view.hpp>
-
 namespace detray::tutorial {
 
 // Detector
 using detector_host_t =
-    detector<detray::toy_metadata<>, covfie::field, host_container_types>;
-using detector_device_t = detector<detray::toy_metadata<>, covfie::field_view,
-                                   device_container_types>;
+    detector<detray::toy_metadata, covfie::field<bfield::const_bknd_t>,
+             host_container_types>;
+using detector_device_t =
+    detector<detray::toy_metadata, covfie::field_view<bfield::const_bknd_t>,
+             device_container_types>;
 
 using mask_id = typename detector_host_t::masks::id;
 using acc_id = typename detector_host_t::sf_finders::id;
 
 /// Detector construction tutorial function (prints some detector statistics)
-void print(typename detector_host_t::detector_view_type det_data);
+void print(typename detector_host_t::detector_view_type<bfield::const_bknd_t>
+               det_data);
 
 }  // namespace detray::tutorial
diff --git a/tutorials/src/device/cuda/propagation.cpp b/tutorials/src/device/cuda/propagation.cpp
index 2e56aa176..b25f1ca94 100644
--- a/tutorials/src/device/cuda/propagation.cpp
+++ b/tutorials/src/device/cuda/propagation.cpp
@@ -30,11 +30,10 @@ int main() {
                                   2. * detray::unit<detray::scalar>::T};
 
     // Create the toy geometry
-    auto [det, names] =
-        detray::create_toy_geometry<detray::host_container_types>(
-            mng_mr, detray::tutorial::field_t(
-                        detray::tutorial::field_t::backend_t::configuration_t{
-                            B[0], B[1], B[2]}));
+    detray::toy_det_config toy_cfg{};
+    toy_cfg.bfield_vec(B);
+
+    auto [det, names] = detray::create_toy_geometry(mng_mr, toy_cfg);
 
     // Create the vector of initial track parameters
     vecmem::vector<detray::free_track_parameters<detray::tutorial::transform3>>
@@ -61,7 +60,7 @@ int main() {
     }
 
     // Get data for device
-    auto det_data = detray::get_data(det);
+    auto det_data = detray::get_data<detray::bfield::const_bknd_t>(det);
     auto tracks_data = detray::get_data(tracks);
 
     // Create navigator candidates buffer
diff --git a/tutorials/src/device/cuda/propagation.hpp b/tutorials/src/device/cuda/propagation.hpp
index 9d565ccac..0ca1a07f3 100644
--- a/tutorials/src/device/cuda/propagation.hpp
+++ b/tutorials/src/device/cuda/propagation.hpp
@@ -8,6 +8,7 @@
 #pragma once
 
 // Project include(s).
+#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/units.hpp"
 #include "detray/detectors/create_toy_geometry.hpp"
 #include "detray/propagator/actor_chain.hpp"
@@ -21,22 +22,19 @@
 #include "detray/tracks/tracks.hpp"
 #include "detray/tutorial/types.hpp"
 
-// Covfie include(s).
-#include <covfie/core/field.hpp>
-#include <covfie/core/field_view.hpp>
-
 namespace detray::tutorial {
 
 // Detector
 using detector_host_t =
-    detector<detray::toy_metadata<>, covfie::field, host_container_types>;
-using detector_device_t = detector<detray::toy_metadata<>, covfie::field_view,
-                                   device_container_types>;
+    detector<detray::toy_metadata, covfie::field<bfield::const_bknd_t>,
+             host_container_types>;
+using detector_device_t =
+    detector<detray::toy_metadata, covfie::field_view<bfield::const_bknd_t>,
+             device_container_types>;
 
 // Navigator
-using intersection_t = intersection2D<typename detector_device_t::surface_type,
-                                      detray::tutorial::transform3>;
 using navigator_t = navigator<detector_device_t>;
+using intersection_t = navigator_t::intersection_type;
 
 // Stepper
 using field_t = detector_host_t::bfield_type;
@@ -54,7 +52,7 @@ using propagator_t = propagator<stepper_t, navigator_t, actor_chain_t>;
 
 /// Propagation tutorial function
 void propagation(
-    typename detector_host_t::detector_view_type det_data,
+    typename detector_host_t::detector_view_type<bfield::const_bknd_t> det_data,
     const vecmem::data::vector_view<
         free_track_parameters<detray::tutorial::transform3>>
         tracks_data,
diff --git a/tutorials/src/device/cuda/propagation_kernel.cu b/tutorials/src/device/cuda/propagation_kernel.cu
index 763abbfe9..4f768a280 100644
--- a/tutorials/src/device/cuda/propagation_kernel.cu
+++ b/tutorials/src/device/cuda/propagation_kernel.cu
@@ -16,7 +16,9 @@ inline constexpr detray::scalar path_limit{2.f *
 
 /// Kernel that runs the entire propagation loop
 __global__ void propagation_kernel(
-    typename detray::tutorial::detector_host_t::detector_view_type det_data,
+    typename detray::tutorial::detector_host_t::detector_view_type<
+        bfield::const_bknd_t>
+        det_data,
     const vecmem::data::vector_view<
         detray::free_track_parameters<detray::tutorial::transform3>>
         tracks_data,
@@ -67,7 +69,9 @@ __global__ void propagation_kernel(
 }
 
 void propagation(
-    typename detray::tutorial::detector_host_t::detector_view_type det_data,
+    typename detray::tutorial::detector_host_t::detector_view_type<
+        bfield::const_bknd_t>
+        det_data,
     const vecmem::data::vector_view<
         detray::free_track_parameters<detray::tutorial::transform3>>
         tracks_data,
diff --git a/utils/include/detray/detectors/create_telescope_detector.hpp b/utils/include/detray/detectors/create_telescope_detector.hpp
index 35605da61..ea122cc4e 100644
--- a/utils/include/detray/detectors/create_telescope_detector.hpp
+++ b/utils/include/detray/detectors/create_telescope_detector.hpp
@@ -9,6 +9,7 @@
 
 // Project include(s)
 #include "detray/core/detector.hpp"
+#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/units.hpp"
 #include "detray/detectors/telescope_metadata.hpp"
 #include "detray/masks/masks.hpp"
@@ -19,11 +20,6 @@
 // Vecmem include(s)
 #include <vecmem/memory/memory_resource.hpp>
 
-// Covfie include(s)
-#include <covfie/core/backend/primitive/constant.hpp>
-#include <covfie/core/field.hpp>
-#include <covfie/core/vector.hpp>
-
 // System include(s)
 #include <algorithm>
 #include <iterator>
@@ -35,9 +31,6 @@ namespace detray {
 
 namespace {
 
-template <typename mask_shape_t>
-using telescope_types = telescope_metadata<mask_shape_t>;
-
 /// Configure the toy detector
 template <typename mask_shape_t = rectangle2D<>,
           typename trajectory_t = detail::ray<__plugin::transform3<scalar>>>
@@ -443,8 +436,9 @@ inline auto create_telescope_detector(
         20.f * unit<scalar>::mm, 20.f * unit<scalar>::mm}) {
 
     // detector type
-    using detector_t = detector<telescope_types<mask_shape_t>, covfie::field,
-                                host_container_types>;
+    using detector_t =
+        detector<telescope_metadata<mask_shape_t>,
+                 covfie::field<bfield::const_bknd_t>, host_container_types>;
 
     // Detector and volume names
     typename detector_t::name_map name_map = {{0u, "telescope_detector"},
@@ -472,12 +466,10 @@ inline auto create_telescope_detector(
     assert((positions.size() < 20u) &&
            "Due to WIP, please choose less than 20 surfaces for now");
 
-    using const_bfield_bknd_t =
-        covfie::backend::constant<covfie::vector::vector_d<scalar, 3>,
-                                  covfie::vector::vector_d<scalar, 3>>;
     const auto &B = cfg.bfield_vec();
-    auto bfield = covfie::field<const_bfield_bknd_t>(
-        const_bfield_bknd_t::configuration_t{B[0], B[1], B[2]});
+    auto bfield =
+        covfie::field<bfield::const_bknd_t>{covfie::make_parameter_pack(
+            bfield::const_bknd_t::configuration_t{B[0], B[1], B[2]})};
 
     // create empty detector
     detector_t det(resource, std::move(bfield));
diff --git a/utils/include/detray/detectors/create_toy_geometry.hpp b/utils/include/detray/detectors/create_toy_geometry.hpp
index 0dce95f3f..da4399500 100644
--- a/utils/include/detray/detectors/create_toy_geometry.hpp
+++ b/utils/include/detray/detectors/create_toy_geometry.hpp
@@ -9,12 +9,14 @@
 
 // Project include(s)
 #include "detray/core/detector.hpp"
+#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/math.hpp"
 #include "detray/definitions/units.hpp"
 #include "detray/detectors/detector_helper.hpp"
 #include "detray/detectors/toy_metadata.hpp"
 #include "detray/geometry/detector_volume.hpp"
 #include "detray/geometry/surface.hpp"
+#include "detray/io/common/detail/file_handle.hpp"
 #include "detray/materials/predefined_materials.hpp"
 #include "detray/tools/grid_builder.hpp"
 #include "detray/tools/volume_builder.hpp"
@@ -22,13 +24,11 @@
 // Vecmem include(s)
 #include <vecmem/memory/memory_resource.hpp>
 
-// Covfie include(s)
-#include <covfie/core/backend/primitive/constant.hpp>
-#include <covfie/core/field.hpp>
-
 // System include(s)
 #include <limits>
 #include <stdexcept>
+#include <string>
+#include <string_view>
 #include <type_traits>
 #include <utility>
 
@@ -41,6 +41,52 @@ using point3 = __plugin::point3<detray::scalar>;
 using vector3 = __plugin::vector3<detray::scalar>;
 using point2 = __plugin::point2<detray::scalar>;
 
+/// Configure the toy detector
+struct toy_det_config {
+    /// No. of barrel layers the detector should be built with
+    unsigned int m_n_brl_layers{4u};
+    /// No. of endcap layers (on either side) the detector should be built with
+    unsigned int m_n_edc_layers{3u};
+    /// Field vector for an homogenoues b-field
+    vector3 m_bfield_vec{0.f, 0.f, 2.f * unit<scalar>::T};
+    /// Input file name for the covfie b-field
+    std::string m_bfield_file{!std::getenv("DETRAY_BFIELD_FILE")
+                                  ? ""
+                                  : std::getenv("DETRAY_BFIELD_FILE")};
+
+    /// Setters
+    /// @{
+    constexpr toy_det_config &n_brl_layers(const unsigned int n) {
+        m_n_brl_layers = n;
+        return *this;
+    }
+    constexpr toy_det_config &n_edc_layers(const unsigned int n) {
+        m_n_edc_layers = n;
+        return *this;
+    }
+    toy_det_config &bfield_vec(const vector3 &field_vec) {
+        m_bfield_vec = field_vec;
+        return *this;
+    }
+    toy_det_config &bfield_vec(const scalar x, const scalar y, const scalar z) {
+        m_bfield_vec = {x, y, z};
+        return *this;
+    }
+    toy_det_config &bfield_file(const std::string &file_name) {
+        m_bfield_file = file_name;
+        return *this;
+    }
+    /// @}
+
+    /// Getters
+    /// @{
+    constexpr unsigned int n_brl_layers() const { return m_n_brl_layers; }
+    constexpr unsigned int n_edc_layers() const { return m_n_edc_layers; }
+    constexpr const vector3 &bfield_vec() const { return m_bfield_vec; }
+    const std::string &bfield_file() const { return m_bfield_file; }
+    /// @}
+};
+
 /** Helper function that creates a layer of rectangular barrel modules.
  *
  * @tparam rctangle_id default rectangle id
@@ -357,11 +403,12 @@ template <typename context_t, typename volume_type,
           typename surface_container_t, typename mask_container_t,
           typename material_container_t, typename transform_container_t,
           typename config_t>
-void create_endcap_modules(context_t &ctx, volume_type &vol,
-                           surface_container_t &surfaces,
-                           mask_container_t &masks,
-                           material_container_t &materials,
-                           transform_container_t &transforms, config_t cfg) {
+inline void create_endcap_modules(context_t &ctx, volume_type &vol,
+                                  surface_container_t &surfaces,
+                                  mask_container_t &masks,
+                                  material_container_t &materials,
+                                  transform_container_t &transforms,
+                                  config_t cfg) {
     using surface_type = typename surface_container_t::value_type;
     using nav_link_t = typename surface_type::navigation_link;
     using mask_id = typename surface_type::mask_id;
@@ -679,7 +726,7 @@ inline void add_endcap_barrel_connection(
  * @param cfg config struct for module creation
  */
 template <typename edc_module_factory, typename detector_t, typename config_t>
-void add_endcap_detector(
+inline void add_endcap_detector(
     detector_t &det, vecmem::memory_resource &resource,
     typename detector_t::geometry_context &ctx,
     typename detector_t::name_map &names, dindex n_layers, dindex beampipe_idx,
@@ -782,7 +829,7 @@ void add_endcap_detector(
  * @param cfg config struct for module creation
  */
 template <typename brl_module_factory, typename detector_t, typename config_t>
-void add_barrel_detector(
+inline void add_barrel_detector(
     detector_t &det, vecmem::memory_resource &resource,
     typename detector_t::geometry_context &ctx,
     typename detector_t::name_map &names, const unsigned int n_layers,
@@ -857,24 +904,24 @@ void add_barrel_detector(
 
 }  // namespace
 
-/** Builds a detray geometry that contains the innermost tml layers. The number
- *  of barrel and endcap layers can be chosen, but all barrel layers should be
- *  present when an endcap detector is built to have the barrel region radius
- *  match the endcap diameter.
- *
- * @param n_brl_layers number of pixel barrel layer to build (max 4)
- * @param n_edc_layers number of pixel endcap discs to build (max 7)
- *
- * @returns a complete detector object
- */
-template <typename container_t = host_container_types>
-auto create_toy_geometry(
-    vecmem::memory_resource &resource,
-    covfie::field<toy_metadata<>::bfield_backend_t> &&bfield,
-    unsigned int n_brl_layers = 4u, unsigned int n_edc_layers = 3u) {
+/// Builds a detray geometry that contains the innermost tml layers. The number
+/// of barrel and endcap layers can be chosen, but all barrel layers should be
+/// present when an endcap detector is built to have the barrel region radius
+/// match the endcap diameter.
+///
+/// @tparam bfield_bknd_t the type of magnetic field to construct
+///
+/// @param resource vecmem memory resource to use for container allocations
+/// @param cfg toy detector configuration
+///
+/// @returns a complete detector object
+template <typename bfield_bknd_t = bfield::const_bknd_t>
+inline auto create_toy_geometry(vecmem::memory_resource &resource,
+                                const toy_det_config &cfg = {}) {
 
     // detector type
-    using detector_t = detector<toy_metadata<>, covfie::field, container_t>;
+    using detector_t = detector<toy_metadata, covfie::field<bfield_bknd_t>,
+                                host_container_types>;
 
     // Detector and volume names
     typename detector_t::name_map name_map = {{0u, "toy_detector"}};
@@ -969,7 +1016,22 @@ auto create_toy_geometry(
     };
 
     // create empty detector
-    detector_t det(resource, std::move(bfield));
+    detector_t det(resource);
+
+    // Constant b-field: 2T in z-direction as default
+    if constexpr (std::is_same_v<bfield_bknd_t, bfield::const_bknd_t>) {
+        const vector3 &B = cfg.bfield_vec();
+        auto bfield = covfie::field<bfield_bknd_t>(covfie::make_parameter_pack(
+            bfield::const_bknd_t::configuration_t{B[0], B[1], B[2]}));
+        det.set_bfield(std::move(bfield));
+    }
+    // Read b-field map from file
+    else {
+        detray::io::detail::file_handle file(cfg.bfield_file(),
+                                             std::ios::binary | std::ios::in);
+
+        det.set_bfield(covfie::field<bfield_bknd_t>(*file));
+    }
 
     // geometry context object
     typename detector_t::geometry_context ctx0{};
@@ -977,19 +1039,20 @@ auto create_toy_geometry(
     brl_m_config brl_config{};
     edc_m_config edc_config{};
 
-    if (n_edc_layers > edc_positions.size()) {
+    if (cfg.n_edc_layers() > edc_positions.size()) {
         throw std::invalid_argument(
             "ERROR: Too many endcap layers requested (max " +
             std::to_string(edc_positions.size()) + ")!");
     }
-    if (n_brl_layers > brl_positions.size() - 1u) {
+    if (cfg.n_brl_layers() > brl_positions.size() - 1u) {
         throw std::invalid_argument(
             "ERROR: Too many barrel layers requested (max " +
             std::to_string(brl_positions.size() - 1u) + ")!");
     }
     // the radius of the endcaps and  the barrel section need to match
-    if (n_edc_layers > 0 and
-        std::fabs(brl_lay_sizes[n_brl_layers].second - edc_config.outer_r) >
+    if (cfg.n_edc_layers() > 0 and
+        std::fabs(brl_lay_sizes[cfg.n_brl_layers()].second -
+                  edc_config.outer_r) >
             std::numeric_limits<scalar>::epsilon()) {
         throw std::invalid_argument(
             "ERROR: Barrel and endcap radii do not match!");
@@ -997,53 +1060,54 @@ auto create_toy_geometry(
 
     // beampipe
     const dindex beampipe_idx{0u};
-    add_beampipe(det, resource, ctx0, name_map, n_edc_layers, n_brl_layers,
-                 edc_lay_sizes, brl_lay_sizes[0], brl_positions[0], brl_half_z,
-                 edc_config.inner_r);
+    add_beampipe(det, resource, ctx0, name_map, cfg.n_edc_layers(),
+                 cfg.n_brl_layers(), edc_lay_sizes, brl_lay_sizes[0],
+                 brl_positions[0], brl_half_z, edc_config.inner_r);
 
-    if (n_edc_layers > 0u) {
+    if (cfg.n_edc_layers() > 0u) {
         edc_config.side = -1;
         // negative endcap layers
         add_endcap_detector<edc_module_factory>(
-            det, resource, ctx0, name_map, n_edc_layers, beampipe_idx,
+            det, resource, ctx0, name_map, cfg.n_edc_layers(), beampipe_idx,
             edc_lay_sizes, edc_positions, edc_config);
 
         // gap volume that connects barrel and neg. endcap
         dindex prev_vol_idx = det.volumes().back().index();
         prev_vol_idx = prev_vol_idx == 0u ? leaving_world : prev_vol_idx;
-        dindex next_vol_idx = n_brl_layers == 0u
+        dindex next_vol_idx = cfg.n_brl_layers() == 0u
                                   ? leaving_world
                                   : det.volumes().back().index() + 2u;
 
         add_endcap_barrel_connection(
-            det, resource, ctx0, name_map, edc_config.side, n_brl_layers,
+            det, resource, ctx0, name_map, edc_config.side, cfg.n_brl_layers(),
             beampipe_idx, brl_lay_sizes, edc_config.inner_r, edc_config.outer_r,
             edc_lay_sizes[0].first, brl_half_z, next_vol_idx, prev_vol_idx);
     }
-    if (n_brl_layers > 0u) {
+    if (cfg.n_brl_layers() > 0u) {
         // barrel
         add_barrel_detector<brl_module_factory>(
-            det, resource, ctx0, name_map, n_brl_layers, beampipe_idx,
+            det, resource, ctx0, name_map, cfg.n_brl_layers(), beampipe_idx,
             brl_half_z, brl_lay_sizes, brl_positions, brl_binning, brl_config);
     }
-    if (n_edc_layers > 0u) {
+    if (cfg.n_edc_layers() > 0u) {
         // gap layer that connects barrel and pos. endcap
         edc_config.side = 1.;
         // innermost barrel layer volume id
-        dindex prev_vol_idx =
-            n_brl_layers == 0 ? leaving_world : 2u * n_edc_layers + 1u;
+        dindex prev_vol_idx = cfg.n_brl_layers() == 0
+                                  ? leaving_world
+                                  : 2u * cfg.n_edc_layers() + 1u;
         dindex next_vol_idx = prev_vol_idx == 1u
                                   ? leaving_world
                                   : det.volumes().back().index() + 2u;
 
         add_endcap_barrel_connection(
-            det, resource, ctx0, name_map, edc_config.side, n_brl_layers,
+            det, resource, ctx0, name_map, edc_config.side, cfg.n_brl_layers(),
             beampipe_idx, brl_lay_sizes, edc_config.inner_r, edc_config.outer_r,
             brl_half_z, edc_lay_sizes[0].first, prev_vol_idx, next_vol_idx);
 
         // positive endcap layers
         add_endcap_detector<edc_module_factory>(
-            det, resource, ctx0, name_map, n_edc_layers, beampipe_idx,
+            det, resource, ctx0, name_map, cfg.n_edc_layers(), beampipe_idx,
             edc_lay_sizes, edc_positions, edc_config);
     }
 
@@ -1070,17 +1134,4 @@ auto create_toy_geometry(
     return std::make_pair(std::move(det), std::move(name_map));
 }
 
-/** Wrapper for create_toy_geometry with constant zero bfield.
- */
-template <typename container_t = host_container_types>
-auto create_toy_geometry(vecmem::memory_resource &resource,
-                         unsigned int n_brl_layers = 4u,
-                         unsigned int n_edc_layers = 3u) {
-    return create_toy_geometry<container_t>(
-        resource,
-        covfie::field<toy_metadata<>::bfield_backend_t>{
-            toy_metadata<>::bfield_backend_t::configuration_t{0.f, 0.f, 0.f}},
-        n_brl_layers, n_edc_layers);
-}
-
 }  // namespace detray
diff --git a/utils/include/detray/detectors/create_wire_chamber.hpp b/utils/include/detray/detectors/create_wire_chamber.hpp
index f98e91716..78b3f7b10 100644
--- a/utils/include/detray/detectors/create_wire_chamber.hpp
+++ b/utils/include/detray/detectors/create_wire_chamber.hpp
@@ -10,8 +10,10 @@
 // Project include(s)
 #include "detray/core/detector.hpp"
 #include "detray/core/detector_metadata.hpp"
+#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/units.hpp"
 #include "detray/detectors/detector_helper.hpp"
+#include "detray/io/common/detail/file_handle.hpp"
 #include "detray/masks/masks.hpp"
 #include "detray/materials/predefined_materials.hpp"
 #include "detray/tools/bounding_volume.hpp"
@@ -22,11 +24,6 @@
 // Vecmem include(s)
 #include <vecmem/memory/memory_resource.hpp>
 
-// Covfie include(s)
-#include <covfie/core/backend/primitive/constant.hpp>
-#include <covfie/core/field.hpp>
-#include <covfie/core/vector.hpp>
-
 namespace detray {
 
 namespace {
@@ -49,6 +46,11 @@ struct wire_chamber_config {
     /// Field vector for an homogenoues b-field
     vector3 m_bfield_vec{0.f, 0.f, 2.f * unit<scalar>::T};
 
+    /// Input file name for the covfie b-field
+    std::string m_bfield_file{!std::getenv("DETRAY_BFIELD_FILE")
+                                  ? ""
+                                  : std::getenv("DETRAY_BFIELD_FILE")};
+
     constexpr wire_chamber_config &n_layers(const unsigned int n) {
         m_n_layers = n;
         return *this;
@@ -70,18 +72,25 @@ struct wire_chamber_config {
         return *this;
     }
 
+    wire_chamber_config &bfield_file(const std::string &file_name) {
+        m_bfield_file = file_name;
+        return *this;
+    }
+
     constexpr unsigned int n_layers() const { return m_n_layers; }
     constexpr scalar half_z() const { return m_half_z; }
     constexpr const vector3 &bfield_vec() const { return m_bfield_vec; }
+    const std::string &bfield_file() const { return m_bfield_file; }
 
 };  // wire chamber config
 
-template <typename container_t = host_container_types>
+template <typename bfield_bknd_t = bfield::const_bknd_t>
 auto create_wire_chamber(vecmem::memory_resource &resource,
                          const wire_chamber_config &cfg) {
 
     // Detector type
-    using detector_t = detector<default_metadata, covfie::field, container_t>;
+    using detector_t = detector<default_metadata, covfie::field<bfield_bknd_t>,
+                                host_container_types>;
 
     using nav_link_t = typename detector_t::surface_type::navigation_link;
     using mask_id = typename detector_t::surface_type::mask_id;
@@ -100,16 +109,24 @@ auto create_wire_chamber(vecmem::memory_resource &resource,
     const material<scalar> wire_mat = tungsten<scalar>();
     constexpr scalar wire_rad = 15.f * unit<scalar>::um;
 
+    // Create detector
+    detector_t det(resource);
+
     // B field
-    using const_bfield_bknd_t =
-        covfie::backend::constant<covfie::vector::vector_d<scalar, 3>,
-                                  covfie::vector::vector_d<scalar, 3>>;
-    const auto &B = cfg.bfield_vec();
-    auto bfield = covfie::field<const_bfield_bknd_t>(
-        const_bfield_bknd_t::configuration_t{B[0], B[1], B[2]});
+    // Constant b-field: 2T in z-direction as default
+    if constexpr (std::is_same_v<bfield_bknd_t, bfield::const_bknd_t>) {
+        const vector3 &B = cfg.bfield_vec();
+        auto bfield = covfie::field<bfield_bknd_t>(covfie::make_parameter_pack(
+            bfield::const_bknd_t::configuration_t{B[0], B[1], B[2]}));
+        det.set_bfield(std::move(bfield));
+    }
+    // Read b-field map from file
+    else {
+        detray::io::detail::file_handle file(cfg.bfield_file(),
+                                             std::ios::binary | std::ios::in);
 
-    // Create detector
-    detector_t det(resource, std::move(bfield));
+        det.set_bfield(covfie::field<bfield_bknd_t>(*file));
+    }
 
     // Detector and volume names
     typename detector_t::name_map name_map = {{0u, "wire_chamber"}};
diff --git a/utils/include/detray/detectors/itk_metadata.hpp b/utils/include/detray/detectors/itk_metadata.hpp
index 671047d98..47e4987fc 100644
--- a/utils/include/detray/detectors/itk_metadata.hpp
+++ b/utils/include/detray/detectors/itk_metadata.hpp
@@ -23,10 +23,6 @@
 // Linear algebra types
 #include "detray/definitions/algebra.hpp"
 
-// Covfie include(s)
-#include <covfie/core/backend/primitive/constant.hpp>
-#include <covfie/core/vector.hpp>
-
 namespace detray {
 
 // linear algebra types
@@ -63,11 +59,6 @@ struct itk_metadata {
     /// material
     using slab = material_slab<detray::scalar>;
 
-    /// Constant B-field
-    using bfield_backend_t =
-        covfie::backend::constant<covfie::vector::vector_d<scalar, 3>,
-                                  covfie::vector::vector_d<scalar, 3>>;
-
     /// How to store and link transforms. The geometry context allows to resolve
     /// the conditions data for e.g. module alignment
     template <template <typename...> class vector_t = dvector>
diff --git a/utils/include/detray/detectors/telescope_metadata.hpp b/utils/include/detray/detectors/telescope_metadata.hpp
index aec69df08..c76184273 100644
--- a/utils/include/detray/detectors/telescope_metadata.hpp
+++ b/utils/include/detray/detectors/telescope_metadata.hpp
@@ -18,18 +18,11 @@
 #include "detray/materials/material_slab.hpp"
 #include "detray/surface_finders/brute_force_finder.hpp"
 
-// Covfie include(s)
-#include <covfie/core/backend/primitive/constant.hpp>
-#include <covfie/core/vector.hpp>
-
 namespace detray {
 
 /// Defines a telescope detector type with only rectangle portals and one
 /// additional kind of contained module surfaces (@tparam mask_shape_t)
-template <typename mask_shape_t = rectangle2D<>,
-          typename _bfield_backend_t =
-              covfie::backend::constant<covfie::vector::vector_d<scalar, 3>,
-                                        covfie::vector::vector_d<scalar, 3>>>
+template <typename mask_shape_t = rectangle2D<>>
 struct telescope_metadata {
 
     /// Mask to (next) volume link: next volume(s)
@@ -45,8 +38,6 @@ struct telescope_metadata {
     using rod = material_rod<detray::scalar>;
     using slab = material_slab<detray::scalar>;
 
-    using bfield_backend_t = _bfield_backend_t;
-
     /// How to store coordinate transform matrices
     template <template <typename...> class vector_t = dvector>
     using transform_store = single_store<__plugin::transform3<detray::scalar>,
diff --git a/utils/include/detray/detectors/toy_metadata.hpp b/utils/include/detray/detectors/toy_metadata.hpp
index 0112502d7..bcbc5f5ba 100644
--- a/utils/include/detray/detectors/toy_metadata.hpp
+++ b/utils/include/detray/detectors/toy_metadata.hpp
@@ -21,16 +21,9 @@
 #include "detray/surface_finders/accelerator_grid.hpp"
 #include "detray/surface_finders/brute_force_finder.hpp"
 
-// Covfie include(s)
-#include <covfie/core/backend/primitive/constant.hpp>
-#include <covfie/core/vector.hpp>
-
 namespace detray {
 
 /// Defines the data types needed for the toy detector
-template <typename _bfield_backend_t =
-              covfie::backend::constant<covfie::vector::vector_d<scalar, 3>,
-                                        covfie::vector::vector_d<scalar, 3>>>
 struct toy_metadata {
 
     /// Mask to (next) volume link: next volume(s)
@@ -68,8 +61,6 @@ struct toy_metadata {
 
     /// @}
 
-    using bfield_backend_t = _bfield_backend_t;
-
     /// How to store coordinate transform matrices
     template <template <typename...> class vector_t = dvector>
     using transform_store = single_store<__plugin::transform3<detray::scalar>,

From e68eca1a37958a17e654cdbf43c9506c654bde8e Mon Sep 17 00:00:00 2001
From: Fred <92879080+fredevb@users.noreply.github.com>
Date: Mon, 2 Oct 2023 09:38:19 +0200
Subject: [PATCH 11/29] feat: visualization of trajectories and connected
 information boxes (#550)

  Added visualization of rays and helix trajectories.
  Now optionally displays information boxes when surfaces are selected.
---
 .../conversion/information_section.hpp        |  49 +++++++
 .../plugins/svgtools/conversion/surface.hpp   |  10 ++
 .../svgtools/conversion/trajectory.hpp        |  60 +++++++++
 .../detray/plugins/svgtools/illustrator.hpp   | 122 ++++++++++++++++--
 .../svgtools/meta/display/geometry.hpp        |  28 +++-
 .../svgtools/meta/display/information.hpp     |  57 ++++++++
 .../meta/proto/information_section.hpp        |  29 +++++
 .../plugins/svgtools/meta/proto/landmark.hpp  |   2 +-
 .../svgtools/meta/proto/trajectory.hpp        |  28 ++++
 .../plugins/svgtools/styling/styling.hpp      |  62 ++++++---
 tests/unit_tests/svgtools/CMakeLists.txt      |   4 +
 tests/unit_tests/svgtools/detectors.cpp       |   2 +-
 tests/unit_tests/svgtools/trajectories.cpp    |  76 +++++++++++
 13 files changed, 497 insertions(+), 32 deletions(-)
 create mode 100644 plugins/svgtools/include/detray/plugins/svgtools/conversion/information_section.hpp
 create mode 100644 plugins/svgtools/include/detray/plugins/svgtools/conversion/trajectory.hpp
 create mode 100644 plugins/svgtools/include/detray/plugins/svgtools/meta/display/information.hpp
 create mode 100644 plugins/svgtools/include/detray/plugins/svgtools/meta/proto/information_section.hpp
 create mode 100644 plugins/svgtools/include/detray/plugins/svgtools/meta/proto/trajectory.hpp
 create mode 100644 tests/unit_tests/svgtools/trajectories.cpp

diff --git a/plugins/svgtools/include/detray/plugins/svgtools/conversion/information_section.hpp b/plugins/svgtools/include/detray/plugins/svgtools/conversion/information_section.hpp
new file mode 100644
index 000000000..85e17a929
--- /dev/null
+++ b/plugins/svgtools/include/detray/plugins/svgtools/conversion/information_section.hpp
@@ -0,0 +1,49 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/geometry/surface.hpp"
+#include "detray/plugins/svgtools/conversion/point.hpp"
+#include "detray/plugins/svgtools/meta/proto/information_section.hpp"
+
+// Actsvg include(s)
+#include "actsvg/core.hpp"
+#include "actsvg/meta.hpp"
+
+// System include(s)
+#include <array>
+#include <iomanip>
+#include <sstream>
+#include <string>
+
+namespace detray::svgtools::conversion {
+
+template <typename point3_t>
+inline std::string point_to_string(point3_t point) {
+
+    std::stringstream stream;
+    stream << std::fixed << std::setprecision(2) << "(" << point[0] << ", "
+           << point[1] << ", " << point[2] << ")";
+    return stream.str();
+}
+
+template <typename point3_t, typename detector_t>
+inline auto information_section(
+    const typename detector_t::geometry_context& context,
+    const detray::surface<detector_t>& d_surface) {
+    svgtools::meta::proto::information_section<point3_t> is;
+    is._title = d_surface.is_portal() ? "Portal" : "Surface";
+    const auto position = d_surface.center(context);
+    is._info = {"Idx: " + std::to_string(d_surface.index()),
+                point_to_string(position)};
+    is._position = svgtools::conversion::point<point3_t>(position);
+    return is;
+}
+
+}  // namespace detray::svgtools::conversion
\ No newline at end of file
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/conversion/surface.hpp b/plugins/svgtools/include/detray/plugins/svgtools/conversion/surface.hpp
index d61ee7eb2..29686030a 100644
--- a/plugins/svgtools/include/detray/plugins/svgtools/conversion/surface.hpp
+++ b/plugins/svgtools/include/detray/plugins/svgtools/conversion/surface.hpp
@@ -152,6 +152,16 @@ auto inline surface(const transform_t& transform, const mask<annulus2D<>>& m) {
     return p_surface;
 }
 
+/// @brief Returns the proto surface for a shape.
+/// @note For lines, the thickness is fixed and not determined by the cross
+/// section.
+template <typename point3_container_t, typename mask_t>
+auto inline surface(const mask_t& m) {
+    using transform_t = typename mask_t::local_frame_type::transform3_type;
+    return detray::svgtools::conversion::surface<point3_container_t>(
+        transform_t{}, m);
+}
+
 namespace {
 /// @brief A functor to set the proto surfaces type and bounds to be equivalent
 /// to the mask.
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/conversion/trajectory.hpp b/plugins/svgtools/include/detray/plugins/svgtools/conversion/trajectory.hpp
new file mode 100644
index 000000000..2994db87e
--- /dev/null
+++ b/plugins/svgtools/include/detray/plugins/svgtools/conversion/trajectory.hpp
@@ -0,0 +1,60 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/intersection/detail/trajectories.hpp"
+#include "detray/plugins/svgtools/conversion/point.hpp"
+#include "detray/plugins/svgtools/meta/proto/trajectory.hpp"
+
+// System include(s)
+#include <vector>
+
+namespace detray::svgtools::conversion {
+
+/// @returns The proto trajectory of a vector of points.
+template <typename point3_t>
+inline auto trajectory(const std::vector<point3_t>& points) {
+    using p_trajectory_t = svgtools::meta::proto::trajectory<point3_t>;
+    p_trajectory_t p_trajectory;
+    p_trajectory._points = points;
+    return p_trajectory;
+}
+/// @param traj the trajectory
+/// @param path_legth the length of the path
+/// @param step_size the step size, ie., ds
+/// @returns The proto trajectory of a parametrized trajectory
+template <typename point3_t, template <typename> class trajectory_t,
+          typename transform3_t>
+inline auto trajectory(
+    const trajectory_t<transform3_t>& traj,
+    const typename transform3_t::scalar_type path_length = 500.f,
+    const typename transform3_t::scalar_type step_size = 1.f) {
+    const typename transform3_t::scalar_type S0 = 0.f;
+    std::vector<point3_t> points;
+    for (auto s = S0; s < path_length; s += step_size) {
+        points.push_back(svgtools::conversion::point<point3_t>(traj.pos(s)));
+    }
+    return trajectory(points);
+}
+
+/// @param traj the trajectory
+/// @param path_legth the length of the path
+/// @returns The proto trajectory of a ray.
+template <typename point3_t, typename transform3_t>
+inline auto trajectory(
+    const detray::detail::ray<transform3_t>& traj,
+    const typename transform3_t::scalar_type path_length = 500.f) {
+    const typename transform3_t::scalar_type S0 = 0.f;
+    std::vector<point3_t> points = {
+        svgtools::conversion::point<point3_t>(traj.pos(S0)),
+        svgtools::conversion::point<point3_t>(traj.pos(path_length))};
+    return trajectory<point3_t>(points);
+}
+
+}  // namespace detray::svgtools::conversion
\ No newline at end of file
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/illustrator.hpp b/plugins/svgtools/include/detray/plugins/svgtools/illustrator.hpp
index f9155780f..401e12365 100644
--- a/plugins/svgtools/include/detray/plugins/svgtools/illustrator.hpp
+++ b/plugins/svgtools/include/detray/plugins/svgtools/illustrator.hpp
@@ -9,11 +9,14 @@
 
 // Project include(s)
 #include "detray/geometry/surface.hpp"
+#include "detray/plugins/svgtools/conversion/information_section.hpp"
 #include "detray/plugins/svgtools/conversion/intersection_record.hpp"
 #include "detray/plugins/svgtools/conversion/landmark.hpp"
 #include "detray/plugins/svgtools/conversion/surface.hpp"
+#include "detray/plugins/svgtools/conversion/trajectory.hpp"
 #include "detray/plugins/svgtools/conversion/volume.hpp"
 #include "detray/plugins/svgtools/meta/display/geometry.hpp"
+#include "detray/plugins/svgtools/meta/display/information.hpp"
 #include "detray/plugins/svgtools/styling/styling.hpp"
 #include "detray/plugins/svgtools/utils/volume_utils.hpp"
 #include "detray/utils/ranges.hpp"
@@ -40,8 +43,16 @@ class illustrator {
 
     illustrator(const detector_t& detector,
                 const typename detector_t::name_map& name_map,
-                const styling::style& style)
-        : _detector{detector}, _name_map{name_map}, _style{style} {}
+                const bool show_info)
+        : _detector{detector}, _name_map{name_map}, _show_info{show_info} {}
+
+    illustrator(const detector_t& detector,
+                const typename detector_t::name_map& name_map,
+                const bool show_info, const styling::style& style)
+        : _detector{detector},
+          _name_map{name_map},
+          _show_info{show_info},
+          _style{style} {}
 
     /// @brief Converts a detray surface in the detector to an svg.
     /// @param identification the id of the svg object.
@@ -57,18 +68,40 @@ class illustrator {
         const auto surface = detray::surface{
             _detector,
             _detector.surface_lookup()[static_cast<detray::dindex>(index)]};
+        actsvg::svg::object ret;
+        ret._tag = "g";
+        ret._id = identification;
+        actsvg::svg::object svg_sur;
+        std::array<int, 3> color;
         if (surface.is_portal()) {
             auto p_portal = svgtools::conversion::portal<point3_container>(
                 context, _detector, surface);
             svgtools::styling::apply_style(p_portal,
                                            _style._volume_style._portal_style);
-            return actsvg::display::portal(identification, p_portal, view);
+            std::copy(p_portal._surface._fill._fc._rgb.begin(),
+                      p_portal._surface._fill._fc._rgb.end(), color.begin());
+            svg_sur = actsvg::display::portal(identification, p_portal, view);
+        } else {
+            auto p_surface = svgtools::conversion::surface<point3_container>(
+                context, surface);
+            svgtools::styling::apply_style(p_surface,
+                                           _style._volume_style._surface_style);
+            std::copy(p_surface._fill._fc._rgb.begin(),
+                      p_surface._fill._fc._rgb.end(), color.begin());
+            svg_sur = actsvg::display::surface(identification, p_surface, view);
+        }
+        if (_show_info) {
+            auto p_information_section =
+                svgtools::conversion::information_section<point3>(context,
+                                                                  surface);
+            std::copy(color.begin(), color.end(),
+                      p_information_section._color.begin());
+            ret.add_object(svgtools::meta::display::information_section(
+                identification + "_information_section", p_information_section,
+                view, _info_screen_offset, svg_sur));
         }
-        auto p_surface =
-            svgtools::conversion::surface<point3_container>(context, surface);
-        svgtools::styling::apply_style(p_surface,
-                                       _style._volume_style._surface_style);
-        return actsvg::display::surface(identification, p_surface, view);
+        ret.add_object(svg_sur);
+        return ret;
     }
 
     /// @brief Converts a collection of detray surfaces in the detector to an
@@ -107,12 +140,20 @@ class illustrator {
         const std::string& identification,
         const typename detector_t::geometry_context& context,
         const std::size_t index, const view_t& view) const {
-        const auto volume =
+        actsvg::svg::object ret;
+        ret._tag = "g";
+        ret._id = identification;
+        const auto d_volume =
             _detector.volume_by_index(static_cast<detray::dindex>(index));
-        auto p_volume = svgtools::conversion::volume<point3_container>(
-            context, _detector, volume);
-        svgtools::styling::apply_style(p_volume, _style._volume_style);
-        return actsvg::display::volume(identification, p_volume, view);
+        auto surface_descs =
+            svgtools::utils::surface_lookup(_detector, d_volume);
+        for (std::size_t i = 0; i < surface_descs.size(); i++) {
+            const auto surface_index = surface_descs[i].index();
+            ret.add_object(draw_surface(
+                identification + "_surface" + std::to_string(surface_index),
+                context, surface_index, view));
+        }
+        return ret;
     }
 
     /// @brief Converts a collection of detray volumes in the detector to an
@@ -178,12 +219,67 @@ class illustrator {
                                                             p_ir, view);
     }
 
+    /// @brief Converts a trajectory to an svg.
+    /// @param identification the id of the svg object.
+    /// @param trajectory the trajectory (eg. ray or helix).
+    /// @param view the display view.
+    /// @return @c actsvg::svg::object of the trajectory.
+    template <typename view_t, template <typename> class trajectory_t,
+              typename transform3_t>
+    inline auto draw_trajectory(const std::string& identification,
+                                const trajectory_t<transform3_t>& trajectory,
+                                const view_t& view) const {
+        auto p_trajectory =
+            svgtools::conversion::trajectory<point3>(trajectory);
+        svgtools::styling::apply_style(p_trajectory, _style._trajectory_style);
+        return svgtools::meta::display::trajectory(identification, p_trajectory,
+                                                   view);
+    }
+
+    /// @brief Converts a trajectory and its intersection record to an svg with
+    /// a related coloring.
+    /// @param identification the id of the svg object.
+    /// @param trajectory the trajectory (eg. ray or helix).
+    /// @param intersection_record the intersection record.
+    /// @param view the display view.
+    /// @return @c actsvg::svg::object of the trajectory and intersection
+    /// record.
+    template <typename view_t, template <typename> class trajectory_t,
+              typename transform3_t>
+    inline auto draw_intersections_and_trajectory(
+        const std::string& identification,
+        const typename detector_t::geometry_context& context,
+        std::vector<
+            std::pair<detray::dindex,
+                      detray::intersection2D<typename detector_t::surface_type,
+                                             typename detector_t::transform3>>>&
+            intersection_record,
+        const trajectory_t<transform3_t>& trajectory,
+        const view_t& view) const {
+
+        actsvg::svg::object ret;
+        ret._tag = "g";
+        ret._id = identification;
+        auto i_style = svgtools::styling::copy_fill_colors(
+            _style._intersection_style, _style._trajectory_style);
+        auto p_ir = svgtools::conversion::intersection_record<point3>(
+            context, _detector, intersection_record);
+        svgtools::styling::apply_style(p_ir, i_style);
+        ret.add_object(svgtools::meta::display::intersection_record(
+            identification + "_record", p_ir, view));
+        ret.add_object(
+            draw_trajectory(identification + "_trajectory", trajectory, view));
+        return ret;
+    }
+
     private:
     using point3 = std::array<actsvg::scalar, 3>;
     using point3_container = std::vector<point3>;
 
+    const actsvg::point2 _info_screen_offset{-400, 400};
     const detector_t& _detector;
     const typename detector_t::name_map& _name_map;
+    const bool _show_info = false;
     const styling::style _style = styling::style1;
 };
 
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/meta/display/geometry.hpp b/plugins/svgtools/include/detray/plugins/svgtools/meta/display/geometry.hpp
index ade9bee7e..c4ed6422e 100644
--- a/plugins/svgtools/include/detray/plugins/svgtools/meta/display/geometry.hpp
+++ b/plugins/svgtools/include/detray/plugins/svgtools/meta/display/geometry.hpp
@@ -10,11 +10,13 @@
 // Project inlude(s)
 #include "detray/plugins/svgtools/meta/proto/intersection_record.hpp"
 #include "detray/plugins/svgtools/meta/proto/landmark.hpp"
+#include "detray/plugins/svgtools/meta/proto/trajectory.hpp"
 
 // Actsvg include(s)
 #include "actsvg/core.hpp"
 
 // System include(s)
+#include <algorithm>
 #include <string>
 #include <vector>
 
@@ -47,4 +49,28 @@ inline auto intersection_record(
     return ret;
 }
 
-}  // namespace detray::svgtools::meta::display
\ No newline at end of file
+/// @brief Converts a proto trajectory to a SVG object.
+template <typename point3_t, typename view_t>
+inline auto trajectory(
+    const std::string& id,
+    const svgtools::meta::proto::trajectory<point3_t>& p_trajectory,
+    const view_t& view) {
+    std::vector<actsvg::point2> points;
+    auto change_view = [view](const point3_t& p) {
+        return view(std::vector{p})[0];
+    };
+    std::transform(p_trajectory._points.cbegin(), p_trajectory._points.cend(),
+                   std::back_inserter(points), change_view);
+    actsvg::svg::object ret;
+    ret._tag = "g";
+    ret._id = id;
+    for (std::size_t i = 0; i < points.size() - 1; i++) {
+        // TODO: use smooth curves instead of lines.
+        const auto l = actsvg::draw::line(id, points[i], points[i + 1],
+                                          p_trajectory._stroke);
+        ret.add_object(l);
+    }
+    return ret;
+}
+
+}  // namespace detray::svgtools::meta::display
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/meta/display/information.hpp b/plugins/svgtools/include/detray/plugins/svgtools/meta/display/information.hpp
new file mode 100644
index 000000000..58cbe99e6
--- /dev/null
+++ b/plugins/svgtools/include/detray/plugins/svgtools/meta/display/information.hpp
@@ -0,0 +1,57 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project inlude(s)
+#include "detray/plugins/svgtools/meta/proto/information_section.hpp"
+
+// Actsvg include(s)
+#include "actsvg/core.hpp"
+
+// System include(s)
+#include <string>
+
+namespace detray::svgtools::meta::display {
+
+template <typename point3_t, typename point2_t, typename view_t>
+inline auto information_section(
+    const std::string& id,
+    const svgtools::meta::proto::information_section<point3_t>& is,
+    const view_t& view, const point2_t& screen_offset,
+    const actsvg::svg::object& connected_object,
+    const bool use_relative_offset = false) {
+    // Title style
+    actsvg::style::fill title_fill;
+    title_fill._fc._rgb = is._color;
+    title_fill._fc._opacity = 0.8f;
+    actsvg::style::font title_font;
+
+    title_font._size = 16u;
+    title_font._fc = actsvg::style::color{{255, 255, 255}};
+
+    // Info text style
+    actsvg::style::fill info_fill;
+    info_fill._fc._rgb = is._color;
+    info_fill._fc._opacity = 0.4f;
+
+    actsvg::style::font info_font;
+    info_font._size = 12;
+
+    // Box stroke
+    actsvg::style::stroke stroke;
+
+    const auto position =
+        use_relative_offset
+            ? (screen_offset + view(std::vector{is._position})[0])
+            : screen_offset;
+
+    return actsvg::draw::connected_info_box(
+        id, position, is._title, title_fill, title_font, is._info, info_fill,
+        info_font, stroke, connected_object, {"mousedown", "mouseout"});
+}
+}  // namespace detray::svgtools::meta::display
\ No newline at end of file
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/meta/proto/information_section.hpp b/plugins/svgtools/include/detray/plugins/svgtools/meta/proto/information_section.hpp
new file mode 100644
index 000000000..1ed0a0e23
--- /dev/null
+++ b/plugins/svgtools/include/detray/plugins/svgtools/meta/proto/information_section.hpp
@@ -0,0 +1,29 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Actsvg include(s)
+#include "actsvg/core.hpp"
+
+// System include(s)
+#include <string>
+#include <vector>
+
+namespace detray::svgtools::meta::proto {
+
+/// @brief A proto intersection record class as a simple translation layer from
+/// a intersection record description.
+template <typename point3_t>
+class information_section {
+    public:
+    std::vector<std::string> _info;
+    std::string _title;
+    std::array<int, 3> _color;
+    point3_t _position;
+};
+}  // namespace detray::svgtools::meta::proto
\ No newline at end of file
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/meta/proto/landmark.hpp b/plugins/svgtools/include/detray/plugins/svgtools/meta/proto/landmark.hpp
index b14457379..f0261e715 100644
--- a/plugins/svgtools/include/detray/plugins/svgtools/meta/proto/landmark.hpp
+++ b/plugins/svgtools/include/detray/plugins/svgtools/meta/proto/landmark.hpp
@@ -22,6 +22,6 @@ class landmark {
     public:
     point3_t _position;
     std::string _name;
-    actsvg::style::marker _marker{"x", 1.};
+    actsvg::style::marker _marker{"x", 1.f};
 };
 }  // namespace detray::svgtools::meta::proto
\ No newline at end of file
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/meta/proto/trajectory.hpp b/plugins/svgtools/include/detray/plugins/svgtools/meta/proto/trajectory.hpp
new file mode 100644
index 000000000..ccc111c2a
--- /dev/null
+++ b/plugins/svgtools/include/detray/plugins/svgtools/meta/proto/trajectory.hpp
@@ -0,0 +1,28 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Actsvg include(s)
+#include "actsvg/core.hpp"
+
+// System include(s)
+#include <string>
+#include <vector>
+
+namespace detray::svgtools::meta::proto {
+
+/// @brief A proto landmark class as a simple translation layer from a
+/// description of a point.
+template <typename point3_t>
+class trajectory {
+    public:
+    std::vector<point3_t> _points;
+    std::string _name;
+    actsvg::style::stroke _stroke = actsvg::style::stroke();
+};
+}  // namespace detray::svgtools::meta::proto
\ No newline at end of file
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/styling/styling.hpp b/plugins/svgtools/include/detray/plugins/svgtools/styling/styling.hpp
index 774e2c5c7..6fc29d024 100644
--- a/plugins/svgtools/include/detray/plugins/svgtools/styling/styling.hpp
+++ b/plugins/svgtools/include/detray/plugins/svgtools/styling/styling.hpp
@@ -27,6 +27,9 @@ auto pick_random(container_t container) {
     return container[idx];
 }
 
+// Black
+constexpr std::array black{0, 0, 0};
+
 // Red tones
 constexpr std::array cardinal{167, 51, 63};
 constexpr std::array madder{165, 28, 48};
@@ -48,6 +51,10 @@ constexpr std::array aquamarine2{141, 255, 205};
 constexpr std::array emerald{104, 216, 155};
 constexpr std::array shamrock_green{79, 157, 105};
 
+std::vector<actsvg::style::color> black_theme(const actsvg::scalar opacity) {
+    return {{black, opacity}};
+}
+
 std::vector<actsvg::style::color> red_theme(const actsvg::scalar opacity) {
     return {{cardinal, opacity},
             {madder, opacity},
@@ -75,38 +82,44 @@ std::vector<actsvg::style::color> green_theme(const actsvg::scalar opacity) {
 }  // namespace colors
 
 struct landmark_style {
-    const std::vector<actsvg::style::color> _fill_colors;
-    const actsvg::scalar _marker_size;
+    std::vector<actsvg::style::color> _fill_colors;
+    actsvg::scalar _marker_size;
+};
+
+struct trajectory_style {
+    std::vector<actsvg::style::color> _fill_colors;
+    actsvg::scalar _stroke_width;
 };
 
 struct surface_style {
-    const std::vector<actsvg::style::color> _fill_colors;
-    const actsvg::scalar _stroke_width;
+    std::vector<actsvg::style::color> _fill_colors;
+    actsvg::scalar _stroke_width;
 };
 
 struct link_style {
-    const actsvg::scalar _marker_size;
+    actsvg::scalar _marker_size;
 };
 
 struct portal_style {
-    const surface_style _surface_style;
-    const link_style _link_style;
-    const bool _hide_links;
+    surface_style _surface_style;
+    link_style _link_style;
+    bool _hide_links;
 };
 
 struct volume_style {
-    const surface_style _surface_style;
-    const portal_style _portal_style;
+    surface_style _surface_style;
+    portal_style _portal_style;
 };
 
 struct style {
-    const volume_style _volume_style;
-    const landmark_style _intersection_style;
+    volume_style _volume_style;
+    landmark_style _intersection_style;
+    trajectory_style _trajectory_style;
 };
 
-const surface_style surface_style1{colors::blue_theme(0.8f), 1.f};
+const surface_style surface_style1{colors::blue_theme(0.8f), 3.f};
 
-const surface_style surface_style2{colors::red_theme(0.8f), 1.f};
+const surface_style surface_style2{colors::red_theme(0.8f), 3.f};
 
 const link_style link_style1{1.2f};
 
@@ -114,9 +127,11 @@ const portal_style portal_style1{surface_style2, link_style1, false};
 
 const volume_style volume_style1{surface_style1, portal_style1};
 
-const landmark_style landmark_style1{colors::green_theme(0.8f), 5.f};
+const landmark_style landmark_style1{colors::black_theme(0.8f), 5.f};
+
+const trajectory_style trajectory_style1{colors::green_theme(1.f), 1.f};
 
-const style style1{volume_style1, landmark_style1};
+const style style1{volume_style1, landmark_style1, trajectory_style1};
 
 /// @brief Sets the style of the proto surface.
 template <typename point3_container_t>
@@ -179,4 +194,19 @@ void apply_style(
     }
 }
 
+/// @brief Sets the style of the proto trajectory.
+template <typename point3_t>
+void apply_style(meta::proto::trajectory<point3_t>& p_trajectory,
+                 const trajectory_style& styling) {
+    auto fill_color = colors::pick_random(styling._fill_colors);
+    p_trajectory._stroke =
+        actsvg::style::stroke(fill_color, styling._stroke_width);
+}
+
+template <typename style1_t, typename style2_t>
+auto copy_fill_colors(style1_t target, const style2_t& reference) {
+    target._fill_colors = reference._fill_colors;
+    return target;
+}
+
 }  // namespace detray::svgtools::styling
diff --git a/tests/unit_tests/svgtools/CMakeLists.txt b/tests/unit_tests/svgtools/CMakeLists.txt
index 411978cfb..1c6f7be92 100644
--- a/tests/unit_tests/svgtools/CMakeLists.txt
+++ b/tests/unit_tests/svgtools/CMakeLists.txt
@@ -32,3 +32,7 @@ detray_add_test( svgtools_groups
 detray_add_test( svgtools_intersections
    "intersections.cpp"
    LINK_LIBRARIES GTest::gtest_main detray_tests_common detray::core_array actsvg::core actsvg::meta detray::svgtools)
+
+detray_add_test( svgtools_trajectories
+   "trajectories.cpp"
+   LINK_LIBRARIES GTest::gtest_main detray_tests_common detray::core_array actsvg::core actsvg::meta detray::svgtools)
diff --git a/tests/unit_tests/svgtools/detectors.cpp b/tests/unit_tests/svgtools/detectors.cpp
index 67b7e1d43..527913df3 100644
--- a/tests/unit_tests/svgtools/detectors.cpp
+++ b/tests/unit_tests/svgtools/detectors.cpp
@@ -42,7 +42,7 @@ int main(int, char**) {
     toy_detector_t::geometry_context context{};
 
     // Creating the svg generator for the detector.
-    detray::svgtools::illustrator il{det, names};
+    detray::svgtools::illustrator il{det, names, true};
 
     // Get the svg of the toy detetector in x-y view.
     const auto svg_xy = il.draw_detector("detector_xy", context, xy);
diff --git a/tests/unit_tests/svgtools/trajectories.cpp b/tests/unit_tests/svgtools/trajectories.cpp
new file mode 100644
index 000000000..96bcfeba7
--- /dev/null
+++ b/tests/unit_tests/svgtools/trajectories.cpp
@@ -0,0 +1,76 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+// Project include(s)
+#include "detray/intersection/detail/trajectories.hpp"
+
+#include "detray/core/detector.hpp"
+#include "detray/definitions/units.hpp"
+#include "detray/detectors/create_toy_geometry.hpp"
+#include "detray/plugins/svgtools/illustrator.hpp"
+#include "detray/plugins/svgtools/writer.hpp"
+#include "tests/common/tools/particle_gun.hpp"
+
+// Vecmem include(s)
+#include <vecmem/memory/host_memory_resource.hpp>
+
+// Actsvg include(s)
+#include "actsvg/core.hpp"
+
+// System include(s)
+#include <array>
+#include <string>
+
+int main(int, char**) {
+
+    // Axes.
+    const auto axes =
+        actsvg::draw::x_y_axes("axes", {-250, 250}, {-250, 250},
+                               actsvg::style::stroke(), "axis1", "axis2");
+
+    // Creating the view.
+    const actsvg::views::z_r view;
+
+    // Creating the detector and geomentry context.
+    using detector_t = detray::detector<detray::toy_metadata>;
+    vecmem::host_memory_resource host_mr;
+    const auto [det, names] = detray::create_toy_geometry(host_mr);
+    detector_t::geometry_context context{};
+
+    // Svg for the detector.
+    const detray::svgtools::illustrator il{det, names};
+    const auto svg_det = il.draw_detector("detector", context, view);
+
+    // Creating the rays.
+    using transform3_t = typename detector_t::transform3;
+    using vector3 = typename detector_t::vector3;
+
+    const typename detector_t::point3 ori{0.f, 0.f, 100.f};
+    const typename detector_t::point3 dir{0, 1, 1};
+
+    const detray::detail::ray<transform3_t> ray(ori, 0.f, dir, 0.f);
+    const auto ray_ir = detray::particle_gun::shoot_particle(det, ray);
+
+    const auto svg_ray = il.draw_trajectory("trajectory", ray, view);
+    const auto svg_ray_ir =
+        il.draw_intersections("record", context, ray_ir, view);
+    detray::svgtools::write_svg("ray.svg", {svg_det, svg_ray, svg_ray_ir});
+
+    // Constant magnetic field
+    vector3 B{1.f * detray::unit<detray::scalar>::T,
+              1.f * detray::unit<detray::scalar>::T,
+              1.f * detray::unit<detray::scalar>::T};
+
+    const detray::detail::helix<transform3_t> helix(ori, 0.f, dir, -500.f, &B);
+    const auto helix_ir = detray::particle_gun::shoot_particle(det, helix);
+
+    const auto svg_helix = il.draw_trajectory("trajectory", helix, view);
+    const auto svg_helix_ir =
+        il.draw_intersections("record", context, helix_ir, view);
+    detray::svgtools::write_svg("helix.svg",
+                                {svg_det, svg_helix, svg_helix_ir});
+}
\ No newline at end of file

From 5c3071befb8b77fbb408af06b8950d3cb7a82633 Mon Sep 17 00:00:00 2001
From: Joana Niermann <joana.niermann@cern.ch>
Date: Wed, 2 Aug 2023 20:41:49 +0200
Subject: [PATCH 12/29] Add the grid reader to the detector reader. It
 generates all possible grid types and then selects the ones to be added to
 the detector by switch case statements on the type ids that are in the
 payloads. In the grid builder, the missing information is added to the
 surface descriptors, once the basic volume geometry has been build.

It contains some other fixes, like correctly adapting the cylinder grid radius to the volume,
updating the index offsets when pushing a grid into a grid collection,
as well as maintaining correct surface sorting during the IO, so that the surface indices
saved in the grid match still match the content of the surface_lookup.O
---
 .../detray/core/detail/multi_store.hpp        |   7 +
 .../detray/core/detail/single_store.hpp       |   7 +-
 core/include/detray/definitions/grid_axis.hpp |   2 +-
 core/include/detray/geometry/barcode.hpp      |   2 +-
 .../geometry/detail/surface_descriptor.hpp    |  11 +
 core/include/detray/geometry/surface.hpp      |   7 +-
 core/include/detray/masks/masks.hpp           |   7 +
 .../surface_finders/brute_force_finder.hpp    |  24 ++
 .../detray/surface_finders/grid/grid.hpp      |  19 +-
 .../surface_finders/grid/grid_collection.hpp  |  43 +++
 core/include/detray/tools/bin_fillers.hpp     |   7 +-
 core/include/detray/tools/bounding_volume.hpp |   1 -
 .../include/detray/tools/detector_builder.hpp |   6 +-
 core/include/detray/tools/grid_builder.hpp    | 145 +++----
 core/include/detray/tools/grid_factory.hpp    |  57 ++-
 core/include/detray/tools/surface_factory.hpp |  47 ++-
 .../tools/surface_factory_interface.hpp       |  26 +-
 core/include/detray/tools/volume_builder.hpp  |   2 +-
 .../detray/utils/consistency_checker.hpp      |   1 +
 core/include/detray/utils/inspectors.hpp      |   1 -
 core/include/detray/utils/type_list.hpp       | 170 +++++++++
 .../common/detail/detector_components_io.hpp  |  12 +-
 .../detray/io/common/detector_reader.hpp      |  13 +-
 .../detray/io/common/geometry_reader.hpp      |  21 +-
 .../detray/io/common/geometry_writer.hpp      |  10 +-
 io/include/detray/io/common/grid_reader.hpp   | 356 ++++++++++++++++++
 io/include/detray/io/common/grid_writer.hpp   |  43 ++-
 .../io/common/homogeneous_material_reader.hpp |   5 +-
 io/include/detray/io/common/payloads.hpp      |  12 +-
 .../detray/io/json/json_geometry_io.hpp       |   6 +
 io/include/detray/io/json/json_grids_io.hpp   |  28 +-
 io/include/detray/io/json/json_reader.hpp     |  16 +-
 io/include/detray/io/json/json_writer.hpp     |  12 +-
 .../plugins/svgtools/conversion/surface.hpp   |   3 +-
 .../plugins/svgtools/utils/mask_utils.hpp     |   3 +-
 .../tests/common/test_toy_detector.hpp        |  51 +--
 .../include/tests/common/tools/hash_tree.hpp  |   1 -
 tests/unit_tests/core/CMakeLists.txt          |   1 +
 tests/unit_tests/core/tools_hash_tree.cpp     |   1 -
 tests/unit_tests/core/utils_type_list.cpp     |  40 ++
 tests/unit_tests/cpu/grid_grid_builder.cpp    |  35 +-
 .../unit_tests/cpu/tools_material_builder.cpp |   3 +-
 .../unit_tests/io/io_json_detector_reader.cpp |  12 +-
 tests/unit_tests/io/io_json_payload.cpp       |  12 +-
 .../detray/detectors/create_toy_geometry.hpp  |  84 +++--
 .../detray/detectors/create_wire_chamber.hpp  |  34 +-
 .../detray/detectors/detector_helper.hpp      |   4 +-
 .../include/detray/detectors/toy_metadata.hpp |   2 +-
 48 files changed, 1131 insertions(+), 281 deletions(-)
 create mode 100644 core/include/detray/utils/type_list.hpp
 create mode 100644 io/include/detray/io/common/grid_reader.hpp
 create mode 100644 tests/unit_tests/core/utils_type_list.cpp

diff --git a/core/include/detray/core/detail/multi_store.hpp b/core/include/detray/core/detail/multi_store.hpp
index 718df5027..83a9fcd62 100644
--- a/core/include/detray/core/detail/multi_store.hpp
+++ b/core/include/detray/core/detail/multi_store.hpp
@@ -207,6 +207,13 @@ class multi_store {
         detail::get<value_types::to_index(id)>(m_tuple_container).reserve(n);
     }
 
+    /// Resize the underlying container to @param n for a collection given by
+    /// @tparam id
+    template <ID id>
+    DETRAY_HOST void resize(std::size_t n, const context_type & /*ctx*/) {
+        detail::get<value_types::to_index(id)>(m_tuple_container).resize(n);
+    }
+
     /// Add a new element to a collection
     ///
     /// @tparam ID is the id of the collection
diff --git a/core/include/detray/core/detail/single_store.hpp b/core/include/detray/core/detail/single_store.hpp
index 9ba70059b..8c7f3893c 100644
--- a/core/include/detray/core/detail/single_store.hpp
+++ b/core/include/detray/core/detail/single_store.hpp
@@ -164,11 +164,16 @@ class single_store {
         m_container.clear();
     }
 
-    /// Reserve memory of size @param n for a collection given by @tparam id
+    /// Reserve memory of size @param n for a given geometry context
     DETRAY_HOST void reserve(std::size_t n, const context_type & /*ctx*/) {
         m_container.reserve(n);
     }
 
+    /// Resize the underlying container to @param n for a given geometry context
+    DETRAY_HOST void resize(std::size_t n, const context_type & /*ctx*/) {
+        m_container.resize(n);
+    }
+
     /// Add a new element to the collection - copy
     ///
     /// @tparam U type that can be converted to T
diff --git a/core/include/detray/definitions/grid_axis.hpp b/core/include/detray/definitions/grid_axis.hpp
index 08e9285cf..0524bc54d 100644
--- a/core/include/detray/definitions/grid_axis.hpp
+++ b/core/include/detray/definitions/grid_axis.hpp
@@ -62,4 +62,4 @@ using bounds_t =
                        n_axis::closed<axis_label>>;
 /// @}
 
-}  // namespace detray::n_axis
\ No newline at end of file
+}  // namespace detray::n_axis
diff --git a/core/include/detray/geometry/barcode.hpp b/core/include/detray/geometry/barcode.hpp
index 7c48d5d4b..e2e48941f 100644
--- a/core/include/detray/geometry/barcode.hpp
+++ b/core/include/detray/geometry/barcode.hpp
@@ -142,7 +142,7 @@ class barcode {
     DETRAY_HOST
     friend std::ostream& operator<<(std::ostream& os, const barcode c) {
         if (c.is_invalid()) {
-            return (os << "undefined");
+            os << "INVALID: ";
         }
 
         static const char* const names[] = {
diff --git a/core/include/detray/geometry/detail/surface_descriptor.hpp b/core/include/detray/geometry/detail/surface_descriptor.hpp
index 3af3cc509..9c4515d13 100644
--- a/core/include/detray/geometry/detail/surface_descriptor.hpp
+++ b/core/include/detray/geometry/detail/surface_descriptor.hpp
@@ -192,6 +192,17 @@ class surface_descriptor {
         return m_barcode.id() == surface_id::e_passive;
     }
 
+    /// @returns a string stream that prints the surface details
+    DETRAY_HOST
+    friend std::ostream &operator<<(std::ostream &os,
+                                    const surface_descriptor &sf) {
+        os << sf.m_barcode;
+        os << " | trf.: " << sf._trf;
+        os << " | mask: " << sf._mask;
+        os << " | mat.: " << sf._material;
+        return os;
+    }
+
     private:
     geometry::barcode m_barcode{};
     mask_link _mask{};
diff --git a/core/include/detray/geometry/surface.hpp b/core/include/detray/geometry/surface.hpp
index 2a2ee1927..a3f66cdd0 100644
--- a/core/include/detray/geometry/surface.hpp
+++ b/core/include/detray/geometry/surface.hpp
@@ -357,12 +357,7 @@ class surface {
     /// @returns a string stream that prints the surface details
     DETRAY_HOST
     friend std::ostream &operator<<(std::ostream &os, const surface &sf) {
-        os << sf.barcode();
-        os << " | trf.: " << sf.m_desc.transform();
-        os << " | mask: " << static_cast<dindex>(sf.m_desc.mask().id()) << ", "
-           << sf.m_desc.mask().index();
-        os << " | mat.: " << static_cast<dindex>(sf.m_desc.material().id())
-           << ", " << sf.m_desc.material().index();
+        os << sf.m_desc;
         return os;
     }
 
diff --git a/core/include/detray/masks/masks.hpp b/core/include/detray/masks/masks.hpp
index fe0ba6ae8..778cc07f0 100644
--- a/core/include/detray/masks/masks.hpp
+++ b/core/include/detray/masks/masks.hpp
@@ -244,6 +244,13 @@ class mask {
         return ss.str();
     }
 
+    /// @returns a string stream that prints the mask details
+    DETRAY_HOST
+    friend std::ostream& operator<<(std::ostream& os, const mask& m) {
+        os << m.to_string();
+        return os;
+    }
+
     private:
     shape _shape;
     mask_values _values;
diff --git a/core/include/detray/surface_finders/brute_force_finder.hpp b/core/include/detray/surface_finders/brute_force_finder.hpp
index 62efa7026..50ad35b0e 100644
--- a/core/include/detray/surface_finders/brute_force_finder.hpp
+++ b/core/include/detray/surface_finders/brute_force_finder.hpp
@@ -11,6 +11,7 @@
 #include "detray/core/detail/container_buffers.hpp"
 #include "detray/core/detail/container_views.hpp"
 #include "detray/definitions/containers.hpp"
+#include "detray/definitions/detail/algorithms.hpp"
 #include "detray/definitions/indexing.hpp"
 #include "detray/definitions/qualifiers.hpp"
 #include "detray/utils/ranges.hpp"
@@ -131,6 +132,12 @@ class brute_force_collection {
         return size() == size_type{0};
     }
 
+    /// @returns access to the volume offsets - const
+    DETRAY_HOST const auto& offsets() const { return m_offsets; }
+
+    /// @returns access to the volume offsets
+    DETRAY_HOST auto& offsets() { return m_offsets; }
+
     /// @return access to the surface container - const.
     DETRAY_HOST_DEVICE
     auto all() const -> const vector_type<surface_t>& { return m_surfaces; }
@@ -161,6 +168,23 @@ class brute_force_collection {
         m_offsets.push_back(static_cast<dindex>(m_surfaces.size()));
     }
 
+    /// Remove surface from collection
+    DETRAY_HOST auto erase(
+        typename vector_type<surface_t>::iterator pos) noexcept(false) {
+        // Remove one element
+        auto next = m_surfaces.erase(pos);
+
+        // Update the upper bound of the range and all following ranges
+        const auto idx{static_cast<std::size_t>(pos - m_surfaces.begin())};
+        auto offset =
+            detail::upper_bound(m_offsets.begin(), m_offsets.end(), idx);
+        for (auto itr = offset; itr != m_offsets.end(); ++itr) {
+            --(*itr);
+        }
+
+        return next;
+    }
+
     /// @return the view on the brute force finders - non-const
     DETRAY_HOST
     constexpr auto get_data() noexcept -> view_type {
diff --git a/core/include/detray/surface_finders/grid/grid.hpp b/core/include/detray/surface_finders/grid/grid.hpp
index 33d07a9bb..17939a75d 100644
--- a/core/include/detray/surface_finders/grid/grid.hpp
+++ b/core/include/detray/surface_finders/grid/grid.hpp
@@ -202,12 +202,18 @@ class grid {
         return bin(n_axis::multi_bin<Dim>{{indices...}});
     }
 
-    /// @param mbin the multi-index of bins over all axes
+    /// @param mbin the multi-index of bins over all axes - const
     DETRAY_HOST_DEVICE
     auto bin(const n_axis::multi_bin<Dim> &mbin) const {
         return bin(m_serializer(m_axes, mbin));
     }
 
+    /// @param mbin the multi-index of bins over all axes
+    DETRAY_HOST_DEVICE
+    auto bin(const n_axis::multi_bin<Dim> &mbin) {
+        return bin(m_serializer(m_axes, mbin));
+    }
+
     /// @param gbin the global bin index - const
     DETRAY_HOST_DEVICE
     auto bin(const dindex gbin) const {
@@ -276,7 +282,7 @@ class grid {
         return all();
     }
 
-    /// Find the value of a single bin
+    /// Find the value of a single bin - const
     ///
     /// @param p is point in the local frame
     ///
@@ -286,6 +292,15 @@ class grid {
         return bin(m_axes.bins(p));
     }
 
+    /// Find the value of a single bin
+    ///
+    /// @param p is point in the local frame
+    ///
+    /// @return the iterable view of the bin content
+    DETRAY_HOST_DEVICE auto search(const typename local_frame_type::point3 &p) {
+        return bin(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
diff --git a/core/include/detray/surface_finders/grid/grid_collection.hpp b/core/include/detray/surface_finders/grid/grid_collection.hpp
index 29ea44597..9e86f901f 100644
--- a/core/include/detray/surface_finders/grid/grid_collection.hpp
+++ b/core/include/detray/surface_finders/grid/grid_collection.hpp
@@ -181,21 +181,64 @@ class grid_collection<
     DETRAY_HOST constexpr auto push_back(
         const typename grid_type::template type<true> &gr) noexcept(false)
         -> void {
+        // Current offset into the global bin storage for the new grid
         m_offsets.push_back(static_cast<size_type>(m_bins.size()));
 
+        // Add the bins of the new grid to the collection
         const auto *grid_bins = gr.data().bin_data();
         m_bins.insert(m_bins.end(), grid_bins->begin(), grid_bins->end());
 
+        // Add the axes data of the new grid to the collection
+        // (how to lookup the axis bin edges)
         const auto *axes_data = gr.axes().data().axes_data();
         m_axes_data.insert(m_axes_data.end(), axes_data->begin(),
                            axes_data->end());
 
+        // Current offset into the global bin edges storage
+        dindex bin_edges_offset = static_cast<dindex>(m_bin_edges.size());
+        // The binning types of the axes
+        const auto binnings = get_binning(gr.axes());
+
+        // Update the bin edges index range for the axes in the grid collection
+        for (std::size_t i = m_axes_data.size() - grid_type::Dim;
+             i < m_axes_data.size(); ++i) {
+            auto &bin_entry_range = m_axes_data[i];
+            bin_entry_range[0] += bin_edges_offset;
+            // If the axis has irregular binning, the second entry is the index
+            // of the last bin edge value instead of the number of bins
+            if (binnings[i] == n_axis::binning::e_irregular) {
+                bin_entry_range[1] += bin_edges_offset;
+            }
+        }
+
+        // Add the bin edges of the new grid to the collection
         const auto *bin_edges = gr.axes().data().edges();
+
         m_bin_edges.insert(m_bin_edges.end(), bin_edges->begin(),
                            bin_edges->end());
     }
 
     private:
+    /// @returns an array that contians the binning enum values of the
+    /// corresponding single axes in @param axes
+    template <bool ownership, typename local_frame_t, typename... axis_ts>
+    static auto get_binning(
+        const n_axis::multi_axis<ownership, local_frame_t, axis_ts...> &axes) {
+
+        // Serialize every single axis and construct array from their payloads
+        std::array<n_axis::binning, sizeof...(axis_ts)> binning_types{
+            get_binning(axes.template get_axis<axis_ts>())...};
+
+        return binning_types;
+    }
+
+    /// @returns the binning enum value of a single axis @param axis
+    template <typename bounds_t, typename binning_t>
+    static auto get_binning(
+        const n_axis::single_axis<bounds_t, binning_t> &axis) {
+        return axis.binning();
+    }
+
     /// Offsets for the respective grids into the bin storage
     vector_type<size_type> m_offsets{};
     /// Contains the bin content for all grids
diff --git a/core/include/detray/tools/bin_fillers.hpp b/core/include/detray/tools/bin_fillers.hpp
index f1f8d7c98..7d9c7c742 100644
--- a/core/include/detray/tools/bin_fillers.hpp
+++ b/core/include/detray/tools/bin_fillers.hpp
@@ -69,10 +69,13 @@ struct fill_by_pos {
         // Fill the volumes surfaces into the grid
         for (const auto [idx, sf] : detray::views::enumerate(surfaces)) {
             // no portals in grids allowed
-            assert(not sf.is_portal());
+            if (not sf.is_sensitive() or sf.volume() != vol.index()) {
+                continue;
+            }
 
-            const auto &sf_trf = transforms.at(idx, ctx);
+            const auto &sf_trf = transforms.at(sf.transform(), ctx);
             const auto &t = sf_trf.translation();
+
             // transform to axis coordinate system
             const auto loc_pos = grid.global_to_local(vol.transform(), t, t);
 
diff --git a/core/include/detray/tools/bounding_volume.hpp b/core/include/detray/tools/bounding_volume.hpp
index 5b0661af2..1c973aaa7 100644
--- a/core/include/detray/tools/bounding_volume.hpp
+++ b/core/include/detray/tools/bounding_volume.hpp
@@ -15,7 +15,6 @@
 
 // System include(s)
 #include <cassert>
-#include <iostream>
 #include <limits>
 #include <type_traits>
 #include <vector>
diff --git a/core/include/detray/tools/detector_builder.hpp b/core/include/detray/tools/detector_builder.hpp
index 6528c25c1..f07f1675f 100644
--- a/core/include/detray/tools/detector_builder.hpp
+++ b/core/include/detray/tools/detector_builder.hpp
@@ -59,12 +59,12 @@ class detector_builder {
 
     /// Decorate a volume builder at position @param volume_idx with more
     /// functionality
-    template <template <typename> class builder_t>
+    template <class builder_t>
     DETRAY_HOST auto decorate(dindex volume_idx)
         -> volume_builder_interface<detector_type>* {
 
-        m_volumes[volume_idx] = std::make_unique<builder_t<detector_type>>(
-            std::move(m_volumes[volume_idx]));
+        m_volumes[volume_idx] =
+            std::make_unique<builder_t>(std::move(m_volumes[volume_idx]));
 
         return m_volumes[volume_idx].get();
     }
diff --git a/core/include/detray/tools/grid_builder.hpp b/core/include/detray/tools/grid_builder.hpp
index 4f6b617e4..b97958124 100644
--- a/core/include/detray/tools/grid_builder.hpp
+++ b/core/include/detray/tools/grid_builder.hpp
@@ -39,8 +39,8 @@ class grid_builder final : public volume_decorator<detector_t> {
 
     // TODO: nullptr can lead to exceptions, remove in the full implementation
     DETRAY_HOST
-    grid_builder(std::unique_ptr<volume_builder_interface<detector_t>>
-                     vol_builder = nullptr)
+    grid_builder(
+        std::unique_ptr<volume_builder_interface<detector_t>> vol_builder)
         : volume_decorator<detector_t>(std::move(vol_builder)) {}
 
     /// Should the passive surfaces be added to the grid ?
@@ -49,17 +49,28 @@ class grid_builder final : public volume_decorator<detector_t> {
     }
 
     /// Delegate init call depending on @param span type
-    template <typename axis_span_t>
+    template <typename grid_shape_t>
     DETRAY_HOST void init_grid(
-        const axis_span_t &span,
+        const mask<grid_shape_t> &bounds,
         const std::array<std::size_t, grid_t::Dim> &n_bins,
         const std::array<std::vector<scalar_type>, grid_t::Dim> &ax_bin_edges =
             {{}}) {
-        init_impl(span, n_bins, ax_bin_edges,
+        init_impl(bounds, n_bins, ax_bin_edges,
                   typename grid_t::axes_type::bounds{},
                   typename grid_t::axes_type::binnings{});
     }
 
+    /// Build the empty grid from axis parameters
+    DETRAY_HOST void init_grid(
+        const std::vector<scalar_type> &spans,
+        const std::vector<std::size_t> &n_bins,
+        const std::vector<std::vector<scalar_type>> &ax_bin_edges = {{}}) {
+
+        m_grid = m_factory.template new_grid<typename grid_t::local_frame_type>(
+            spans, n_bins, ax_bin_edges, typename grid_t::axes_type::bounds{},
+            typename grid_t::axes_type::binnings{});
+    }
+
     /// Fill grid from existing volume using a bin filling strategy
     /// This can also be called without a volume builder
     template <typename volume_type, typename... Args>
@@ -83,53 +94,79 @@ class grid_builder final : public volume_decorator<detector_t> {
         bin_filler(m_grid, vol, surfaces, transforms, masks, ctx, args...);
     }
 
-    /// Overwrite, to add the sensitives to the grid, instead of the surface vec
-    DETRAY_HOST
-    void add_sensitives(
-        std::shared_ptr<surface_factory_interface<detector_t>> sf_factory,
-        typename detector_t::geometry_context ctx = {}) override {
-        (*sf_factory)(volume_decorator<detector_t>::operator()(), m_surfaces,
-                      m_transforms, m_masks, ctx);
-    }
-
-    /// Overwrite, to add the passives to the grid, instead of the surface vec
-    DETRAY_HOST
-    void add_passives(
-        std::shared_ptr<surface_factory_interface<detector_t>> ps_factory,
-        typename detector_t::geometry_context ctx = {}) override {
-        if (m_add_passives) {
-            (*ps_factory)(volume_decorator<detector_t>::operator()(),
-                          m_surfaces, m_transforms, m_masks, ctx);
-            ps_factory->clear();
-        } else {
-            volume_decorator<detector_t>::add_passives(std::move(ps_factory),
-                                                       ctx);
-        }
-    }
-
     /// Add the volume and the grid to the detector @param det
     DETRAY_HOST
     auto build(detector_t &det, typename detector_t::geometry_context ctx = {})
         -> typename detector_t::volume_type * override {
+
+        using surface_desc_t = typename detector_t::surface_type;
+
         // Add the surfaces (portals and/or passives) that are owned by the vol
         typename detector_t::volume_type *vol_ptr =
             volume_decorator<detector_t>::build(det, ctx);
-        m_bin_filler(m_grid, detector_volume{det, *vol_ptr}, m_surfaces,
-                     m_transforms, m_masks, ctx);
-
-        // Add the surfaces that were filled into the grid directly to the
-        // detector and update their links
-        const auto trf_offset{det.transform_store().size(ctx)};
-        for (auto &sf_desc : m_grid.all()) {
-            const auto sf = surface{det, sf_desc};
-            sf.template visit_mask<detail::mask_index_update>(sf_desc);
-            sf_desc.set_volume(vol_ptr->index());
-            sf_desc.update_transform(trf_offset);
-        }
 
-        // Add transforms and masks to detector
-        det.append_masks(std::move(m_masks));
-        det.append_transforms(std::move(m_transforms));
+        // Take the surfaces that should be filled into the grid out of the
+        // brute force finder
+        const auto vol_idx{vol_ptr->index()};
+        constexpr auto bf_id{detector_t::sf_finders::id::e_brute_force};
+        auto &bf_search = det.surface_store().template get<bf_id>();
+
+        // Grid has not been filled previously, fill it automatically
+        if (m_grid.size() == 0u) {
+            std::vector<surface_desc_t> surfaces{};
+            for (auto itr = bf_search.all().begin();
+                 itr != bf_search.all().end();) {
+                if (itr->volume() != vol_idx) {
+                    continue;
+                }
+                if (itr->is_sensitive() or
+                    (m_add_passives and itr->is_passive())) {
+                    surfaces.push_back(*itr);
+                    bf_search.erase(itr);
+                } else {
+                    ++itr;
+                }
+            }
+
+            this->fill_grid(
+                detector_volume{det,
+                                volume_decorator<detector_t>::operator()()},
+                surfaces, det.transform_store(), det.mask_store(), ctx);
+        } else {
+            // The grid is prefilled with surface descriptors that contain the
+            // correct surface indices per bin (e.g. from file IO).
+            // Now add the rest of the linking information, which is only
+            // available after the volume builder ran
+            for (auto itr = bf_search.all().begin();
+                 itr != bf_search.all().end();) {
+                if (itr->volume() != vol_idx) {
+                    ++itr;
+                    continue;
+                }
+                if (itr->is_sensitive() or
+                    (m_add_passives and itr->is_passive())) {
+                    const auto vol = det.volume_by_index(itr->volume());
+                    // The current volume is already built, so the surface
+                    // interface is safe to use
+                    const auto sf = surface{det, *itr};
+                    const auto t = sf.center(ctx);
+                    const auto loc_pos =
+                        m_grid.global_to_local(vol.transform(), t, t);
+                    auto bin_content = m_grid.search(loc_pos);
+
+                    for (surface_desc_t &sf_desc : bin_content) {
+                        // Find the correct surface and update all links
+                        if (sf_desc.index() == sf.index()) {
+                            sf_desc = *itr;
+                        }
+                    }
+
+                    bf_search.erase(itr);
+                } else {
+                    ++itr;
+                }
+            }
+        }
 
         // Add the grid to the detector and link it to its volume
         constexpr auto gid{detector_t::sf_finders::template get_id<grid_t>()};
@@ -159,30 +196,10 @@ class grid_builder final : public volume_decorator<detector_t> {
             bounds, n_bins, ax_bin_edges);
     }
 
-    /// Build the empty grid from axis parameters
-    template <typename grid_shape_t, typename... axis_bounds,
-              typename... binning_ts>
-    DETRAY_HOST void init_impl(
-        const std::vector<scalar_type> &spans,
-        const std::vector<std::size_t> *n_bins,
-        const std::vector<std::vector<scalar_type>> &ax_bin_edges,
-        std::tuple<axis_bounds...>, std::tuple<binning_ts...>) {
-
-        m_grid =
-            m_factory
-                .template new_grid<grid_shape_t, axis_bounds..., binning_ts...>(
-                    spans, n_bins, ax_bin_edges);
-    }
-
     grid_factory_t m_factory{};
     typename grid_t::template type<true> m_grid{};
     bin_filler_t m_bin_filler{};
     bool m_add_passives{false};
-
-    // surfaces that are filled into the grid, but not the volume
-    typename detector_t::surface_container_t m_surfaces{};
-    typename detector_t::transform_container m_transforms{};
-    typename detector_t::mask_container m_masks{};
 };
 
 /// Grid builder from single components
diff --git a/core/include/detray/tools/grid_factory.hpp b/core/include/detray/tools/grid_factory.hpp
index 9de78548e..17b94cfb7 100644
--- a/core/include/detray/tools/grid_factory.hpp
+++ b/core/include/detray/tools/grid_factory.hpp
@@ -23,6 +23,7 @@
 #include <cassert>
 #include <iostream>
 #include <string>
+#include <type_traits>
 
 namespace detray {
 
@@ -58,13 +59,6 @@ class grid_factory {
     explicit grid_factory(vecmem::memory_resource &resource)
         : m_resource(&resource) {}
 
-    /// Get new grid collection
-    template <typename grid_t>
-    constexpr auto new_collection() {
-        return grid_collection<typename grid_t::template type<!is_owning>>(
-            m_resource);
-    }
-
     /// Print grid - up to three dimensions
     /// @note will likely become obsolete with the actsvg implementation
     template <typename grid_t>
@@ -305,6 +299,7 @@ class grid_factory {
         // Axes boundaries and local indices
         using boundary = trapezoid2D<>::boundaries;
         using axes = trapezoid2D<>::axes<>;
+
         constexpr auto e_x_axis = static_cast<dindex>(axes::axis_loc0);
         constexpr auto e_y_axis = static_cast<dindex>(axes::axis_loc1);
 
@@ -336,22 +331,54 @@ class grid_factory {
     /// @param ax_bin_edges the explicit bin edges for irregular axes
     ///                     (lower bin edges + the the upper edge of the
     ///                     last bin), otherwise ignored.
-    template <typename grid_shape_t, typename... bound_ts,
-              typename... binning_ts>
+    template <
+        typename grid_shape_t, typename... bound_ts, typename... binning_ts,
+        std::enable_if_t<std::is_enum_v<typename grid_shape_t::boundaries>,
+                         bool> = true>
+    auto new_grid(const std::vector<scalar_type> spans,
+                  const std::vector<std::size_t> n_bins,
+                  const std::vector<std::vector<scalar_type>> &ax_bin_edges,
+                  const std::tuple<bound_ts...> &bounds,
+                  const std::tuple<binning_ts...> &binnings) const {
+
+        return new_grid<
+            typename grid_shape_t::template local_frame_type<algebra_t>>(
+            spans, n_bins, ax_bin_edges, bounds, binnings);
+    }
+
+    /// @brief Create and empty grid with fully initialized axes.
+    ///
+    /// @tparam grid_shape_t the shape of the resulting grid
+    ///         (e.g. cylinder2D).
+    /// @tparam e_bounds the bounds of the regular axes
+    ///         (open vs. closed bounds).
+    /// @tparam binnings the binning types of the axes
+    ///         (regular vs. irregular)
+    ///
+    /// @param spans the span of the axis values for regular axes, otherwise
+    ///              ignored.
+    /// @param n_bins the number of bins for regular axes, otherwise ignored
+    /// @param ax_bin_edges the explicit bin edges for irregular axes
+    ///                     (lower bin edges + the the upper edge of the
+    ///                     last bin), otherwise ignored.
+    template <
+        typename grid_frame_t, typename... bound_ts, typename... binning_ts,
+        std::enable_if_t<
+            std::is_object_v<typename grid_frame_t::rotation_matrix>, bool> =
+            true>
     auto new_grid(const std::vector<scalar_type> spans,
                   const std::vector<std::size_t> n_bins,
                   const std::vector<std::vector<scalar_type>> &ax_bin_edges,
-                  const std::tuple<bound_ts...>,
-                  const std::tuple<binning_ts...>) const {
+                  const std::tuple<bound_ts...> & = {},
+                  const std::tuple<binning_ts...> & = {}) const {
 
         static_assert(sizeof...(bound_ts) == sizeof...(binning_ts),
                       "number of axis bounds and binning types has to match");
 
         // Build the coordinate axes and the grid
-        using axes_t = n_axis::multi_axis<
-            is_owning,
-            typename grid_shape_t::template local_frame_type<algebra_t>,
-            n_axis::single_axis<bound_ts, binning_ts>...>;
+        using axes_t =
+            n_axis::multi_axis<is_owning, grid_frame_t,
+                               n_axis::single_axis<bound_ts, binning_ts>...>;
         using bin_t = typename grid_type<axes_t>::bin_type;
 
         // Prepare data
diff --git a/core/include/detray/tools/surface_factory.hpp b/core/include/detray/tools/surface_factory.hpp
index 078ec16fa..6fdda35b0 100644
--- a/core/include/detray/tools/surface_factory.hpp
+++ b/core/include/detray/tools/surface_factory.hpp
@@ -17,6 +17,7 @@
 #include "detray/utils/ranges.hpp"
 
 // System include(s)
+#include <algorithm>
 #include <cassert>
 #include <limits>
 #include <memory>
@@ -99,7 +100,7 @@ class surface_factory
     DETRAY_HOST
     void push_back(surface_data_t &&sf_data) override {
 
-        auto [trf, vlink, bounds] = sf_data.get_data();
+        auto [vlink, bounds, trf, index] = sf_data.get_data();
 
         assert(bounds.size() == mask_shape_t::boundaries::e_size);
 
@@ -113,6 +114,7 @@ class surface_factory
             m_volume_link.push_back(vlink);
         }
 
+        m_indices.push_back(index);
         m_transforms.push_back(trf);
         m_components.push_back(std::move(bounds));
     }
@@ -127,6 +129,7 @@ class surface_factory
         const auto n_surfaces{
             static_cast<dindex>(size() + surface_data.size())};
 
+        m_indices.reserve(n_surfaces);
         m_transforms.reserve(n_surfaces);
         m_components.reserve(n_surfaces);
 
@@ -145,6 +148,7 @@ class surface_factory
     /// Clear old data
     DETRAY_HOST
     auto clear() -> void override {
+        m_indices.clear();
         m_components.clear();
         m_transforms.clear();
         // cannot clear the single-view
@@ -176,7 +180,7 @@ class surface_factory
         // The material will be added in a later step
         constexpr auto no_material = surface_t::material_id::e_none;
         // In case the surfaces container is prefilled with other surfaces
-        dindex surfaces_offset = static_cast<dindex>(surfaces.size());
+        const dindex surfaces_offset = static_cast<dindex>(surfaces.size());
 
         // Nothing to construct
         if (size() == 0u) {
@@ -185,8 +189,15 @@ class surface_factory
 
         for (const auto [idx, comp] : detray::views::enumerate(m_components)) {
 
+            // Append the surfaces relative to the current number of surfaces
+            // in the stores
+            const dindex sf_idx{is_invalid_value(m_indices[idx])
+                                    ? dindex_invalid
+                                    : m_indices[idx]};
+
             // Add transform
-            transforms.push_back(m_transforms[idx], ctx);
+            const dindex trf_idx =
+                insert_in_container(transforms, m_transforms[idx], sf_idx, ctx);
 
             if constexpr (std::is_same_v<mask_shape_t, unmasked>) {
                 masks.template emplace_back<mask_id>(
@@ -200,20 +211,42 @@ class surface_factory
             // Add surface with all links set (relative to the given containers)
             mask_link_t mask_link{mask_id, masks.template size<mask_id>() - 1u};
             material_link_t material_link{no_material, dindex_invalid};
-            surfaces.emplace_back(transforms.size(ctx) - 1u, mask_link,
-                                  material_link, volume.index(), dindex_invalid,
-                                  sf_id);
+
+            insert_in_container(surfaces,
+                                {trf_idx, mask_link, material_link,
+                                 volume.index(), dindex_invalid, sf_id},
+                                sf_idx);
         }
 
         return {surfaces_offset, static_cast<dindex>(surfaces.size())};
     }
 
     private:
+    template <typename container_t, typename... Args>
+    DETRAY_HOST dindex insert_in_container(
+        container_t &cont, const typename container_t::value_type value,
+        const dindex idx, Args &&... args) const {
+        if (is_invalid_value(idx)) {
+            cont.push_back(value, std::forward<Args>(args)...);
+
+            return static_cast<dindex>(cont.size() - 1u);
+        } else {
+            if (cont.size() < idx + 1) {
+                cont.resize(idx + 1, std::forward<Args>(args)...);
+            }
+
+            cont.at(idx, std::forward<Args>(args)...) = value;
+
+            return idx;
+        }
+    }
+
     /// Check that the containers have the same size
     DETRAY_HOST
     void check() const {
         // This should not happend (need same number and ordering of data)
         assert(m_components.size() == m_transforms.size());
+        assert(m_components.size() == m_indices.size());
         if constexpr (sf_id == surface_id::e_portal) {
             assert(m_components.size() == m_volume_link.size());
         } else {
@@ -221,6 +254,8 @@ class surface_factory
         }
     }
 
+    dindex_range m_range{dindex_invalid, dindex_invalid};
+    std::vector<dindex> m_indices{};
     std::vector<std::vector<scalar_t>> m_components{};
     std::vector<typename detector_t::transform3> m_transforms{};
     volume_link_collection m_volume_link{};
diff --git a/core/include/detray/tools/surface_factory_interface.hpp b/core/include/detray/tools/surface_factory_interface.hpp
index 851c62f5f..a133399d3 100644
--- a/core/include/detray/tools/surface_factory_interface.hpp
+++ b/core/include/detray/tools/surface_factory_interface.hpp
@@ -33,26 +33,32 @@ class surface_data {
     DETRAY_HOST
     surface_data(
         const typename detector_t::transform3 &trf, navigation_link volume_link,
-        const std::vector<typename detector_t::scalar_type> &mask_boundaries)
-        : m_transform{trf},
-          m_volume_link{volume_link},
-          m_boundaries{mask_boundaries} {}
+        const std::vector<typename detector_t::scalar_type> &mask_boundaries,
+        const dindex idx = dindex_invalid)
+        : m_volume_link{volume_link},
+          m_index{idx},
+          m_boundaries{mask_boundaries},
+          m_transform{trf} {}
 
     DETRAY_HOST
     auto get_data()
-        -> std::tuple<typename detector_t::transform3 &, navigation_link &,
-                      std::vector<typename detector_t::scalar_type> &> {
-        return std::tie(m_transform, m_volume_link, m_boundaries);
+        -> std::tuple<navigation_link &,
+                      std::vector<typename detector_t::scalar_type> &,
+                      typename detector_t::transform3 &, dindex &> {
+        return std::tie(m_volume_link, m_boundaries, m_transform, m_index);
     }
 
     private:
-    /// The surface placement
-    typename detector_t::transform3 m_transform;
     /// The index of the volume that this surface links to
     navigation_link m_volume_link;
-    // simple tuple of all mask types in the detector. Only one entry is filled
+    /// The position of the surface in the detector containers, used to match
+    /// the surface to e.g. its material
+    dindex m_index;
+    // Simple tuple of all mask types in the detector. Only one entry is filled
     // with the mask that corresponds to this specific surface.
     std::vector<typename detector_t::scalar_type> m_boundaries;
+    /// The surface placement
+    typename detector_t::transform3 m_transform;
 };
 
 /// @brief How to generate surfaces with their corresponding masks and
diff --git a/core/include/detray/tools/volume_builder.hpp b/core/include/detray/tools/volume_builder.hpp
index e4fa2c7b3..39d6610e4 100644
--- a/core/include/detray/tools/volume_builder.hpp
+++ b/core/include/detray/tools/volume_builder.hpp
@@ -147,7 +147,7 @@ class volume_builder : public volume_builder_interface<detector_t> {
 
         // Update mask and transform index of surfaces and set a
         // unique barcode (index of surface in container)
-        auto sf_offset{static_cast<dindex>(det.portals().size())};
+        auto sf_offset{static_cast<dindex>(det.surface_lookup().size())};
         for (auto& sf_desc : m_surfaces) {
             const auto sf = surface{det, sf_desc};
             sf.template visit_mask<detail::mask_index_update>(sf_desc);
diff --git a/core/include/detray/utils/consistency_checker.hpp b/core/include/detray/utils/consistency_checker.hpp
index 0044f096c..26b91ab92 100644
--- a/core/include/detray/utils/consistency_checker.hpp
+++ b/core/include/detray/utils/consistency_checker.hpp
@@ -209,6 +209,7 @@ inline bool check_consistency(const detector_t &det) {
 
         // Check that nothing is obviously broken
         if (not sf.self_check(err_stream)) {
+            err_stream << "\nat surface no. " << std::to_string(idx);
             throw std::invalid_argument(err_stream.str());
         }
 
diff --git a/core/include/detray/utils/inspectors.hpp b/core/include/detray/utils/inspectors.hpp
index db324dab3..ee33a5654 100644
--- a/core/include/detray/utils/inspectors.hpp
+++ b/core/include/detray/utils/inspectors.hpp
@@ -16,7 +16,6 @@
 
 // System include(s)
 #include <iomanip>
-#include <iostream>
 #include <sstream>
 #include <string>
 #include <tuple>
diff --git a/core/include/detray/utils/type_list.hpp b/core/include/detray/utils/type_list.hpp
new file mode 100644
index 000000000..e5a6cefd2
--- /dev/null
+++ b/core/include/detray/utils/type_list.hpp
@@ -0,0 +1,170 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/utils/tuple.hpp"
+#include "detray/utils/type_traits.hpp"
+
+// System include(s)
+#include <string>
+#include <string_view>
+#include <type_traits>
+
+namespace detray::types {
+
+/// @brief type list implementation
+template <typename... Ts>
+struct type_list {};
+
+/// Number of types in the list
+/// @{
+template <typename = void>
+struct get_size {};
+
+template <typename... Ts>
+struct get_size<type_list<Ts...>>
+    : std::integral_constant<std::size_t, sizeof...(Ts)> {};
+
+template <typename L>
+constexpr inline std::size_t size{get_size<L>()};
+/// @}
+
+/// Access the first type
+/// @{
+template <typename = void>
+struct get_front {};
+
+template <typename T, typename... Ts>
+struct get_front<type_list<T, Ts...>> {
+    using type = T;
+};
+template <typename L>
+using front = typename get_front<L>::type;
+/// @}
+
+/// Access the last type
+/// @{
+template <typename = void>
+struct get_back {};
+
+template <typename T, typename... Ts>
+struct get_back<type_list<T, Ts...>> {
+    using type = std::conditional_t<sizeof...(Ts) == 0, T,
+                                    typename get_back<type_list<Ts...>>::type>;
+};
+// Base case
+template <>
+struct get_back<type_list<>> {
+    using type = void;
+};
+template <typename L>
+using back = typename get_back<L>::type;
+/// @}
+
+/// Access the N-th type
+/// @{
+template <int N, typename = void>
+struct get_at {};
+
+template <int N, typename T, typename... Ts>
+struct get_at<N, type_list<T, Ts...>> {
+    using type = detail::remove_cvref_t<decltype(
+        detray::get<N>(detray::tuple<T, Ts...>{}))>;
+};
+template <typename L, int N>
+using at = typename get_at<N, L>::type;
+/// @}
+
+/// Append a type
+/// @{
+template <typename N, typename = void>
+struct do_push_back {};
+
+template <typename N, typename... Ts>
+struct do_push_back<N, type_list<Ts...>> {
+    using type = type_list<Ts..., N>;
+};
+template <typename L, typename N>
+using push_back = typename do_push_back<N, L>::type;
+/// @}
+
+/// Prepend a type
+/// @{
+template <typename N, typename = void>
+struct do_push_front {};
+
+template <typename N, typename... Ts>
+struct do_push_front<N, type_list<Ts...>> {
+    using type = type_list<N, Ts...>;
+};
+template <typename L, typename N>
+using push_front = typename do_push_front<N, L>::type;
+/// @}
+
+/// Print the type list
+/// @{
+
+/// @see
+/// https://stackoverflow.com/questions/281818/unmangling-the-result-of-stdtype-infoname
+template <typename T>
+std::string demangle_type_name() {
+#if defined(__clang__)
+    constexpr std::string_view prefix{"[T = "};
+    constexpr std::string_view suffix{"; "};
+    constexpr std::string_view function{__PRETTY_FUNCTION__};
+#elif defined(__GNUC__)
+    constexpr std::string_view prefix{"with T = "};
+    constexpr std::string_view suffix{"; "};
+    constexpr std::string_view function{__PRETTY_FUNCTION__};
+#elif defined(_MSC_VER)
+    constexpr std::string_view prefix{"get_type_name<"};
+    constexpr std::string_view suffix{">(void)"};
+    constexpr std::string_view function{__FUNCSIG__};
+#else
+    std::string type_name{typeid(T).name()};
+    type_name += " ";
+    std::string_view function{type_name};
+    constexpr std::string_view prefix{""};
+    constexpr std::string_view suffix{" "};
+#endif
+
+    const std::size_t start{function.find(prefix) + prefix.size()};
+    const std::size_t end{function.find(suffix)};
+    const std::size_t size{end - start};
+
+    return std::string{function.substr(start, size)};
+}
+
+template <typename = void>
+struct print {};
+
+template <typename... Ts>
+struct print<type_list<Ts...>> {
+
+    template <typename P = void, typename... Ps>
+    void print_typeid() {
+
+        std::printf("%s", demangle_type_name<P>().c_str());
+
+        // Keep unrolling the pack
+        if constexpr (sizeof...(Ps) > 0) {
+            std::printf(", ");
+            return print_typeid<Ps...>();
+        }
+    }
+
+    print() {
+        std::printf("type_list<");
+        print_typeid<Ts...>();
+        std::printf(">\n");
+    }
+};
+/// @}
+
+}  // namespace detray::types
diff --git a/io/include/detray/io/common/detail/detector_components_io.hpp b/io/include/detray/io/common/detail/detector_components_io.hpp
index 16a7978b8..4d7caa079 100644
--- a/io/include/detray/io/common/detail/detector_components_io.hpp
+++ b/io/include/detray/io/common/detail/detector_components_io.hpp
@@ -41,12 +41,12 @@ class detector_component_writers final {
     detector_component_writers() = default;
 
     /// Create a new writer of type @tparam writer_t
-    template <template <typename> class writer_t,
+    template <template <typename...> class writer_t, typename... Args,
               std::enable_if_t<std::is_base_of_v<writer_interface<detector_t>,
-                                                 writer_t<detector_t>>,
+                                                 writer_t<detector_t, Args...>>,
                                bool> = true>
     void add() {
-        add(std::make_unique<writer_t<detector_t>>());
+        add(std::make_unique<writer_t<detector_t, Args...>>());
     }
 
     /// Attach an existing writer via @param w_ptr to the writers
@@ -92,12 +92,12 @@ class detector_component_readers final {
     detector_component_readers() = default;
 
     /// Create a new reader of type @tparam reader_t
-    template <template <typename> class reader_t,
+    template <template <typename...> class reader_t, typename... Args,
               std::enable_if_t<std::is_base_of_v<reader_interface<detector_t>,
-                                                 reader_t<detector_t>>,
+                                                 reader_t<detector_t, Args...>>,
                                bool> = true>
     void add(const std::string& file_name) {
-        add(std::make_unique<reader_t<detector_t>>(), file_name);
+        add(std::make_unique<reader_t<detector_t, Args...>>(), file_name);
     }
 
     /// Attach an existing reader via @param w_ptr to the readers
diff --git a/io/include/detray/io/common/detector_reader.hpp b/io/include/detray/io/common/detector_reader.hpp
index b2cb7273a..a7cd4ff46 100644
--- a/io/include/detray/io/common/detector_reader.hpp
+++ b/io/include/detray/io/common/detector_reader.hpp
@@ -78,7 +78,7 @@ namespace detail {
 
 /// From the list of file that are given as part of the config @param cfg,
 /// infer the readers that are needed by peeking into the file header
-template <class detector_t>
+template <class detector_t, std::size_t CAP, std::size_t DIM>
 auto assemble_reader(const io::detector_reader_config& cfg) {
 
     detail::detector_component_readers<detector_t> readers;
@@ -99,6 +99,12 @@ auto assemble_reader(const io::detector_reader_config& cfg) {
             } else if (header.tag == "homogeneous_material") {
                 readers.template add<json_homogeneous_material_reader>(
                     file_name);
+            } else if (header.tag == "surface_grids") {
+                using surface_t = typename detector_t::surface_type;
+                readers.template add<json_grid_reader, surface_t,
+                                     std::integral_constant<std::size_t, CAP>,
+                                     std::integral_constant<std::size_t, DIM>>(
+                    file_name);
             } else {
                 throw std::invalid_argument("Unsupported file tag '" +
                                             header.tag +
@@ -134,7 +140,7 @@ namespace io {
 /// @param cfg the detector reader configuration
 ///
 /// @returns a complete detector object + a map that contains the volume names
-template <class detector_t,
+template <class detector_t, std::size_t CAP = 9u, std::size_t DIM = 2u,
           template <typename> class volume_builder_t = volume_builder>
 auto read_detector(vecmem::memory_resource& resc,
                    const detector_reader_config& cfg) {
@@ -149,7 +155,8 @@ auto read_detector(vecmem::memory_resource& resc,
         det_builder;
 
     // Find all required readers
-    auto [reader, det_name] = detray::detail::assemble_reader<detector_t>(cfg);
+    auto [reader, det_name] =
+        detray::detail::assemble_reader<detector_t, CAP, DIM>(cfg);
 
     // Add a constant b-field (no bfield reader is added in this case)
     if constexpr (std::is_same_v<bfield_bknd_t, bfield::const_bknd_t>) {
diff --git a/io/include/detray/io/common/geometry_reader.hpp b/io/include/detray/io/common/geometry_reader.hpp
index e70daea21..f42b080d5 100644
--- a/io/include/detray/io/common/geometry_reader.hpp
+++ b/io/include/detray/io/common/geometry_reader.hpp
@@ -76,8 +76,6 @@ class geometry_reader : public reader_interface<detector_t> {
         typename detector_t::name_map& name_map,
         const detector_payload& det_data) {
 
-        // @todo Add volume grid
-
         // Deserialize the volumes one-by-one
         for (const auto& vol_data : det_data.volumes) {
             // Get a generic volume builder first and decorate it later
@@ -87,8 +85,8 @@ class geometry_reader : public reader_interface<detector_t> {
             // Set the volume name
             name_map[vbuilder->vol_index() + 1u] = vol_data.name;
 
-            // @todo add the volume placement, once it can be checked for the
-            // test detectors
+            // Volume placement
+            vbuilder->add_volume_placement(deserialize(vol_data.transform));
 
             // Prepare the surface factories (one per shape and surface type)
             std::map<std::pair<surface_id, mask_shape>, sf_factory_ptr_t>
@@ -172,10 +170,14 @@ class geometry_reader : public reader_interface<detector_t> {
                   sf_data.mask.boundaries.end(),
                   std::back_inserter(mask_boundaries));
 
+        const std::size_t sf_idx{sf_data.index_in_coll.has_value()
+                                     ? *(sf_data.index_in_coll)
+                                     : detail::invalid_value<std::size_t>()};
+
         return {deserialize(sf_data.transform),
                 static_cast<nav_link_t>(
                     base_type::deserialize(sf_data.mask.volume_link)),
-                std::move(mask_boundaries)};
+                std::move(mask_boundaries), static_cast<dindex>(sf_idx)};
     }
 
     private:
@@ -214,7 +216,7 @@ class geometry_reader : public reader_interface<detector_t> {
                                             surface_id::e_passive>;
                         return std::make_shared<ps_factory_t>();
                     case surface_id::e_unknown:
-                        throw std::runtime_error(
+                        throw std::invalid_argument(
                             "Unknown surface type in geometry file");
                 };
             }
@@ -227,10 +229,11 @@ class geometry_reader : public reader_interface<detector_t> {
         }
         // Test some edge cases
         if (shape_id == mask_shape::unknown) {
-            throw std::runtime_error("Unknown mask shape in geometry file!");
+            throw std::invalid_argument(
+                "Unknown mask shape id in geometry file!");
         } else {
-            throw std::runtime_error(
-                "Given mask type could not be matched: " +
+            throw std::invalid_argument(
+                "Given shape id could not be matched to a mask type: " +
                 std::to_string(static_cast<std::int64_t>(shape_id)));
 
             // Cannot be reached
diff --git a/io/include/detray/io/common/geometry_writer.hpp b/io/include/detray/io/common/geometry_writer.hpp
index ccd9c1ba7..bfe44fb99 100644
--- a/io/include/detray/io/common/geometry_writer.hpp
+++ b/io/include/detray/io/common/geometry_writer.hpp
@@ -109,9 +109,11 @@ class geometry_writer : public writer_interface<detector_t> {
     }
 
     /// Serialize a detector surface @param sf into its io payload
-    static surface_payload serialize(const surface<detector_t>& sf) {
+    static surface_payload serialize(const surface<detector_t>& sf,
+                                     std::size_t sf_idx) {
         surface_payload sf_data;
 
+        sf_data.index_in_coll = sf_idx;
         sf_data.type = sf.id();
         sf_data.barcode = sf.barcode().value();
         sf_data.transform = serialize(sf.transform({}));
@@ -134,9 +136,13 @@ class geometry_writer : public writer_interface<detector_t> {
             serialize(det.transform_store()[vol_desc.transform()]);
         vol_data.type = vol_desc.id();
 
+        // Count the surfaces belonging to this volume
+        std::size_t sf_idx{0};
+
         for (const auto& sf_desc : det.surface_lookup()) {
             if (sf_desc.volume() == vol_desc.index()) {
-                vol_data.surfaces.push_back(serialize(surface{det, sf_desc}));
+                vol_data.surfaces.push_back(
+                    serialize(surface{det, sf_desc}, sf_idx++));
             }
         }
 
diff --git a/io/include/detray/io/common/grid_reader.hpp b/io/include/detray/io/common/grid_reader.hpp
new file mode 100644
index 000000000..5b819f9be
--- /dev/null
+++ b/io/include/detray/io/common/grid_reader.hpp
@@ -0,0 +1,356 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 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/io/common/detail/type_traits.hpp"
+#include "detray/io/common/io_interface.hpp"
+#include "detray/io/common/payloads.hpp"
+#include "detray/tools/detector_builder.hpp"
+#include "detray/tools/grid_builder.hpp"
+#include "detray/tools/grid_factory.hpp"
+#include "detray/utils/ranges.hpp"
+#include "detray/utils/type_list.hpp"
+
+// System include(s)
+#include <queue>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+namespace detray {
+
+/// @brief Abstract base class for surface grid readers
+template <class detector_t,
+          typename value_t = typename detector_t::surface_type,
+          typename CAP = std::integral_constant<std::size_t, 9>,
+          typename DIM = std::integral_constant<std::size_t, 2>>
+class grid_reader : public reader_interface<detector_t> {
+
+    using base_type = reader_interface<detector_t>;
+    /// IO accelerator ids do not need to coincide with the detector ids,
+    /// because they are shared with ACTS
+    using acc_type = io::detail::acc_type;
+    using algebra_t = typename detector_t::transform3;
+    using scalar_t = typename algebra_t::scalar_type;
+
+    // Bin content type to be written into the grid bin payloads
+    // For detector surface descriptors, write only the surface index
+    using content_t = std::conditional_t<
+        std::is_same_v<value_t, typename detector_t::surface_type>, std::size_t,
+        value_t>;
+
+    static constexpr std::size_t Dim{DIM()};
+    static constexpr std::size_t bin_capacity{CAP()};
+
+    protected:
+    /// Tag the reader as "surface_grids"
+    inline static const std::string tag = "surface_grids";
+
+    public:
+    /// Same constructors for this class as for base_type
+    using base_type::base_type;
+
+    protected:
+    /// Deserialize the detector grids @param grids_data from their IO
+    /// payload
+    static void deserialize(
+        detector_builder<typename detector_t::metadata,
+                         typename detector_t::bfield_type::backend_t,
+                         volume_builder> &det_builder,
+        typename detector_t::name_map &,
+        const detector_grids_payload<content_t> &grids_data) {
+
+        // Deserialize the grids volume by volume
+        for (const auto &grid_data : grids_data.grids) {
+
+            std::queue<n_axis::bounds> bounds;
+            std::queue<n_axis::binning> binnings;
+            for (const auto &axis_data : grid_data.axes) {
+                bounds.push(axis_data.bounds);
+                binnings.push(axis_data.binning);
+            }
+            deserialize(bounds, binnings, grid_data, det_builder);
+        }
+    }
+
+    private:
+    /// @brief recursively build the grid: axis bounds (open, closed, circular)
+    ///
+    /// @tparam bounds_ts type list that contains the bounds types that were
+    ///         identified from the IO ids so far (start with empty list)
+    /// @tparam binning_ts type list that contains the binning types that were
+    ///         identified from the IO ids so far (start with empty list)
+    ///
+    /// @param bound_ids runtime queue of bounds type ids (read from file)
+    /// @param binning_ids runtime queue of binning type ids (read from file)
+    template <typename bounds_ts = types::type_list<>,
+              typename binning_ts = types::type_list<>, typename... Ts>
+    static void deserialize(std::queue<n_axis::bounds> &bound_ids,
+                            std::queue<n_axis::binning> &binning_ids,
+                            Ts &&... data) {
+        using namespace n_axis;
+
+        constexpr std::size_t n_bounds_types{types::size<bounds_ts>};
+
+        // Base case: If the bounds types are filled, continue with the binnings
+        if constexpr (n_bounds_types == Dim) {
+            return deserialize<bounds_ts, binning_ts>(
+                binning_ids, std::forward<Ts>(data)...);
+        } else if (!bound_ids.empty()) {
+            // The axis label, e.g. x, y or z by number
+            constexpr auto lb{static_cast<label>(n_bounds_types)};
+
+            const auto first_id{bound_ids.front()};
+            bound_ids.pop();
+
+            // Based on the type id, add the next bounds type to the type list
+            // and continue
+            switch (first_id) {
+                case bounds::e_closed: {
+                    using new_bounds_ts =
+                        types::push_back<bounds_ts, closed<lb>>;
+                    return deserialize<new_bounds_ts, binning_ts>(
+                        bound_ids, binning_ids, std::forward<Ts>(data)...);
+                }
+                case bounds::e_open: {
+                    using new_bounds_ts = types::push_back<bounds_ts, open<lb>>;
+                    return deserialize<new_bounds_ts, binning_ts>(
+                        bound_ids, binning_ids, std::forward<Ts>(data)...);
+                }
+                case bounds::e_circular: {
+                    using new_bounds_ts =
+                        types::push_back<bounds_ts, circular<lb>>;
+                    return deserialize<new_bounds_ts, binning_ts>(
+                        bound_ids, binning_ids, std::forward<Ts>(data)...);
+                }
+                // Test some edge cases
+                default: {
+                    throw std::invalid_argument(
+                        "Given type id could not be matched to a grid boundary "
+                        "type: " +
+                        std::to_string(static_cast<std::int64_t>(first_id)));
+                    break;
+                }
+            };
+        }
+    }
+
+    /// @brief recursively build the grid: axis binning (regular, irregular)
+    ///
+    /// @tparam bounds_ts type list that contains the bounds types
+    /// @tparam binning_ts type list that contains the binning types that were
+    ///         identified from the IO ids so far (start with empty list)
+    ///
+    /// @param binning_ids runtime queue of binning type ids (read from file)
+    template <typename bounds_ts, typename binning_ts, typename... Ts,
+              std::enable_if_t<types::size<bounds_ts> == Dim, bool> = true>
+    static void deserialize(std::queue<n_axis::binning> &binning_ids,
+                            Ts &&... data) {
+
+        using namespace n_axis;
+
+        using regular_binning_t = regular<host_container_types, scalar_t>;
+        using irregular_binning_t = irregular<host_container_types, scalar_t>;
+
+        // Base case: If the binning types are filled, continue with the frame
+        if constexpr (types::size<binning_ts> == Dim) {
+            return deserialize<bounds_ts, binning_ts>(
+                std::forward<Ts>(data)...);
+        } else if (!binning_ids.empty()) {
+
+            const auto first_id{binning_ids.front()};
+            binning_ids.pop();
+
+            switch (first_id) {
+                case binning::e_regular: {
+                    using new_binning_ts =
+                        types::push_back<binning_ts, regular_binning_t>;
+                    return deserialize<bounds_ts, new_binning_ts>(
+                        binning_ids, std::forward<Ts>(data)...);
+                }
+                case binning::e_irregular: {
+                    using new_binning_ts =
+                        types::push_back<binning_ts, irregular_binning_t>;
+                    return deserialize<bounds_ts, new_binning_ts>(
+                        binning_ids, std::forward<Ts>(data)...);
+                }
+                // Test some edge cases
+                default: {
+                    throw std::invalid_argument(
+                        "Given type id could not be matched to a grid binning "
+                        "type: " +
+                        std::to_string(static_cast<std::int64_t>(first_id)));
+                    break;
+                }
+            };
+        }
+    }
+
+    /// @brief recursively build the grid: find the grid geometry (loc. coord.)
+    ///
+    /// @tparam bounds_ts type list that contains the bounds types
+    /// @tparam binning_ts type list that contains the binning types
+    ///
+    /// @param grid_data grid IO payload (read from file)
+    /// @param det_builder gather the grid data and build the final volume
+    template <typename bounds_ts, typename binning_ts,
+              std::enable_if_t<types::size<bounds_ts> == Dim and
+                                   types::size<binning_ts> == Dim,
+                               bool> = true>
+    static void deserialize(
+        const grid_payload<content_t> &grid_data,
+        detector_builder<typename detector_t::metadata,
+                         typename detector_t::bfield_type::backend_t,
+                         volume_builder> &det_builder) {
+
+        // Throw expection if the accelerator link type id is invalid
+        auto print_error = [](io::detail::acc_type acc_link) -> void {
+            if (acc_link == io::detail::acc_type::unknown) {
+                throw std::invalid_argument(
+                    "Unknown accelerator id in geometry file!");
+            } else {
+                throw std::invalid_argument(
+                    "Given accelerator id could not be matched to a grid "
+                    "type: " +
+                    std::to_string(static_cast<std::int64_t>(acc_link)));
+            }
+        };
+
+        // Need to pass actual instances to deduce contained types as
+        // template parameter packs
+        constexpr auto bounds = bounds_ts{};
+        constexpr auto binnings = binning_ts{};
+
+        // Check only 2-dimensional grid types
+        if constexpr (Dim >= 2) {
+            switch (grid_data.acc_link.type) {
+                // rectangle, trapezoid, (triangle) grids
+                case io::detail::acc_type::cartesian2_grid: {
+                    return deserialize<cartesian2<algebra_t>>(
+                        grid_data, det_builder, bounds, binnings);
+                }
+                // ring/disc, annulus grids
+                case io::detail::acc_type::polar2_grid: {
+                    return deserialize<polar2<algebra_t>>(
+                        grid_data, det_builder, bounds, binnings);
+                }
+                // 2D cylinder grid
+                case io::detail::acc_type::cylinder2_grid: {
+                    return deserialize<cylindrical2<algebra_t>>(
+                        grid_data, det_builder, bounds, binnings);
+                }
+                default: {
+                    print_error(grid_data.acc_link.type);
+                    break;
+                }
+            };
+        } else if constexpr (Dim >= 3) {
+            switch (grid_data.acc_link.type) {
+                // cuboid grid
+                case io::detail::acc_type::cuboid3_grid: {
+                    return deserialize<cartesian3<algebra_t>>(
+                        grid_data, det_builder, bounds, binnings);
+                }
+                // 3D cylinder grid
+                case io::detail::acc_type::cylinder3_grid: {
+                    return deserialize<cylindrical3<algebra_t>>(
+                        grid_data, det_builder, bounds, binnings);
+                }
+                default: {
+                    print_error(grid_data.acc_link.type);
+                    break;
+                }
+            };
+        } else {
+            throw std::invalid_argument("No 1D grid type defined in detray");
+        }
+    }
+
+    /// @brief End of recursion: build the grid from the @param grid_data
+    template <typename local_frame_t, typename... bounds_ts,
+              typename... binning_ts,
+              std::enable_if_t<sizeof...(bounds_ts) == Dim and
+                                   sizeof...(binning_ts) == Dim,
+                               bool> = true>
+    static void deserialize(
+        const grid_payload<content_t> &grid_data,
+        detector_builder<typename detector_t::metadata,
+                         typename detector_t::bfield_type::backend_t,
+                         volume_builder> &det_builder,
+        types::type_list<bounds_ts...>, types::type_list<binning_ts...>) {
+        // Assemble the grid type
+        using populator_t = regular_attacher<bin_capacity>;
+        using axes_t =
+            n_axis::multi_axis<false, local_frame_t,
+                               n_axis::single_axis<bounds_ts, binning_ts>...>;
+        // Ok for now: Only have this serializer
+        using grid_t = grid<axes_t, value_t, simple_serializer, populator_t>;
+
+        static_assert(grid_t::Dim == Dim,
+                      "Grid dimension does not meet dimension of grid reader");
+
+        // The compiler will instantiate this function for all possible types of
+        // grids: Only proceed, if the grid type is known by the detector
+        if constexpr (detector_t::sf_finders::template is_defined<grid_t>()) {
+
+            // Decorate the current volume builder with the grid
+            using grid_builder_t =
+                grid_builder<detector_t, grid_t, detail::fill_by_pos>;
+
+            const auto volume_idx{
+                base_type::deserialize(grid_data.volume_link)};
+            auto v_builder =
+                det_builder.template decorate<grid_builder_t>(volume_idx);
+            auto vgr_builder = dynamic_cast<grid_builder_t *>(v_builder);
+
+            // Initialize the grid axes
+            std::vector<std::size_t> n_bins{};
+            std::vector<scalar_t> spans{};
+            std::vector<std::vector<scalar_t>> ax_bin_edges{};
+
+            for (const auto &axis_data : grid_data.axes) {
+                n_bins.push_back(axis_data.bins);
+                std::vector<scalar_t> edges{};
+                std::copy(axis_data.edges.begin(), axis_data.edges.end(),
+                          std::back_inserter(edges));
+                ax_bin_edges.emplace_back(std::move(edges));
+                spans.push_back(static_cast<scalar_t>(axis_data.edges.front()));
+                spans.push_back(static_cast<scalar_t>(axis_data.edges.back()));
+            }
+
+            vgr_builder->init_grid(spans, n_bins, ax_bin_edges);
+
+            value_t empty_sf{};
+            n_axis::multi_bin<Dim> mbin;
+            for (const auto &bin_data : grid_data.bins) {
+
+                assert(Dim == bin_data.loc_index.size() &&
+                       "Numer of local bin indices in input file does not "
+                       "match grid dimension");
+
+                // The local bin indices for the bin to be filled
+                for (const auto &[i, bin_idx] :
+                     detray::views::enumerate(bin_data.loc_index)) {
+                    mbin[i] = bin_idx;
+                }
+
+                // For now assume surfaces ids as the only grid input
+                for (const auto c : bin_data.content) {
+                    empty_sf.set_volume(volume_idx);
+                    empty_sf.set_index(static_cast<dindex>(c));
+                    vgr_builder->get().populate(mbin, empty_sf);
+                }
+            }
+        }
+    }
+};
+
+}  // namespace detray
diff --git a/io/include/detray/io/common/grid_writer.hpp b/io/include/detray/io/common/grid_writer.hpp
index 46d5fc02e..33adf559a 100644
--- a/io/include/detray/io/common/grid_writer.hpp
+++ b/io/include/detray/io/common/grid_writer.hpp
@@ -26,14 +26,21 @@
 namespace detray {
 
 /// @brief Abstract base class for accelerator grid writers
-template <class detector_t>
+template <class detector_t,
+          typename value_t = typename detector_t::surface_type>
 class grid_writer : public writer_interface<detector_t> {
 
     using base_type = writer_interface<detector_t>;
 
+    // Bin content type to be written into the grid bin payloads
+    // For detector surface descriptors, write only the surface index
+    using content_t = std::conditional_t<
+        std::is_same_v<value_t, typename detector_t::surface_type>, std::size_t,
+        value_t>;
+
     protected:
-    /// Tag the writer as "grids"
-    inline static const std::string tag = "grids";
+    /// Tag the writer as "surface_grids"
+    inline static const std::string tag = "surface_grids";
 
     public:
     /// Same constructors for this class as for base_type
@@ -43,6 +50,7 @@ class grid_writer : public writer_interface<detector_t> {
     /// Serialize the header information into its payload
     static grid_header_payload write_header(const detector_t& det,
                                             const std::string_view det_name) {
+
         grid_header_payload header_data;
 
         header_data.common = base_type::serialize(det_name, tag);
@@ -56,10 +64,14 @@ class grid_writer : public writer_interface<detector_t> {
 
     /// Serialize the grid collections of a detector @param det into their io
     /// payload
-    static detector_grids_payload serialize(
+    template <
+        typename V = value_t,
+        std::enable_if_t<std::is_same_v<V, typename detector_t::surface_type>,
+                         bool> = true>
+    static detector_grids_payload<std::size_t> serialize(
         const detector_t& det, const typename detector_t::name_map&) {
 
-        detector_grids_payload grids_data;
+        detector_grids_payload<std::size_t> grids_data;
 
         for (const auto& vol_desc : det.volumes()) {
             // Links to all acceleration data structures in the volume
@@ -84,10 +96,12 @@ class grid_writer : public writer_interface<detector_t> {
     /// Serialize a grid @param gr of type @param type and index @param idx
     /// into its io payload
     template <class grid_t>
-    static grid_payload serialize(std::size_t volume_index,
-                                  io::detail::acc_type type,
-                                  const std::size_t idx, const grid_t& gr) {
-        grid_payload grid_data;
+    static grid_payload<content_t> serialize(std::size_t volume_index,
+                                             io::detail::acc_type type,
+                                             const std::size_t idx,
+                                             const grid_t& gr) {
+
+        grid_payload<content_t> grid_data;
 
         grid_data.volume_link = base_type::serialize(volume_index);
         grid_data.acc_link = base_type::serialize(type, idx);
@@ -147,9 +161,10 @@ class grid_writer : public writer_interface<detector_t> {
 
     /// Serialize a multi-bin @param mbin into its io payload
     template <std::size_t DIM, typename content_range_t>
-    static grid_bin_payload serialize(const n_axis::multi_bin<DIM> mbin,
-                                      const content_range_t& content) {
-        grid_bin_payload bin_data;
+    static grid_bin_payload<content_t> serialize(
+        const n_axis::multi_bin<DIM> mbin, const content_range_t& content) {
+
+        grid_bin_payload<content_t> bin_data;
 
         // Local bin indices are written in the order the grid axis are stored
         for (unsigned int i = 0u; i < DIM; ++i) {
@@ -174,7 +189,9 @@ class grid_writer : public writer_interface<detector_t> {
             [[maybe_unused]] const grid_group_t& coll,
             [[maybe_unused]] const index_t& index,
             [[maybe_unused]] std::size_t volume_index,
-            [[maybe_unused]] detector_grids_payload& grids_data) const {
+            [[maybe_unused]] detector_grids_payload<content_t>& grids_data)
+            const {
+
             using accel_t = typename grid_group_t::value_type;
 
             if constexpr (detail::is_grid_v<accel_t>) {
diff --git a/io/include/detray/io/common/homogeneous_material_reader.hpp b/io/include/detray/io/common/homogeneous_material_reader.hpp
index 3a9c8c34c..5e7d8fd81 100644
--- a/io/include/detray/io/common/homogeneous_material_reader.hpp
+++ b/io/include/detray/io/common/homogeneous_material_reader.hpp
@@ -57,8 +57,9 @@ class homogeneous_material_reader : public reader_interface<detector_t> {
         // Deserialize the material volume by volume
         for (const auto& mv_data : det_mat_data.volumes) {
             // Decorate the current volume builder with material
-            auto vm_builder = det_builder.template decorate<material_builder>(
-                base_type::deserialize(mv_data.volume_link));
+            auto vm_builder =
+                det_builder.template decorate<material_builder<detector_t>>(
+                    base_type::deserialize(mv_data.volume_link));
 
             // Add the material data to the factory
             auto mat_factory = std::make_shared<material_factory<detector_t>>();
diff --git a/io/include/detray/io/common/payloads.hpp b/io/include/detray/io/common/payloads.hpp
index 78ac52529..808bffe9d 100644
--- a/io/include/detray/io/common/payloads.hpp
+++ b/io/include/detray/io/common/payloads.hpp
@@ -85,6 +85,7 @@ struct mask_payload {
 
 /// @brief  A payload for surfaces
 struct surface_payload {
+    std::optional<std::size_t> index_in_coll;
     transform_payload transform{};
     mask_payload mask{};
     std::optional<material_link_payload> material;
@@ -171,12 +172,14 @@ struct axis_payload {
 };
 
 /// @brief A payload for a grid bin
+template <typename content_t = std::size_t>
 struct grid_bin_payload {
     std::vector<unsigned int> loc_index{};
-    std::vector<std::size_t> content{};
+    std::vector<content_t> content{};
 };
 
 /// @brief A payload for a grid definition
+template <typename bin_content_t = std::size_t>
 struct grid_payload {
     using grid_type = io::detail::acc_type;
 
@@ -184,13 +187,14 @@ struct grid_payload {
     acc_links_payload acc_link{};
 
     std::vector<axis_payload> axes{};
-    std::vector<grid_bin_payload> bins{};
+    std::vector<grid_bin_payload<bin_content_t>> bins{};
     std::optional<transform_payload> transform;
 };
 
 /// @brief A payload for the grid collections of a detector
+template <typename bin_content_t = std::size_t>
 struct detector_grids_payload {
-    std::vector<grid_payload> grids = {};
+    std::vector<grid_payload<bin_content_t>> grids = {};
 };
 
 /// @}
@@ -198,7 +202,7 @@ struct detector_grids_payload {
 /// @brief A payload for a detector geometry
 struct detector_payload {
     std::vector<volume_payload> volumes = {};
-    grid_payload volume_grid;
+    grid_payload<std::size_t> volume_grid;
 };
 
 }  // namespace detray
diff --git a/io/include/detray/io/json/json_geometry_io.hpp b/io/include/detray/io/json/json_geometry_io.hpp
index 791dbec63..db11faaf4 100644
--- a/io/include/detray/io/json/json_geometry_io.hpp
+++ b/io/include/detray/io/json/json_geometry_io.hpp
@@ -67,6 +67,9 @@ inline void to_json(nlohmann::ordered_json& j, const surface_payload& s) {
     if (s.material.has_value()) {
         j["material"] = s.material.value();
     }
+    if (s.index_in_coll.has_value()) {
+        j["index_in_coll"] = s.index_in_coll.value();
+    }
 }
 
 inline void from_json(const nlohmann::ordered_json& j, surface_payload& s) {
@@ -78,6 +81,9 @@ inline void from_json(const nlohmann::ordered_json& j, surface_payload& s) {
     if (j.find("material") != j.end()) {
         s.material = j["material"];
     }
+    if (j.find("index_in_coll") != j.end()) {
+        s.index_in_coll = j["index_in_coll"];
+    }
 }
 
 inline void to_json(nlohmann::ordered_json& j, const volume_payload& v) {
diff --git a/io/include/detray/io/json/json_grids_io.hpp b/io/include/detray/io/json/json_grids_io.hpp
index 9ac533de0..a38e844c2 100644
--- a/io/include/detray/io/json/json_grids_io.hpp
+++ b/io/include/detray/io/json/json_grids_io.hpp
@@ -56,17 +56,23 @@ inline void from_json(const nlohmann::ordered_json& j, axis_payload& a) {
     a.edges = j["edges"].get<std::vector<real_io>>();
 }
 
-inline void to_json(nlohmann::ordered_json& j, const grid_bin_payload& g) {
+template <typename content_t>
+inline void to_json(nlohmann::ordered_json& j,
+                    const grid_bin_payload<content_t>& g) {
     j["loc_index"] = g.loc_index;
     j["content"] = g.content;
 }
 
-inline void from_json(const nlohmann::ordered_json& j, grid_bin_payload& g) {
+template <typename content_t>
+inline void from_json(const nlohmann::ordered_json& j,
+                      grid_bin_payload<content_t>& g) {
     g.loc_index = j["loc_index"].get<std::vector<unsigned int>>();
-    g.content = j["content"].get<std::vector<std::size_t>>();
+    g.content = j["content"].get<std::vector<content_t>>();
 }
 
-inline void to_json(nlohmann::ordered_json& j, const grid_payload& g) {
+template <typename content_t>
+inline void to_json(nlohmann::ordered_json& j,
+                    const grid_payload<content_t>& g) {
     j["volume_link"] = g.volume_link;
     j["acc_link"] = g.acc_link;
 
@@ -87,7 +93,9 @@ inline void to_json(nlohmann::ordered_json& j, const grid_payload& g) {
     }
 }
 
-inline void from_json(const nlohmann::ordered_json& j, grid_payload& g) {
+template <typename content_t>
+inline void from_json(const nlohmann::ordered_json& j,
+                      grid_payload<content_t>& g) {
     g.volume_link = j["volume_link"];
     g.acc_link = j["acc_link"];
 
@@ -99,7 +107,7 @@ inline void from_json(const nlohmann::ordered_json& j, grid_payload& g) {
 
     nlohmann::ordered_json jbins = j["bins"];
     for (auto jbin : jbins) {
-        grid_bin_payload b = jbin;
+        grid_bin_payload<content_t> b = jbin;
         g.bins.push_back(std::move(b));
     }
 
@@ -109,8 +117,9 @@ inline void from_json(const nlohmann::ordered_json& j, grid_payload& g) {
     }
 }
 
+template <typename content_t>
 inline void to_json(nlohmann::ordered_json& j,
-                    const detector_grids_payload& d) {
+                    const detector_grids_payload<content_t>& d) {
     if (not d.grids.empty()) {
         nlohmann::ordered_json jgrids;
         for (const auto& gr : d.grids) {
@@ -120,11 +129,12 @@ inline void to_json(nlohmann::ordered_json& j,
     }
 }
 
+template <typename content_t>
 inline void from_json(const nlohmann::ordered_json& j,
-                      detector_grids_payload& d) {
+                      detector_grids_payload<content_t>& d) {
     if (j.find("grids") != j.end()) {
         for (auto jgrid : j["grids"]) {
-            grid_payload grp = jgrid;
+            grid_payload<content_t> grp = jgrid;
             d.grids.push_back(std::move(grp));
         }
     }
diff --git a/io/include/detray/io/json/json_reader.hpp b/io/include/detray/io/json/json_reader.hpp
index 832c4864a..55b548b85 100644
--- a/io/include/detray/io/json/json_reader.hpp
+++ b/io/include/detray/io/json/json_reader.hpp
@@ -11,6 +11,7 @@
 #include "detray/io/common/detail/file_handle.hpp"
 #include "detray/io/common/detail/utils.hpp"
 #include "detray/io/common/geometry_reader.hpp"
+#include "detray/io/common/grid_reader.hpp"
 #include "detray/io/common/homogeneous_material_reader.hpp"
 #include "detray/io/json/json.hpp"
 #include "detray/io/json/json_serializers.hpp"
@@ -56,10 +57,11 @@ inline common_header_payload read_json_header(const std::string& file_name) {
 ///
 /// @note The resulting reader types will fulfill @c reader_interface through
 /// the common readers they are being extended with
-template <class detector_t, template <class> class common_reader_t>
-class json_reader final : public common_reader_t<detector_t> {
+template <class detector_t, template <typename...> class common_reader_t,
+          typename... Args>
+class json_reader final : public common_reader_t<detector_t, Args...> {
 
-    using base_reader = common_reader_t<detector_t>;
+    using base_reader = common_reader_t<detector_t, Args...>;
 
     public:
     /// Set json file extension
@@ -93,4 +95,12 @@ template <typename detector_t>
 using json_homogeneous_material_reader =
     json_reader<detector_t, homogeneous_material_reader>;
 
+/// Reads a homogeneous material descritption from file in json format
+template <typename detector_t,
+          typename value_t = typename detector_t::surface_type,
+          typename CAP = std::integral_constant<std::size_t, 2>,
+          typename DIM = std::integral_constant<std::size_t, 2>>
+using json_grid_reader =
+    json_reader<detector_t, grid_reader, value_t, CAP, DIM>;
+
 }  // namespace detray
diff --git a/io/include/detray/io/json/json_writer.hpp b/io/include/detray/io/json/json_writer.hpp
index e1dd56e86..5345d307f 100644
--- a/io/include/detray/io/json/json_writer.hpp
+++ b/io/include/detray/io/json/json_writer.hpp
@@ -32,10 +32,11 @@ namespace detray {
 ///
 /// @note The resulting writer types will fulfill @c writer_interface through
 /// the common writers they are being extended with
-template <class detector_t, template <class> class common_writer_t>
-class json_writer final : public common_writer_t<detector_t> {
+template <class detector_t, template <typename...> class common_writer_t,
+          typename... Args>
+class json_writer final : public common_writer_t<detector_t, Args...> {
 
-    using base_writer = common_writer_t<detector_t>;
+    using base_writer = common_writer_t<detector_t, Args...>;
 
     public:
     /// File gets created with the json file extension
@@ -88,7 +89,8 @@ using json_homogeneous_material_writer =
     json_writer<detector_t, homogeneous_material_writer>;
 
 /// Write the detector grid collections to file in json format
-template <typename detector_t>
-using json_grid_writer = json_writer<detector_t, grid_writer>;
+template <typename detector_t,
+          typename value_t = typename detector_t::surface_type>
+using json_grid_writer = json_writer<detector_t, grid_writer, value_t>;
 
 }  // namespace detray
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/conversion/surface.hpp b/plugins/svgtools/include/detray/plugins/svgtools/conversion/surface.hpp
index 29686030a..bd7e52e7a 100644
--- a/plugins/svgtools/include/detray/plugins/svgtools/conversion/surface.hpp
+++ b/plugins/svgtools/include/detray/plugins/svgtools/conversion/surface.hpp
@@ -17,7 +17,6 @@
 
 // System include(s)
 #include <algorithm>
-#include <iostream>
 #include <iterator>
 
 namespace detray::svgtools::conversion {
@@ -193,4 +192,4 @@ auto surface(const typename detector_t::geometry_context& context,
         d_surface.transform(context));
 }
 
-}  // namespace detray::svgtools::conversion
\ No newline at end of file
+}  // namespace detray::svgtools::conversion
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/utils/mask_utils.hpp b/plugins/svgtools/include/detray/plugins/svgtools/utils/mask_utils.hpp
index 489ed7602..b6c9b47df 100644
--- a/plugins/svgtools/include/detray/plugins/svgtools/utils/mask_utils.hpp
+++ b/plugins/svgtools/include/detray/plugins/svgtools/utils/mask_utils.hpp
@@ -13,7 +13,6 @@
 
 // System include(s)
 #include <cmath>
-#include <iostream>
 
 namespace detray::svgtools::utils {
 
@@ -41,4 +40,4 @@ inline auto global_vertices(const transform_t& transform, const mask_t& mask) {
     return ret;
 }
 
-}  // namespace detray::svgtools::utils
\ No newline at end of file
+}  // namespace detray::svgtools::utils
diff --git a/tests/common/include/tests/common/test_toy_detector.hpp b/tests/common/include/tests/common/test_toy_detector.hpp
index 75e90905f..790d7b643 100644
--- a/tests/common/include/tests/common/test_toy_detector.hpp
+++ b/tests/common/include/tests/common/test_toy_detector.hpp
@@ -37,7 +37,8 @@ inline void test_finder(const acc_t& finder, const dindex volume_index,
 
     std::vector<dindex> indices;
 
-    // Check if right volume is linked to surface in grid
+    // Check if the correct volume is linked to surface in grid
+    // and record the surface indices
     for (const auto& sf : finder.all()) {
         EXPECT_EQ(sf.volume(), volume_index);
         indices.push_back(sf.index());
@@ -51,13 +52,12 @@ inline void test_finder(const acc_t& finder, const dindex volume_index,
     }
 }
 
+template <typename bfield_t>
 inline bool test_toy_detector(
-    const detector<toy_metadata, covfie::field<bfield::const_bknd_t>>& toy_det,
-    const detector<toy_metadata, covfie::field<bfield::const_bknd_t>>::name_map&
-        names) {
+    const detector<toy_metadata, bfield_t>& toy_det,
+    const typename detector<toy_metadata, bfield_t>::name_map& names) {
 
-    using detector_t =
-        detector<toy_metadata, covfie::field<bfield::const_bknd_t>>;
+    using detector_t = detector<toy_metadata, bfield_t>;
     using geo_obj_ids = typename detector_t::geo_obj_ids;
     using volume_t = typename detector_t::volume_type;
     using nav_link_t = typename detector_t::surface_type::navigation_link;
@@ -93,25 +93,27 @@ inline bool test_toy_detector(
     // Link to outer world (leaving detector)
     constexpr auto leaving_world{detail::invalid_value<nav_link_t>()};
     const bool has_grids =
-        (sf_finders.size<sf_finder_ids::e_cylinder2_grid>() != 0u) ||
-        (sf_finders.size<sf_finder_ids::e_disc_grid>() != 0u);
-    const bool has_material = (materials.size<material_ids::e_slab>() != 0);
+        (sf_finders.template size<sf_finder_ids::e_cylinder2_grid>() != 0u) ||
+        (sf_finders.template size<sf_finder_ids::e_disc_grid>() != 0u);
+    const bool has_material =
+        (materials.template size<material_ids::e_slab>() != 0);
 
     // Check number of geomtery objects
     EXPECT_EQ(volumes.size(), 20u);
     EXPECT_EQ(toy_det.n_surfaces(), 3244u);
     EXPECT_EQ(transforms.size(ctx), 3264u);
-    EXPECT_EQ(masks.size<mask_ids::e_rectangle2>(), 2492u);
-    EXPECT_EQ(masks.size<mask_ids::e_trapezoid2>(), 648u);
-    EXPECT_EQ(masks.size<mask_ids::e_portal_cylinder2>(), 52u);
-    EXPECT_EQ(masks.size<mask_ids::e_portal_ring2>(), 52u);
-    EXPECT_EQ(sf_finders.size<sf_finder_ids::e_brute_force>(), 20u);
+    EXPECT_EQ(masks.template size<mask_ids::e_rectangle2>(), 2492u);
+    EXPECT_EQ(masks.template size<mask_ids::e_trapezoid2>(), 648u);
+    EXPECT_EQ(masks.template size<mask_ids::e_portal_cylinder2>(), 52u);
+    EXPECT_EQ(masks.template size<mask_ids::e_portal_ring2>(), 52u);
+    EXPECT_EQ(sf_finders.template size<sf_finder_ids::e_brute_force>(), 20u);
     if (has_grids) {
-        EXPECT_EQ(sf_finders.size<sf_finder_ids::e_cylinder2_grid>(), 4);
-        EXPECT_EQ(sf_finders.size<sf_finder_ids::e_disc_grid>(), 6);
+        EXPECT_EQ(sf_finders.template size<sf_finder_ids::e_cylinder2_grid>(),
+                  4);
+        EXPECT_EQ(sf_finders.template size<sf_finder_ids::e_disc_grid>(), 6);
     }
     if (has_material) {
-        EXPECT_EQ(materials.size<material_ids::e_slab>(), 3244u);
+        EXPECT_EQ(materials.template size<material_ids::e_slab>(), 3244u);
     }
 
     /** Test the links of a volume.
@@ -164,7 +166,7 @@ inline bool test_toy_detector(
                 if (has_material) {
                     EXPECT_EQ(sf_itr->material(), material_index);
                     EXPECT_EQ(
-                        materials.get<
+                        materials.template get<
                             material_ids::e_slab>()[sf_itr->material().index()],
                         mat);
                 }
@@ -206,7 +208,7 @@ inline bool test_toy_detector(
                 if (has_material) {
                     EXPECT_EQ(sf_itr->material(), material_index);
                     EXPECT_EQ(
-                        materials.get<
+                        materials.template get<
                             material_ids::e_slab>()[sf_itr->material().index()],
                         mat);
                 }
@@ -223,7 +225,7 @@ inline bool test_toy_detector(
     /// @param vol_itr iterator over the volume descriptors
     /// @param sf_finder_store the detectors acceleration data structure store
     /// @param pt_range index range of the portals in the surface lookup
-    /// @param sf_range index range of the portals in the surface lookup
+    /// @param sf_range index range of the surfaces in the surface lookup
     auto test_sf_finders =
         [has_grids](
             decltype(volumes.begin())& vol_itr,
@@ -234,9 +236,8 @@ inline bool test_toy_detector(
             const auto& link = vol_itr->full_link();
 
             // Test the portal search
-            const auto& bf_finder =
-                sf_finder_store
-                    .get<sf_finder_ids::e_brute_force>()[link[0].index()];
+            const auto& bf_finder = sf_finder_store.template get<
+                sf_finder_ids::e_brute_force>()[link[0].index()];
 
             // This means no grids, all surfaces are in the brute force method
             if (not has_grids) {
@@ -249,11 +250,11 @@ inline bool test_toy_detector(
                 // Test the module search if grids were filled
                 if (not link[1].is_invalid()) {
                     if (link[1].id() == sf_finder_ids::e_cylinder2_grid) {
-                        const auto& cyl_grid = sf_finder_store.get<
+                        const auto& cyl_grid = sf_finder_store.template get<
                             sf_finder_ids::e_cylinder2_grid>()[link[1].index()];
                         test_finder(cyl_grid, vol_itr->index(), sf_range);
                     } else {
-                        const auto& disc_grid = sf_finder_store.get<
+                        const auto& disc_grid = sf_finder_store.template get<
                             sf_finder_ids::e_disc_grid>()[link[1].index()];
                         test_finder(disc_grid, vol_itr->index(), sf_range);
                     }
diff --git a/tests/common/include/tests/common/tools/hash_tree.hpp b/tests/common/include/tests/common/tools/hash_tree.hpp
index 439f2ac7b..577ee0bc4 100644
--- a/tests/common/include/tests/common/tools/hash_tree.hpp
+++ b/tests/common/include/tests/common/tools/hash_tree.hpp
@@ -8,7 +8,6 @@
 #pragma once
 
 #include <cmath>
-#include <iostream>
 #include <iterator>
 #include <type_traits>
 
diff --git a/tests/unit_tests/core/CMakeLists.txt b/tests/unit_tests/core/CMakeLists.txt
index 4e5041642..9c91991d4 100644
--- a/tests/unit_tests/core/CMakeLists.txt
+++ b/tests/unit_tests/core/CMakeLists.txt
@@ -18,4 +18,5 @@ detray_add_test( core
    "utils_ranges.cpp"
    "utils_quadratic_equation.cpp"
    "utils_sort.cpp"
+   "utils_type_list.cpp"
    LINK_LIBRARIES GTest::gtest_main detray_tests_common detray::core_array )
diff --git a/tests/unit_tests/core/tools_hash_tree.cpp b/tests/unit_tests/core/tools_hash_tree.cpp
index fc0982c84..097980d21 100644
--- a/tests/unit_tests/core/tools_hash_tree.cpp
+++ b/tests/unit_tests/core/tools_hash_tree.cpp
@@ -8,7 +8,6 @@
 #include <gtest/gtest.h>
 
 #include <cmath>
-#include <iostream>
 
 // detray test
 #include "tests/common/tools/hash_tree.hpp"
diff --git a/tests/unit_tests/core/utils_type_list.cpp b/tests/unit_tests/core/utils_type_list.cpp
new file mode 100644
index 000000000..4f41dbe21
--- /dev/null
+++ b/tests/unit_tests/core/utils_type_list.cpp
@@ -0,0 +1,40 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+// Project include(s).
+#include "detray/utils/type_list.hpp"
+
+// Google Test include(s).
+#include <gtest/gtest.h>
+
+// Test type list implementation
+TEST(utils, type_list) {
+    using namespace detray;
+
+    using list = types::type_list<float, int, double>;
+
+    static_assert(std::is_same_v<types::front<list>, float>,
+                  "Could not access type list front");
+
+    static_assert(std::is_same_v<types::back<list>, double>,
+                  "Could not access type list back");
+
+    static_assert(std::is_same_v<types::push_back<list, char>,
+                                 types::type_list<float, int, double, char>>,
+                  "Failed to push back new type");
+
+    static_assert(std::is_same_v<types::push_front<list, char>,
+                                 types::type_list<char, float, int, double>>,
+                  "Failed to push front new type");
+
+    static_assert(types::size<list> == 3ul, "Incorrect size");
+
+    static_assert(std::is_same_v<types::at<list, 1>, int>,
+                  "Failed access type");
+
+    types::print<list>();
+}
diff --git a/tests/unit_tests/cpu/grid_grid_builder.cpp b/tests/unit_tests/cpu/grid_grid_builder.cpp
index 1156d00d4..a17470a89 100644
--- a/tests/unit_tests/cpu/grid_grid_builder.cpp
+++ b/tests/unit_tests/cpu/grid_grid_builder.cpp
@@ -118,16 +118,6 @@ GTEST_TEST(detray_tools, grid_factory) {
                                                 closed<label::e_cyl_z>,
                                                 regular<>, irregular<>>(
         cyl2, {bin_edges_z.size() - 1, 10u}, {bin_edges_phi, bin_edges_z});
-
-    // Get grid collection with the correct allocator
-    auto grid_coll = gr_factory.new_collection<decltype(cyl_gr)>();
-    EXPECT_TRUE(grid_coll.size() == 0u);
-    grid_coll.push_back(cyl_gr);
-    grid_coll.push_back(cyl_gr2);
-    EXPECT_TRUE(grid_coll.size() == 2u);
-
-    EXPECT_EQ(grid_coll[0].search(loc_p)[0], 33u);
-    // gr_factory.to_string(grid_coll[0]);
 }
 
 /// Unittest: Test the grid builder
@@ -137,10 +127,10 @@ GTEST_TEST(detray_tools, grid_builder) {
     using cyl_grid_t =
         grid<coordinate_axes<cylinder2D<>::axes<>, false, host_container_types>,
              test_detector_t::surface_type, simple_serializer,
-             regular_attacher<9>>;
+             regular_attacher<1>>;
 
     auto gbuilder = grid_builder<test_detector_t, cyl_grid_t,
-                                 detray::detail::bin_associator>{};
+                                 detray::detail::bin_associator>{nullptr};
 
     // The cylinder portals are at the end of the surface range by construction
     const auto cyl_mask = mask<cylinder2D<>>{0u, 10.f, -500.f, 500.f};
@@ -173,7 +163,7 @@ GTEST_TEST(detray_tools, decorator_grid_builder) {
     using cyl_grid_t =
         grid<coordinate_axes<cylinder2D<>::axes<>, false, host_container_types>,
              test_detector_t::surface_type, simple_serializer,
-             regular_attacher<9>>;
+             regular_attacher<1>>;
 
     using portal_cylinder_factory_t =
         surface_factory<test_detector_t, cylinder2D<>,
@@ -225,18 +215,18 @@ GTEST_TEST(detray_tools, decorator_grid_builder) {
     auto rect_factory = std::make_shared<rectangle_factory>();
 
     typename rectangle_factory::sf_data_collection rect_sf_data;
-    rect_sf_data.emplace_back(transform3(point3{0.f, 0.f, -10.f}), vol_idx,
+    rect_sf_data.emplace_back(transform3(point3{7.07f, 7.07f, -500.f}), vol_idx,
                               std::vector<scalar>{10.f, 8.f});
-    rect_sf_data.emplace_back(transform3(point3{0.f, 0.f, -20.f}), vol_idx,
+    rect_sf_data.emplace_back(transform3(point3{7.07f, 7.07f, -250.f}), vol_idx,
                               std::vector<scalar>{10.f, 8.f});
-    rect_sf_data.emplace_back(transform3(point3{0.f, 0.f, -30.f}), vol_idx,
+    rect_sf_data.emplace_back(transform3(point3{7.07f, 7.07f, 100.f}), vol_idx,
                               std::vector<scalar>{10.f, 8.f});
     rect_factory->push_back(std::move(rect_sf_data));
 
     auto trpz_factory = std::make_shared<trapezoid_factory>();
 
     typename trapezoid_factory::sf_data_collection trpz_sf_data;
-    trpz_sf_data.emplace_back(transform3(point3{0.f, 0.f, 1000.f}), vol_idx,
+    trpz_sf_data.emplace_back(transform3(point3{7.07f, 7.07f, 600.f}), vol_idx,
                               std::vector<scalar>{1.f, 3.f, 2.f, 0.25f});
     trpz_factory->push_back(std::move(trpz_sf_data));
 
@@ -280,8 +270,7 @@ GTEST_TEST(detray_tools, decorator_grid_builder) {
     EXPECT_EQ(vol.template link<geo_obj_id::e_passive>(),
               sf_range[geo_obj_id::e_passive]);
 
-    // Only the portals should be in the detector's surface container now
-    EXPECT_EQ(d.surface_lookup().size(), 3u);
+    EXPECT_EQ(d.surface_lookup().size(), 7u);
     EXPECT_EQ(d.mask_store().template size<mask_id::e_portal_cylinder2>(), 3u);
     EXPECT_EQ(d.mask_store().template size<mask_id::e_portal_ring2>(), 0u);
     EXPECT_EQ(d.mask_store().template size<mask_id::e_cylinder2>(), 3u);
@@ -289,9 +278,13 @@ GTEST_TEST(detray_tools, decorator_grid_builder) {
     EXPECT_EQ(d.mask_store().template size<mask_id::e_trapezoid2>(), 1u);
 
     // check the portals in the detector
-    for (const auto& sf : d.surface_lookup()) {
+    const auto& bf_finder =
+        d.surface_store()
+            .template get<test_detector_t::sf_finders::id::e_brute_force>()[0];
+    for (const auto& sf : bf_finder.all()) {
         EXPECT_TRUE((sf.id() == surface_id::e_portal) or
                     (sf.id() == surface_id::e_passive));
+        EXPECT_EQ(sf.volume(), 0u);
     }
 
     // check the sensitive surfaces in the grid
@@ -299,7 +292,7 @@ GTEST_TEST(detray_tools, decorator_grid_builder) {
         d.surface_store()
             .template get<
                 test_detector_t::sf_finders::id::e_cylinder2_grid>()[0];
-    dindex trf_idx{4u};
+    dindex trf_idx{3u};
     for (const auto& sf : cyl_grid.all()) {
         EXPECT_TRUE(sf.is_sensitive());
         EXPECT_EQ(sf.volume(), 0u);
diff --git a/tests/unit_tests/cpu/tools_material_builder.cpp b/tests/unit_tests/cpu/tools_material_builder.cpp
index 3f6afd257..91e59334d 100644
--- a/tests/unit_tests/cpu/tools_material_builder.cpp
+++ b/tests/unit_tests/cpu/tools_material_builder.cpp
@@ -239,7 +239,8 @@ GTEST_TEST(detray_tools, detector_builder_with_material) {
 
     // Add material
     auto mv_builder =
-        det_builder.template decorate<material_builder>(vbuilder->vol_index());
+        det_builder.template decorate<material_builder<detector_t>>(
+            vbuilder->vol_index());
 
     typename detector_t::point3 t{0.f, 0.f, 20.f};
     mv_builder->add_volume_placement(t);
diff --git a/tests/unit_tests/io/io_json_detector_reader.cpp b/tests/unit_tests/io/io_json_detector_reader.cpp
index 0e816149f..60f6a3ec0 100644
--- a/tests/unit_tests/io/io_json_detector_reader.cpp
+++ b/tests/unit_tests/io/io_json_detector_reader.cpp
@@ -98,12 +98,17 @@ TEST(io, json_toy_detector_reader) {
     io::detector_reader_config reader_cfg{};
     reader_cfg.add_file("toy_detector_geometry.json")
         .add_file("toy_detector_homogeneous_material.json")
+        .add_file("toy_detector_surface_grids.json")
         .add_file(toy_cfg.bfield_file());
 
     const auto [det, names] =
-        io::read_detector<detector_t>(host_mr, reader_cfg);
+        io::read_detector<detector_t, 1u>(host_mr, reader_cfg);
+
+    // Write the result to a different set of files
+    writer_cfg.replace_files(false);
+    io::write_detector(det, names, writer_cfg);
 
-    // EXPECT_TRUE(test_toy_detector(det, names));
+    EXPECT_TRUE(test_toy_detector(det, names));
 }
 
 /// Test the reading and writing of a wire chamber
@@ -124,7 +129,8 @@ TEST(io, json_wire_chamber_reader) {
     // Read the detector back in
     io::detector_reader_config reader_cfg{};
     reader_cfg.add_file("wire_chamber_geometry.json")
-        .add_file("wire_chamber_homogeneous_material.json");
+        .add_file("wire_chamber_homogeneous_material.json")
+        .add_file("wire_chamber_surface_grids.json");
 
     const auto [det, names] =
         io::read_detector<detector_t>(host_mr, reader_cfg);
diff --git a/tests/unit_tests/io/io_json_payload.cpp b/tests/unit_tests/io/io_json_payload.cpp
index f1fc95d89..11bf29770 100644
--- a/tests/unit_tests/io/io_json_payload.cpp
+++ b/tests/unit_tests/io/io_json_payload.cpp
@@ -107,14 +107,14 @@ TEST(io, json_axis_payload) {
 /// This tests the json io for a grid bin
 TEST(io, json_bin_payload) {
 
-    detray::grid_bin_payload b;
+    detray::grid_bin_payload<> b;
     b.loc_index = std::vector<unsigned int>{1u, 0u, 2u};
     b.content = std::vector<std::size_t>{0u, 1u, 2u, 3u};
 
     nlohmann::ordered_json jbin;
     jbin["bin"] = b;
 
-    detray::grid_bin_payload pb = jbin["bin"];
+    detray::grid_bin_payload<> pb = jbin["bin"];
 
     EXPECT_EQ(b.loc_index.size(), pb.loc_index.size());
     EXPECT_EQ(b.content.size(), pb.content.size());
@@ -123,7 +123,7 @@ TEST(io, json_bin_payload) {
 /// This tests the json io for a grid
 TEST(io, json_grid_payload) {
 
-    std::vector<detray::grid_bin_payload> bins = {
+    std::vector<detray::grid_bin_payload<>> bins = {
         {{0u, 1u}, {0u, 2u}}, {{1u, 1u}, {1u, 2u}}, {{2u, 1u}, {2u, 2u}}};
 
     detray::axis_payload a0{
@@ -136,8 +136,8 @@ TEST(io, json_grid_payload) {
         detray::n_axis::binning::e_regular, detray::n_axis::bounds::e_closed,
         detray::n_axis::label::e_r, 2u, std::vector<detray::real_io>{0.f, 2.f}};
 
-    detray::grid_payload g;
-    g.acc_link = {detray::grid_payload::grid_type::polar2_grid, 12u};
+    detray::grid_payload<> g;
+    g.acc_link = {detray::grid_payload<>::grid_type::polar2_grid, 12u};
     g.volume_link = {2u};
     g.axes = {a0, a1};
     g.bins = bins;
@@ -145,7 +145,7 @@ TEST(io, json_grid_payload) {
     nlohmann::ordered_json j;
     j["grid"] = g;
 
-    detray::grid_payload pg = j["grid"];
+    detray::grid_payload<> pg = j["grid"];
 
     EXPECT_EQ(g.acc_link.type, pg.acc_link.type);
     EXPECT_EQ(g.acc_link.index, pg.acc_link.index);
diff --git a/utils/include/detray/detectors/create_toy_geometry.hpp b/utils/include/detray/detectors/create_toy_geometry.hpp
index da4399500..e60887adc 100644
--- a/utils/include/detray/detectors/create_toy_geometry.hpp
+++ b/utils/include/detray/detectors/create_toy_geometry.hpp
@@ -190,11 +190,13 @@ inline void create_barrel_modules(context_t &ctx, volume_type &vol,
 
 /// Helper function that creates a surface grid of rectangular barrel modules.
 ///
-/// @param surfaces_grid the grid to be created with proper axes
-/// @param resource vecmem memory resource
-/// @param cfg config struct for module creation
+/// @param ctx the detector geometry context
+/// @param resource memory resource for the grid data allocations
+/// @param vol the detector volume in which to build the grid
+/// @param det the detector to fill the grid into
+/// @param module_factory factory to create the volume surfaces
 template <
-    typename detector_t, typename config_t, typename factory_t,
+    typename detector_t, typename factory_t,
     std::enable_if_t<
         std::is_invocable_v<factory_t, typename detector_t::geometry_context &,
                             typename detector_t::volume_type &,
@@ -206,8 +208,7 @@ template <
 inline void add_cylinder_grid(const typename detector_t::geometry_context &ctx,
                               vecmem::memory_resource &resource,
                               typename detector_t::volume_type &vol,
-                              detector_t &det, const config_t &cfg,
-                              factory_t &module_factory) {
+                              detector_t &det, factory_t &module_factory) {
     // Get relevant ids
     using geo_obj_ids = typename detector_t::geo_obj_ids;
 
@@ -217,13 +218,25 @@ inline void add_cylinder_grid(const typename detector_t::geometry_context &ctx,
     using cyl_grid_t =
         typename detector_t::surface_container::template get_type<grid_id>;
     auto gbuilder =
-        grid_builder<detector_t, cyl_grid_t, detray::detail::fill_by_pos>{};
+        grid_builder<detector_t, cyl_grid_t, detray::detail::fill_by_pos>{
+            nullptr};
 
-    // The disc portals are at the end of the portal range by construction
-    auto portal_mask_idx = (det.portals(vol).end() - 3u)->mask().index();
-    const auto &cyl_mask =
+    // The portals are at the end of the portal range by construction
+    auto portal_mask_idx = (det.portals(vol).end() - 4u)->mask().index();
+    const auto &inner_cyl_mask =
+        det.mask_store().template get<cyl_id>().at(portal_mask_idx);
+    portal_mask_idx = (det.portals(vol).end() - 3u)->mask().index();
+    const auto &outer_cyl_mask =
         det.mask_store().template get<cyl_id>().at(portal_mask_idx);
 
+    // Correct cylinder radius so that the grid lies in the middle
+    using cyl_mask_t = detail::remove_cvref_t<decltype(outer_cyl_mask)>;
+    typename cyl_mask_t::mask_values mask_values{outer_cyl_mask.values()};
+    mask_values[cylinder2D<>::e_r] =
+        0.5f * (inner_cyl_mask.values()[cylinder2D<>::e_r] +
+                outer_cyl_mask.values()[cylinder2D<>::e_r]);
+    const cyl_mask_t cyl_mask{mask_values, 0u};
+
     // Create the sensitive surfaces
     typename detector_t::surface_container_t surfaces(&resource);
     typename detector_t::mask_container masks(resource);
@@ -249,16 +262,18 @@ inline void add_cylinder_grid(const typename detector_t::geometry_context &ctx,
         det.add_surface_to_lookup(sf_desc);
     }
 
-    // Add new grid to the detector
-    gbuilder.init_grid(cyl_mask, {cfg.m_binning.first, cfg.m_binning.second});
-    gbuilder.fill_grid(detector_volume{det, vol}, surfaces, transforms, masks,
-                       ctx);
-    assert(gbuilder.get().all().size() == surfaces.size());
-
     // Add transforms, masks and material to detector
     det.append_masks(std::move(masks));
     det.append_transforms(std::move(transforms));
     det.append_materials(std::move(materials));
+
+    // Add new grid to the detector
+    gbuilder.init_grid(cyl_mask, {module_factory.cfg.m_binning.first,
+                                  module_factory.cfg.m_binning.second});
+    gbuilder.fill_grid(detector_volume{det, vol}, det.surface_lookup(),
+                       det.transform_store(), det.mask_store(), ctx);
+    assert(gbuilder.get().all().size() == surfaces.size());
+
     det.surface_store().template push_back<grid_id>(gbuilder.get());
     vol.template set_link<geo_obj_ids::e_sensitive>(
         grid_id, det.surface_store().template size<grid_id>() - 1u);
@@ -266,12 +281,13 @@ inline void add_cylinder_grid(const typename detector_t::geometry_context &ctx,
 
 /// Helper function that creates a surface grid of trapezoidal endcap modules.
 ///
-/// @param vol the detector volume that should be equipped with a grid
-/// @param surfaces_grid the grid to be created with proper axes
-/// @param resource vecmem memory resource
-/// @param cfg config struct for module creation
+/// @param ctx the detector geometry context
+/// @param resource memory resource for the grid data allocations
+/// @param vol the detector volume in which to build the grid
+/// @param det the detector to fill the grid into
+/// @param module_factory factory to create the volume surfaces
 template <
-    typename detector_t, typename config_t, typename factory_t,
+    typename detector_t, typename factory_t,
     std::enable_if_t<
         std::is_invocable_v<factory_t, typename detector_t::geometry_context &,
                             typename detector_t::volume_type &,
@@ -283,8 +299,7 @@ template <
 inline void add_disc_grid(const typename detector_t::geometry_context &ctx,
                           vecmem::memory_resource &resource,
                           typename detector_t::volume_type &vol,
-                          detector_t &det, const config_t &cfg,
-                          factory_t &module_factory) {
+                          detector_t &det, factory_t &module_factory) {
     // Get relevant ids
     using geo_obj_ids = typename detector_t::geo_obj_ids;
 
@@ -294,7 +309,8 @@ inline void add_disc_grid(const typename detector_t::geometry_context &ctx,
     using disc_grid_t =
         typename detector_t::surface_container::template get_type<grid_id>;
     auto gbuilder =
-        grid_builder<detector_t, disc_grid_t, detray::detail::fill_by_pos>{};
+        grid_builder<detector_t, disc_grid_t, detray::detail::fill_by_pos>{
+            nullptr};
 
     // The disc portals are at the end of the portal range by construction
     auto portal_mask_idx = det.portals(vol).back().mask().index();
@@ -326,17 +342,18 @@ inline void add_disc_grid(const typename detector_t::geometry_context &ctx,
         det.add_surface_to_lookup(sf_desc);
     }
 
-    // Add new grid to the detector
-    gbuilder.init_grid(disc_mask,
-                       {cfg.disc_binning.size(), cfg.disc_binning.front()});
-    gbuilder.fill_grid(detector_volume{det, vol}, surfaces, transforms, masks,
-                       ctx);
-    assert(gbuilder.get().all().size() == surfaces.size());
-
     // Add transforms, masks and material to detector
     det.append_masks(std::move(masks));
     det.append_transforms(std::move(transforms));
     det.append_materials(std::move(materials));
+
+    // Add new grid to the detector
+    gbuilder.init_grid(disc_mask, {module_factory.cfg.disc_binning.size(),
+                                   module_factory.cfg.disc_binning.back()});
+    gbuilder.fill_grid(detector_volume{det, vol}, det.surface_lookup(),
+                       det.transform_store(), det.mask_store(), ctx);
+    assert(gbuilder.get().all().size() == surfaces.size());
+
     det.surface_store().template push_back<grid_id>(gbuilder.get());
     vol.template set_link<geo_obj_ids::e_sensitive>(
         grid_id, det.surface_store().template size<grid_id>() - 1u);
@@ -810,8 +827,7 @@ inline void add_endcap_detector(
             dindex vol_idx = det.volumes().back().index();
             names[vol_idx + 1u] = "endcap_" + std::to_string(vol_idx);
 
-            add_disc_grid(ctx, resource, det.volumes().back(), det, cfg,
-                          m_factory);
+            add_disc_grid(ctx, resource, det.volumes().back(), det, m_factory);
         }
     }
 }
@@ -896,7 +912,7 @@ inline void add_barrel_detector(
             dindex vol_idx = det.volumes().back().index();
             names[vol_idx + 1u] = "barrel_" + std::to_string(vol_idx);
 
-            add_cylinder_grid(ctx, resource, det.volumes().back(), det, cfg,
+            add_cylinder_grid(ctx, resource, det.volumes().back(), det,
                               m_factory);
         }
     }
diff --git a/utils/include/detray/detectors/create_wire_chamber.hpp b/utils/include/detray/detectors/create_wire_chamber.hpp
index 78b3f7b10..4be903867 100644
--- a/utils/include/detray/detectors/create_wire_chamber.hpp
+++ b/utils/include/detray/detectors/create_wire_chamber.hpp
@@ -247,6 +247,11 @@ auto create_wire_chamber(vecmem::memory_resource &resource,
             det.add_surface_to_lookup(sf_desc);
         }
 
+        // Add transforms, masks and material to detector
+        det.append_masks(std::move(masks));
+        det.append_transforms(std::move(transforms));
+        det.append_materials(std::move(materials));
+
         //
         // Fill Grid
         //
@@ -259,27 +264,34 @@ auto create_wire_chamber(vecmem::memory_resource &resource,
         using cyl_grid_t =
             typename detector_t::surface_container::template get_type<grid_id>;
         auto gbuilder =
-            grid_builder<detector_t, cyl_grid_t, detray::detail::fill_by_pos>{};
+            grid_builder<detector_t, cyl_grid_t, detray::detail::fill_by_pos>{
+                nullptr};
 
-        // The disc portals are at the end of the portal range by construction
-        auto portal_mask_idx = (det.portals(vol).end() - 3u)->mask().index();
-        const auto &cyl_mask =
+        // The portal portals are at the end of the portal range by construction
+        auto portal_mask_idx = (det.portals(vol).end() - 4u)->mask().index();
+        const auto &inner_cyl_mask =
+            det.mask_store().template get<cyl_id>().at(portal_mask_idx);
+        portal_mask_idx = (det.portals(vol).end() - 3u)->mask().index();
+        const auto &outer_cyl_mask =
             det.mask_store().template get<cyl_id>().at(portal_mask_idx);
 
+        // Correct cylinder radius so that the grid lies in the middle
+        using cyl_mask_t = detail::remove_cvref_t<decltype(outer_cyl_mask)>;
+        typename cyl_mask_t::mask_values mask_values{outer_cyl_mask.values()};
+        mask_values[cylinder2D<>::e_r] =
+            0.5f * (inner_cyl_mask.values()[cylinder2D<>::e_r] +
+                    outer_cyl_mask.values()[cylinder2D<>::e_r]);
+        const cyl_mask_t cyl_mask{mask_values, 0u};
+
         // Add new grid to the detector
         gbuilder.init_grid(cyl_mask, {100u, 1u});
-        gbuilder.fill_grid(detector_volume{det, vol}, surfaces, transforms,
-                           masks, ctx0);
+        gbuilder.fill_grid(detector_volume{det, vol}, det.surface_lookup(),
+                           det.transform_store(), det.mask_store(), ctx0);
 
         det.surface_store().template push_back<grid_id>(gbuilder.get());
         vol.template set_link<geo_obj_ids::e_sensitive>(
             grid_id, det.surface_store().template size<grid_id>() - 1u);
 
-        // Add transforms, masks and material to detector
-        det.append_masks(std::move(masks));
-        det.append_transforms(std::move(transforms));
-        det.append_materials(std::move(materials));
-
         // Add volume grid
         // TODO: Fill it
 
diff --git a/utils/include/detray/detectors/detector_helper.hpp b/utils/include/detray/detectors/detector_helper.hpp
index 393dc880f..7061ce96b 100644
--- a/utils/include/detray/detectors/detector_helper.hpp
+++ b/utils/include/detray/detectors/detector_helper.hpp
@@ -8,8 +8,6 @@
 #pragma once
 
 // Project include(s).
-#include <iostream>
-
 #include "detray/core/detail/data_context.hpp"
 #include "detray/definitions/geometry.hpp"
 #include "detray/definitions/indexing.hpp"
@@ -211,4 +209,4 @@ struct detector_helper {
     }
 };
 
-}  // namespace detray::detail
\ No newline at end of file
+}  // namespace detray::detail
diff --git a/utils/include/detray/detectors/toy_metadata.hpp b/utils/include/detray/detectors/toy_metadata.hpp
index bcbc5f5ba..8858536ca 100644
--- a/utils/include/detray/detectors/toy_metadata.hpp
+++ b/utils/include/detray/detectors/toy_metadata.hpp
@@ -47,7 +47,7 @@ struct toy_metadata {
     template <typename grid_shape_t, typename bin_entry_t, typename container_t>
     using surface_grid_t =
         grid<coordinate_axes<grid_shape_t, false, container_t>, bin_entry_t,
-             simple_serializer, regular_attacher<9>>;
+             simple_serializer, regular_attacher<1>>;
 
     // cylindrical grid for the barrel layers
     template <typename bin_entry_t, typename container_t>

From ca84a1fe0400e49ab4087ab3924c64a43cb6e146 Mon Sep 17 00:00:00 2001
From: Joana Niermann <joana.niermann@cern.ch>
Date: Mon, 2 Oct 2023 20:01:02 +0200
Subject: [PATCH 13/29] Enable regular steps in eta for uniform_track_generator
 (this is needed for the material scans). The stepping for theta/eta has been
 adjusted, so that it becomes symmetric for positive and negative eta. Theta
 and eta ranges are inclusive, but clamped to (0, pi) and [-0.001num_max,
 0.001num_max], respectively.

In order to facilitate the more complex configuration,
the config structs of the track generators are used in more places
and the possibility to pass complicated configurations to the
parametrized constructors has been limited to the most common case.
---
 core/include/detray/propagator/navigator.hpp  |   5 +-
 tests/benchmarks/cpu/intersect_all.cpp        |  33 +--
 tests/benchmarks/cpu/intersect_surfaces.cpp   |  35 ++--
 .../cuda/benchmark_propagator_cuda.cpp        |   5 +-
 .../common/test_base/propagator_test.hpp      |   7 +-
 .../helix_cylinder_intersector.hpp            |  14 +-
 .../tests/common/tools/particle_gun.hpp       |   3 +-
 tests/unit_tests/cpu/tools_particle_gun.cpp   |   7 +-
 tests/unit_tests/cpu/tools_propagator.cpp     |   7 +-
 tests/unit_tests/cpu/tools_stepper.cpp        |  10 +-
 .../unit_tests/cpu/tools_track_generators.cpp | 173 +++++++++++-----
 .../unit_tests/device/cuda/navigator_cuda.cpp |   6 +-
 tests/unit_tests/svgtools/intersections.cpp   |  11 +-
 .../detail/navigation_check_helper.hpp        |   2 +-
 .../src/toy_detector_validation.cpp           |   7 +-
 .../src/wire_chamber_validation.cpp           |   6 +-
 .../src/cpu/detector/detector_ray_scan.cpp    |  10 +-
 .../cpu/propagation/navigation_inspection.cpp |   5 +-
 tutorials/src/device/cuda/propagation.cpp     |   5 +-
 .../random_track_generator.hpp                | 102 ++++++----
 .../uniform_track_generator.hpp               | 189 +++++++++++++-----
 21 files changed, 396 insertions(+), 246 deletions(-)

diff --git a/core/include/detray/propagator/navigator.hpp b/core/include/detray/propagator/navigator.hpp
index 244c3981e..f801d4702 100644
--- a/core/include/detray/propagator/navigator.hpp
+++ b/core/include/detray/propagator/navigator.hpp
@@ -126,7 +126,7 @@ class navigator {
 
             sf.template visit_mask<intersection_initialize>(
                 candidates, detail::ray(track), sf_descr, det.transform_store(),
-                tol);
+                sf.is_portal() ? 0.f : tol);
         }
     };
 
@@ -740,7 +740,8 @@ class navigator {
 
         // Check whether this candidate is reachable by the track
         return sf.template visit_mask<intersection_update>(
-            detail::ray(track), candidate, det->transform_store(), tol);
+            detail::ray(track), candidate, det->transform_store(),
+            sf.is_portal() ? 0.f : tol);
     }
 
     /// Helper to evict all unreachable/invalid candidates from the cache:
diff --git a/tests/benchmarks/cpu/intersect_all.cpp b/tests/benchmarks/cpu/intersect_all.cpp
index 8e2fcc37a..702e12359 100644
--- a/tests/benchmarks/cpu/intersect_all.cpp
+++ b/tests/benchmarks/cpu/intersect_all.cpp
@@ -29,12 +29,15 @@
 // Use the detray:: namespace implicitly.
 using namespace detray;
 
+using trk_generator_t =
+    uniform_track_generator<free_track_parameters<test::transform3>>;
+
+constexpr unsigned int theta_steps{100u};
+constexpr unsigned int phi_steps{100u};
+
 // This test runs intersection with all surfaces of the TrackML detector
 void BM_INTERSECT_ALL(benchmark::State &state) {
 
-    static const unsigned int theta_steps{100u};
-    static const unsigned int phi_steps{100u};
-
     // Detector configuration
     vecmem::host_memory_resource host_mr;
     toy_det_config toy_cfg{};
@@ -48,18 +51,22 @@ void BM_INTERSECT_ALL(benchmark::State &state) {
 
     std::size_t hits{0u};
     std::size_t missed{0u};
+    std::size_t n_surfaces{0u};
+    test::point3 origin{0.f, 0.f, 0.f};
+    std::vector<intersection2D<typename detector_t::surface_type,
+                               typename detector_t::transform3>>
+        intersections{};
+
+    // Iterate through uniformly distributed momentum directions
+    auto trk_generator = trk_generator_t{};
+    trk_generator.config()
+        .theta_steps(theta_steps)
+        .phi_steps(phi_steps)
+        .origin(origin);
 
     for (auto _ : state) {
-        test::point3 pos{0.f, 0.f, 0.f};
-        std::vector<intersection2D<typename detector_t::surface_type,
-                                   typename detector_t::transform3>>
-            intersections{};
-        std::size_t n_surfaces{0u};
-
-        // Iterate through uniformly distributed momentum directions
-        for (const auto track :
-             uniform_track_generator<free_track_parameters<test::transform3>>(
-                 theta_steps, phi_steps, pos)) {
+
+        for (const auto track : trk_generator) {
 
             // Loop over all surfaces in detector
             for (const auto &sf_desc : d.surface_lookup()) {
diff --git a/tests/benchmarks/cpu/intersect_surfaces.cpp b/tests/benchmarks/cpu/intersect_surfaces.cpp
index 0617b67fd..5637821ab 100644
--- a/tests/benchmarks/cpu/intersect_surfaces.cpp
+++ b/tests/benchmarks/cpu/intersect_surfaces.cpp
@@ -26,6 +26,8 @@
 // Use the detray:: namespace implicitly.
 using namespace detray;
 
+using ray_generator_t = uniform_track_generator<detail::ray<test::transform3>>;
+
 static const unsigned int theta_steps = 1000u;
 static const unsigned int phi_steps = 1000u;
 
@@ -41,16 +43,17 @@ void BM_INTERSECT_PLANES(benchmark::State &state) {
     auto planes = test::planes_along_direction(
         dists, vector::normalize(test::vector3{1.f, 1.f, 1.f}));
     constexpr mask<rectangle2D<>> rect{0u, 10.f, 20.f};
-    test::point3 ori = {0.f, 0.f, 0.f};
+
+    // Iterate through uniformly distributed momentum directions
+    auto ray_generator = ray_generator_t{};
+    ray_generator.config().theta_steps(theta_steps).phi_steps(phi_steps);
 
     for (auto _ : state) {
         benchmark::DoNotOptimize(sfhit);
         benchmark::DoNotOptimize(sfmiss);
 
         // Iterate through uniformly distributed momentum directions
-        for (const auto ray :
-             uniform_track_generator<detail::ray<test::transform3>>(
-                 theta_steps, phi_steps, ori, 1.f)) {
+        for (const auto ray : ray_generator) {
 
             for (const auto &plane : planes) {
                 auto pi = rect.intersector<intersection2D<
@@ -115,16 +118,16 @@ void BM_INTERSECT_CYLINDERS(benchmark::State &state) {
     plane_surface plane(test::transform3(), mask_link, material_link, 0u, false,
                         surface_id::e_sensitive);
 
-    const test::point3 ori = {0.f, 0.f, 0.f};
+    // Iterate through uniformly distributed momentum directions
+    auto ray_generator = ray_generator_t{};
+    ray_generator.config().theta_steps(theta_steps).phi_steps(phi_steps);
 
     for (auto _ : state) {
         benchmark::DoNotOptimize(sfhit);
         benchmark::DoNotOptimize(sfmiss);
 
         // Iterate through uniformly distributed momentum directions
-        for (const auto ray :
-             uniform_track_generator<detail::ray<test::transform3>>(
-                 theta_steps, phi_steps, ori, 1.f)) {
+        for (const auto ray : ray_generator) {
 
             for (const auto &cylinder : cylinders) {
                 auto ci = cylinder.intersector<intersection_t>();
@@ -170,16 +173,16 @@ void BM_INTERSECT_PORTAL_CYLINDERS(benchmark::State &state) {
     plane_surface plane(test::transform3(), mask_link, material_link, 0u, false,
                         surface_id::e_sensitive);
 
-    const test::point3 ori = {0.f, 0.f, 0.f};
+    // Iterate through uniformly distributed momentum directions
+    auto ray_generator = ray_generator_t{};
+    ray_generator.config().theta_steps(theta_steps).phi_steps(phi_steps);
 
     for (auto _ : state) {
         benchmark::DoNotOptimize(sfhit);
         benchmark::DoNotOptimize(sfmiss);
 
         // Iterate through uniformly distributed momentum directions
-        for (const auto ray :
-             uniform_track_generator<detail::ray<test::transform3>>(
-                 theta_steps, phi_steps, ori, 1.f)) {
+        for (const auto ray : ray_generator) {
 
             for (const auto &cylinder : cylinders) {
                 auto cpi = cylinder.intersector<intersection_t>();
@@ -222,14 +225,14 @@ void BM_INTERSECT_CONCETRIC_CYLINDERS(benchmark::State &state) {
     plane_surface plane(test::transform3(), mask_link, material_link, 0u, false,
                         surface_id::e_sensitive);
 
-    const test::point3 ori = {0.f, 0.f, 0.f};
+    // Iterate through uniformly distributed momentum directions
+    auto ray_generator = ray_generator_t{};
+    ray_generator.config().theta_steps(theta_steps).phi_steps(phi_steps);
 
     for (auto _ : state) {
 
         // Iterate through uniformly distributed momentum directions
-        for (const auto ray :
-             uniform_track_generator<detail::ray<test::transform3>>(
-                 theta_steps, phi_steps, ori, 1.f)) {
+        for (const auto ray : ray_generator) {
 
             for (const auto &cylinder : cylinders) {
                 auto cci = cylinder.intersector<intersection_t>();
diff --git a/tests/benchmarks/cuda/benchmark_propagator_cuda.cpp b/tests/benchmarks/cuda/benchmark_propagator_cuda.cpp
index 522a22119..d962310cd 100644
--- a/tests/benchmarks/cuda/benchmark_propagator_cuda.cpp
+++ b/tests/benchmarks/cuda/benchmark_propagator_cuda.cpp
@@ -31,13 +31,12 @@ toy_det_config toy_cfg{4u, 7u};
 
 void fill_tracks(vecmem::vector<free_track_parameters<transform3>> &tracks,
                  const std::size_t theta_steps, const std::size_t phi_steps) {
-    // Set origin position of tracks
-    const point3 ori{0.f, 0.f, 0.f};
+    // Set momentum of tracks
     const scalar mom_mag{10.f * unit<scalar>::GeV};
 
     // Iterate through uniformly distributed momentum directions
     for (auto traj : uniform_track_generator<free_track_parameters<transform3>>(
-             theta_steps, phi_steps, ori, mom_mag)) {
+             phi_steps, theta_steps, mom_mag)) {
         tracks.push_back(traj);
     }
 }
diff --git a/tests/common/include/tests/common/test_base/propagator_test.hpp b/tests/common/include/tests/common/test_base/propagator_test.hpp
index 70be60af0..ec7096a53 100644
--- a/tests/common/include/tests/common/test_base/propagator_test.hpp
+++ b/tests/common/include/tests/common/test_base/propagator_test.hpp
@@ -139,14 +139,11 @@ inline vecmem::vector<track_t> generate_tracks(
     // Track collection
     vecmem::vector<track_t> tracks(mr);
 
-    // Set origin position of tracks
-    const point3 ori{0.f, 0.f, 0.f};
+    // Set momentum of tracks
     const scalar p_mag{10.f * unit<scalar>::GeV};
 
     // Iterate through uniformly distributed momentum directions
-    for (auto track : uniform_track_generator<track_t>(
-             ts, ps, ori, p_mag, {0.01f, constant<scalar>::pi},
-             {-constant<scalar>::pi, constant<scalar>::pi})) {
+    for (auto track : uniform_track_generator<track_t>(ps, ts, p_mag)) {
         track.set_overstep_tolerance(overstep_tolerance);
 
         // Put it into vector of trajectories
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 c8245d8f6..43ab34f40 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
@@ -66,7 +66,7 @@ struct helix_cylinder_intersector
         // Guard against inifinite loops
         constexpr std::size_t max_n_tries{1000u};
         // Tolerance for convergence
-        constexpr scalar_type tol{1e-4f};
+        constexpr scalar_type tol{1e-3f};
 
         // Get the surface placement
         const auto &sm = trf.matrix();
@@ -128,10 +128,12 @@ struct helix_cylinder_intersector
                 const vector3 crp = vector::cross(h.pos(s) - sc, sz);
                 const scalar_type denom{
                     2.f * vector::dot(crp, vector::cross(h.dir(s), sz))};
+
                 // No intersection can be found if dividing by zero
                 if (denom == 0.f) {
                     return ret;
                 }
+
                 // x_n+1 = x_n - f(s) / f'(s)
                 s_prev = s;
                 s -= (vector::dot(crp, crp) - r * r) / denom;
@@ -149,16 +151,6 @@ struct helix_cylinder_intersector
             is.local = mask.to_local_frame(trf, p3);
             is.status = mask.is_inside(is.local, mask_tolerance);
 
-            // Perform the r-check for Newton solution even if it is not
-            // required by the mask's shape
-            const bool r_check =
-                std::abs(r - is.local[2]) <
-                mask_tolerance +
-                    5.f * std::numeric_limits<scalar_type>::epsilon();
-            if (not r_check) {
-                is.status = intersection::status::e_outside;
-            }
-
             // Compute some additional information if the intersection is valid
             if (is.status == intersection::status::e_inside) {
                 is.sf_desc = sf;
diff --git a/tests/common/include/tests/common/tools/particle_gun.hpp b/tests/common/include/tests/common/tools/particle_gun.hpp
index b974b6d68..95ce87ba0 100644
--- a/tests/common/include/tests/common/tools/particle_gun.hpp
+++ b/tests/common/include/tests/common/tools/particle_gun.hpp
@@ -63,7 +63,8 @@ struct particle_gun {
             // Retrieve candidate(s) from the surface
             const auto sf = surface{detector, sf_desc};
             sf.template visit_mask<intersection_kernel_t>(
-                intersections, traj, sf_desc, tf_store, mask_tolerance);
+                intersections, traj, sf_desc, tf_store,
+                sf.is_portal() ? 0.f : mask_tolerance);
 
             // Candidate is invalid if it lies in the opposite direction
             for (auto &sfi : intersections) {
diff --git a/tests/unit_tests/cpu/tools_particle_gun.cpp b/tests/unit_tests/cpu/tools_particle_gun.cpp
index d2b014126..b8c30be22 100644
--- a/tests/unit_tests/cpu/tools_particle_gun.cpp
+++ b/tests/unit_tests/cpu/tools_particle_gun.cpp
@@ -43,7 +43,6 @@ GTEST_TEST(detray_tools, particle_gun) {
 
     unsigned int theta_steps{50u};
     unsigned int phi_steps{50u};
-    const point3 ori{0.f, 0.f, 0.f};
 
     // Record ray tracing
     using detector_t = decltype(toy_det);
@@ -52,8 +51,8 @@ GTEST_TEST(detray_tools, particle_gun) {
     std::vector<std::vector<std::pair<dindex, intersection_t>>> expected;
     //  Iterate through uniformly distributed momentum directions with ray
     for (const auto test_ray :
-         uniform_track_generator<detail::ray<transform3_type>>(
-             theta_steps, phi_steps, ori)) {
+         uniform_track_generator<detail::ray<transform3_type>>(phi_steps,
+                                                               theta_steps)) {
 
         // Record all intersections and objects along the ray
         const auto intersection_record =
@@ -66,7 +65,7 @@ GTEST_TEST(detray_tools, particle_gun) {
     std::size_t n_tracks{0u};
     for (const auto track :
          uniform_track_generator<free_track_parameters<transform3_type>>(
-             theta_steps, phi_steps, ori)) {
+             phi_steps, theta_steps)) {
         const detail::helix test_helix(track, &B);
 
         // Record all intersections and objects along the ray
diff --git a/tests/unit_tests/cpu/tools_propagator.cpp b/tests/unit_tests/cpu/tools_propagator.cpp
index ff3ed2038..3b0589007 100644
--- a/tests/unit_tests/cpu/tools_propagator.cpp
+++ b/tests/unit_tests/cpu/tools_propagator.cpp
@@ -160,7 +160,6 @@ class PropagatorWithRkStepper
     /// Track generator configuration
     unsigned int theta_steps{50u};
     unsigned int phi_steps{50u};
-    point3 ori{0.f, 0.f, 0.f};
     scalar mom{10.f * unit<scalar>::GeV};
 
     /// Stepper configuration
@@ -200,7 +199,7 @@ TEST_P(PropagatorWithRkStepper, rk4_propagator_const_bfield) {
 
     // Iterate through uniformly distributed momentum directions
     for (auto track :
-         uniform_track_generator<track_t>(theta_steps, phi_steps, ori, mom)) {
+         uniform_track_generator<track_t>(phi_steps, theta_steps, mom)) {
         // Generate second track state used for propagation with pathlimit
         track_t lim_track(track);
 
@@ -241,7 +240,7 @@ TEST_P(PropagatorWithRkStepper, rk4_propagator_const_bfield) {
         // Propagate the entire detector
         ASSERT_TRUE(p.propagate(state, actor_states))
             << print_insp_state.to_string() << std::endl;
-        // << state._navigation.inspector().to_string() << std::endl;
+        //  << state._navigation.inspector().to_string() << std::endl;
 
         // Propagate with path limit
         ASSERT_NEAR(pathlimit_aborter_state.path_limit(), path_limit, tol);
@@ -299,7 +298,7 @@ TEST_P(PropagatorWithRkStepper, rk4_propagator_inhom_bfield) {
 
     // Iterate through uniformly distributed momentum directions
     for (auto track :
-         uniform_track_generator<track_t>(theta_steps, phi_steps, ori, mom)) {
+         uniform_track_generator<track_t>(phi_steps, theta_steps, mom)) {
         // Genrate second track state used for propagation with pathlimit
         track_t lim_track(track);
 
diff --git a/tests/unit_tests/cpu/tools_stepper.cpp b/tests/unit_tests/cpu/tools_stepper.cpp
index 55b9acfbb..b05221c60 100644
--- a/tests/unit_tests/cpu/tools_stepper.cpp
+++ b/tests/unit_tests/cpu/tools_stepper.cpp
@@ -166,7 +166,6 @@ GTEST_TEST(detray_propagator, rk_stepper) {
     constexpr scalar stepsize_constr{0.5f * unit<scalar>::mm};
 
     // Track generator configuration
-    const point3 ori{0.f, 0.f, 0.f};
     const scalar p_mag{10.f * unit<scalar>::GeV};
     constexpr unsigned int theta_steps = 100u;
     constexpr unsigned int phi_steps = 100u;
@@ -174,7 +173,7 @@ GTEST_TEST(detray_propagator, rk_stepper) {
     // Iterate through uniformly distributed momentum directions
     for (auto track :
          uniform_track_generator<free_track_parameters<transform3>>(
-             theta_steps, phi_steps, ori, p_mag)) {
+             phi_steps, theta_steps, p_mag)) {
         // Generate track state used for propagation with constrained step size
         free_track_parameters c_track(track);
 
@@ -241,7 +240,7 @@ GTEST_TEST(detray_propagator, rk_stepper) {
         ASSERT_NEAR(crk_state.path_length(), 0.f, tol);
 
         const point3 backward_relative_error{1.f / (2.f * path_length) *
-                                             (rk_state().pos() - ori)};
+                                             (rk_state().pos())};
         // Make sure that relative error is smaller than the tolerance
         EXPECT_NEAR(getter::norm(backward_relative_error), 0.f, tol);
 
@@ -271,7 +270,6 @@ TEST(detray_propagator, rk_stepper_inhomogeneous_bfield) {
     constexpr scalar stepsize_constr{0.5f * unit<scalar>::mm};
 
     // Track generator configuration
-    const point3 ori{0.f, 0.f, 0.f};
     const scalar p_mag{10.f * unit<scalar>::GeV};
     constexpr unsigned int theta_steps = 100u;
     constexpr unsigned int phi_steps = 100u;
@@ -279,7 +277,7 @@ TEST(detray_propagator, rk_stepper_inhomogeneous_bfield) {
     // Iterate through uniformly distributed momentum directions
     for (auto track :
          uniform_track_generator<free_track_parameters<transform3>>(
-             theta_steps, phi_steps, ori, p_mag)) {
+             phi_steps, theta_steps, p_mag)) {
         // Generate track state used for propagation with constrained step size
         free_track_parameters c_track(track);
 
@@ -328,7 +326,7 @@ TEST(detray_propagator, rk_stepper_inhomogeneous_bfield) {
         ASSERT_NEAR(crk_state.path_length(), 0.f, tol);
 
         const point3 backward_relative_error{1.f / (2.f * path_length) *
-                                             (rk_state().pos() - ori)};
+                                             (rk_state().pos())};
         // Make sure that relative error is smaller than the tolerance
         EXPECT_NEAR(getter::norm(backward_relative_error), 0.f, tol);
 
diff --git a/tests/unit_tests/cpu/tools_track_generators.cpp b/tests/unit_tests/cpu/tools_track_generators.cpp
index 1517181ab..c89780800 100644
--- a/tests/unit_tests/cpu/tools_track_generators.cpp
+++ b/tests/unit_tests/cpu/tools_track_generators.cpp
@@ -1,6 +1,6 @@
 /** Detray library, part of the ACTS project (R&D line)
  *
- * (c) 2022 CERN for the benefit of the ACTS project
+ * (c) 2022-2023 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -20,21 +20,25 @@ using point3 = test::point3;
 using transform3 = test::transform3;
 
 GTEST_TEST(detray_simulation, uniform_track_generator) {
+    using generator_t =
+        uniform_track_generator<free_track_parameters<transform3>>;
 
     constexpr const scalar tol{1e-5f};
+    constexpr const scalar epsilon{generator_t::configuration::epsilon};
 
     constexpr std::size_t phi_steps{50u};
     constexpr std::size_t theta_steps{50u};
 
     std::array<vector3, phi_steps * theta_steps> momenta{};
 
-    // Loops of theta values ]0,pi[
+    // Loop over theta values ]0,pi[
     for (std::size_t itheta{0u}; itheta < theta_steps; ++itheta) {
-        const scalar theta{0.01f + static_cast<scalar>(itheta) *
-                                       (constant<scalar>::pi - 0.01f) /
-                                       static_cast<scalar>(theta_steps)};
+        const scalar theta{epsilon +
+                           static_cast<scalar>(itheta) *
+                               (constant<scalar>::pi - 2.f * epsilon) /
+                               static_cast<scalar>(theta_steps - 1u)};
 
-        // Loops of phi values [-pi, pi]
+        // Loop over phi values [-pi, pi]
         for (std::size_t iphi{0u}; iphi < phi_steps; ++iphi) {
             // The direction
             const scalar phi{-constant<scalar>::pi +
@@ -55,10 +59,8 @@ GTEST_TEST(detray_simulation, uniform_track_generator) {
 
     // Now run the track generator and compare
     std::size_t n_tracks{0u};
-    for (const auto track :
-         uniform_track_generator<free_track_parameters<transform3>>(
-             theta_steps, phi_steps)) {
-        vector3 &expected = momenta[n_tracks];
+    for (const auto track : generator_t(phi_steps, theta_steps)) {
+        vector3& expected = momenta[n_tracks];
         vector3 result = track.mom();
 
         // Compare with for loop
@@ -74,9 +76,8 @@ GTEST_TEST(detray_simulation, uniform_track_generator) {
 
     // Generate rays
     n_tracks = 0u;
-    for (const auto r : uniform_track_generator<detail::ray<transform3>>(
-             theta_steps, phi_steps)) {
-        vector3 &expected = momenta[n_tracks];
+    for (const auto r : generator_t(phi_steps, theta_steps)) {
+        vector3& expected = momenta[n_tracks];
         vector3 result = r.dir();
 
         // Compare with for loop
@@ -94,11 +95,9 @@ GTEST_TEST(detray_simulation, uniform_track_generator) {
     const vector3 B{0.f * unit<scalar>::T, 0.f * unit<scalar>::T,
                     2.f * unit<scalar>::T};
     n_tracks = 0u;
-    for (const auto track :
-         uniform_track_generator<free_track_parameters<transform3>>(
-             theta_steps, phi_steps)) {
+    for (const auto track : generator_t(phi_steps, theta_steps)) {
         detail::helix<transform3> helix_traj(track, &B);
-        vector3 &expected = momenta[n_tracks];
+        vector3& expected = momenta[n_tracks];
         vector3 result = helix_traj.dir(0.f);
 
         // Compare with for loop
@@ -113,19 +112,77 @@ GTEST_TEST(detray_simulation, uniform_track_generator) {
     ASSERT_EQ(momenta.size(), n_tracks);
 }
 
-GTEST_TEST(detray_simulation, uniform_track_generator_with_range) {
+GTEST_TEST(detray_simulation, uniform_track_generator_eta) {
+    using generator_t =
+        uniform_track_generator<free_track_parameters<transform3>>;
 
     constexpr const scalar tol{1e-5f};
 
-    constexpr std::size_t theta_steps{2u};
-    constexpr std::size_t phi_steps{4u};
+    constexpr std::size_t phi_steps{50u};
+    constexpr std::size_t eta_steps{50u};
+
+    std::array<vector3, phi_steps * eta_steps> momenta{};
+
+    // Loop over eta values [-5, 5]
+    for (std::size_t ieta{0u}; ieta < eta_steps; ++ieta) {
+        const scalar eta{-5.f + static_cast<scalar>(ieta) * (10.f) /
+                                    static_cast<scalar>(eta_steps - 1u)};
+        const scalar theta{2.f * std::atan(std::exp(-eta))};
+
+        // Loop over phi values [-pi, pi]
+        for (std::size_t iphi{0u}; iphi < phi_steps; ++iphi) {
+            // The direction
+            const scalar phi{-constant<scalar>::pi +
+                             static_cast<scalar>(iphi) *
+                                 (2.f * constant<scalar>::pi) /
+                                 static_cast<scalar>(phi_steps)};
+
+            // intialize a track
+            vector3 mom{std::cos(phi) * std::sin(theta),
+                        std::sin(phi) * std::sin(theta), std::cos(theta)};
+            vector::normalize(mom);
+            free_track_parameters<transform3> traj({0.f, 0.f, 0.f}, 0.f, mom,
+                                                   -1.f);
+
+            momenta[ieta * phi_steps + iphi] = traj.mom();
+        }
+    }
+
+    // Now run the track generator and compare
+    std::size_t n_tracks{0u};
+
+    auto trk_generator = generator_t{};
+    trk_generator.config().phi_steps(phi_steps).eta_steps(eta_steps);
+
+    for (const auto track : trk_generator) {
+        vector3& expected = momenta[n_tracks];
+        vector3 result = track.mom();
+
+        // Compare with for loop
+        EXPECT_NEAR(getter::norm(expected - result), 0.f, tol)
+            << "Expected\tResult: \n"
+            << expected[0] << "\t" << result[0] << "\n"
+            << expected[1] << "\t" << result[1] << "\n"
+            << expected[2] << "\t" << result[2] << std::endl;
+
+        ++n_tracks;
+    }
+    ASSERT_EQ(momenta.size(), n_tracks);
+}
+
+GTEST_TEST(detray_simulation, uniform_track_generator_with_range) {
+    using generator_t =
+        uniform_track_generator<free_track_parameters<transform3>>;
+
+    constexpr const scalar tol{1e-5f};
 
     std::vector<std::array<scalar, 2>> theta_phi;
 
-    for (const auto track :
-         uniform_track_generator<free_track_parameters<transform3>>(
-             theta_steps, phi_steps, {0.f, 0.f, 0.f}, 1.f * unit<scalar>::GeV,
-             {1.f, 2.f}, {-2.f, 2.f})) {
+    auto trk_gen_cfg = generator_t::configuration{};
+    trk_gen_cfg.phi_range(-2.f, 2.f).phi_steps(4u);
+    trk_gen_cfg.theta_range(1.f, 2.f).theta_steps(2u);
+
+    for (const auto track : generator_t{trk_gen_cfg}) {
         const auto dir = track.dir();
         theta_phi.push_back({getter::theta(dir), getter::phi(dir)});
     }
@@ -139,13 +196,13 @@ GTEST_TEST(detray_simulation, uniform_track_generator_with_range) {
     EXPECT_NEAR(theta_phi[2][1], 0.f, tol);
     EXPECT_NEAR(theta_phi[3][0], 1.f, tol);
     EXPECT_NEAR(theta_phi[3][1], 1.f, tol);
-    EXPECT_NEAR(theta_phi[4][0], 1.5f, tol);
+    EXPECT_NEAR(theta_phi[4][0], 2.f, tol);
     EXPECT_NEAR(theta_phi[4][1], -2.f, tol);
-    EXPECT_NEAR(theta_phi[5][0], 1.5f, tol);
+    EXPECT_NEAR(theta_phi[5][0], 2.f, tol);
     EXPECT_NEAR(theta_phi[5][1], -1.f, tol);
-    EXPECT_NEAR(theta_phi[6][0], 1.5f, tol);
+    EXPECT_NEAR(theta_phi[6][0], 2.f, tol);
     EXPECT_NEAR(theta_phi[6][1], 0.f, tol);
-    EXPECT_NEAR(theta_phi[7][0], 1.5f, tol);
+    EXPECT_NEAR(theta_phi[7][0], 2.f, tol);
     EXPECT_NEAR(theta_phi[7][1], 1.f, tol);
 }
 
@@ -156,6 +213,9 @@ GTEST_TEST(detray_simulation, random_track_generator_uniform) {
     using uniform_gen_t =
         random_numbers<scalar, std::uniform_real_distribution<scalar>,
                        std::seed_seq>;
+    using trk_generator_t =
+        random_track_generator<free_track_parameters<transform3>,
+                               uniform_gen_t>;
 
     // Tolerance depends on sample size
     constexpr scalar tol{0.05f};
@@ -165,14 +225,13 @@ GTEST_TEST(detray_simulation, random_track_generator_uniform) {
     constexpr std::size_t n_gen_tracks{10000u};
 
     // Other params
-    point3 ori = {0.f, 0.f, 0.f};
-    point3 ori_stddev = {0.1f * unit<scalar>::mm, 0.f * unit<scalar>::mm,
-                         0.2f * unit<scalar>::mm};
-    std::array<scalar, 2> mom_range = {1.f * unit<scalar>::GeV,
-                                       2.f * unit<scalar>::GeV};
-    std::array<scalar, 2> theta_range = {0.01f, constant<scalar>::pi};
-    std::array<scalar, 2> phi_range = {-0.9f * constant<scalar>::pi,
-                                       0.8f * constant<scalar>::pi};
+    trk_generator_t::configuration trk_gen_cfg{};
+    trk_gen_cfg.n_tracks(n_gen_tracks);
+    trk_gen_cfg.phi_range(-0.9f * constant<scalar>::pi,
+                          0.8f * constant<scalar>::pi);
+    trk_gen_cfg.mom_range(1.f * unit<scalar>::GeV, 2.f * unit<scalar>::GeV);
+    trk_gen_cfg.origin_stddev({0.1f * unit<scalar>::mm, 0.f * unit<scalar>::mm,
+                               0.2f * unit<scalar>::mm});
 
     // Catch the results
     std::array<scalar, n_gen_tracks> x{};
@@ -182,11 +241,7 @@ GTEST_TEST(detray_simulation, random_track_generator_uniform) {
     std::array<scalar, n_gen_tracks> phi{};
     std::array<scalar, n_gen_tracks> theta{};
 
-    for (const auto track :
-         random_track_generator<free_track_parameters<transform3>,
-                                uniform_gen_t>(n_gen_tracks, ori, ori_stddev,
-                                               mom_range, theta_range,
-                                               phi_range)) {
+    for (const auto track : trk_generator_t{trk_gen_cfg}) {
         const auto pos = track.pos();
         x[n_tracks] = pos[0];
         y[n_tracks] = pos[1];
@@ -201,6 +256,11 @@ GTEST_TEST(detray_simulation, random_track_generator_uniform) {
     ASSERT_EQ(n_gen_tracks, n_tracks);
 
     // Check uniform distrubution
+    const auto& ori = trk_gen_cfg.origin();
+    const auto& ori_stddev = trk_gen_cfg.origin_stddev();
+    const auto& phi_range = trk_gen_cfg.phi_range();
+    const auto& theta_range = trk_gen_cfg.theta_range();
+    const auto& mom_range = trk_gen_cfg.mom_range();
 
     // Mean
     EXPECT_NEAR(statistics::mean(x), ori[0], tol);
@@ -232,6 +292,8 @@ GTEST_TEST(detray_simulation, random_track_generator_normal) {
     // Use deterministic random number generator for testing
     using normal_gen_t =
         random_numbers<scalar, std::normal_distribution<scalar>, std::seed_seq>;
+    using trk_generator_t =
+        random_track_generator<free_track_parameters<transform3>, normal_gen_t>;
 
     // Tolerance depends on sample size
     constexpr scalar tol{0.05f};
@@ -241,14 +303,14 @@ GTEST_TEST(detray_simulation, random_track_generator_normal) {
     constexpr std::size_t n_gen_tracks{10000u};
 
     // Other params
-    point3 ori = {0.f, 0.f, 0.f};
-    point3 ori_stddev = {0.1f * unit<scalar>::mm, 0.5f * unit<scalar>::mm,
-                         0.3f * unit<scalar>::mm};
-    std::array<scalar, 2> mom_range = {1.f * unit<scalar>::GeV,
-                                       2.f * unit<scalar>::GeV};
-    std::array<scalar, 2> theta_range = {0.01f, constant<scalar>::pi};
-    std::array<scalar, 2> phi_range = {-0.9f * constant<scalar>::pi,
-                                       0.8f * constant<scalar>::pi};
+    trk_generator_t::configuration trk_gen_cfg{};
+    trk_gen_cfg.n_tracks(n_gen_tracks);
+    trk_gen_cfg.phi_range(-0.9f * constant<scalar>::pi,
+                          0.8f * constant<scalar>::pi);
+    trk_gen_cfg.mom_range(1.f * unit<scalar>::GeV, 2.f * unit<scalar>::GeV);
+    trk_gen_cfg.origin({0.f, 0.f, 0.f});
+    trk_gen_cfg.origin_stddev({0.1f * unit<scalar>::mm, 0.5f * unit<scalar>::mm,
+                               0.3f * unit<scalar>::mm});
 
     // Catch the results
     std::array<scalar, n_gen_tracks> x{};
@@ -258,11 +320,7 @@ GTEST_TEST(detray_simulation, random_track_generator_normal) {
     std::array<scalar, n_gen_tracks> phi{};
     std::array<scalar, n_gen_tracks> theta{};
 
-    for (const auto track :
-         random_track_generator<free_track_parameters<transform3>,
-                                normal_gen_t>(n_gen_tracks, ori, ori_stddev,
-                                              mom_range, theta_range,
-                                              phi_range)) {
+    for (const auto track : trk_generator_t{trk_gen_cfg}) {
         const auto pos = track.pos();
         x[n_tracks] = pos[0];
         y[n_tracks] = pos[1];
@@ -277,6 +335,11 @@ GTEST_TEST(detray_simulation, random_track_generator_normal) {
     ASSERT_EQ(n_gen_tracks, n_tracks);
 
     // check gaussian distribution - values are clamped to phi/theta range
+    const auto& ori = trk_gen_cfg.origin();
+    const auto& ori_stddev = trk_gen_cfg.origin_stddev();
+    const auto& phi_range = trk_gen_cfg.phi_range();
+    const auto& theta_range = trk_gen_cfg.theta_range();
+    const auto& mom_range = trk_gen_cfg.mom_range();
 
     // Mean
     EXPECT_NEAR(statistics::mean(x), ori[0], tol);
@@ -302,4 +365,4 @@ GTEST_TEST(detray_simulation, random_track_generator_normal) {
     EXPECT_NEAR(statistics::variance(theta),
                 std::pow(0.5f / 3.0f * (theta_range[1] - theta_range[0]), 2.f),
                 tol);
-}
\ No newline at end of file
+}
diff --git a/tests/unit_tests/device/cuda/navigator_cuda.cpp b/tests/unit_tests/device/cuda/navigator_cuda.cpp
index 6597e0038..a622042b3 100644
--- a/tests/unit_tests/device/cuda/navigator_cuda.cpp
+++ b/tests/unit_tests/device/cuda/navigator_cuda.cpp
@@ -32,15 +32,13 @@ TEST(navigator_cuda, navigator) {
     vecmem::vector<free_track_parameters<transform3>> tracks_host(&mng_mr);
     vecmem::vector<free_track_parameters<transform3>> tracks_device(&mng_mr);
 
-    // Set origin position of tracks
-    const point3 ori{0.f, 0.f, 0.f};
+    // Magnitude of total momentum of tracks
     const scalar p_mag{10.f * unit<scalar>::GeV};
 
     // Iterate through uniformly distributed momentum directions
     for (auto track :
          uniform_track_generator<free_track_parameters<transform3>>(
-             theta_steps, phi_steps, ori, p_mag, {0.01f, constant<scalar>::pi},
-             {-constant<scalar>::pi, constant<scalar>::pi})) {
+             phi_steps, theta_steps, p_mag)) {
         track.set_overstep_tolerance(overstep_tolerance);
 
         tracks_host.push_back(track);
diff --git a/tests/unit_tests/svgtools/intersections.cpp b/tests/unit_tests/svgtools/intersections.cpp
index 3d086ac7c..00efe6c5a 100644
--- a/tests/unit_tests/svgtools/intersections.cpp
+++ b/tests/unit_tests/svgtools/intersections.cpp
@@ -48,15 +48,14 @@ int main(int, char**) {
     const auto svg_det = il.draw_detector("detector", context, view);
 
     // Creating the rays.
-    unsigned int theta_steps{10u};
-    unsigned int phi_steps{10u};
-    const typename detector_t::point3 ori{0.f, 0.f, 100.f};
+    using generator_t =
+        detray::uniform_track_generator<detray::detail::ray<transform3_t>>;
+    auto trk_gen_cfg = generator_t::configuration{};
+    trk_gen_cfg.origin({0.f, 0.f, 100.f}).phi_steps(10u).theta_steps(10u);
 
     std::size_t index = 0;
     // Iterate through uniformly distributed momentum directions with ray
-    for (const auto test_ray :
-         detray::uniform_track_generator<detray::detail::ray<transform3_t>>(
-             theta_steps, phi_steps, ori)) {
+    for (const auto test_ray : generator_t{trk_gen_cfg}) {
 
         // Record all intersections and objects along the ray
         const auto intersection_record =
diff --git a/tests/validation/include/detray/validation/detail/navigation_check_helper.hpp b/tests/validation/include/detray/validation/detail/navigation_check_helper.hpp
index 96bff3b21..127ec05c2 100644
--- a/tests/validation/include/detray/validation/detail/navigation_check_helper.hpp
+++ b/tests/validation/include/detray/validation/detail/navigation_check_helper.hpp
@@ -84,7 +84,7 @@ bool compare_traces(const inters_trace_t &intersection_trace,
     // Do a final check on the trace sizes
     const bool is_size{n_inters_nav == intersection_trace.size()};
     EXPECT_TRUE(is_size) << "ERROR: Intersection traces found different number "
-                            "of surfaces! Please check the last elements"
+                            "of surfaces! Please check the last elements\n"
                          << debug_stream.str();
     if (not is_size) {
         return false;
diff --git a/tests/validation/src/toy_detector_validation.cpp b/tests/validation/src/toy_detector_validation.cpp
index 47b1f53b0..31c81a822 100644
--- a/tests/validation/src/toy_detector_validation.cpp
+++ b/tests/validation/src/toy_detector_validation.cpp
@@ -61,10 +61,7 @@ int main(int argc, char **argv) {
     cfg_hel_scan.name("toy_detector_helix_scan");
     cfg_hel_scan.overstepping_tolerance(-100.f * unit<scalar_t>::um);
     cfg_hel_scan.track_generator().p_mag(10.f * unit<scalar_t>::GeV);
-    // Fails in single precision for more helices (unless is configured with
-    // only three edc layers)
-    // cfg_hel_scan.track_generator().theta_steps(100u).phi_steps(100u);
-    cfg_hel_scan.track_generator().theta_steps(30u).phi_steps(30u);
+    cfg_hel_scan.track_generator().theta_steps(100u).phi_steps(100u);
     detray::detail::register_checks<detray::helix_scan>(toy_det, toy_names,
                                                         cfg_hel_scan);
 
@@ -84,7 +81,7 @@ int main(int argc, char **argv) {
     // TODO: Fails due to mask tolerances for more helices, regardless of edc
     // configuration/precision
     // cfg_hel_nav.track_generator().theta_steps(100u).phi_steps(100u);
-    cfg_hel_nav.track_generator().theta_steps(30u).phi_steps(30u);
+    cfg_hel_nav.track_generator().theta_steps(50u).phi_steps(50u);
 
     detail::register_checks<helix_navigation>(toy_det, toy_names, cfg_hel_nav);
 
diff --git a/tests/validation/src/wire_chamber_validation.cpp b/tests/validation/src/wire_chamber_validation.cpp
index 96803d378..b7e8a20d6 100644
--- a/tests/validation/src/wire_chamber_validation.cpp
+++ b/tests/validation/src/wire_chamber_validation.cpp
@@ -60,9 +60,7 @@ int main(int argc, char **argv) {
     cfg_hel_scan.name("wire_chamber_helix_scan");
     cfg_hel_scan.overstepping_tolerance(-100.f * unit<scalar_t>::um);
     cfg_hel_scan.track_generator().p_mag(10.f * unit<scalar_t>::GeV);
-    // Fails in single precision for more helices
-    // cfg_hel_scan.track_generator().theta_steps(100u).phi_steps(100u);
-    cfg_hel_scan.track_generator().theta_steps(3u).phi_steps(10u);
+    cfg_hel_scan.track_generator().theta_steps(100u).phi_steps(100u);
     detray::detail::register_checks<detray::helix_scan>(det, names,
                                                         cfg_hel_scan);
 
@@ -80,7 +78,7 @@ int main(int argc, char **argv) {
     cfg_hel_nav.track_generator() = cfg_hel_scan.track_generator();
     // TODO: Fails for more helices
     // cfg_hel_nav.track_generator().theta_steps(100u).phi_steps(100u);
-    cfg_hel_nav.track_generator().theta_steps(3u).phi_steps(10u);
+    cfg_hel_nav.track_generator().theta_steps(25u).phi_steps(25u);
 
     detail::register_checks<helix_navigation>(det, names, cfg_hel_nav);
 
diff --git a/tutorials/src/cpu/detector/detector_ray_scan.cpp b/tutorials/src/cpu/detector/detector_ray_scan.cpp
index ffc9c665d..2249a18c1 100644
--- a/tutorials/src/cpu/detector/detector_ray_scan.cpp
+++ b/tutorials/src/cpu/detector/detector_ray_scan.cpp
@@ -56,13 +56,9 @@ int main() {
     // Index of the volume that the ray origin lies in
     detray::dindex start_index{0u};
 
-    // Number of rays in theta and phi
-    unsigned int theta_steps{100u};
-    unsigned int phi_steps{100u};
-    // Origin of the rays
-    const detray::tutorial::point3 origin{0.f, 0.f, 0.f};
-    auto ray_generator =
-        detray::uniform_track_generator<ray_t>(theta_steps, phi_steps, origin);
+    // Generate a number of rays
+    auto ray_generator = detray::uniform_track_generator<ray_t>{};
+    ray_generator.config().theta_steps(100u).phi_steps(100u);
 
     // Run the check
     std::cout << "\nScanning detector (" << ray_generator.size()
diff --git a/tutorials/src/cpu/propagation/navigation_inspection.cpp b/tutorials/src/cpu/propagation/navigation_inspection.cpp
index 0420fe5eb..344dfde38 100644
--- a/tutorials/src/cpu/propagation/navigation_inspection.cpp
+++ b/tutorials/src/cpu/propagation/navigation_inspection.cpp
@@ -75,11 +75,10 @@ int main() {
     using ray_type = detray::detail::ray<detray::tutorial::transform3>;
     constexpr std::size_t theta_steps{1};
     constexpr std::size_t phi_steps{1};
-    const detray::tutorial::point3 origin{0.f, 0.f, 0.f};
 
     // Iterate through uniformly distributed momentum directions
-    for (const auto ray : detray::uniform_track_generator<ray_type>(
-             theta_steps, phi_steps, origin)) {
+    for (const auto ray :
+         detray::uniform_track_generator<ray_type>(phi_steps, theta_steps)) {
 
         // Shoot ray through the detector and record all surface intersections
         const auto intersection_trace =
diff --git a/tutorials/src/device/cuda/propagation.cpp b/tutorials/src/device/cuda/propagation.cpp
index b25f1ca94..0135e21e3 100644
--- a/tutorials/src/device/cuda/propagation.cpp
+++ b/tutorials/src/device/cuda/propagation.cpp
@@ -42,8 +42,7 @@ int main() {
     // Track directions to be generated
     constexpr unsigned int theta_steps{10u};
     constexpr unsigned int phi_steps{10u};
-    // Set origin and direction of tracks
-    const detray::tutorial::point3 origin{0.f, 0.f, 0.f};
+    // Set momentum of tracks
     const detray::scalar p_mag{10.f * detray::unit<detray::scalar>::GeV};
     // How much can the navigator overshoot on a given surface?
     constexpr detray::scalar overstep_tolerance{
@@ -52,7 +51,7 @@ int main() {
     // Genrate the tracks
     for (auto track : detray::uniform_track_generator<
              detray::free_track_parameters<detray::tutorial::transform3>>(
-             theta_steps, phi_steps, origin, p_mag)) {
+             phi_steps, theta_steps, p_mag)) {
         // Set the oversetpping tolerance for every track
         track.set_overstep_tolerance(overstep_tolerance);
         // Put it into vector of tracks
diff --git a/utils/include/detray/simulation/event_generator/random_track_generator.hpp b/utils/include/detray/simulation/event_generator/random_track_generator.hpp
index e85d005b2..341fbdfee 100644
--- a/utils/include/detray/simulation/event_generator/random_track_generator.hpp
+++ b/utils/include/detray/simulation/event_generator/random_track_generator.hpp
@@ -82,6 +82,8 @@ class random_track_generator
 
     /// Configure how tracks are generated
     struct configuration {
+        /// Ensure sensible values at the theta bounds, even in single precision
+        static constexpr scalar epsilon{1e-2f};
 
         /// Gaussian vertex smearing
         bool m_do_vtx_smearing = true;
@@ -89,10 +91,12 @@ class random_track_generator
         /// How many tracks will be generated
         std::size_t m_n_tracks{10u};
 
-        /// Range for theta and phi
+        /// Range for phi and theta
         std::array<scalar, 2> m_phi_range{-constant<scalar>::pi,
                                           constant<scalar>::pi};
-        std::array<scalar, 2> m_theta_range{0.01f, constant<scalar>::pi};
+        std::array<scalar, 2> m_theta_range{epsilon,
+                                            constant<scalar>::pi - epsilon};
+
         /// Momentum range
         std::array<scalar, 2> m_mom_range{1.f * unit<scalar>::GeV,
                                           1.f * unit<scalar>::GeV};
@@ -104,35 +108,49 @@ class random_track_generator
 
         /// Setters
         /// @{
-        configuration& do_vertex_smearing(bool b) {
+        DETRAY_HOST_DEVICE configuration& do_vertex_smearing(bool b) {
             m_do_vtx_smearing = b;
             return *this;
         }
-        configuration& n_tracks(std::size_t n) {
+        DETRAY_HOST_DEVICE configuration& n_tracks(std::size_t n) {
+            assert(n > 0);
             m_n_tracks = n;
             return *this;
         }
-        configuration& theta_range(scalar low, scalar high) {
-            m_theta_range = {low, high};
+        DETRAY_HOST_DEVICE configuration& phi_range(scalar low, scalar high) {
+            assert(low <= high);
+            m_phi_range = {low, high};
             return *this;
         }
-        configuration& phi_range(scalar low, scalar high) {
-            m_phi_range = {low, high};
+        DETRAY_HOST_DEVICE configuration& theta_range(scalar low, scalar high) {
+            auto min_theta{
+                std::clamp(low, epsilon, constant<scalar>::pi - epsilon)};
+            auto max_theta{
+                std::clamp(high, epsilon, constant<scalar>::pi - epsilon)};
+
+            assert(min_theta <= max_theta);
+
+            m_theta_range = {min_theta, max_theta};
             return *this;
         }
-        configuration& origin(point3 ori) {
+        DETRAY_HOST_DEVICE configuration& mom_range(scalar low, scalar high) {
+            assert(low <= high);
+            m_mom_range = {low, high};
+            return *this;
+        }
+        DETRAY_HOST_DEVICE configuration& origin(point3 ori) {
             m_origin = ori;
             return *this;
         }
-        configuration& origin_stddev(point3 stddev) {
+        DETRAY_HOST_DEVICE configuration& origin_stddev(point3 stddev) {
             m_origin_stddev = stddev;
             return *this;
         }
-        configuration& time(scalar t) {
+        DETRAY_HOST_DEVICE configuration& time(scalar t) {
             m_time = t;
             return *this;
         }
-        configuration& charge(scalar q) {
+        DETRAY_HOST_DEVICE configuration& charge(scalar q) {
             m_charge = q;
             return *this;
         }
@@ -140,23 +158,32 @@ class random_track_generator
 
         /// Getters
         /// @{
-        constexpr bool do_vertex_smearing() const { return m_do_vtx_smearing; }
-        constexpr std::size_t n_tracks() const { return m_n_tracks; }
-        constexpr const std::array<scalar, 2>& theta_range() const {
-            return m_theta_range;
+        DETRAY_HOST_DEVICE constexpr bool do_vertex_smearing() const {
+            return m_do_vtx_smearing;
+        }
+        DETRAY_HOST_DEVICE constexpr std::size_t n_tracks() const {
+            return m_n_tracks;
         }
-        constexpr const std::array<scalar, 2>& phi_range() const {
+        DETRAY_HOST_DEVICE constexpr const std::array<scalar, 2>& phi_range()
+            const {
             return m_phi_range;
         }
-        constexpr const std::array<scalar, 2>& mom_range() const {
+        DETRAY_HOST_DEVICE constexpr const std::array<scalar, 2>& theta_range()
+            const {
+            return m_theta_range;
+        }
+        DETRAY_HOST_DEVICE constexpr const std::array<scalar, 2>& mom_range()
+            const {
             return m_mom_range;
         }
-        constexpr const point3& origin() const { return m_origin; }
-        constexpr const point3& origin_stddev() const {
+        DETRAY_HOST_DEVICE constexpr const point3& origin() const {
+            return m_origin;
+        }
+        DETRAY_HOST_DEVICE constexpr const point3& origin_stddev() const {
             return m_origin_stddev;
         }
-        constexpr scalar time() const { return m_time; }
-        constexpr scalar charge() const { return m_charge; }
+        DETRAY_HOST_DEVICE constexpr scalar time() const { return m_time; }
+        DETRAY_HOST_DEVICE constexpr scalar charge() const { return m_charge; }
         /// @}
     };
 
@@ -253,38 +280,35 @@ class random_track_generator
     constexpr random_track_generator() = default;
 
     /// Construct from external configuration
+    DETRAY_HOST_DEVICE
     constexpr random_track_generator(configuration cfg) : m_gen{}, m_cfg(cfg) {}
 
-    /// Paramtetrized constructor for fine-grained configurations
+    /// Paramtetrized constructor for quick construction of simple tasks
+    ///
+    /// @note For more complex tasks, use the @c configuration type
     ///
     /// @param n_tracks the number of steps in the theta space
-    /// @param trk_origin the starting point of the track
-    /// @param origin_stddev the standard deviation of origin
     /// @param mom_range the range of the track momentum (in GeV)
-    /// @param theta_range the range for theta values
-    /// @param phi_range the range for phi values
-    /// @param time time measurement (micro seconds)
     /// @param charge charge of particle (e)
     DETRAY_HOST_DEVICE
     random_track_generator(
-        std::size_t n_tracks, point3 trk_origin = {0.f, 0.f, 0.f},
-        point3 origin_stddev = {0.f, 0.f, 0.f},
+        std::size_t n_tracks,
         std::array<scalar, 2> mom_range = {1.f * unit<scalar>::GeV,
                                            1.f * unit<scalar>::GeV},
-        std::array<scalar, 2> theta_range = {0.01f, constant<scalar>::pi},
-        std::array<scalar, 2> phi_range = {-constant<scalar>::pi,
-                                           constant<scalar>::pi},
-        scalar time = 0.f * unit<scalar>::us,
-        scalar charge = -1.f * unit<scalar>::e, bool do_vertex_smearing = true)
-        : m_gen{}, m_cfg{do_vertex_smearing, n_tracks,  phi_range,
-                         theta_range,        mom_range, trk_origin,
-                         origin_stddev,      time,      charge} {}
+        scalar charge = -1.f * unit<scalar>::e)
+        : m_gen{}, m_cfg{} {
+        m_cfg.n_tracks(n_tracks);
+        m_cfg.mom_range(mom_range);
+        m_cfg.charge(charge);
+    }
 
     /// Move constructor
+    DETRAY_HOST_DEVICE
     random_track_generator(random_track_generator&& other)
         : m_gen(std::move(other.m_gen)), m_cfg(std::move(other.m_cfg)) {}
 
     /// Access the configuration
+    DETRAY_HOST_DEVICE
     constexpr configuration& config() { return m_cfg; }
 
     /// @returns the generator in initial state.
@@ -304,4 +328,4 @@ class random_track_generator
     }
 };
 
-}  // namespace detray
\ No newline at end of file
+}  // namespace detray
diff --git a/utils/include/detray/simulation/event_generator/uniform_track_generator.hpp b/utils/include/detray/simulation/event_generator/uniform_track_generator.hpp
index 78327bc4b..4c1382366 100644
--- a/utils/include/detray/simulation/event_generator/uniform_track_generator.hpp
+++ b/utils/include/detray/simulation/event_generator/uniform_track_generator.hpp
@@ -39,14 +39,23 @@ class uniform_track_generator
 
     /// Configure how tracks are generated
     struct configuration {
+        /// Ensure sensible values at the theta bounds, even in single precision
+        static constexpr scalar epsilon{1e-2f};
 
         /// Range for theta and phi
-        std::array<scalar, 2> m_theta_range{0.01f, constant<scalar>::pi};
         std::array<scalar, 2> m_phi_range{-constant<scalar>::pi,
                                           constant<scalar>::pi};
+        std::array<scalar, 2> m_theta_range{epsilon,
+                                            constant<scalar>::pi - epsilon};
+        std::array<scalar, 2> m_eta_range{-5.f, 5.f};
+
         /// Angular step size
-        std::size_t m_theta_steps{50u};
         std::size_t m_phi_steps{50u};
+        std::size_t m_theta_steps{50u};
+
+        /// Do uniform eta steps instead of uniform theta steps
+        /// (use same number of steps and range)
+        bool m_uniform_eta{false};
 
         /// Track origin
         point3 m_origin{0.f, 0.f, 0.f};
@@ -56,39 +65,74 @@ class uniform_track_generator
         scalar m_p_mag{1.f * unit<scalar>::GeV};
 
         /// Time parameter and charge of the track
-        scalar m_time{0.f * unit<scalar>::us}, m_charge{-1.f * unit<scalar>::e};
+        scalar m_time{0.f * unit<scalar>::us};
+        scalar m_charge{-1.f * unit<scalar>::e};
 
         /// Setters
         /// @{
-        configuration& theta_range(scalar low, scalar high) {
-            m_theta_range = {low, high};
+        DETRAY_HOST_DEVICE configuration& phi_range(scalar low, scalar high) {
+            assert(low <= high);
+            m_phi_range = {low, high};
             return *this;
         }
-        configuration& phi_range(scalar low, scalar high) {
-            m_phi_range = {low, high};
+        DETRAY_HOST_DEVICE configuration& theta_range(scalar low, scalar high) {
+            auto min_theta{
+                std::clamp(low, epsilon, constant<scalar>::pi - epsilon)};
+            auto max_theta{
+                std::clamp(high, epsilon, constant<scalar>::pi - epsilon)};
+
+            assert(min_theta <= max_theta);
+
+            m_theta_range = {min_theta, max_theta};
+            m_uniform_eta = false;
             return *this;
         }
-        configuration& theta_steps(std::size_t n) {
-            m_theta_steps = n;
+        DETRAY_HOST_DEVICE configuration& eta_range(scalar low, scalar high) {
+            // This value is more or less random
+            constexpr auto num_max{0.001f * std::numeric_limits<scalar>::max()};
+            auto min_eta{low > -num_max ? low : -num_max};
+            auto max_eta{high < num_max ? high : num_max};
+
+            assert(min_eta <= max_eta);
+
+            m_eta_range = {min_eta, max_eta};
+            m_uniform_eta = true;
             return *this;
         }
-        configuration& phi_steps(std::size_t n) {
+        DETRAY_HOST_DEVICE configuration& phi_steps(std::size_t n) {
+            assert(n > 0);
             m_phi_steps = n;
             return *this;
         }
-        configuration& origin(point3 ori) {
+        DETRAY_HOST_DEVICE configuration& theta_steps(std::size_t n) {
+            assert(n > 0);
+            m_theta_steps = n;
+            m_uniform_eta = false;
+            return *this;
+        }
+        DETRAY_HOST_DEVICE configuration& eta_steps(std::size_t n) {
+            assert(n > 0);
+            m_theta_steps = n;
+            m_uniform_eta = true;
+            return *this;
+        }
+        DETRAY_HOST_DEVICE configuration& uniform_eta(bool b) {
+            m_uniform_eta = b;
+            return *this;
+        }
+        DETRAY_HOST_DEVICE configuration& origin(point3 ori) {
             m_origin = ori;
             return *this;
         }
-        configuration& p_mag(scalar p) {
+        DETRAY_HOST_DEVICE configuration& p_mag(scalar p) {
             m_p_mag = p;
             return *this;
         }
-        configuration& time(scalar t) {
+        DETRAY_HOST_DEVICE configuration& time(scalar t) {
             m_time = t;
             return *this;
         }
-        configuration& charge(scalar q) {
+        DETRAY_HOST_DEVICE configuration& charge(scalar q) {
             m_charge = q;
             return *this;
         }
@@ -96,18 +140,33 @@ class uniform_track_generator
 
         /// Getters
         /// @{
-        constexpr std::array<scalar, 2> theta_range() const {
+        DETRAY_HOST_DEVICE constexpr std::array<scalar, 2> phi_range() const {
+            return m_phi_range;
+        }
+        DETRAY_HOST_DEVICE constexpr std::array<scalar, 2> theta_range() const {
             return m_theta_range;
         }
-        constexpr std::array<scalar, 2> phi_range() const {
-            return m_phi_range;
+        DETRAY_HOST_DEVICE constexpr std::array<scalar, 2> eta_range() const {
+            return m_eta_range;
+        }
+        DETRAY_HOST_DEVICE constexpr std::size_t phi_steps() const {
+            return m_phi_steps;
+        }
+        DETRAY_HOST_DEVICE constexpr std::size_t theta_steps() const {
+            return m_theta_steps;
+        }
+        DETRAY_HOST_DEVICE constexpr std::size_t eta_steps() const {
+            return m_theta_steps;
+        }
+        DETRAY_HOST_DEVICE constexpr bool uniform_eta() const {
+            return m_uniform_eta;
+        }
+        DETRAY_HOST_DEVICE constexpr const point3& origin() const {
+            return m_origin;
         }
-        constexpr std::size_t theta_steps() const { return m_theta_steps; }
-        constexpr std::size_t phi_steps() const { return m_phi_steps; }
-        constexpr const point3& origin() const { return m_origin; }
-        constexpr scalar p_mag() const { return m_p_mag; }
-        constexpr scalar time() const { return m_time; }
-        constexpr scalar charge() const { return m_charge; }
+        DETRAY_HOST_DEVICE constexpr scalar p_mag() const { return m_p_mag; }
+        DETRAY_HOST_DEVICE constexpr scalar time() const { return m_time; }
+        DETRAY_HOST_DEVICE constexpr scalar charge() const { return m_charge; }
         /// @}
     };
 
@@ -127,12 +186,15 @@ class uniform_track_generator
         constexpr iterator(configuration cfg, std::size_t iph = 1u,
                            std::size_t ith = 0u)
             : m_cfg{cfg},
-              m_theta_step_size{(cfg.theta_range()[1] - cfg.theta_range()[0]) /
-                                static_cast<scalar>(cfg.theta_steps())},
               m_phi_step_size{(cfg.phi_range()[1] - cfg.phi_range()[0]) /
                               static_cast<scalar>(cfg.phi_steps())},
+              m_theta_step_size{(cfg.theta_range()[1] - cfg.theta_range()[0]) /
+                                static_cast<scalar>(cfg.theta_steps() - 1u)},
+              m_eta_step_size{(cfg.eta_range()[1] - cfg.eta_range()[0]) /
+                              static_cast<scalar>(cfg.eta_steps() - 1u)},
               m_phi{cfg.phi_range()[0]},
-              m_theta{cfg.theta_range()[0]},
+              m_theta{cfg.uniform_eta() ? get_theta(cfg.eta_range()[0])
+                                        : cfg.theta_range()[0]},
               i_phi{iph},
               i_theta{ith} {}
 
@@ -153,8 +215,10 @@ class uniform_track_generator
         /// @returns the generator at its next position.
         DETRAY_HOST_DEVICE
         constexpr auto operator++() -> iterator& {
+
             // Check theta range according to step size
             if (i_theta < m_cfg.theta_steps()) {
+
                 // Check phi sub-range
                 if (i_phi < m_cfg.phi_steps()) {
                     // Calculate new phi in the given range
@@ -169,8 +233,16 @@ class uniform_track_generator
 
                 // Calculate new theta in the given range
                 ++i_theta;
-                m_theta = m_cfg.theta_range()[0] +
-                          static_cast<scalar>(i_theta) * m_theta_step_size;
+
+                if (m_cfg.uniform_eta()) {
+                    const scalar eta =
+                        m_cfg.eta_range()[0] +
+                        static_cast<scalar>(i_theta) * m_eta_step_size;
+                    m_theta = get_theta(eta);
+                } else {
+                    m_theta = m_cfg.theta_range()[0] +
+                              static_cast<scalar>(i_theta) * m_theta_step_size;
+                }
             }
             return *this;
         }
@@ -179,29 +251,38 @@ class uniform_track_generator
         DETRAY_HOST_DEVICE
         track_t operator*() const {
             // Momentum direction from angles
-            vector3 mom{math_ns::cos(m_phi) * std::sin(m_theta),
-                        std::sin(m_phi) * std::sin(m_theta),
-                        math_ns::cos(m_theta)};
+            vector3 p{math_ns::cos(m_phi) * std::sin(m_theta),
+                      std::sin(m_phi) * std::sin(m_theta),
+                      math_ns::cos(m_theta)};
             // Magnitude of momentum
-            vector::normalize(mom);
-            mom = m_cfg.p_mag() * mom;
+            vector::normalize(p);
+            p = m_cfg.p_mag() * p;
 
-            return track_t{m_cfg.origin(), m_cfg.time(), mom, m_cfg.charge()};
+            return track_t{m_cfg.origin(), m_cfg.time(), p, m_cfg.charge()};
         }
 
         /// Current configuration
         configuration m_cfg{};
 
         /// Angular step sizes
-        scalar m_theta_step_size{0.f};
         scalar m_phi_step_size{0.f};
+        scalar m_theta_step_size{0.f};
+        scalar m_eta_step_size{0.f};
 
         /// Phi and theta angles of momentum direction
-        scalar m_phi{-constant<scalar>::pi}, m_theta{0.01f};
+        scalar m_phi{-constant<scalar>::pi};
+        scalar m_theta{configuration::epsilon};
 
         /// Iteration indices
         std::size_t i_phi{0u};
         std::size_t i_theta{0u};
+
+        private:
+        /// @returns the theta angle for a given @param eta value
+        DETRAY_HOST_DEVICE
+        scalar get_theta(const scalar eta) {
+            return 2.f * std::atan(std::exp(-eta));
+        }
     };
 
     configuration m_cfg{};
@@ -216,30 +297,29 @@ class uniform_track_generator
     DETRAY_HOST_DEVICE
     constexpr uniform_track_generator(configuration cfg) : m_cfg{cfg} {}
 
-    /// Paramtetrized constructor for fine-grained configurations
+    /// Paramtetrized constructor for quick construction of simple tasks
+    ///
+    /// @note For more complex tasks, use the @c configuration type
     ///
     /// @param n_theta the number of steps in the theta space
     /// @param n_phi the number of steps in the phi space
-    /// @param trk_origin the starting point of the track
-    /// @param trk_mom magnitude of the track momentum (in GeV)
-    /// @param theta_range the range for theta values
-    /// @param phi_range the range for phi values
-    /// @param time time measurement (micro seconds)
+    /// @param p_mag magnitude of the track momentum (in GeV)
+    /// @param uniform_eta uniformly step through eta space instead of theta
     /// @param charge charge of particle (e)
     DETRAY_HOST_DEVICE
-    uniform_track_generator(
-        std::size_t n_theta, std::size_t n_phi,
-        point3 trk_origin = {0.f, 0.f, 0.f},
-        scalar trk_mom = 1.f * unit<scalar>::GeV,
-        std::array<scalar, 2> theta_range = {0.01f, constant<scalar>::pi},
-        std::array<scalar, 2> phi_range = {-constant<scalar>::pi,
-                                           constant<scalar>::pi},
-        scalar time = 0.f * unit<scalar>::us,
-        scalar charge = -1.f * unit<scalar>::e)
-        : m_cfg{theta_range, phi_range, n_theta, n_phi,
-                trk_origin,  trk_mom,   time,    charge} {}
+    uniform_track_generator(std::size_t n_phi, std::size_t n_theta,
+                            scalar p_mag = 1.f * unit<scalar>::GeV,
+                            bool uniform_eta = false,
+                            scalar charge = -1.f * unit<scalar>::e)
+        : m_cfg{} {
+        m_cfg.phi_steps(n_phi).theta_steps(n_theta);
+        m_cfg.uniform_eta(uniform_eta);
+        m_cfg.p_mag(p_mag);
+        m_cfg.charge(charge);
+    }
 
     /// Move constructor
+    DETRAY_HOST_DEVICE
     uniform_track_generator(uniform_track_generator&& other)
         : m_cfg(std::move(other.m_cfg)) {}
 
@@ -252,6 +332,7 @@ class uniform_track_generator
     }
 
     /// Access the configuration
+    DETRAY_HOST_DEVICE
     constexpr configuration& config() { return m_cfg; }
 
     /// @returns the generator in initial state: Default values reflect the
@@ -270,7 +351,7 @@ class uniform_track_generator
     /// @returns the number of tracks that will be generated
     DETRAY_HOST_DEVICE
     constexpr auto size() const noexcept -> std::size_t {
-        return m_cfg.theta_steps() * m_cfg.phi_steps();
+        return m_cfg.phi_steps() * m_cfg.theta_steps();
     }
 };
 

From 7cd20130ed8ee9297dc032def554bf8aad4dcdec Mon Sep 17 00:00:00 2001
From: Attila Krasznahorkay <Attila.Krasznahorkay@cern.ch>
Date: Mon, 9 Oct 2023 16:17:16 +0200
Subject: [PATCH 14/29] Updated some externals for (better) Windows
 compatibility.

---
 extern/covfie/CMakeLists.txt     | 4 ++--
 extern/googletest/CMakeLists.txt | 4 ++--
 extern/vecmem/CMakeLists.txt     | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/extern/covfie/CMakeLists.txt b/extern/covfie/CMakeLists.txt
index c43476f33..86f3467e5 100644
--- a/extern/covfie/CMakeLists.txt
+++ b/extern/covfie/CMakeLists.txt
@@ -1,6 +1,6 @@
 # Detray library, part of the ACTS project (R&D line)
 #
-# (c) 2022 CERN for the benefit of the ACTS project
+# (c) 2022-2023 CERN for the benefit of the ACTS project
 #
 # Mozilla Public License Version 2.0
 
@@ -18,7 +18,7 @@ message( STATUS "Fetching covfie as part of the Detray project" )
 
 # Declare where to get covfie from.
 set( DETRAY_COVFIE_SOURCE
-   "URL;https://github.com/acts-project/covfie/archive/refs/tags/v0.8.0.tar.gz;URL_MD5;b29a452aa529ee1b170650a15c591ce8"
+   "URL;https://github.com/acts-project/covfie/archive/refs/tags/v0.8.1.tar.gz;URL_MD5;0b4dc9624533d1ed4ea7a763da47f07e"
    CACHE STRING "Source for covfie, when built as part of this project" )
 mark_as_advanced( DETRAY_COVFIE_SOURCE )
 FetchContent_Declare( covfie ${DETRAY_COVFIE_SOURCE} )
diff --git a/extern/googletest/CMakeLists.txt b/extern/googletest/CMakeLists.txt
index 8ad9bdd40..de5f3f4c2 100644
--- a/extern/googletest/CMakeLists.txt
+++ b/extern/googletest/CMakeLists.txt
@@ -1,6 +1,6 @@
 # Detray library, part of the ACTS project (R&D line)
 #
-# (c) 2021 CERN for the benefit of the ACTS project
+# (c) 2021-2023 CERN for the benefit of the ACTS project
 #
 # Mozilla Public License Version 2.0
 
@@ -18,7 +18,7 @@ message( STATUS "Building GoogleTest as part of the Detray project" )
 
 # Declare where to get GoogleTest from.
 set( DETRAY_GOOGLETEST_SOURCE
-   "URL;https://github.com/google/googletest/archive/release-1.11.0.tar.gz;URL_MD5;e8a8df240b6938bb6384155d4c37d937"
+   "URL;https://github.com/google/googletest/archive/refs/tags/v1.14.0.tar.gz;URL_MD5;c8340a482851ef6a3fe618a082304cfc"
    CACHE STRING "Source for GoogleTest, when built as part of this project" )
 mark_as_advanced( DETRAY_GOOGLETEST_SOURCE )
 FetchContent_Declare( GoogleTest ${DETRAY_GOOGLETEST_SOURCE} )
diff --git a/extern/vecmem/CMakeLists.txt b/extern/vecmem/CMakeLists.txt
index 2cdb553cd..07f907011 100644
--- a/extern/vecmem/CMakeLists.txt
+++ b/extern/vecmem/CMakeLists.txt
@@ -18,7 +18,7 @@ message( STATUS "Building VecMem as part of the Detray project" )
 
 # Declare where to get VecMem from.
 set( DETRAY_VECMEM_SOURCE
-   "URL;https://github.com/acts-project/vecmem/archive/refs/tags/v0.24.0.tar.gz;URL_MD5;f6936ea57921d7e5110606c7a9e9a371"
+   "URL;https://github.com/acts-project/vecmem/archive/refs/tags/v0.27.0.tar.gz;URL_MD5;cd1520efbd46d5d09ac5727452939ede"
    CACHE STRING "Source for VecMem, when built as part of this project" )
 mark_as_advanced( DETRAY_VECMEM_SOURCE )
 FetchContent_Declare( VecMem ${DETRAY_VECMEM_SOURCE} )

From 573ba648f7f50b962418f853ae6a5fd981f50748 Mon Sep 17 00:00:00 2001
From: Joana Niermann <joana.niermann@cern.ch>
Date: Mon, 7 Aug 2023 16:23:29 +0200
Subject: [PATCH 15/29] Various fixes and refactoring: - Remove some template
 arguments from the surface factories and pass information as runtime
 parameters instead. - Collaps the various ways to add surfaces to one
 `add_surfaces` method - Improved comments - Similar to the `surface_factory`,
 explicitly preserve ordering of material data by adding indices to the
 payloads and direct placing in the container. Can alternatively also be
 passed without explicit ordering (if surface index is invalid) - clear the
 placement vector in the telescope creation to add surface only once -
 correctly initialize material rod vector in IO, so that wire chamber can be
 built correctly

---
 .../surface_finders/brute_force_finder.hpp    |  12 +-
 .../detray/tools/cuboid_portal_generator.hpp  |   6 -
 .../include/detray/tools/detector_builder.hpp |   4 +-
 .../include/detray/tools/material_builder.hpp |  40 +--
 .../include/detray/tools/material_factory.hpp | 106 ++++---
 core/include/detray/tools/surface_factory.hpp | 230 +++++++---------
 .../tools/surface_factory_interface.hpp       |  64 ++++-
 core/include/detray/tools/volume_builder.hpp  |  61 +++--
 .../detray/tools/volume_builder_interface.hpp |  38 +--
 core/include/detray/utils/type_registry.hpp   |   3 +-
 io/include/detray/io/common/detail/utils.hpp  |   2 +-
 .../detray/io/common/detector_reader.hpp      |  34 ++-
 .../detray/io/common/detector_writer.hpp      |   5 +-
 .../detray/io/common/geometry_reader.hpp      |  79 ++----
 .../io/common/homogeneous_material_reader.hpp |  22 +-
 .../io/common/homogeneous_material_writer.hpp |  35 ++-
 io/include/detray/io/common/payloads.hpp      |   6 +-
 .../detray/io/json/json_material_io.hpp       |  14 +-
 io/include/detray/io/json/json_reader.hpp     |   4 +-
 tests/unit_tests/cpu/core_detector.cpp        | 259 ++++++++----------
 tests/unit_tests/cpu/grid_grid_builder.cpp    |  95 ++++---
 .../unit_tests/cpu/tools_material_builder.cpp |  64 ++---
 .../unit_tests/io/io_json_detector_reader.cpp | 142 +++++++++-
 tests/unit_tests/io/io_json_payload.cpp       |   9 +-
 .../tutorial/square_surface_generator.hpp     |   8 +-
 .../cpu/detector/do_it_yourself_detector.cpp  |  13 +-
 .../cpu/detector/read_detector_from_file.cpp  |   4 +-
 .../cpu/detector/track_geometry_changes.cpp   |   4 +-
 .../detectors/create_telescope_detector.hpp   |   1 +
 29 files changed, 741 insertions(+), 623 deletions(-)

diff --git a/core/include/detray/surface_finders/brute_force_finder.hpp b/core/include/detray/surface_finders/brute_force_finder.hpp
index 50ad35b0e..2fda8b192 100644
--- a/core/include/detray/surface_finders/brute_force_finder.hpp
+++ b/core/include/detray/surface_finders/brute_force_finder.hpp
@@ -119,6 +119,12 @@ class brute_force_collection {
         : m_offsets(detail::get<0>(view.m_view)),
           m_surfaces(detail::get<1>(view.m_view)) {}
 
+    /// @returns access to the volume offsets - const
+    DETRAY_HOST const auto& offsets() const { return m_offsets; }
+
+    /// @returns access to the volume offsets
+    DETRAY_HOST auto& offsets() { return m_offsets; }
+
     /// @returns number of surface collections (at least on per volume) - const
     DETRAY_HOST_DEVICE
     constexpr auto size() const noexcept -> size_type {
@@ -132,12 +138,6 @@ class brute_force_collection {
         return size() == size_type{0};
     }
 
-    /// @returns access to the volume offsets - const
-    DETRAY_HOST const auto& offsets() const { return m_offsets; }
-
-    /// @returns access to the volume offsets
-    DETRAY_HOST auto& offsets() { return m_offsets; }
-
     /// @return access to the surface container - const.
     DETRAY_HOST_DEVICE
     auto all() const -> const vector_type<surface_t>& { return m_surfaces; }
diff --git a/core/include/detray/tools/cuboid_portal_generator.hpp b/core/include/detray/tools/cuboid_portal_generator.hpp
index e994345e6..7954d7268 100644
--- a/core/include/detray/tools/cuboid_portal_generator.hpp
+++ b/core/include/detray/tools/cuboid_portal_generator.hpp
@@ -54,12 +54,6 @@ class cuboid_portal_generator final
     DETRAY_HOST
     cuboid_portal_generator(const scalar_t env) : m_envelope{env} {}
 
-    /// @returns the id for the surface type (portal surfaces)
-    DETRAY_HOST
-    auto surface_type() const -> surface_id override {
-        return surface_id::e_portal;
-    }
-
     /// @returns the number of rectangle portals this factory will produce
     DETRAY_HOST
     auto size() const -> dindex override { return 6u; }
diff --git a/core/include/detray/tools/detector_builder.hpp b/core/include/detray/tools/detector_builder.hpp
index f07f1675f..4cfe7afa8 100644
--- a/core/include/detray/tools/detector_builder.hpp
+++ b/core/include/detray/tools/detector_builder.hpp
@@ -29,9 +29,10 @@ namespace detray {
 /// @brief Provides functionality to build a detray detector volume by volume
 ///
 /// @tparam metadata the type definitions for the detector
+/// @tparam bfield_bknd_t the type of magnetic field to be used
 /// @tparam volume_builder_t the basic volume builder to be used for the
 ///                          geometry data
-/// @tparam volume_data_t the data structure that hold the volume builders
+/// @tparam volume_data_t the data structure that holds the volume builders
 template <typename metadata = default_metadata,
           typename bfield_bknd_t = bfield::const_bknd_t,
           template <typename> class volume_builder_t = volume_builder,
@@ -96,7 +97,6 @@ class detector_builder {
     }
 
     /// Assembles the detector, without a magnetic field
-    // TODO: Remove, won't work for non-constant bfields
     DETRAY_HOST
     void set_bfield(typename detector_type::bfield_type&& field) {
         m_bfield = std::forward<typename detector_type::bfield_type>(field);
diff --git a/core/include/detray/tools/material_builder.hpp b/core/include/detray/tools/material_builder.hpp
index 2d9581362..ae7383f8f 100644
--- a/core/include/detray/tools/material_builder.hpp
+++ b/core/include/detray/tools/material_builder.hpp
@@ -40,30 +40,12 @@ class material_builder final : public volume_decorator<detector_t> {
     /// present in the factory, otherwise only add material)
     /// @{
     DETRAY_HOST
-    void add_portals(
-        std::shared_ptr<surface_factory_interface<detector_t>> pt_factory,
-        typename detector_t::geometry_context ctx = {}) override {
-
-        // If the factory also holds surface data, call base volume builder
-        volume_decorator<detector_t>::add_portals(pt_factory, ctx);
-
-        // Add material
-        auto mat_factory =
-            std::dynamic_pointer_cast<material_factory<detector_t>>(pt_factory);
-        if (mat_factory) {
-            (*mat_factory)(this->surfaces(), m_materials);
-        } else {
-            throw std::runtime_error("Not a material factory");
-        }
-    }
-
-    DETRAY_HOST
-    void add_sensitives(
+    void add_surfaces(
         std::shared_ptr<surface_factory_interface<detector_t>> sf_factory,
         typename detector_t::geometry_context ctx = {}) override {
 
         // If the factory also holds surface data, call base volume builder
-        volume_decorator<detector_t>::add_sensitives(sf_factory, ctx);
+        volume_decorator<detector_t>::add_surfaces(sf_factory, ctx);
 
         // Add material
         auto mat_factory =
@@ -74,24 +56,6 @@ class material_builder final : public volume_decorator<detector_t> {
             throw std::runtime_error("Not a material factory");
         }
     }
-
-    DETRAY_HOST
-    void add_passives(
-        std::shared_ptr<surface_factory_interface<detector_t>> ps_factory,
-        typename detector_t::geometry_context ctx = {}) override {
-
-        // If the factory also holds surface data, call base volume builder
-        volume_decorator<detector_t>::add_passives(ps_factory, ctx);
-
-        // Add material
-        auto mat_factory =
-            std::dynamic_pointer_cast<material_factory<detector_t>>(ps_factory);
-        if (mat_factory) {
-            (*mat_factory)(this->surfaces(), m_materials);
-        } else {
-            throw std::runtime_error("Not a material factory");
-        }
-    }
     /// @}
 
     /// Add the volume and the material to the detector @param det
diff --git a/core/include/detray/tools/material_factory.hpp b/core/include/detray/tools/material_factory.hpp
index 0b8b75da3..f4f22bbc3 100644
--- a/core/include/detray/tools/material_factory.hpp
+++ b/core/include/detray/tools/material_factory.hpp
@@ -15,8 +15,10 @@
 #include "detray/utils/ranges.hpp"
 
 // System include(s)
+#include <algorithm>
 #include <cassert>
 #include <memory>
+#include <numeric>
 #include <tuple>
 #include <type_traits>
 #include <vector>
@@ -32,10 +34,13 @@ class material_data {
     /// @param mat predefined material, see
     ///            'detray/materials/predefined_materials.hpp'
     /// @param thickness of the material slab/rod
+    /// @param sf_idx the index of the surface this material belongs to, needs
+    ///               to be passed only if a special oredering must be observed
     DETRAY_HOST
-    constexpr material_data(const scalar_t thickness,
-                            const material<scalar_t> &mat)
-        : m_mat{mat}, m_thickness{thickness} {}
+    constexpr material_data(
+        const scalar_t thickness, const material<scalar_t> &mat,
+        const std::size_t sf_idx = detail::invalid_value<std::size_t>())
+        : m_sf_index{sf_idx}, m_mat{mat}, m_thickness{thickness} {}
 
     /// Construct from all parameters:
     ///
@@ -46,23 +51,30 @@ class material_data {
     /// @param material_paramters3 z is the nuclear charge number
     /// @param material_paramters4 molarRho is the molar density
     /// @param state of the material (liquid, solid etc.)
+    /// @param sf_idx the index of the surface this material belongs to, needs
+    ///               to be passed only if a special oredering must be observed
     DETRAY_HOST
     constexpr material_data(
         const scalar_t thickness,
         const std::vector<scalar_t> &material_paramters,
-        const material_state state = material_state::e_solid)
-        : m_mat{material_paramters[0], material_paramters[1],
+        const material_state state = material_state::e_solid,
+        const std::size_t sf_idx = detail::invalid_value<std::size_t>())
+        : m_sf_index{sf_idx},
+          m_mat{material_paramters[0], material_paramters[1],
                 material_paramters[2], material_paramters[3],
                 material_paramters[4], state},
           m_thickness{thickness} {}
 
     /// @returns tuple based access to the contained material data.
     DETRAY_HOST
-    constexpr auto get_data() -> std::tuple<material<scalar_t> &, scalar_t &> {
-        return std::tie(m_mat, m_thickness);
+    constexpr auto get_data()
+        -> std::tuple<std::size_t &, material<scalar_t> &, scalar_t &> {
+        return std::tie(m_sf_index, m_mat, m_thickness);
     }
 
     private:
+    /// The position of the material in its respective detector collection
+    std::size_t m_sf_index{detail::invalid_value<std::size_t>()};
     /// The material parametrization
     material<scalar_t> m_mat{};
     /// Thickness/radius of the material slab/rod
@@ -84,9 +96,7 @@ class material_factory final : public factory_decorator<detector_t> {
     using material_id = typename detector_t::materials::id;
 
     using base_factory = factory_decorator<detector_t>;
-    using placeholder_factory_t =
-        surface_factory<detector_t, unmasked, static_cast<mask_id>(0),
-                        surface_id::e_passive>;
+    using placeholder_factory_t = surface_factory<detector_t, unmasked>;
 
     public:
     using scalar_type = typename detector_t::scalar_type;
@@ -98,20 +108,23 @@ class material_factory final : public factory_decorator<detector_t> {
                          sf_factory = std::make_unique<placeholder_factory_t>())
         : base_factory(std::move(sf_factory)) {}
 
-    /// @returns the number of material that will be built by the factory
+    /// @returns the number of material instances that will be built by the
+    /// factory
     DETRAY_HOST
     auto size() const -> dindex {
 
         const dindex n_surfaces{static_cast<dindex>(m_links.size())};
 
         // Need exactly one material per surface
+        assert(m_indices.empty() or (m_indices.size() == n_surfaces));
+        assert(m_links.size() == n_surfaces);
         assert(m_materials.size() == n_surfaces);
         assert(m_thickness.size() == n_surfaces);
 
         return n_surfaces;
     }
 
-    /// @returns the material links to the surface (counted for this volume)
+    /// @returns the material links to the surfaces (counted for this volume)
     DETRAY_HOST
     auto links() const -> const std::vector<material_id> & { return m_links; }
 
@@ -130,11 +143,14 @@ class material_factory final : public factory_decorator<detector_t> {
     /// Add all necessary compontents to the factory for a single material slab
     /// or rod (determined by the @param id)
     DETRAY_HOST
-    void add_material(material_id id, material_data<scalar_type> &&mat_data) {
+    void add_material(
+        material_id id, material_data<scalar_type> &&mat_data,
+        std::size_t index = detail::invalid_value<std::size_t>()) {
 
-        auto [mat, thickness] = mat_data.get_data();
+        auto [sf_index, mat, thickness] = mat_data.get_data();
 
-        m_links.push_back(id);
+        m_links.push_back(std::make_pair(id, index));
+        m_indices.push_back(sf_index);
         m_materials.push_back(mat);
         m_thickness.push_back(thickness);
     }
@@ -166,55 +182,73 @@ class material_factory final : public factory_decorator<detector_t> {
     /// factory interface, but presents an overload for the case when material
     /// should be added.
     ///
-    /// @param surfaces surface store of the volume builder that should get
+    /// @param surfaces surface container of the volume builder that should get
     ///                 decorated with material.
     /// @param material material store of the volume builder that the new
     ///                 materials get added to.
     DETRAY_HOST
     auto operator()(typename detector_t::surface_container_t &surfaces,
-                    typename detector_t::material_container &materials) const {
+                    typename detector_t::material_container &materials) {
 
         // This builder is only called on a homogeneous material description
         using mat_types = typename detector_t::material_container::value_types;
         using link_t = typename detector_t::surface_type::material_link;
 
         // Check that the surfaces were set up correctly
-        const dindex n_material{this->size()};
-        assert(surfaces.size() >= n_material);
+        const std::size_t n_materials{this->size()};
+        assert(surfaces.size() >= n_materials);
+
+        // If no concrete surface ordering was passed, use index sequence
+        // and add the materials to the trailing elements in the surfaces cont.
+        if (m_indices.empty() or
+            std::find(m_indices.begin(), m_indices.end(),
+                      detail::invalid_value<std::size_t>()) !=
+                m_indices.end()) {
+            m_indices.resize(n_materials);
+            std::iota(std::begin(m_indices), std::end(m_indices),
+                      surfaces.size() - n_materials);
+        }
 
-        // Range of surfaces for which to add material
-        dindex_range r{static_cast<dindex>(surfaces.size() - n_material),
-                       static_cast<dindex>(surfaces.size())};
-        std::size_t sf_idx{0u};
-        for (auto &sf : detray::ranges::subrange(surfaces, r)) {
+        // Correctly index the data in this factory
+        std::size_t sf_offset{
+            *std::min_element(m_indices.begin(), m_indices.end())};
 
+        // Add the material to the surfaces that the data links against
+        for (auto [i, sf] : detray::views::pick(surfaces, m_indices)) {
+            std::size_t sf_idx{i - sf_offset};
             const material<scalar_type> &mat = m_materials.at(sf_idx);
             scalar_type t = m_thickness.at(sf_idx);
 
-            dindex n{0u};
-            if (m_links.at(sf_idx) == material_id::e_slab) {
-                n = materials.template size<material_id::e_slab>();
-                materials.template emplace_back<material_id::e_slab>({}, mat,
-                                                                     t);
+            dindex mat_idx{0u};
+            if (m_links.at(sf_idx).first == material_id::e_slab) {
+                auto &mat_coll = materials.template get<material_id::e_slab>();
+
+                material_slab<scalar_type> mat_slab{mat, t};
+                mat_idx = this->insert_in_container(mat_coll, mat_slab,
+                                                    m_links[sf_idx].second);
             }
             if constexpr (mat_types::n_types == 2u) {
-                if (m_links.at(sf_idx) == material_id::e_rod) {
-                    n = materials.template size<material_id::e_rod>();
-                    materials.template emplace_back<material_id::e_rod>({}, mat,
-                                                                        t);
+                if (m_links.at(sf_idx).first == material_id::e_rod) {
+                    auto &mat_coll =
+                        materials.template get<material_id::e_rod>();
+
+                    material_rod<scalar_type> mat_rod{mat, t};
+                    mat_idx = this->insert_in_container(mat_coll, mat_rod,
+                                                        m_links[sf_idx].second);
                 }
             }
 
             // Set the initial surface material link (will be updated when
             // added to the detector)
-            sf.material() = link_t{m_links[sf_idx], n};
-            ++sf_idx;
+            surfaces[i].material() = link_t{m_links[sf_idx].first, mat_idx};
         }
     }
 
     protected:
     /// Material links of surfaces (currently only type ids)
-    std::vector<material_id> m_links{};
+    std::vector<std::pair<material_id, dindex>> m_links{};
+    /// Position of the material in the detector material collection
+    std::vector<std::size_t> m_indices{};
     /// Material thickness
     std::vector<scalar_type> m_thickness{};
     /// The pre-computed material to be wrapped in a slab or rod
diff --git a/core/include/detray/tools/surface_factory.hpp b/core/include/detray/tools/surface_factory.hpp
index 6fdda35b0..37f2173d6 100644
--- a/core/include/detray/tools/surface_factory.hpp
+++ b/core/include/detray/tools/surface_factory.hpp
@@ -13,13 +13,15 @@
 #include "detray/definitions/qualifiers.hpp"
 #include "detray/masks/masks.hpp"
 #include "detray/masks/unmasked.hpp"
+#include "detray/materials/material_rod.hpp"
+#include "detray/materials/material_slab.hpp"
 #include "detray/tools/surface_factory_interface.hpp"
 #include "detray/utils/ranges.hpp"
 
 // System include(s)
 #include <algorithm>
 #include <cassert>
-#include <limits>
+#include <exception>
 #include <memory>
 #include <tuple>
 #include <type_traits>
@@ -32,34 +34,20 @@ namespace detray {
 ///
 /// @tparam detector_t the type of detector the volume belongs to.
 /// @tparam mask_shape_t the shape of the surface.
-/// @tparam mask_id the concrete mask id that must be defined in the detector_t.
-/// @tparam sf_id eihter portal, passive or sensitive.
-template <typename detector_t, typename mask_shape_t,
-          typename detector_t::mask_link::id_type mask_id, surface_id sf_id,
-          typename volume_link_t = dindex>
-class surface_factory
-    : public surface_factory_interface<detector_t>,
-      public std::enable_shared_from_this<surface_factory<
-          detector_t, mask_shape_t, mask_id, sf_id, volume_link_t>> {
-    public:
+template <typename detector_t, typename mask_shape_t>
+class surface_factory : public surface_factory_interface<detector_t> {
+
     using scalar_t = typename detector_t::scalar_type;
-    using shape_type = mask_shape_t;
-    using detector_type = detector_t;
+    using volume_link_t = typename detector_t::surface_type::navigation_link;
     // Set individual volume link for portals, but only the mothervolume index
     // for other surfaces.
-    using volume_link_collection =
-        std::conditional_t<sf_id == surface_id::e_portal,
-                           std::vector<volume_link_t>,
-                           detray::views::single<volume_link_t>>;
-    // ensures correct returning of shared pointers without pointless
-    // construction and destructing of surface factories
-    using smart_ptr_handler = std::enable_shared_from_this<surface_factory<
-        detector_t, mask_shape_t, mask_id, sf_id, volume_link_t>>;
+    using volume_link_collection = std::vector<volume_link_t>;
+
+    public:
+    using detector_type = detector_t;
 
     /// shorthad for a colleciton of surface data that can be read by a surface
     /// factory
-    // using surface_data_t = std::unique_ptr<
-    //     surface_data_interface<detector_t, mask_shape_t, volume_link_t>>;
     using surface_data_t = surface_data<detector_t>;
     using sf_data_collection = std::vector<surface_data_t>;
 
@@ -67,22 +55,22 @@ class surface_factory
     DETRAY_HOST
     surface_factory() = default;
 
-    /// @returns the id for the surface type the factory handles (e.g. portals)
-    DETRAY_HOST
-    auto surface_type() const -> surface_id override { return sf_id; }
-
     /// @returns the current number of surfaces that will be built by this
     /// factory
     DETRAY_HOST
     auto size() const -> dindex override {
         check();
-        return static_cast<dindex>(m_components.size());
+        return static_cast<dindex>(m_bounds.size());
     }
 
+    /// @returns the surface types
+    DETRAY_HOST
+    auto types() const -> const std::vector<surface_id> & { return m_types; }
+
     /// @returns the mask boundaries currently held by the factory
     DETRAY_HOST
-    auto components() const -> const std::vector<std::vector<scalar_t>> & {
-        return m_components;
+    auto bounds() const -> const std::vector<std::vector<scalar_t>> & {
+        return m_bounds;
     }
 
     /// @returns the transforms currently held by the factory
@@ -100,63 +88,43 @@ class surface_factory
     DETRAY_HOST
     void push_back(surface_data_t &&sf_data) override {
 
-        auto [vlink, bounds, trf, index] = sf_data.get_data();
+        auto [type, vlink, index, bounds, trf] = sf_data.get_data();
 
         assert(bounds.size() == mask_shape_t::boundaries::e_size);
 
-        if constexpr (sf_id != surface_id::e_portal) {
-            if (size() == 0u) {
-                *m_volume_link = vlink;
-            } else {
-                assert(*m_volume_link == vlink);
-            }
-        } else {
-            m_volume_link.push_back(vlink);
-        }
-
+        m_types.push_back(type);
+        m_volume_link.push_back(vlink);
         m_indices.push_back(index);
+        m_bounds.push_back(std::move(bounds));
         m_transforms.push_back(trf);
-        m_components.push_back(std::move(bounds));
     }
 
     /// Add all necessary compontents to the factory from bundled surface
     /// data in @param surface_data .
     DETRAY_HOST
-    auto push_back(sf_data_collection &&surface_data)
-        -> void /*std::shared_ptr<surface_factory<detector_t, mask_shape_t,
-                   mask_id, sf_id, volume_link_t>>*/
-        override {
+    auto push_back(sf_data_collection &&surface_data) -> void override {
         const auto n_surfaces{
             static_cast<dindex>(size() + surface_data.size())};
 
+        m_volume_link.reserve(n_surfaces);
         m_indices.reserve(n_surfaces);
+        m_bounds.reserve(n_surfaces);
         m_transforms.reserve(n_surfaces);
-        m_components.reserve(n_surfaces);
-
-        if constexpr (sf_id == surface_id::e_portal) {
-            m_volume_link.reserve(n_surfaces);
-        }
 
         // Get per-surface data into detector level container layout
         for (auto &sf_data : surface_data) {
             push_back(std::move(sf_data));
         }
-
-        // return smart_ptr_handler::shared_from_this();
     }
 
     /// Clear old data
     DETRAY_HOST
     auto clear() -> void override {
+        m_types.clear();
+        m_volume_link.clear();
         m_indices.clear();
-        m_components.clear();
+        m_bounds.clear();
         m_transforms.clear();
-        // cannot clear the single-view
-        if constexpr (sf_id == surface_id::e_portal) {
-            m_volume_link.clear();
-        } else {
-            *m_volume_link = volume_link_t{};
-        }
     }
 
     /// Generate the surfaces and add them to given data collections.
@@ -166,19 +134,18 @@ class surface_factory
     /// @param transforms the transforms of the surfaces.
     /// @param masks the masks of the surfaces (all of the same shape).
     /// @param ctx the geometry context.
+    ///
+    /// @returns index range of inserted surfaces in @param surfaces container
     DETRAY_HOST
-    auto operator()(typename detector_t::volume_type &volume,
+    auto operator()([[maybe_unused]] typename detector_t::volume_type &volume,
+                    [[maybe_unused]]
                     typename detector_t::surface_container_t &surfaces,
+                    [[maybe_unused]]
                     typename detector_t::transform_container &transforms,
-                    typename detector_t::mask_container &masks,
+                    [[maybe_unused]] typename detector_t::mask_container &masks,
+                    [[maybe_unused]]
                     typename detector_t::geometry_context ctx = {}) const
         -> dindex_range override {
-        using surface_t = typename detector_t::surface_type;
-        using mask_link_t = typename surface_t::mask_link;
-        using material_link_t = typename surface_t::material_link;
-
-        // The material will be added in a later step
-        constexpr auto no_material = surface_t::material_id::e_none;
         // In case the surfaces container is prefilled with other surfaces
         const dindex surfaces_offset = static_cast<dindex>(surfaces.size());
 
@@ -187,78 +154,91 @@ class surface_factory
             return {surfaces_offset, surfaces_offset};
         }
 
-        for (const auto [idx, comp] : detray::views::enumerate(m_components)) {
-
-            // Append the surfaces relative to the current number of surfaces
-            // in the stores
-            const dindex sf_idx{is_invalid_value(m_indices[idx])
-                                    ? dindex_invalid
-                                    : m_indices[idx]};
-
-            // Add transform
-            const dindex trf_idx =
-                insert_in_container(transforms, m_transforms[idx], sf_idx, ctx);
-
-            if constexpr (std::is_same_v<mask_shape_t, unmasked>) {
-                masks.template emplace_back<mask_id>(
-                    empty_context{}, m_volume_link[idx],
-                    std::numeric_limits<scalar_t>::infinity());
-            } else {
-                masks.template emplace_back<mask_id>(empty_context{}, comp,
-                                                     m_volume_link[idx]);
-            }
+        constexpr auto mask_id{detector_t::masks::template get_id<
+            mask<mask_shape_t, volume_link_t>>()};
 
-            // Add surface with all links set (relative to the given containers)
-            mask_link_t mask_link{mask_id, masks.template size<mask_id>() - 1u};
-            material_link_t material_link{no_material, dindex_invalid};
+        if constexpr (static_cast<std::size_t>(mask_id) >=
+                      detector_t::masks::n_types) {
 
-            insert_in_container(surfaces,
-                                {trf_idx, mask_link, material_link,
-                                 volume.index(), dindex_invalid, sf_id},
-                                sf_idx);
-        }
+            throw std::invalid_argument(
+                "ERROR: Cannot match shape type to mask ID: Found " +
+                mask_shape_t::name + " at mask id " +
+                std::to_string(static_cast<std::size_t>(mask_id)));
 
-        return {surfaces_offset, static_cast<dindex>(surfaces.size())};
-    }
-
-    private:
-    template <typename container_t, typename... Args>
-    DETRAY_HOST dindex insert_in_container(
-        container_t &cont, const typename container_t::value_type value,
-        const dindex idx, Args &&... args) const {
-        if (is_invalid_value(idx)) {
-            cont.push_back(value, std::forward<Args>(args)...);
-
-            return static_cast<dindex>(cont.size() - 1u);
         } else {
-            if (cont.size() < idx + 1) {
-                cont.resize(idx + 1, std::forward<Args>(args)...);
-            }
 
-            cont.at(idx, std::forward<Args>(args)...) = value;
-
-            return idx;
+            using surface_t = typename detector_t::surface_type;
+            using mask_link_t = typename surface_t::mask_link;
+            using material_link_t = typename surface_t::material_link;
+
+            // The material will be added in a later step
+            constexpr auto no_material{surface_t::material_id::e_none};
+
+            for (const auto [idx, bound] : detray::views::enumerate(m_bounds)) {
+
+                // Append the surfaces relative to the current number of
+                // surfaces in the stores
+                const dindex sf_idx{is_invalid_value(m_indices[idx])
+                                        ? dindex_invalid
+                                        : m_indices[idx]};
+
+                // Add transform
+                const dindex trf_idx = this->insert_in_container(
+                    transforms, m_transforms[idx], sf_idx, ctx);
+
+                // Masks are simply appended, since they are distributed onto
+                // multiple containers, their ordering is different from the
+                // surfaces
+                if constexpr (std::is_same_v<mask_shape_t, unmasked>) {
+                    masks.template emplace_back<mask_id>(
+                        empty_context{}, m_volume_link[idx],
+                        detail::invalid_value<scalar_t>());
+                } else {
+                    masks.template emplace_back<mask_id>(empty_context{}, bound,
+                                                         m_volume_link[idx]);
+                }
+
+                // Add surface with all links set (relative to the given
+                // containers)
+                mask_link_t mask_link{mask_id,
+                                      masks.template size<mask_id>() - 1u};
+                // If material is present, it is added in a later step
+                material_link_t material_link{no_material, dindex_invalid};
+
+                // Add the surface descriptor at the position given by 'sf_idx'
+                this->insert_in_container(
+                    surfaces,
+                    {trf_idx, mask_link, material_link, volume.index(),
+                     dindex_invalid, m_types[idx]},
+                    sf_idx);
+            }
         }
+
+        return {surfaces_offset, static_cast<dindex>(surfaces.size())};
     }
 
-    /// Check that the containers have the same size
+    private:
+    /// Run internal consistency check of surface data in the builder
     DETRAY_HOST
     void check() const {
         // This should not happend (need same number and ordering of data)
-        assert(m_components.size() == m_transforms.size());
-        assert(m_components.size() == m_indices.size());
-        if constexpr (sf_id == surface_id::e_portal) {
-            assert(m_components.size() == m_volume_link.size());
-        } else {
-            assert(m_volume_link.size() == 1);
-        }
+        assert(m_bounds.size() == m_types.size());
+        assert(m_bounds.size() == m_volume_link.size());
+        assert(m_bounds.size() == m_indices.size());
+        assert(m_bounds.size() == m_transforms.size());
     }
 
-    dindex_range m_range{dindex_invalid, dindex_invalid};
+    /// Types of the surface (portal|sensitive|passive)
+    std::vector<surface_id> m_types{};
+    /// Mask volume link (used for navigation)
+    volume_link_collection m_volume_link{};
+    /// Indices of surfaces for the placement in container
+    /// (counted as "volume-local": 0 to n_sf_in_volume)
     std::vector<dindex> m_indices{};
-    std::vector<std::vector<scalar_t>> m_components{};
+    /// Mask boundaries of surfaces
+    std::vector<std::vector<scalar_t>> m_bounds{};
+    /// Transforms of surfaces
     std::vector<typename detector_t::transform3> m_transforms{};
-    volume_link_collection m_volume_link{};
 };
 
 }  // namespace detray
diff --git a/core/include/detray/tools/surface_factory_interface.hpp b/core/include/detray/tools/surface_factory_interface.hpp
index a133399d3..4154fe7aa 100644
--- a/core/include/detray/tools/surface_factory_interface.hpp
+++ b/core/include/detray/tools/surface_factory_interface.hpp
@@ -30,25 +30,39 @@ class surface_data {
     public:
     using navigation_link = typename detector_t::surface_type::navigation_link;
 
+    /// Parametrized constructor
+    ///
+    /// @param type the surface type (portal|sensitive|passive)
+    /// @param trf the surface placement transformation
+    /// @param volume_link the mask volume link (used for navigation)
+    /// @param mask_boundaries define the extent of the surface
+    /// @param idx the index of the surface in the global detector lookup, needs
+    ///            to be passed only if a special ordering should be observed
     DETRAY_HOST
     surface_data(
-        const typename detector_t::transform3 &trf, navigation_link volume_link,
+        const surface_id type, const typename detector_t::transform3 &trf,
+        navigation_link volume_link,
         const std::vector<typename detector_t::scalar_type> &mask_boundaries,
         const dindex idx = dindex_invalid)
-        : m_volume_link{volume_link},
+        : m_type{type},
+          m_volume_link{volume_link},
           m_index{idx},
           m_boundaries{mask_boundaries},
           m_transform{trf} {}
 
+    /// Access the contained data through structured binding
     DETRAY_HOST
     auto get_data()
-        -> std::tuple<navigation_link &,
+        -> std::tuple<surface_id &, navigation_link &, dindex &,
                       std::vector<typename detector_t::scalar_type> &,
-                      typename detector_t::transform3 &, dindex &> {
-        return std::tie(m_volume_link, m_boundaries, m_transform, m_index);
+                      typename detector_t::transform3 &> {
+        return std::tie(m_type, m_volume_link, m_index, m_boundaries,
+                        m_transform);
     }
 
     private:
+    /// Surface type
+    surface_id m_type;
     /// The index of the volume that this surface links to
     navigation_link m_volume_link;
     /// The position of the surface in the detector containers, used to match
@@ -77,11 +91,6 @@ class surface_factory_interface {
     DETRAY_HOST
     virtual dindex size() const = 0;
 
-    /// @returns a surface id that corresponds to the surface type
-    /// i.e. portal/sensisitve/passive
-    DETRAY_HOST
-    virtual surface_id surface_type() const = 0;
-
     /// Add data to the factory
     /// @{
     DETRAY_HOST
@@ -105,6 +114,36 @@ class surface_factory_interface {
         typename detector_t::mask_container &masks,
         typename detector_t::geometry_context ctx = {}) const
         -> dindex_range = 0;
+
+    protected:
+    /// Insert a value in a container at a specific index
+    ///
+    /// @param cont the container to be filled
+    /// @param value the value to be put into the container
+    /// @param idx the position where to insert the value
+    /// @param args optional additional parameters for the container access
+    ///
+    /// @returns the position where the value has been copied.
+    template <typename container_t, typename... Args>
+    DETRAY_HOST dindex insert_in_container(
+        container_t &cont, const typename container_t::value_type value,
+        const dindex idx, Args &&... args) const {
+        // If no valid position is given, perform push back
+        if (is_invalid_value(idx)) {
+            cont.push_back(value, std::forward<Args>(args)...);
+
+            return static_cast<dindex>(cont.size() - 1u);
+        } else {
+            // Make sure the container size encompasses the new value
+            if (cont.size() < idx + 1) {
+                cont.resize(idx + 1, std::forward<Args>(args)...);
+            }
+
+            cont.at(idx, std::forward<Args>(args)...) = value;
+
+            return idx;
+        }
+    }
 };
 
 /// @brief Decorator for the surface factories.
@@ -124,11 +163,6 @@ class factory_decorator : public surface_factory_interface<detector_t> {
     DETRAY_HOST
     dindex size() const override { return m_factory->size(); }
 
-    DETRAY_HOST
-    surface_id surface_type() const override {
-        return m_factory->surface_type();
-    }
-
     DETRAY_HOST
     void push_back(surface_data<detector_t> &&data) override {
         m_factory->push_back(std::move(data));
diff --git a/core/include/detray/tools/volume_builder.hpp b/core/include/detray/tools/volume_builder.hpp
index 39d6610e4..caf50f4d2 100644
--- a/core/include/detray/tools/volume_builder.hpp
+++ b/core/include/detray/tools/volume_builder.hpp
@@ -36,43 +36,58 @@ class volume_builder : public volume_builder_interface<detector_t> {
     using volume_type = typename detector_t::volume_type;
     using geo_obj_ids = typename detector_t::geo_obj_ids;
 
+    /// Parametrized Constructor
+    ///
+    /// @param id flags the type of volume geometry (e.g. cylindrical, cuboid)
+    /// @param idx the index of the volume in the detector volume container
     volume_builder(const volume_id id, const dindex idx = dindex_invalid)
         : m_volume{id} {
         m_volume.set_index(idx);
+        // The first surface search data structure in every volume is a brute
+        // force method that will at least contain the portals
         m_volume
             .template set_link<static_cast<typename volume_type::object_id>(0)>(
                 detector_t::sf_finders::id::e_default, 0);
     };
 
-    /// Adds the @param name of the volume to a name map
+    /// Adds the @param name of the volume to a @param name_map
     template <typename name_map>
     DETRAY_HOST void add_name(const name_map& names, std::string&& name) {
         names.at(vol_index()) = std::move(name);
     }
 
+    /// @returns the volume index in the detector volume container
     DETRAY_HOST
     auto vol_index() -> dindex override { return m_volume.index(); }
 
+    /// Access to the volume under construction - const
     DETRAY_HOST
     auto operator()() const -> const
         typename detector_t::volume_type& override {
         return m_volume;
     }
+
+    /// Access to the volume under construction - non-const
     DETRAY_HOST
     auto operator()() -> typename detector_t::volume_type& override {
         return m_volume;
     }
 
+    /// Build the volume with internal surfaces and portals and add it to the
+    /// detector instance @param det
     DETRAY_HOST
     auto build(detector_t& det, typename detector_t::geometry_context ctx = {})
         -> typename detector_t::volume_type* override {
+        // Prepare volume data
         m_volume.set_index(static_cast<dindex>(det.volumes().size()));
 
         m_volume.set_transform(det.transform_store().size());
         det.transform_store().push_back(m_trf);
 
-        add_objects_per_volume(ctx, det);
+        // Add all data from the builder to the detector containers
+        add_to_detector(ctx, det);
 
+        // Reset after the data was added to the detector
         m_surfaces.clear();
         m_transforms.clear(ctx);
         m_masks.clear_all();
@@ -81,17 +96,22 @@ class volume_builder : public volume_builder_interface<detector_t> {
         return &(det.volumes().back());
     }
 
+    /// Adds a placement transform @param trf for the volume
     DETRAY_HOST
     void add_volume_placement(
         const typename detector_t::transform3& trf = {}) override {
         m_trf = trf;
     }
 
+    /// Constructs a placement transform with identity rotation and translation
+    /// @param t for the volume
     DETRAY_HOST
     void add_volume_placement(const typename detector_t::point3& t) override {
         m_trf = typename detector_t::transform3{t};
     }
 
+    /// Constructs a placement transform from axes @param x and @param z
+    /// and the translation @param t for the volume
     DETRAY_HOST
     void add_volume_placement(const typename detector_t::point3& t,
                               const typename detector_t::vector3& x,
@@ -99,45 +119,37 @@ class volume_builder : public volume_builder_interface<detector_t> {
         m_trf = typename detector_t::transform3{t, z, x, true};
     }
 
+    /// Add data for (a) new surface(s) to the builder
     DETRAY_HOST
-    void add_portals(
-        std::shared_ptr<surface_factory_interface<detector_t>> pt_factory,
-        typename detector_t::geometry_context ctx = {}) override {
-        (*pt_factory)(m_volume, m_surfaces, m_transforms, m_masks, ctx);
-    }
-
-    DETRAY_HOST
-    void add_sensitives(
+    void add_surfaces(
         std::shared_ptr<surface_factory_interface<detector_t>> sf_factory,
         typename detector_t::geometry_context ctx = {}) override {
         (*sf_factory)(m_volume, m_surfaces, m_transforms, m_masks, ctx);
     }
 
-    DETRAY_HOST
-    void add_passives(
-        std::shared_ptr<surface_factory_interface<detector_t>> ps_factory,
-        typename detector_t::geometry_context ctx = {}) override {
-        (*ps_factory)(m_volume, m_surfaces, m_transforms, m_masks, ctx);
-    }
-
     protected:
+    /// @returns Access to the surface descriptor data
     typename detector_t::surface_container_t& surfaces() override {
         return m_surfaces;
     }
+
+    /// @returns Access to the surface/volume transform data
     typename detector_t::transform_container& transforms() override {
         return m_transforms;
     }
+
+    /// @returns Access to the surface mask data
     typename detector_t::mask_container& masks() override { return m_masks; }
 
-    /// Add a new full set of detector components (e.g. transforms or volumes)
-    /// according to given geometry_context.
+    /// Adds a new full set of volume components (e.g. transforms or masks)
+    /// to the global detector data stores and updates all links.
     ///
     /// @param ctx is the geometry_context of the call
     /// @param det is the detector instance that the volume should be added to
     ///
     /// @note can throw an exception if input data is inconsistent
     template <geo_obj_ids surface_id = static_cast<geo_obj_ids>(0)>
-    DETRAY_HOST auto add_objects_per_volume(
+    DETRAY_HOST auto add_to_detector(
         const typename detector_t::geometry_context ctx,
         detector_t& det) noexcept(false) -> void {
 
@@ -145,8 +157,8 @@ class volume_builder : public volume_builder_interface<detector_t> {
         const auto trf_offset = det.transform_store().size(ctx);
         det.append_transforms(std::move(m_transforms), ctx);
 
-        // Update mask and transform index of surfaces and set a
-        // unique barcode (index of surface in container)
+        // Update mask and transform index of surfaces and set the
+        // correct index of the surface in container
         auto sf_offset{static_cast<dindex>(det.surface_lookup().size())};
         for (auto& sf_desc : m_surfaces) {
             const auto sf = surface{det, sf_desc};
@@ -176,12 +188,17 @@ class volume_builder : public volume_builder_interface<detector_t> {
         det.volumes().push_back(m_volume);
     }
 
+    /// Volume descriptor of the volume under construction
     typename detector_t::volume_type m_volume{};
+    /// Placement of the volume under construction
     typename detector_t::transform3 m_trf{};
 
+    /// Data of conatined surfaces
+    /// @{
     typename detector_t::surface_container_t m_surfaces{};
     typename detector_t::transform_container m_transforms{};
     typename detector_t::mask_container m_masks{};
+    /// @}
 };
 
 namespace detail {
diff --git a/core/include/detray/tools/volume_builder_interface.hpp b/core/include/detray/tools/volume_builder_interface.hpp
index 9d2ac55d1..32a54e1fa 100644
--- a/core/include/detray/tools/volume_builder_interface.hpp
+++ b/core/include/detray/tools/volume_builder_interface.hpp
@@ -71,30 +71,14 @@ class volume_builder_interface {
         const typename detector_t::vector3 &x,
         const typename detector_t::vector3 &z) = 0;
 
-    /// @brief Add the portals to the volume.
-    /// @returns the index range of the portals in the temporary surface
-    /// container used by the factory ( gets final update in @c build() )
-    DETRAY_HOST
-    virtual void add_portals(
-        std::shared_ptr<surface_factory_interface<detector_t>> pt_factory,
-        typename detector_t::geometry_context ctx = {}) = 0;
-
-    /// @brief Add sensitive surfaces to the volume, if any
+    /// @brief Add surfaces to the volume
     /// @returns the index range of the sensitives in the temporary surface
     /// container used by the factory ( gets final update in @c build() )
     DETRAY_HOST
-    virtual void add_sensitives(
+    virtual void add_surfaces(
         std::shared_ptr<surface_factory_interface<detector_t>> sf_factory,
         typename detector_t::geometry_context ctx = {}) = 0;
 
-    /// @brief Add passive surfaces to the volume, if any
-    /// @returns the index range of the passives in the temporary surface
-    /// container used by the factory ( gets final update in @c build() )
-    DETRAY_HOST
-    virtual void add_passives(
-        std::shared_ptr<surface_factory_interface<detector_t>> ps_factory,
-        typename detector_t::geometry_context ctx = {}) = 0;
-
     protected:
     /// Access to builder data
     /// @{
@@ -161,24 +145,10 @@ class volume_decorator : public volume_builder_interface<detector_t> {
     }
 
     DETRAY_HOST
-    void add_portals(
-        std::shared_ptr<surface_factory_interface<detector_t>> pt_factory,
-        typename detector_t::geometry_context ctx = {}) override {
-        return m_builder->add_portals(std::move(pt_factory), ctx);
-    }
-
-    DETRAY_HOST
-    void add_sensitives(
+    void add_surfaces(
         std::shared_ptr<surface_factory_interface<detector_t>> sf_factory,
         typename detector_t::geometry_context ctx = {}) override {
-        return m_builder->add_sensitives(std::move(sf_factory), ctx);
-    }
-
-    DETRAY_HOST
-    void add_passives(
-        std::shared_ptr<surface_factory_interface<detector_t>> ps_factory,
-        typename detector_t::geometry_context ctx = {}) override {
-        return m_builder->add_passives(std::move(ps_factory), ctx);
+        return m_builder->add_surfaces(std::move(sf_factory), ctx);
     }
     /// @}
 
diff --git a/core/include/detray/utils/type_registry.hpp b/core/include/detray/utils/type_registry.hpp
index 22c183662..e28101e7b 100644
--- a/core/include/detray/utils/type_registry.hpp
+++ b/core/include/detray/utils/type_registry.hpp
@@ -38,8 +38,7 @@ class type_registry {
     /// Get the index for a type. Needs to be unrolled in case of thrust tuple.
     template <typename object_t>
     DETRAY_HOST_DEVICE static constexpr ID get_id() {
-        return unroll_ids<std::remove_reference_t<object_t>,
-                          registered_types...>();
+        return unroll_ids<std::decay_t<object_t>, registered_types...>();
     }
 
     /// Get the index for a type. Use template parameter deduction.
diff --git a/io/include/detray/io/common/detail/utils.hpp b/io/include/detray/io/common/detail/utils.hpp
index 2eecccfc8..d4529461e 100644
--- a/io/include/detray/io/common/detail/utils.hpp
+++ b/io/include/detray/io/common/detail/utils.hpp
@@ -44,6 +44,6 @@ inline std::string get_detray_version() {
     return "detray - " + std::string(detray::version);
 }
 
-inline static const std::string minimal_io_version{"detray - 0.35.0"};
+inline static const std::string minimal_io_version{"detray - 0.43.0"};
 
 }  // namespace detray::detail
diff --git a/io/include/detray/io/common/detector_reader.hpp b/io/include/detray/io/common/detector_reader.hpp
index a7cd4ff46..b5c8a5c07 100644
--- a/io/include/detray/io/common/detector_reader.hpp
+++ b/io/include/detray/io/common/detector_reader.hpp
@@ -38,7 +38,7 @@ struct detector_reader_config {
     /// Input files
     std::vector<std::string> m_files;
     /// Run detector consistency check after reading
-    bool m_do_check{false};
+    bool m_do_check{true};
     /// Field vector for an homogenoues b-field
     std::array<scalar, 3> m_bfield_vec{};
 
@@ -76,10 +76,15 @@ struct detector_reader_config {
 
 namespace detail {
 
-/// From the list of file that are given as part of the config @param cfg,
-/// infer the readers that are needed by peeking into the file header
+/// From the list of files that are given as part of the config @param cfg,
+/// infer the readers that are needed by peeking into the file headers
+///
+/// @tparam detector_t type of the detector instance: Must match the data that
+///                    is read from file!
+/// @tparam CAP surface grid bin capacity (@TODO make runtime)
+/// @tparam DIM dimension of the surface grids, usually 2D
 template <class detector_t, std::size_t CAP, std::size_t DIM>
-auto assemble_reader(const io::detector_reader_config& cfg) {
+auto assemble_reader(const io::detector_reader_config& cfg) noexcept(false) {
 
     detail::detector_component_readers<detector_t> readers;
 
@@ -88,17 +93,27 @@ auto assemble_reader(const io::detector_reader_config& cfg) {
 
     for (const std::string& file_name : cfg.files()) {
 
+        if (file_name.empty()) {
+            std::cout << "WARNING: Empty file name. Component will not be built"
+                      << std::endl;
+            continue;
+        }
+
         std::string extension{std::filesystem::path{file_name}.extension()};
+
         if (extension == ".json") {
+
             // Peek at the header to determine the kind of reader that is needed
             common_header_payload header = read_json_header(file_name);
 
             if (header.tag == "geometry") {
                 det_name = header.detector;
                 readers.template add<json_geometry_reader>(file_name);
+
             } else if (header.tag == "homogeneous_material") {
                 readers.template add<json_homogeneous_material_reader>(
                     file_name);
+
             } else if (header.tag == "surface_grids") {
                 using surface_t = typename detector_t::surface_type;
                 readers.template add<json_grid_reader, surface_t,
@@ -110,12 +125,13 @@ auto assemble_reader(const io::detector_reader_config& cfg) {
                                             header.tag +
                                             "' in input file: " + file_name);
             }
-        } else if (extension == ".cvf" and check_covfie_file(file_name)) {
+
             // This is the file type covfie uses
+        } else if (extension == ".cvf" and check_covfie_file(file_name)) {
+
             if constexpr (not std::is_same_v<
                               typename detector_t::bfield_type::backend_t,
                               bfield::const_bknd_t>) {
-                std::cout << "Adding an inhom bfield reader" << std::endl;
                 readers.template add<covfie_reader>(file_name);
             }
         } else {
@@ -134,6 +150,8 @@ namespace io {
 /// @brief Reader function for detray detectors.
 ///
 /// @tparam detector_t the type of detector to be built
+/// @tparam CAP surface grid bin capacity (@TODO make runtime)
+/// @tparam DIM dimension of the surface grids, usually 2D
 /// @tparam volume_builder_t the type of base volume builder to be used
 ///
 /// @param resc the memory resource to be used for the detector container allocs
@@ -143,7 +161,7 @@ namespace io {
 template <class detector_t, std::size_t CAP = 9u, std::size_t DIM = 2u,
           template <typename> class volume_builder_t = volume_builder>
 auto read_detector(vecmem::memory_resource& resc,
-                   const detector_reader_config& cfg) {
+                   const detector_reader_config& cfg) noexcept(false) {
 
     using bfield_bknd_t = typename detector_t::bfield_type::backend_t;
 
@@ -171,7 +189,9 @@ auto read_detector(vecmem::memory_resource& resc,
     auto det = det_builder.build(resc);
 
     if (cfg.do_check()) {
+        // This will throw an exception in case of inconsistencies
         detray::detail::check_consistency(det);
+        std::cout << "Detector check: OK" << std::endl;
     }
 
     return std::make_pair(std::move(det), std::move(names));
diff --git a/io/include/detray/io/common/detector_writer.hpp b/io/include/detray/io/common/detector_writer.hpp
index 97b82b7d3..30784239f 100644
--- a/io/include/detray/io/common/detector_writer.hpp
+++ b/io/include/detray/io/common/detector_writer.hpp
@@ -70,11 +70,11 @@ struct detector_writer_config {
 
 namespace detail {
 
-/// From the detector type @tparam detector_t, inferr the writers that are
-/// needed
+/// From the detector type @tparam detector_t, infer the writers that are needed
 template <class detector_t>
 detail::detector_component_writers<detector_t> assemble_writer(
     const io::detector_writer_config& cfg) {
+
     detail::detector_component_writers<detector_t> writers;
 
     if (cfg.format() == io::format::json) {
@@ -118,6 +118,7 @@ void write_detector(detector_t& det, const typename detector_t::name_map& names,
 
     // Get the writer
     auto writer = detray::detail::assemble_writer<detector_t>(cfg);
+
     writer.write(det, names, mode);
 }
 
diff --git a/io/include/detray/io/common/geometry_reader.hpp b/io/include/detray/io/common/geometry_reader.hpp
index f42b080d5..eed6f8924 100644
--- a/io/include/detray/io/common/geometry_reader.hpp
+++ b/io/include/detray/io/common/geometry_reader.hpp
@@ -26,16 +26,11 @@
 
 namespace std {
 
-// Specialize std::hash so this pair can be used as key in e.g. a map
+// Specialize std::hash directly to the shape id type
 template <>
-struct hash<std::pair<detray::surface_id, detray::io::detail::mask_shape>> {
-    auto operator()(
-        std::pair<detray::surface_id, detray::io::detail::mask_shape> p)
-        const noexcept {
-        // Calculate a hash from both numbers and avoid collisions
-        return std::hash<std::size_t>()(static_cast<std::size_t>(p.first)) +
-               1000u *
-                   std::hash<std::size_t>()(static_cast<std::size_t>(p.second));
+struct hash<detray::io::detail::mask_shape> {
+    auto operator()(detray::io::detail::mask_shape m) const noexcept {
+        return std::hash<std::size_t>()(static_cast<std::size_t>(m));
     }
 };
 
@@ -89,45 +84,40 @@ class geometry_reader : public reader_interface<detector_t> {
             vbuilder->add_volume_placement(deserialize(vol_data.transform));
 
             // Prepare the surface factories (one per shape and surface type)
-            std::map<std::pair<surface_id, mask_shape>, sf_factory_ptr_t>
-                sf_factories;
+            std::map<mask_shape, sf_factory_ptr_t> pt_factories, sf_factories;
 
             // Add the surfaces to the factories
             for (const auto& sf_data : vol_data.surfaces) {
 
                 const mask_payload& mask_data = sf_data.mask;
 
+                // Get a reference to the correct factory colleciton
+                auto& factories{sf_data.type == surface_id::e_portal
+                                    ? pt_factories
+                                    : sf_factories};
+
                 // Check if a fitting factory already exists. If not, add it
                 // dynamically
-                const auto key = std::make_pair(sf_data.type, mask_data.shape);
-                if (auto search = sf_factories.find(key);
-                    search == sf_factories.end()) {
-                    sf_factories[key] =
+                const auto key{mask_data.shape};
+                if (auto search = factories.find(key);
+                    search == factories.end()) {
+                    factories[key] =
                         std::move(init_factory<mask_shape::n_shapes>(
                             mask_data.shape, sf_data.type));
                 }
 
                 // Add the data to the factory
-                sf_factories.at(key)->push_back(deserialize(sf_data));
+                factories.at(key)->push_back(deserialize(sf_data));
             }
 
-            // Add the surfaces to the volume
+            // Add the portals to the volume first
             typename detector_t::geometry_context geo_ctx{};
-            for (auto [key, sf_factory_ptr] : sf_factories) {
-                // Sort the surfaces into the volume builder by type
-                switch (sf_factory_ptr->surface_type()) {
-                    case surface_id::e_portal:
-                        vbuilder->add_portals(sf_factory_ptr, geo_ctx);
-                        break;
-                    case surface_id::e_sensitive:
-                        vbuilder->add_sensitives(sf_factory_ptr, geo_ctx);
-                        break;
-                    case surface_id::e_passive:
-                        vbuilder->add_passives(sf_factory_ptr, geo_ctx);
-                        break;
-                    case surface_id::e_unknown:
-                        break;
-                };
+            for (auto [key, pt_factory] : pt_factories) {
+                vbuilder->add_surfaces(pt_factory, geo_ctx);
+            }
+            // Add all other surfaces next
+            for (auto [key, sf_factory] : sf_factories) {
+                vbuilder->add_surfaces(sf_factory, geo_ctx);
             }
         }
 
@@ -174,7 +164,7 @@ class geometry_reader : public reader_interface<detector_t> {
                                      ? *(sf_data.index_in_coll)
                                      : detail::invalid_value<std::size_t>()};
 
-        return {deserialize(sf_data.transform),
+        return {sf_data.type, deserialize(sf_data.transform),
                 static_cast<nav_link_t>(
                     base_type::deserialize(sf_data.mask.volume_link)),
                 std::move(mask_boundaries), static_cast<dindex>(sf_idx)};
@@ -194,31 +184,10 @@ class geometry_reader : public reader_interface<detector_t> {
             // detector
             using mask_info_t = mask_info<I>;
             using shape_t = typename mask_info_t::type;
-            [[maybe_unused]] constexpr auto mask_id{mask_info_t::value};
 
             // Test wether this shape exists in detector
             if constexpr (not std::is_same_v<shape_t, void>) {
-                // Get the correct factory for the type of surface
-                switch (sf_type) {
-                    case surface_id::e_portal:
-                        using pt_factory_t =
-                            surface_factory<detector_t, shape_t, mask_id,
-                                            surface_id::e_portal>;
-                        return std::make_shared<pt_factory_t>();
-                    case surface_id::e_sensitive:
-                        using sf_factory_t =
-                            surface_factory<detector_t, shape_t, mask_id,
-                                            surface_id::e_sensitive>;
-                        return std::make_shared<sf_factory_t>();
-                    case surface_id::e_passive:
-                        using ps_factory_t =
-                            surface_factory<detector_t, shape_t, mask_id,
-                                            surface_id::e_passive>;
-                        return std::make_shared<ps_factory_t>();
-                    case surface_id::e_unknown:
-                        throw std::invalid_argument(
-                            "Unknown surface type in geometry file");
-                };
+                return std::make_shared<surface_factory<detector_t, shape_t>>();
             }
         }
         // Test next shape id
diff --git a/io/include/detray/io/common/homogeneous_material_reader.hpp b/io/include/detray/io/common/homogeneous_material_reader.hpp
index 5e7d8fd81..24987896a 100644
--- a/io/include/detray/io/common/homogeneous_material_reader.hpp
+++ b/io/include/detray/io/common/homogeneous_material_reader.hpp
@@ -64,22 +64,33 @@ class homogeneous_material_reader : public reader_interface<detector_t> {
             // Add the material data to the factory
             auto mat_factory = std::make_shared<material_factory<detector_t>>();
             for (const auto& slab_data : mv_data.mat_slabs) {
+                assert(slab_data.type == io::detail::material_type::slab);
+
+                const auto sf_link{slab_data.index_in_coll.has_value()
+                                       ? slab_data.index_in_coll.value()
+                                       : detail::invalid_value<std::size_t>()};
 
                 mat_factory->add_material(material_id::e_slab,
-                                          deserialize(slab_data));
+                                          deserialize(slab_data), sf_link);
             }
             if constexpr (mat_types::n_types == 2u) {
                 if (mv_data.mat_rods.has_value()) {
                     for (const auto& rod_data : *(mv_data.mat_rods)) {
+                        assert(rod_data.type == io::detail::material_type::rod);
+
+                        const auto sf_link{
+                            rod_data.index_in_coll.has_value()
+                                ? rod_data.index_in_coll.value()
+                                : detail::invalid_value<std::size_t>()};
 
-                        mat_factory->add_material(material_id::e_rod,
-                                                  deserialize(rod_data));
+                        mat_factory->add_material(
+                            material_id::e_rod, deserialize(rod_data), sf_link);
                     }
                 }
             }
 
             // Add the material to the volume
-            vm_builder->add_sensitives(mat_factory);
+            vm_builder->add_surfaces(mat_factory);
         }
     }
 
@@ -89,7 +100,8 @@ class homogeneous_material_reader : public reader_interface<detector_t> {
         const material_slab_payload& slab_data) {
 
         return {static_cast<scalar_type>(slab_data.thickness),
-                deserialize(slab_data.mat)};
+                deserialize(slab_data.mat),
+                base_type::deserialize(slab_data.surface)};
     }
 
     /// @returns the material from its IO payload @param mat_data
diff --git a/io/include/detray/io/common/homogeneous_material_writer.hpp b/io/include/detray/io/common/homogeneous_material_writer.hpp
index b16bd5ef2..3479f3ba0 100644
--- a/io/include/detray/io/common/homogeneous_material_writer.hpp
+++ b/io/include/detray/io/common/homogeneous_material_writer.hpp
@@ -82,33 +82,37 @@ class homogeneous_material_writer : public writer_interface<detector_t> {
     static material_volume_payload serialize(
         const typename detector_t::volume_type& vol_desc,
         const detector_t& det) {
-        using material_type = material_slab_payload::type;
+        using material_type = material_slab_payload::mat_type;
 
         material_volume_payload mv_data;
         mv_data.volume_link = base_type::serialize(vol_desc.index());
 
-        // Find all surfaces that belong to the volume
+        // Find all surfaces that belong to the volume and count them
+        std::size_t sf_idx{0u}, slab_idx{0u}, rod_idx{0u};
         for (const auto& sf_desc : det.surface_lookup()) {
             if (sf_desc.volume() != vol_desc.index()) {
                 continue;
             }
             // Serialize material slabs and rods
             const auto sf = surface{det, sf_desc};
-            const material_slab_payload mslp =
-                sf.template visit_material<get_material_payload>();
+            material_slab_payload mslp =
+                sf.template visit_material<get_material_payload>(sf_idx);
 
-            if (mslp.mat_link.type == material_type::slab) {
+            if (mslp.type == material_type::slab) {
+                mslp.index_in_coll = slab_idx++;
                 mv_data.mat_slabs.push_back(mslp);
-            } else if (mslp.mat_link.type == material_type::rod) {
+            } else if (mslp.type == material_type::rod) {
                 if (not mv_data.mat_rods.has_value()) {
                     mv_data.mat_rods.emplace();
                 }
+                mslp.index_in_coll = rod_idx++;
                 mv_data.mat_rods->push_back(mslp);
             } else {
                 throw std::runtime_error(
                     "Material could not be matched to payload (found type " +
-                    std::to_string(static_cast<int>(mslp.mat_link.type)) + ")");
+                    std::to_string(static_cast<int>(mslp.type)) + ")");
             }
+            ++sf_idx;
         }
 
         return mv_data;
@@ -131,11 +135,11 @@ class homogeneous_material_writer : public writer_interface<detector_t> {
 
     /// Serialize a surface material slab @param mat_slab into its io payload
     static material_slab_payload serialize(
-        const material_slab<scalar_t>& mat_slab, std::size_t idx) {
+        const material_slab<scalar_t>& mat_slab, std::size_t sf_idx) {
         material_slab_payload mat_data;
 
-        mat_data.mat_link = base_type::serialize(
-            io::detail::get_material_id<material_slab<scalar_t>>(), idx);
+        mat_data.type = io::detail::get_material_id<material_slab<scalar_t>>();
+        mat_data.surface = base_type::serialize(sf_idx);
         mat_data.thickness = mat_slab.thickness();
         mat_data.mat = serialize(mat_slab.get_material());
 
@@ -144,11 +148,11 @@ class homogeneous_material_writer : public writer_interface<detector_t> {
 
     /// Serialize a wire material rod @param mat_rod into its io payload
     static material_slab_payload serialize(
-        const material_rod<scalar_t>& mat_rod, std::size_t idx) {
+        const material_rod<scalar_t>& mat_rod, std::size_t sf_idx) {
         material_slab_payload mat_data;
 
-        mat_data.mat_link = base_type::serialize(
-            io::detail::get_material_id<material_rod<scalar_t>>(), idx);
+        mat_data.type = io::detail::get_material_id<material_rod<scalar_t>>();
+        mat_data.surface = base_type::serialize(sf_idx);
         mat_data.thickness = mat_rod.radius();
         mat_data.mat = serialize(mat_rod.get_material());
 
@@ -160,9 +164,10 @@ class homogeneous_material_writer : public writer_interface<detector_t> {
     struct get_material_payload {
         template <typename material_group_t, typename index_t>
         inline auto operator()(const material_group_t& material_group,
-                               const index_t& index) const {
+                               const index_t& index,
+                               std::size_t sf_index) const {
             return homogeneous_material_writer<detector_t>::serialize(
-                material_group[index], index);
+                material_group[index], sf_index);
         }
     };
 };
diff --git a/io/include/detray/io/common/payloads.hpp b/io/include/detray/io/common/payloads.hpp
index 808bffe9d..73f12cc0f 100644
--- a/io/include/detray/io/common/payloads.hpp
+++ b/io/include/detray/io/common/payloads.hpp
@@ -128,9 +128,11 @@ struct material_payload {
 
 /// @brief A payload object for a material slab/rod
 struct material_slab_payload {
-    using type = io::detail::material_type;
+    using mat_type = io::detail::material_type;
 
-    material_link_payload mat_link{};
+    mat_type type{mat_type::unknown};
+    std::optional<std::size_t> index_in_coll;
+    single_link_payload surface{};
     real_io thickness{std::numeric_limits<real_io>::max()};
     material_payload mat{};
 };
diff --git a/io/include/detray/io/json/json_material_io.hpp b/io/include/detray/io/json/json_material_io.hpp
index 580e19edf..9079ecfa4 100644
--- a/io/include/detray/io/json/json_material_io.hpp
+++ b/io/include/detray/io/json/json_material_io.hpp
@@ -52,16 +52,24 @@ inline void from_json(const nlohmann::ordered_json& j, material_payload& m) {
 }
 
 inline void to_json(nlohmann::ordered_json& j, const material_slab_payload& m) {
-    j["mat_link"] = m.mat_link;
+    j["type"] = m.type;
+    j["surface_idx"] = m.surface;
     j["thickness"] = m.thickness;
     j["material"] = m.mat;
+    if (m.index_in_coll.has_value()) {
+        j["index_in_coll"] = m.index_in_coll.value();
+    }
 }
 
 inline void from_json(const nlohmann::ordered_json& j,
                       material_slab_payload& m) {
-    m.mat_link = j["mat_link"];
+    m.type = j["type"];
+    m.surface = j["surface_idx"];
     m.thickness = j["thickness"];
     m.mat = j["material"];
+    if (j.find("index_in_coll") != j.end()) {
+        m.index_in_coll = j["index_in_coll"];
+    }
 }
 
 inline void to_json(nlohmann::ordered_json& j,
@@ -95,7 +103,7 @@ inline void from_json(const nlohmann::ordered_json& j,
         }
     }
     if (j.find("material_rods") != j.end()) {
-        mv.mat_rods = {};
+        mv.mat_rods.emplace();
         for (auto jmats : j["material_rods"]) {
             material_slab_payload mslp = jmats;
             mv.mat_rods->push_back(mslp);
diff --git a/io/include/detray/io/json/json_reader.hpp b/io/include/detray/io/json/json_reader.hpp
index 55b548b85..c66912333 100644
--- a/io/include/detray/io/json/json_reader.hpp
+++ b/io/include/detray/io/json/json_reader.hpp
@@ -78,10 +78,12 @@ class json_reader final : public common_reader_t<detector_t, Args...> {
         // Read json from file
         io::detail::file_handle file{file_name,
                                      std::ios_base::in | std::ios_base::binary};
+
+        // Reads the data from file and returns the corresponding io payloads
         nlohmann::json in_json;
         *file >> in_json;
 
-        // Reads the data from file and returns the corresponding io payloads
+        // Add the data from the payload to the detray detector builder
         base_reader::deserialize(det_builder, name_map, in_json["data"]);
     }
 };
diff --git a/tests/unit_tests/cpu/core_detector.cpp b/tests/unit_tests/cpu/core_detector.cpp
index 5074b8f97..3ab0fdf50 100644
--- a/tests/unit_tests/cpu/core_detector.cpp
+++ b/tests/unit_tests/cpu/core_detector.cpp
@@ -205,25 +205,27 @@ GTEST_TEST(detray_tools, surface_factory) {
 
     using detector_t = detector<>;
     using transform3 = typename detector_t::transform3;
-    using mask_id = typename detector_t::masks::id;
 
     //
     // check portal cylinder
     //
     using portal_cylinder_factory =
-        surface_factory<detector_t, typename default_metadata::cylinder_portal,
-                        mask_id::e_portal_cylinder2, surface_id::e_portal>;
+        surface_factory<detector_t,
+                        typename default_metadata::cylinder_portal::shape>;
 
     auto pt_cyl_factory = std::make_shared<portal_cylinder_factory>();
 
     typename portal_cylinder_factory::sf_data_collection cyl_sf_data;
-    cyl_sf_data.emplace_back(transform3(point3{0.f, 0.f, -1000.f}), 0u,
+    cyl_sf_data.emplace_back(surface_id::e_portal,
+                             transform3(point3{0.f, 0.f, -1000.f}), 0u,
                              std::vector<scalar>{10.f, -1000.f, 1500.f});
-    cyl_sf_data.emplace_back(transform3(point3{0.f, 0.f, 1000.f}), 2u,
+    cyl_sf_data.emplace_back(surface_id::e_portal,
+                             transform3(point3{0.f, 0.f, 1000.f}), 2u,
                              std::vector<scalar>{20.f, -1500.f, 1000.f});
 
     EXPECT_EQ(pt_cyl_factory->size(), 0u);
-    EXPECT_TRUE(pt_cyl_factory->components().empty());
+    EXPECT_TRUE(pt_cyl_factory->types().empty());
+    EXPECT_TRUE(pt_cyl_factory->bounds().empty());
     EXPECT_TRUE(pt_cyl_factory->transforms().empty());
     EXPECT_TRUE(pt_cyl_factory->volume_links().empty());
 
@@ -232,10 +234,11 @@ GTEST_TEST(detray_tools, surface_factory) {
     cyl_sf_data.clear();
 
     EXPECT_EQ(pt_cyl_factory->size(), 2u);
-    EXPECT_EQ(pt_cyl_factory->components().size(), 2u);
+    EXPECT_EQ(pt_cyl_factory->types().size(), 2u);
+    EXPECT_EQ(pt_cyl_factory->bounds().size(), 2u);
     EXPECT_EQ(pt_cyl_factory->transforms().size(), 2u);
     EXPECT_EQ(pt_cyl_factory->volume_links().size(), 2u);
-    const auto& portal_cyl_comps = pt_cyl_factory->components().front();
+    const auto& portal_cyl_comps = pt_cyl_factory->bounds().front();
     EXPECT_NEAR(portal_cyl_comps[0], 10.f, tol);
     EXPECT_NEAR(portal_cyl_comps[1], -1000.f, tol);
     EXPECT_NEAR(portal_cyl_comps[2], 1500.f, tol);
@@ -247,89 +250,62 @@ GTEST_TEST(detray_tools, surface_factory) {
     // check sensitive cylinder
     //
     using sensitive_cylinder_factory =
-        surface_factory<detector_t, cylinder2D<>, mask_id::e_cylinder2,
-                        surface_id::e_sensitive>;
+        surface_factory<detector_t, cylinder2D<>>;
 
-    auto sens_cyl_factory = std::make_shared<sensitive_cylinder_factory>();
+    auto cyl_factory = std::make_shared<sensitive_cylinder_factory>();
 
-    cyl_sf_data.emplace_back(transform3(point3{0.f, 0.f, -50.f}), 1u,
+    cyl_sf_data.emplace_back(surface_id::e_sensitive,
+                             transform3(point3{0.f, 0.f, -50.f}), 1u,
                              std::vector<scalar>{5.f, -900.f, 900.f});
-    cyl_sf_data.emplace_back(transform3(point3{0.f, 0.f, 50.f}), 1u,
+    cyl_sf_data.emplace_back(surface_id::e_sensitive,
+                             transform3(point3{0.f, 0.f, 50.f}), 1u,
                              std::vector<scalar>{5.f, -900.f, 900.f});
 
-    EXPECT_EQ(sens_cyl_factory->size(), 0u);
-    EXPECT_TRUE(sens_cyl_factory->components().empty());
-    EXPECT_TRUE(sens_cyl_factory->transforms().empty());
-    // The single view is never empty, only uninitialized
-    EXPECT_FALSE(sens_cyl_factory->volume_links().empty());
+    cyl_sf_data.emplace_back(surface_id::e_passive,
+                             transform3(point3{0.f, 0.f, -20.f}), 1u,
+                             std::vector<scalar>{4.9f, -900.f, 900.f});
+    cyl_sf_data.emplace_back(surface_id::e_passive,
+                             transform3(point3{0.f, 0.f, 20.f}), 1u,
+                             std::vector<scalar>{4.9f, -900.f, 900.f});
 
-    sens_cyl_factory->push_back(std::move(cyl_sf_data));
+    EXPECT_EQ(cyl_factory->size(), 0u);
+    EXPECT_TRUE(cyl_factory->types().empty());
+    EXPECT_TRUE(cyl_factory->bounds().empty());
+    EXPECT_TRUE(cyl_factory->transforms().empty());
+    EXPECT_TRUE(cyl_factory->volume_links().empty());
+
+    cyl_factory->push_back(std::move(cyl_sf_data));
     cyl_sf_data.clear();
 
-    EXPECT_EQ(sens_cyl_factory->size(), 2u);
-    EXPECT_EQ(sens_cyl_factory->components().size(), 2u);
-    EXPECT_EQ(sens_cyl_factory->transforms().size(), 2u);
-    EXPECT_EQ(sens_cyl_factory->volume_links().size(), 1u);
-    const auto& sens_cyl_comps = sens_cyl_factory->components().front();
+    EXPECT_EQ(cyl_factory->size(), 4u);
+    EXPECT_EQ(cyl_factory->types().size(), 4u);
+    EXPECT_EQ(cyl_factory->bounds().size(), 4u);
+    EXPECT_EQ(cyl_factory->transforms().size(), 4u);
+    EXPECT_EQ(cyl_factory->volume_links().size(), 4u);
+    const auto& sens_cyl_comps = cyl_factory->bounds().front();
     EXPECT_NEAR(sens_cyl_comps[0], 5.f, tol);
     EXPECT_NEAR(sens_cyl_comps[1], -900.f, tol);
     EXPECT_NEAR(sens_cyl_comps[2], 900.f, tol);
-    const auto& sens_cyl_vol_links = sens_cyl_factory->volume_links();
+    const auto& sens_cyl_vol_links = cyl_factory->volume_links();
     EXPECT_EQ(sens_cyl_vol_links[0], 1u);
 
-    //
-    // check passive cylinder
-    //
-    using passive_cylinder_factory =
-        surface_factory<detector_t, cylinder2D<>, mask_id::e_cylinder2,
-                        surface_id::e_passive>;
-
-    auto psv_cyl_factory = std::make_shared<passive_cylinder_factory>();
-
-    cyl_sf_data.emplace_back(transform3(point3{0.f, 0.f, -20.f}), 1u,
-                             std::vector<scalar>{4.9f, -900.f, 900.f});
-    cyl_sf_data.emplace_back(transform3(point3{0.f, 0.f, 20.f}), 1u,
-                             std::vector<scalar>{4.9f, -900.f, 900.f});
-
-    EXPECT_EQ(psv_cyl_factory->size(), 0u);
-    EXPECT_TRUE(psv_cyl_factory->components().empty());
-    EXPECT_TRUE(psv_cyl_factory->transforms().empty());
-    // The single view is never empty, only uninitialized
-    EXPECT_FALSE(psv_cyl_factory->volume_links().empty());
-
-    psv_cyl_factory->push_back(std::move(cyl_sf_data));
-    cyl_sf_data.clear();
-
-    EXPECT_EQ(psv_cyl_factory->size(), 2u);
-    EXPECT_EQ(psv_cyl_factory->components().size(), 2u);
-    EXPECT_EQ(psv_cyl_factory->transforms().size(), 2u);
-    EXPECT_EQ(psv_cyl_factory->volume_links().size(), 1u);
-    const auto& psv_cyl_comps = psv_cyl_factory->components().front();
-    EXPECT_NEAR(psv_cyl_comps[0], 4.9f, tol);
-    EXPECT_NEAR(psv_cyl_comps[1], -900.f, tol);
-    EXPECT_NEAR(psv_cyl_comps[2], 900.f, tol);
-    const auto& psv_cyl_vol_links = psv_cyl_factory->volume_links();
-    EXPECT_EQ(psv_cyl_vol_links[0], 1u);
-
     //
     // check the other mask types for this detector
     //
 
     // annulus
-    using annulus_factory =
-        surface_factory<detector_t, annulus2D<>, mask_id::e_annulus2,
-                        surface_id::e_sensitive>;
+    using annulus_factory = surface_factory<detector_t, annulus2D<>>;
 
     auto ann_factory = std::make_shared<annulus_factory>();
 
     typename annulus_factory::sf_data_collection ann_sf_data;
     ann_sf_data.emplace_back(
-        transform3(point3{0.f, 0.f, 0.f}), 1u,
+        surface_id::e_sensitive, transform3(point3{0.f, 0.f, 0.f}), 1u,
         std::vector<scalar>{300.f, 350.f, -0.1f, 0.1f, 0.5f, 0.6f, 1.4f});
     ann_factory->push_back(std::move(ann_sf_data));
     ann_sf_data.clear();
 
-    const auto& ann_comps = ann_factory->components().front();
+    const auto& ann_comps = ann_factory->bounds().front();
     EXPECT_NEAR(ann_comps[0], 300.f, tol);
     EXPECT_NEAR(ann_comps[1], 350.f, tol);
     EXPECT_NEAR(ann_comps[2], -0.1f, tol);
@@ -339,52 +315,50 @@ GTEST_TEST(detray_tools, surface_factory) {
     EXPECT_NEAR(ann_comps[6], 1.4f, tol);
 
     // rectangles
-    using rectangle_factory =
-        surface_factory<detector_t, rectangle2D<>, mask_id::e_rectangle2,
-                        surface_id::e_sensitive>;
+    using rectangle_factory = surface_factory<detector_t, rectangle2D<>>;
 
     auto rect_factory = std::make_shared<rectangle_factory>();
 
     typename rectangle_factory::sf_data_collection rect_sf_data;
-    rect_sf_data.emplace_back(transform3(point3{0.f, 0.f, 0.f}), 1u,
+    rect_sf_data.emplace_back(surface_id::e_sensitive,
+                              transform3(point3{0.f, 0.f, 0.f}), 1u,
                               std::vector<scalar>{10.f, 8.f});
     rect_factory->push_back(std::move(rect_sf_data));
     rect_sf_data.clear();
 
-    const auto& rectgl_comps = rect_factory->components().front();
+    const auto& rectgl_comps = rect_factory->bounds().front();
     EXPECT_NEAR(rectgl_comps[0], 10.f, tol);
     EXPECT_NEAR(rectgl_comps[1], 8.f, tol);
 
     // ring
-    using ring_factory = surface_factory<detector_t, ring2D<>, mask_id::e_ring2,
-                                         surface_id::e_passive>;
+    using disc_factory = surface_factory<detector_t, ring2D<>>;
 
-    auto rng_factory = std::make_shared<ring_factory>();
+    auto sf_disc_factory = std::make_shared<disc_factory>();
 
-    typename ring_factory::sf_data_collection ring_sf_data;
-    ring_sf_data.emplace_back(transform3(point3{0.f, 0.f, 0.f}), 1u,
+    typename disc_factory::sf_data_collection disc_sf_data;
+    disc_sf_data.emplace_back(surface_id::e_passive,
+                              transform3(point3{0.f, 0.f, 0.f}), 1u,
                               std::vector<scalar>{0.f, 5.f});
-    rng_factory->push_back(std::move(ring_sf_data));
-    ring_sf_data.clear();
+    sf_disc_factory->push_back(std::move(disc_sf_data));
+    disc_sf_data.clear();
 
-    const auto& ring_comps = rng_factory->components().front();
+    const auto& ring_comps = sf_disc_factory->bounds().front();
     EXPECT_NEAR(ring_comps[0], 0.f, tol);
     EXPECT_NEAR(ring_comps[1], 5.f, tol);
 
     // trapezoid
-    using trapezoid_factory =
-        surface_factory<detector_t, trapezoid2D<>, mask_id::e_trapezoid2,
-                        surface_id::e_sensitive>;
+    using trapezoid_factory = surface_factory<detector_t, trapezoid2D<>>;
 
     auto trpz_factory = std::make_shared<trapezoid_factory>();
 
     typename trapezoid_factory::sf_data_collection trpz_sf_data;
-    trpz_sf_data.emplace_back(transform3(point3{0.f, 0.f, 0.f}), 1u,
+    trpz_sf_data.emplace_back(surface_id::e_sensitive,
+                              transform3(point3{0.f, 0.f, 0.f}), 1u,
                               std::vector<scalar>{1.f, 3.f, 2.f, 0.25f});
     trpz_factory->push_back(std::move(trpz_sf_data));
     trpz_sf_data.clear();
 
-    const auto& trpz_comps = trpz_factory->components().front();
+    const auto& trpz_comps = trpz_factory->bounds().front();
     EXPECT_NEAR(trpz_comps[0], 1.f, tol);
     EXPECT_NEAR(trpz_comps[1], 3.f, tol);
     EXPECT_NEAR(trpz_comps[2], 2.f, tol);
@@ -426,29 +400,15 @@ GTEST_TEST(detray_tools, detector_volume_construction) {
     using mask_id = typename detector_t::masks::id;
     using sf_finder_id = typename detector_t::sf_finders::id;
 
-    // portal factories
+    // Surface factories
     using portal_cylinder_factory =
-        surface_factory<detector_t, typename default_metadata::cylinder_portal,
-                        mask_id::e_portal_cylinder2, surface_id::e_portal>;
-    using portal_disc_factory =
-        surface_factory<detector_t, ring2D<>, mask_id::e_portal_ring2,
-                        surface_id::e_portal>;
-
-    // sensitive/passive surface factories
-    using annulus_factory =
-        surface_factory<detector_t, annulus2D<>, mask_id::e_annulus2,
-                        surface_id::e_sensitive>;
-    using cylinder_factory =
-        surface_factory<detector_t, cylinder2D<>, mask_id::e_cylinder2,
-                        surface_id::e_passive>;
-    using rectangle_factory =
-        surface_factory<detector_t, rectangle2D<>, mask_id::e_rectangle2,
-                        surface_id::e_sensitive>;
-    using ring_factory = surface_factory<detector_t, ring2D<>, mask_id::e_ring2,
-                                         surface_id::e_passive>;
-    using trapezoid_factory =
-        surface_factory<detector_t, trapezoid2D<>, mask_id::e_trapezoid2,
-                        surface_id::e_sensitive>;
+        surface_factory<detector_t,
+                        typename default_metadata::cylinder_portal::shape>;
+    using annulus_factory = surface_factory<detector_t, annulus2D<>>;
+    using cylinder_factory = surface_factory<detector_t, cylinder2D<>>;
+    using rectangle_factory = surface_factory<detector_t, rectangle2D<>>;
+    using disc_factory = surface_factory<detector_t, ring2D<>>;
+    using trapezoid_factory = surface_factory<detector_t, trapezoid2D<>>;
 
     // detector
     vecmem::host_memory_resource host_mr;
@@ -479,90 +439,104 @@ GTEST_TEST(detray_tools, detector_volume_construction) {
     typename portal_cylinder_factory::sf_data_collection cyl_sf_data;
     // Creates two cylinders at radius 0mm and 10mm with an extent in z
     // of -5mm to 5mm and linking to volumes 0 and 2, respectively.
-    cyl_sf_data.emplace_back(transform3(point3{0.f, 0.f, 0.f}), 0u,
+    cyl_sf_data.emplace_back(surface_id::e_portal,
+                             transform3(point3{0.f, 0.f, 0.f}), 0u,
                              std::vector<scalar>{10.f, -1500.f, 1500.f});
-    cyl_sf_data.emplace_back(transform3(point3{0.f, 0.f, 0.f}), 2u,
+    cyl_sf_data.emplace_back(surface_id::e_portal,
+                             transform3(point3{0.f, 0.f, 0.f}), 2u,
                              std::vector<scalar>{20.f, -1500.f, 1500.f});
     pt_cyl_factory->push_back(std::move(cyl_sf_data));
 
-    auto pt_disc_factory = std::make_shared<portal_disc_factory>();
-    typename portal_disc_factory::sf_data_collection ring_sf_data;
+    auto pt_disc_factory = std::make_shared<disc_factory>();
+    typename disc_factory::sf_data_collection disc_sf_data;
     // Creates two discs with a radius of 10mm, linking to volumes 3 and 4
-    ring_sf_data.emplace_back(transform3(point3{0.f, 0.f, -1500.f}), 3u,
+    disc_sf_data.emplace_back(surface_id::e_portal,
+                              transform3(point3{0.f, 0.f, -1500.f}), 3u,
                               std::vector<scalar>{0.f, 10.f});
-    ring_sf_data.emplace_back(transform3(point3{0.f, 0.f, 1500.f}), 4u,
+    disc_sf_data.emplace_back(surface_id::e_portal,
+                              transform3(point3{0.f, 0.f, 1500.f}), 4u,
                               std::vector<scalar>{0.f, 10.f});
-    pt_disc_factory->push_back(std::move(ring_sf_data));
+    pt_disc_factory->push_back(std::move(disc_sf_data));
 
     // sensitive surfaces
     auto ann_factory = std::make_shared<annulus_factory>();
     typename annulus_factory::sf_data_collection ann_sf_data;
     ann_sf_data.emplace_back(
-        transform3(point3{0.f, 0.f, 1000.f}), vol_idx,
+        surface_id::e_sensitive, transform3(point3{0.f, 0.f, 1000.f}), vol_idx,
         std::vector<scalar>{300.f, 350.f, -0.1f, 0.1f, 0.5f, 0.6f, 1.4f});
     ann_sf_data.emplace_back(
-        transform3(point3{0.f, 0.f, 1000.f}), vol_idx,
+        surface_id::e_sensitive, transform3(point3{0.f, 0.f, 1000.f}), vol_idx,
         std::vector<scalar>{350.f, 400.f, -0.1f, 0.1f, 0.5f, 0.6f, 1.4f});
     ann_factory->push_back(std::move(ann_sf_data));
 
     auto rect_factory = std::make_shared<rectangle_factory>();
     typename rectangle_factory::sf_data_collection rect_sf_data;
-    rect_sf_data.emplace_back(transform3(point3{0.f, 0.f, -10.f}), vol_idx,
+    rect_sf_data.emplace_back(surface_id::e_sensitive,
+                              transform3(point3{0.f, 0.f, -10.f}), vol_idx,
                               std::vector<scalar>{10.f, 8.f});
-    rect_sf_data.emplace_back(transform3(point3{0.f, 0.f, -20.f}), vol_idx,
+    rect_sf_data.emplace_back(surface_id::e_sensitive,
+                              transform3(point3{0.f, 0.f, -20.f}), vol_idx,
                               std::vector<scalar>{10.f, 8.f});
-    rect_sf_data.emplace_back(transform3(point3{0.f, 0.f, -30.f}), vol_idx,
+    rect_sf_data.emplace_back(surface_id::e_sensitive,
+                              transform3(point3{0.f, 0.f, -30.f}), vol_idx,
                               std::vector<scalar>{10.f, 8.f});
     rect_factory->push_back(std::move(rect_sf_data));
 
     auto trpz_factory = std::make_shared<trapezoid_factory>();
     typename trapezoid_factory::sf_data_collection trpz_sf_data;
-    trpz_sf_data.emplace_back(transform3(point3{0.f, 0.f, 1000.f}), vol_idx,
+    trpz_sf_data.emplace_back(surface_id::e_sensitive,
+                              transform3(point3{0.f, 0.f, 1000.f}), vol_idx,
                               std::vector<scalar>{1.f, 3.f, 2.f, 0.25f});
     trpz_factory->push_back(std::move(trpz_sf_data));
 
     // passive surfaces
     auto cyl_factory = std::make_shared<cylinder_factory>();
     cyl_sf_data.clear();
-    cyl_sf_data.emplace_back(transform3(point3{0.f, 0.f, 0.f}), vol_idx,
+    cyl_sf_data.emplace_back(surface_id::e_passive,
+                             transform3(point3{0.f, 0.f, 0.f}), vol_idx,
                              std::vector<scalar>{5.f, -1300.f, 1300.f});
     cyl_factory->push_back(std::move(cyl_sf_data));
 
-    auto rng_factory = std::make_shared<ring_factory>();
-    ring_sf_data.clear();
-    ring_sf_data.emplace_back(transform3(point3{0.f, 0.f, -1300.f}), vol_idx,
+    auto sf_disc_factory = std::make_shared<disc_factory>();
+    disc_sf_data.clear();
+    disc_sf_data.emplace_back(surface_id::e_passive,
+                              transform3(point3{0.f, 0.f, -1300.f}), vol_idx,
                               std::vector<scalar>{0.f, 5.f});
-    ring_sf_data.emplace_back(transform3(point3{0.f, 0.f, 1300.f}), vol_idx,
+    disc_sf_data.emplace_back(surface_id::e_passive,
+                              transform3(point3{0.f, 0.f, 1300.f}), vol_idx,
                               std::vector<scalar>{0.f, 5.f});
-    rng_factory->push_back(std::move(ring_sf_data));
+    sf_disc_factory->push_back(std::move(disc_sf_data));
 
     //
     // Fill everything into volume
     //
-    vbuilder.add_portals(pt_cyl_factory, geo_ctx);
-    vbuilder.add_portals(pt_disc_factory, geo_ctx);
+    vbuilder.add_surfaces(pt_cyl_factory, geo_ctx);
+    vbuilder.add_surfaces(pt_disc_factory, geo_ctx);
 
-    vbuilder.add_sensitives(ann_factory, geo_ctx);
-    vbuilder.add_sensitives(rect_factory, geo_ctx);
-    vbuilder.add_sensitives(trpz_factory, geo_ctx);
+    vbuilder.add_surfaces(ann_factory, geo_ctx);
+    vbuilder.add_surfaces(rect_factory, geo_ctx);
+    vbuilder.add_surfaces(trpz_factory, geo_ctx);
 
-    vbuilder.add_passives(cyl_factory, geo_ctx);
-    vbuilder.add_passives(rng_factory, geo_ctx);
+    vbuilder.add_surfaces(cyl_factory, geo_ctx);
+    vbuilder.add_surfaces(sf_disc_factory, geo_ctx);
 
     // try adding something extra later...
     rect_factory->clear();
     rect_sf_data.clear();
-    rect_sf_data.emplace_back(transform3(point3{0.f, 0.f, 10.f}), vol_idx,
+    rect_sf_data.emplace_back(surface_id::e_sensitive,
+                              transform3(point3{0.f, 0.f, 10.f}), vol_idx,
                               std::vector<scalar>{10.f, 8.f});
-    rect_sf_data.emplace_back(transform3(point3{0.f, 0.f, 20.f}), vol_idx,
+    rect_sf_data.emplace_back(surface_id::e_sensitive,
+                              transform3(point3{0.f, 0.f, 20.f}), vol_idx,
                               std::vector<scalar>{10.f, 8.f});
     rect_factory->push_back(std::move(rect_sf_data));
     rect_sf_data.clear();
-    rect_sf_data.emplace_back(transform3(point3{0.f, 0.f, 30.f}), vol_idx,
+    rect_sf_data.emplace_back(surface_id::e_sensitive,
+                              transform3(point3{0.f, 0.f, 30.f}), vol_idx,
                               std::vector<scalar>{10.f, 8.f});
     rect_factory->push_back(std::move(rect_sf_data));
 
-    vbuilder.add_sensitives(rect_factory, geo_ctx);
+    vbuilder.add_surfaces(rect_factory, geo_ctx);
 
     //
     // Adds all surfaces to the detector
@@ -698,9 +672,7 @@ GTEST_TEST(detray_tools, detector_builder) {
     using mask_id = typename detector_t::masks::id;
 
     // Surface factories
-    using trapezoid_factory =
-        surface_factory<detector_t, trapezoid2D<>, mask_id::e_trapezoid2,
-                        surface_id::e_sensitive>;
+    using trapezoid_factory = surface_factory<detector_t, trapezoid2D<>>;
 
     // detector builder
     auto geo_ctx = typename detector_t::geometry_context{};
@@ -724,15 +696,18 @@ GTEST_TEST(detray_tools, detector_builder) {
 
     auto trpz_factory = std::make_shared<trapezoid_factory>();
     typename trapezoid_factory::sf_data_collection trpz_sf_data;
-    trpz_sf_data.emplace_back(transform3(point3{0.f, 0.f, 1000.f}), vol_idx,
+    trpz_sf_data.emplace_back(surface_id::e_sensitive,
+                              transform3(point3{0.f, 0.f, 1000.f}), vol_idx,
                               std::vector<scalar>{1.f, 3.f, 2.f, 0.25f});
-    trpz_sf_data.emplace_back(transform3(point3{0.f, 0.f, 1100.f}), vol_idx,
+    trpz_sf_data.emplace_back(surface_id::e_sensitive,
+                              transform3(point3{0.f, 0.f, 1100.f}), vol_idx,
                               std::vector<scalar>{1.f, 3.f, 2.f, 0.25f});
-    trpz_sf_data.emplace_back(transform3(point3{0.f, 0.f, 1200.f}), vol_idx,
+    trpz_sf_data.emplace_back(surface_id::e_sensitive,
+                              transform3(point3{0.f, 0.f, 1200.f}), vol_idx,
                               std::vector<scalar>{1.f, 3.f, 2.f, 0.25f});
     trpz_factory->push_back(std::move(trpz_sf_data));
 
-    vbuilder->add_sensitives(trpz_factory, geo_ctx);
+    vbuilder->add_surfaces(trpz_factory, geo_ctx);
 
     //
     // second volume builder
@@ -748,7 +723,7 @@ GTEST_TEST(detray_tools, detector_builder) {
     auto portal_generator =
         std::make_shared<cuboid_portal_generator<detector_t>>(env);
 
-    vbuilder2->add_portals(portal_generator);
+    vbuilder2->add_surfaces(portal_generator);
 
     // initial checks
     EXPECT_EQ(vbuilder2->vol_index(), 1u);
diff --git a/tests/unit_tests/cpu/grid_grid_builder.cpp b/tests/unit_tests/cpu/grid_grid_builder.cpp
index a17470a89..abda75aed 100644
--- a/tests/unit_tests/cpu/grid_grid_builder.cpp
+++ b/tests/unit_tests/cpu/grid_grid_builder.cpp
@@ -12,6 +12,7 @@
 #include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/indexing.hpp"
 #include "detray/detectors/toy_metadata.hpp"
+#include "detray/intersection/cylinder_portal_intersector.hpp"
 #include "detray/masks/masks.hpp"
 #include "detray/surface_finders/grid/populator.hpp"
 #include "detray/surface_finders/grid/serializer.hpp"
@@ -36,7 +37,7 @@ using vector3 = test::vector3;
 
 test::transform3 Identity{};
 
-using test_detector_t = detector<toy_metadata>;
+using detector_t = detector<toy_metadata>;
 
 }  // anonymous namespace
 
@@ -126,11 +127,11 @@ GTEST_TEST(detray_tools, grid_builder) {
     // cylinder grid type of the toy detector
     using cyl_grid_t =
         grid<coordinate_axes<cylinder2D<>::axes<>, false, host_container_types>,
-             test_detector_t::surface_type, simple_serializer,
-             regular_attacher<1>>;
+             detector_t::surface_type, simple_serializer, regular_attacher<1>>;
 
-    auto gbuilder = grid_builder<test_detector_t, cyl_grid_t,
-                                 detray::detail::bin_associator>{nullptr};
+    auto gbuilder =
+        grid_builder<detector_t, cyl_grid_t, detray::detail::bin_associator>{
+            nullptr};
 
     // The cylinder portals are at the end of the surface range by construction
     const auto cyl_mask = mask<cylinder2D<>>{0u, 10.f, -500.f, 500.f};
@@ -154,43 +155,34 @@ GTEST_TEST(detray_tools, grid_builder) {
 /// Integration test: grid builder as volume builder decorator
 GTEST_TEST(detray_tools, decorator_grid_builder) {
 
-    using transform3 = typename test_detector_t::transform3;
-    using geo_obj_id = typename test_detector_t::geo_obj_ids;
-    using acc_ids = typename test_detector_t::sf_finders::id;
-    using mask_id = typename test_detector_t::masks::id;
+    using transform3 = typename detector_t::transform3;
+    using geo_obj_id = typename detector_t::geo_obj_ids;
+    using acc_ids = typename detector_t::sf_finders::id;
+    using mask_id = typename detector_t::masks::id;
 
     // cylinder grid type of the toy detector
     using cyl_grid_t =
         grid<coordinate_axes<cylinder2D<>::axes<>, false, host_container_types>,
-             test_detector_t::surface_type, simple_serializer,
-             regular_attacher<1>>;
-
-    using portal_cylinder_factory_t =
-        surface_factory<test_detector_t, cylinder2D<>,
-                        mask_id::e_portal_cylinder2, surface_id::e_portal>;
-    using rectangle_factory =
-        surface_factory<test_detector_t, rectangle2D<>, mask_id::e_rectangle2,
-                        surface_id::e_sensitive>;
-    using trapezoid_factory =
-        surface_factory<test_detector_t, trapezoid2D<>, mask_id::e_trapezoid2,
-                        surface_id::e_sensitive>;
-    using cylinder_factory =
-        surface_factory<test_detector_t, cylinder2D<>, mask_id::e_cylinder2,
-                        surface_id::e_passive>;
+             detector_t::surface_type, simple_serializer, regular_attacher<1>>;
+
+    using pt_cylinder_t = cylinder2D<false, cylinder_portal_intersector>;
+    using pt_cylinder_factory_t = surface_factory<detector_t, pt_cylinder_t>;
+    using rectangle_factory = surface_factory<detector_t, rectangle2D<>>;
+    using trapezoid_factory = surface_factory<detector_t, trapezoid2D<>>;
+    using cylinder_factory = surface_factory<detector_t, pt_cylinder_t>;
 
     vecmem::host_memory_resource host_mr;
-    test_detector_t d(host_mr);
-    auto geo_ctx = typename test_detector_t::geometry_context{};
+    detector_t d(host_mr);
+    auto geo_ctx = typename detector_t::geometry_context{};
     const auto vol_idx{
-        static_cast<typename test_detector_t::surface_type::navigation_link>(
+        static_cast<typename detector_t::surface_type::navigation_link>(
             d.volumes().size())};
 
-    auto vbuilder = std::make_unique<volume_builder<test_detector_t>>(
-        volume_id::e_cylinder);
-    auto gbuilder =
-        grid_builder<test_detector_t, cyl_grid_t>{std::move(vbuilder)};
+    auto vbuilder =
+        std::make_unique<volume_builder<detector_t>>(volume_id::e_cylinder);
+    auto gbuilder = grid_builder<detector_t, cyl_grid_t>{std::move(vbuilder)};
     // passive surfaces are added to the grid
-    // gbuilder.set_add_passives();
+    // gbuilder.set_add_surfaces();
 
     // The cylinder portals are at the end of the surface range by construction
     const auto cyl_mask = mask<cylinder2D<>>{0u, 10.f, -500.f, 500.f};
@@ -202,12 +194,14 @@ GTEST_TEST(detray_tools, decorator_grid_builder) {
     EXPECT_TRUE(d.volumes().size() == 0);
 
     // Add some portals first
-    auto pt_cyl_factory = std::make_shared<portal_cylinder_factory_t>();
+    auto pt_cyl_factory = std::make_shared<pt_cylinder_factory_t>();
 
-    typename portal_cylinder_factory_t::sf_data_collection cyl_sf_data;
-    cyl_sf_data.emplace_back(transform3(point3{0.f, 0.f, 0.f}), 0u,
+    typename pt_cylinder_factory_t::sf_data_collection cyl_sf_data;
+    cyl_sf_data.emplace_back(surface_id::e_portal,
+                             transform3(point3{0.f, 0.f, 0.f}), 0u,
                              std::vector<scalar>{10.f, -1500.f, 1500.f});
-    cyl_sf_data.emplace_back(transform3(point3{0.f, 0.f, 0.f}), 2u,
+    cyl_sf_data.emplace_back(surface_id::e_portal,
+                             transform3(point3{0.f, 0.f, 0.f}), 2u,
                              std::vector<scalar>{20.f, -1500.f, 1500.f});
     pt_cyl_factory->push_back(std::move(cyl_sf_data));
 
@@ -215,33 +209,38 @@ GTEST_TEST(detray_tools, decorator_grid_builder) {
     auto rect_factory = std::make_shared<rectangle_factory>();
 
     typename rectangle_factory::sf_data_collection rect_sf_data;
-    rect_sf_data.emplace_back(transform3(point3{7.07f, 7.07f, -500.f}), vol_idx,
+    rect_sf_data.emplace_back(surface_id::e_sensitive,
+                              transform3(point3{7.07f, 7.07f, -500.f}), vol_idx,
                               std::vector<scalar>{10.f, 8.f});
-    rect_sf_data.emplace_back(transform3(point3{7.07f, 7.07f, -250.f}), vol_idx,
+    rect_sf_data.emplace_back(surface_id::e_sensitive,
+                              transform3(point3{7.07f, 7.07f, -250.f}), vol_idx,
                               std::vector<scalar>{10.f, 8.f});
-    rect_sf_data.emplace_back(transform3(point3{7.07f, 7.07f, 100.f}), vol_idx,
+    rect_sf_data.emplace_back(surface_id::e_sensitive,
+                              transform3(point3{7.07f, 7.07f, 100.f}), vol_idx,
                               std::vector<scalar>{10.f, 8.f});
     rect_factory->push_back(std::move(rect_sf_data));
 
     auto trpz_factory = std::make_shared<trapezoid_factory>();
 
     typename trapezoid_factory::sf_data_collection trpz_sf_data;
-    trpz_sf_data.emplace_back(transform3(point3{7.07f, 7.07f, 600.f}), vol_idx,
+    trpz_sf_data.emplace_back(surface_id::e_sensitive,
+                              transform3(point3{7.07f, 7.07f, 600.f}), vol_idx,
                               std::vector<scalar>{1.f, 3.f, 2.f, 0.25f});
     trpz_factory->push_back(std::move(trpz_sf_data));
 
     auto cyl_factory = std::make_shared<cylinder_factory>();
 
     cyl_sf_data.clear();
-    cyl_sf_data.emplace_back(transform3(point3{0.f, 0.f, 0.f}), vol_idx,
+    cyl_sf_data.emplace_back(surface_id::e_passive,
+                             transform3(point3{0.f, 0.f, 0.f}), vol_idx,
                              std::vector<scalar>{5.f, -1300.f, 1300.f});
     cyl_factory->push_back(std::move(cyl_sf_data));
 
     // senstivies should end up in the grid, portals in the volume
-    gbuilder.add_portals(pt_cyl_factory, geo_ctx);
-    gbuilder.add_sensitives(rect_factory, geo_ctx);
-    gbuilder.add_sensitives(trpz_factory, geo_ctx);
-    gbuilder.add_passives(cyl_factory, geo_ctx);
+    gbuilder.add_surfaces(pt_cyl_factory, geo_ctx);
+    gbuilder.add_surfaces(rect_factory, geo_ctx);
+    gbuilder.add_surfaces(trpz_factory, geo_ctx);
+    gbuilder.add_surfaces(cyl_factory, geo_ctx);
 
     const auto& cyl_axis_z = gbuilder.get().template get_axis<label::e_cyl_z>();
     EXPECT_EQ(cyl_axis_z.label(), label::e_cyl_z);
@@ -270,6 +269,7 @@ GTEST_TEST(detray_tools, decorator_grid_builder) {
     EXPECT_EQ(vol.template link<geo_obj_id::e_passive>(),
               sf_range[geo_obj_id::e_passive]);
 
+    // Only the portals should be in the detector's surface container now
     EXPECT_EQ(d.surface_lookup().size(), 7u);
     EXPECT_EQ(d.mask_store().template size<mask_id::e_portal_cylinder2>(), 3u);
     EXPECT_EQ(d.mask_store().template size<mask_id::e_portal_ring2>(), 0u);
@@ -280,7 +280,7 @@ GTEST_TEST(detray_tools, decorator_grid_builder) {
     // check the portals in the detector
     const auto& bf_finder =
         d.surface_store()
-            .template get<test_detector_t::sf_finders::id::e_brute_force>()[0];
+            .template get<detector_t::sf_finders::id::e_brute_force>()[0];
     for (const auto& sf : bf_finder.all()) {
         EXPECT_TRUE((sf.id() == surface_id::e_portal) or
                     (sf.id() == surface_id::e_passive));
@@ -290,8 +290,7 @@ GTEST_TEST(detray_tools, decorator_grid_builder) {
     // check the sensitive surfaces in the grid
     const auto& cyl_grid =
         d.surface_store()
-            .template get<
-                test_detector_t::sf_finders::id::e_cylinder2_grid>()[0];
+            .template get<detector_t::sf_finders::id::e_cylinder2_grid>()[0];
     dindex trf_idx{3u};
     for (const auto& sf : cyl_grid.all()) {
         EXPECT_TRUE(sf.is_sensitive());
diff --git a/tests/unit_tests/cpu/tools_material_builder.cpp b/tests/unit_tests/cpu/tools_material_builder.cpp
index 91e59334d..233610f21 100644
--- a/tests/unit_tests/cpu/tools_material_builder.cpp
+++ b/tests/unit_tests/cpu/tools_material_builder.cpp
@@ -42,13 +42,10 @@ constexpr scalar tol{std::numeric_limits<scalar>::epsilon()};
 TEST(detray_tools, material_builder) {
 
     using transform3 = typename detector_t::transform3;
-    using mask_id = typename detector_t::masks::id;
     using material_id = typename detector_t::materials::id;
 
     // Build rectangle surfaces with material slabs
-    using rectangle_factory =
-        surface_factory<detector_t, rectangle2D<>, mask_id::e_rectangle2,
-                        surface_id::e_sensitive>;
+    using rectangle_factory = surface_factory<detector_t, rectangle2D<>>;
     auto mat_factory = std::make_unique<material_factory<detector_t>>(
         std::make_unique<rectangle_factory>());
 
@@ -64,16 +61,19 @@ TEST(detray_tools, material_builder) {
     EXPECT_TRUE(mat_factory->thickness().empty());
 
     // Add material for a few rectangle surfaces
-    mat_factory->push_back({transform3(point3{0.f, 0.f, -1.f}), 1u,
+    mat_factory->push_back({surface_id::e_sensitive,
+                            transform3(point3{0.f, 0.f, -1.f}), 1u,
                             std::vector<scalar>{10.f, 8.f}});
     mat_factory->add_material(material_id::e_slab,
                               {1.f * unit<scalar>::mm, silicon<scalar>()});
-    mat_factory->push_back({transform3(point3{0.f, 0.f, 1.f}), 1u,
+    mat_factory->push_back({surface_id::e_sensitive,
+                            transform3(point3{0.f, 0.f, 1.f}), 1u,
                             std::vector<scalar>{20.f, 16.f}});
     mat_factory->add_material(material_id::e_slab,
                               {10.f * unit<scalar>::mm, tungsten<scalar>()});
     // Pass the parameters for 'gold'
-    mat_factory->push_back({transform3(point3{0.f, 0.f, 1.f}), 1u,
+    mat_factory->push_back({surface_id::e_sensitive,
+                            transform3(point3{0.f, 0.f, 1.f}), 1u,
                             std::vector<scalar>{20.f, 16.f}});
     mat_factory->add_material(
         material_id::e_rod,
@@ -101,18 +101,11 @@ GTEST_TEST(detray_tools, decorator_material_builder) {
     using mask_id = typename detector_t::masks::id;
     using material_id = typename detector_t::materials::id;
 
-    using portal_cylinder_factory_t =
-        surface_factory<detector_t, cylinder2D<>, mask_id::e_portal_cylinder2,
-                        surface_id::e_portal>;
-    using rectangle_factory =
-        surface_factory<detector_t, rectangle2D<>, mask_id::e_rectangle2,
-                        surface_id::e_sensitive>;
-    using trapezoid_factory =
-        surface_factory<detector_t, trapezoid2D<>, mask_id::e_trapezoid2,
-                        surface_id::e_sensitive>;
-    using cylinder_factory =
-        surface_factory<detector_t, cylinder2D<>, mask_id::e_cylinder2,
-                        surface_id::e_passive>;
+    using pt_cylinder_t = cylinder2D<false, cylinder_portal_intersector>;
+    using pt_cylinder_factory_t = surface_factory<detector_t, pt_cylinder_t>;
+    using rectangle_factory = surface_factory<detector_t, rectangle2D<>>;
+    using trapezoid_factory = surface_factory<detector_t, trapezoid2D<>>;
+    using cylinder_factory = surface_factory<detector_t, cylinder2D<>>;
 
     using mat_factory_t = material_factory<detector_t>;
 
@@ -127,33 +120,40 @@ GTEST_TEST(detray_tools, decorator_material_builder) {
     EXPECT_TRUE(d.volumes().size() == 0);
 
     // Add some portals first
-    auto pt_cyl_factory = std::make_unique<portal_cylinder_factory_t>();
+    auto pt_cyl_factory = std::make_unique<pt_cylinder_factory_t>();
 
-    pt_cyl_factory->push_back({transform3(point3{0.f, 0.f, 0.f}), 1u,
+    pt_cyl_factory->push_back({surface_id::e_portal,
+                               transform3(point3{0.f, 0.f, 0.f}), 1u,
                                std::vector<scalar>{10.f, -1500.f, 1500.f}});
-    pt_cyl_factory->push_back({transform3(point3{0.f, 0.f, 0.f}), 2u,
+    pt_cyl_factory->push_back({surface_id::e_portal,
+                               transform3(point3{0.f, 0.f, 0.f}), 2u,
                                std::vector<scalar>{20.f, -1500.f, 1500.f}});
 
     // Then some passive and sensitive surfaces
     auto rect_factory = std::make_unique<rectangle_factory>();
 
     typename rectangle_factory::sf_data_collection rect_sf_data;
-    rect_sf_data.emplace_back(transform3(point3{0.f, 0.f, -10.f}), 0u,
+    rect_sf_data.emplace_back(surface_id::e_sensitive,
+                              transform3(point3{0.f, 0.f, -10.f}), 0u,
                               std::vector<scalar>{10.f, 8.f});
-    rect_sf_data.emplace_back(transform3(point3{0.f, 0.f, -20.f}), 0u,
+    rect_sf_data.emplace_back(surface_id::e_sensitive,
+                              transform3(point3{0.f, 0.f, -20.f}), 0u,
                               std::vector<scalar>{10.f, 8.f});
-    rect_sf_data.emplace_back(transform3(point3{0.f, 0.f, -30.f}), 0u,
+    rect_sf_data.emplace_back(surface_id::e_sensitive,
+                              transform3(point3{0.f, 0.f, -30.f}), 0u,
                               std::vector<scalar>{10.f, 8.f});
     rect_factory->push_back(std::move(rect_sf_data));
 
     auto trpz_factory = std::make_unique<trapezoid_factory>();
 
-    trpz_factory->push_back({transform3(point3{0.f, 0.f, 1000.f}), 0u,
+    trpz_factory->push_back({surface_id::e_sensitive,
+                             transform3(point3{0.f, 0.f, 1000.f}), 0u,
                              std::vector<scalar>{1.f, 3.f, 2.f, 0.25f}});
 
     auto cyl_factory = std::make_unique<cylinder_factory>();
 
-    cyl_factory->push_back({transform3(point3{0.f, 0.f, 0.f}), 0u,
+    cyl_factory->push_back({surface_id::e_passive,
+                            transform3(point3{0.f, 0.f, 0.f}), 0u,
                             std::vector<scalar>{5.f, -1300.f, 1300.f}});
 
     // Now add the material for each surface
@@ -184,10 +184,10 @@ GTEST_TEST(detray_tools, decorator_material_builder) {
         material_id::e_slab, {1.5f * unit<scalar>::mm, tungsten<scalar>()});
 
     // Add surfaces and material to detector
-    mat_builder.add_portals(mat_pt_cyl_factory, geo_ctx);
-    mat_builder.add_sensitives(mat_rect_factory, geo_ctx);
-    mat_builder.add_sensitives(mat_trpz_factory, geo_ctx);
-    mat_builder.add_passives(mat_cyl_factory, geo_ctx);
+    mat_builder.add_surfaces(mat_pt_cyl_factory, geo_ctx);
+    mat_builder.add_surfaces(mat_rect_factory, geo_ctx);
+    mat_builder.add_surfaces(mat_trpz_factory, geo_ctx);
+    mat_builder.add_surfaces(mat_cyl_factory, geo_ctx);
 
     // Add the volume to the detector
     mat_builder.build(d);
@@ -266,7 +266,7 @@ GTEST_TEST(detray_tools, detector_builder_with_material) {
     mat_portal_factory->add_material(
         material_id::e_slab, {6.f * unit<scalar>::mm, silicon<scalar>()});
 
-    mv_builder->add_portals(mat_portal_factory);
+    mv_builder->add_surfaces(mat_portal_factory);
 
     //
     // build the detector
diff --git a/tests/unit_tests/io/io_json_detector_reader.cpp b/tests/unit_tests/io/io_json_detector_reader.cpp
index 60f6a3ec0..c2f5b1ca9 100644
--- a/tests/unit_tests/io/io_json_detector_reader.cpp
+++ b/tests/unit_tests/io/io_json_detector_reader.cpp
@@ -7,6 +7,7 @@
 
 // Project include(s)
 #include "detray/definitions/algebra.hpp"
+#include "detray/detectors/create_telescope_detector.hpp"
 #include "detray/detectors/create_toy_geometry.hpp"
 #include "detray/detectors/create_wire_chamber.hpp"
 #include "detray/io/common/detector_reader.hpp"
@@ -23,10 +24,113 @@
 #include <gtest/gtest.h>
 
 // System include(s)
+#include <filesystem>
 #include <ios>
 
 using namespace detray;
 
+namespace {
+
+/// Compare two files with names @param file_name1 and @param file_name2 for
+/// equality, while skipping the first @param skip lines (header part)
+bool compare_files(const std::string& file_name1, const std::string& file_name2,
+                   std::size_t skip = 15u) {
+    auto file1 = io::detail::file_handle(
+        file_name1, std::ios_base::in | std::ios_base::binary);
+    auto file2 = io::detail::file_handle(
+        file_name2, std::ios_base::in | std::ios_base::binary);
+
+    std::string line1, line2;
+
+    // Check files line by line
+    std::size_t i{1u};
+    while (std::getline(*file1, line1)) {
+        if (std::getline(*file2, line2)) {
+            if (skip < i and line1 != line2) {
+                std::cout << "In line " << i << ":" << std::endl
+                          << line1 << std::endl
+                          << line2 << std::endl;
+                return false;
+            }
+        } else {
+            std::cout << "Could not read next line from file 2:" << std::endl
+                      << "In line " << i << ":" << std::endl
+                      << line1 << std::endl;
+            return false;
+        }
+        ++i;
+    }
+
+    // Are there more lines in file2 than file1?
+    if (std::getline(*file2, line2)) {
+        std::cout << "Could not read next line from file 1:" << std::endl
+                  << "In line " << i << ":" << std::endl
+                  << line2 << std::endl;
+        return false;
+    }
+
+    // Passed
+    return true;
+}
+
+}  // anonymous namespace
+
+/// Test the reading and writing of a telescope detector
+TEST(io, json_telescope_detector_reader) {
+
+    mask<rectangle2D<>> rec2{0u, 100.f, 100.f};
+
+    // Surface positions
+    std::vector<scalar> positions = {1.f,   50.f,  100.f, 150.f, 200.f, 250.f,
+                                     300.f, 350.f, 400.f, 450.f, 500.f};
+
+    tel_det_config<rectangle2D<>> tel_cfg{rec2};
+    tel_cfg.positions(positions);
+
+    // Wire chamber
+    vecmem::host_memory_resource host_mr;
+    auto [telescope_det, telescope_names] =
+        create_telescope_detector(host_mr, tel_cfg);
+
+    using detector_t = decltype(telescope_det);
+
+    auto writer_cfg = io::detector_writer_config{}
+                          .format(io::format::json)
+                          .write_grids(false)
+                          .replace_files(true);
+    io::write_detector(telescope_det, telescope_names, writer_cfg);
+
+    // Read the detector back in
+    io::detector_reader_config reader_cfg{};
+    reader_cfg.do_check(true)
+        .add_file("telescope_detector_geometry.json")
+        .add_file("telescope_detector_homogeneous_material.json");
+
+    const auto [det, names] =
+        io::read_detector<detector_t>(host_mr, reader_cfg);
+
+    const auto mat_store = det.material_store();
+    const auto slabs = mat_store.get<detector_t::materials::id::e_slab>();
+
+    EXPECT_EQ(det.volumes().size(), 1u);
+    EXPECT_EQ(slabs.size(), positions.size() + 6u);
+
+    // Write the result to a different set of files
+    writer_cfg.replace_files(false);
+    io::write_detector(det, names, writer_cfg);
+
+    // Not equal due to missing data deduplication in IO
+    /*EXPECT_TRUE(compare_files("telescope_detector_geometry.json",
+     * "telescope_detector_geometry_2.json"));*/
+    EXPECT_TRUE(
+        compare_files("telescope_detector_homogeneous_material.json",
+                      "telescope_detector_homogeneous_material_2.json"));
+
+    // Remove files
+    std::filesystem::remove("telescope_detector_geometry_2.json");
+    std::filesystem::remove("telescope_detector_homogeneous_material_2.json");
+}
+
 /// Test the reading and writing of a toy detector geometry
 TEST(io, json_toy_geometry) {
 
@@ -96,7 +200,8 @@ TEST(io, json_toy_detector_reader) {
 
     // Read the detector back in
     io::detector_reader_config reader_cfg{};
-    reader_cfg.add_file("toy_detector_geometry.json")
+    reader_cfg.do_check(true)
+        .add_file("toy_detector_geometry.json")
         .add_file("toy_detector_homogeneous_material.json")
         .add_file("toy_detector_surface_grids.json")
         .add_file(toy_cfg.bfield_file());
@@ -104,11 +209,24 @@ TEST(io, json_toy_detector_reader) {
     const auto [det, names] =
         io::read_detector<detector_t, 1u>(host_mr, reader_cfg);
 
+    EXPECT_TRUE(test_toy_detector(det, names));
+
     // Write the result to a different set of files
     writer_cfg.replace_files(false);
     io::write_detector(det, names, writer_cfg);
 
-    EXPECT_TRUE(test_toy_detector(det, names));
+    // Compare writing round-trip
+    EXPECT_TRUE(compare_files("toy_detector_geometry.json",
+                              "toy_detector_geometry_2.json"));
+    EXPECT_TRUE(compare_files("toy_detector_homogeneous_material.json",
+                              "toy_detector_homogeneous_material_2.json"));
+    EXPECT_TRUE(compare_files("toy_detector_surface_grids.json",
+                              "toy_detector_surface_grids_2.json"));
+
+    // Remove files
+    std::filesystem::remove("toy_detector_geometry_2.json");
+    std::filesystem::remove("toy_detector_homogeneous_material_2.json");
+    std::filesystem::remove("toy_detector_surface_grids_2.json");
 }
 
 /// Test the reading and writing of a wire chamber
@@ -128,7 +246,8 @@ TEST(io, json_wire_chamber_reader) {
 
     // Read the detector back in
     io::detector_reader_config reader_cfg{};
-    reader_cfg.add_file("wire_chamber_geometry.json")
+    reader_cfg.do_check(true)
+        .add_file("wire_chamber_geometry.json")
         .add_file("wire_chamber_homogeneous_material.json")
         .add_file("wire_chamber_surface_grids.json");
 
@@ -136,4 +255,21 @@ TEST(io, json_wire_chamber_reader) {
         io::read_detector<detector_t>(host_mr, reader_cfg);
 
     EXPECT_EQ(det.volumes().size(), 11u);
+
+    // Write the result to a different set of files
+    writer_cfg.replace_files(false);
+    io::write_detector(det, names, writer_cfg);
+
+    // Compare writing round-trip
+    EXPECT_TRUE(compare_files("wire_chamber_geometry.json",
+                              "wire_chamber_geometry_2.json"));
+    EXPECT_TRUE(compare_files("wire_chamber_homogeneous_material.json",
+                              "wire_chamber_homogeneous_material_2.json"));
+    EXPECT_TRUE(compare_files("wire_chamber_surface_grids.json",
+                              "wire_chamber_surface_grids_2.json"));
+
+    // Remove files
+    std::filesystem::remove("wire_chamber_geometry_2.json");
+    std::filesystem::remove("wire_chamber_homogeneous_material_2.json");
+    std::filesystem::remove("wire_chamber_surface_grids_2.json");
 }
diff --git a/tests/unit_tests/io/io_json_payload.cpp b/tests/unit_tests/io/io_json_payload.cpp
index 11bf29770..066e9ff47 100644
--- a/tests/unit_tests/io/io_json_payload.cpp
+++ b/tests/unit_tests/io/io_json_payload.cpp
@@ -307,7 +307,9 @@ TEST(io, json_volume_payload) {
 TEST(io, json_material_slab_payload) {
 
     detray::material_slab_payload m;
-    m.mat_link = {detray::material_slab_payload::type::slab, 21u};
+    m.type = detray::material_slab_payload::mat_type::slab;
+    m.index_in_coll = 21u;
+    m.surface.link = 5u;
     m.thickness = 1.2f;
     m.mat.params = {1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f};
 
@@ -316,8 +318,9 @@ TEST(io, json_material_slab_payload) {
 
     detray::material_slab_payload pm = j["material"];
 
-    EXPECT_EQ(m.mat_link.type, pm.mat_link.type);
-    EXPECT_EQ(m.mat_link.index, pm.mat_link.index);
+    EXPECT_EQ(m.type, pm.type);
+    EXPECT_EQ(m.index_in_coll, pm.index_in_coll);
+    EXPECT_EQ(m.surface.link, pm.surface.link);
     EXPECT_EQ(m.thickness, pm.thickness);
     EXPECT_EQ(m.mat.params, pm.mat.params);
 }
diff --git a/tutorials/include/detray/tutorial/square_surface_generator.hpp b/tutorials/include/detray/tutorial/square_surface_generator.hpp
index 715b5a636..3a391acae 100644
--- a/tutorials/include/detray/tutorial/square_surface_generator.hpp
+++ b/tutorials/include/detray/tutorial/square_surface_generator.hpp
@@ -38,12 +38,6 @@ class square_surface_generator final
     square_surface_generator(std::size_t n, scalar_t hl)
         : m_n_squares{static_cast<dindex>(n)}, m_half_length{hl} {}
 
-    /// @returns the id for the surface type (sensitive surfaces)
-    DETRAY_HOST
-    auto surface_type() const -> surface_id override {
-        return surface_id::e_sensitive;
-    }
-
     /// @returns the number of surfaces this factory will produce
     DETRAY_HOST
     auto size() const -> dindex override { return m_n_squares; }
@@ -105,7 +99,7 @@ class square_surface_generator final
                 detail::invalid_value<typename material_link_t::index_type>()};
             surfaces.emplace_back(transforms.size(ctx) - 1u, mask_link,
                                   material_link, volume.index(), dindex_invalid,
-                                  surface_type());
+                                  surface_id::e_sensitive);
         }
 
         return {surfaces_offset, static_cast<dindex>(surfaces.size())};
diff --git a/tutorials/src/cpu/detector/do_it_yourself_detector.cpp b/tutorials/src/cpu/detector/do_it_yourself_detector.cpp
index 5d1104cab..d40502204 100644
--- a/tutorials/src/cpu/detector/do_it_yourself_detector.cpp
+++ b/tutorials/src/cpu/detector/do_it_yourself_detector.cpp
@@ -47,9 +47,7 @@ int main() {
 
     // Fill some squares into the volume
     using square_factory_t =
-        detray::surface_factory<detector_t, detray::tutorial::square2D<>,
-                                detector_t::masks::id::e_square2,
-                                detray::surface_id::e_sensitive>;
+        detray::surface_factory<detector_t, detray::tutorial::square2D<>>;
     auto sq_factory = std::make_shared<square_factory_t>();
 
     // Add a square that is 20x20mm large, links back to its mother volume (0)
@@ -58,7 +56,8 @@ int main() {
         1.f * detray::unit<detray::scalar>::mm,
         2.f * detray::unit<detray::scalar>::mm,
         3.f * detray::unit<detray::scalar>::mm};
-    sq_factory->push_back({detray::tutorial::transform3{translation},
+    sq_factory->push_back({detray::surface_id::e_sensitive,
+                           detray::tutorial::transform3{translation},
                            0u,
                            {20.f * detray::unit<detray::scalar>::mm}});
 
@@ -73,9 +72,9 @@ int main() {
         std::make_shared<detray::cuboid_portal_generator<detector_t>>(env);
 
     // Add surfaces to volume and add the volume to the detector
-    vbuilder.add_sensitives(sq_factory);
-    vbuilder.add_sensitives(sq_generator);
-    vbuilder.add_portals(portal_generator);
+    vbuilder.add_surfaces(sq_factory);
+    vbuilder.add_surfaces(sq_generator);
+    vbuilder.add_surfaces(portal_generator);
 
     vbuilder.build(det);
 
diff --git a/tutorials/src/cpu/detector/read_detector_from_file.cpp b/tutorials/src/cpu/detector/read_detector_from_file.cpp
index b457e2e75..3fc703d4e 100644
--- a/tutorials/src/cpu/detector/read_detector_from_file.cpp
+++ b/tutorials/src/cpu/detector/read_detector_from_file.cpp
@@ -34,8 +34,8 @@ int main(int argc, char** argv) {
         throw std::runtime_error("Please specify an input file name!");
     }
 
-    // Read a toy detector with constant bfield (default)
-    using detector_t = detray::detector<detray::toy_metadata>;
+    // Read a toy detector
+    using detector_t = detray::detector<>;
 
     // Create an empty detector to be filled
     vecmem::host_memory_resource host_mr;
diff --git a/tutorials/src/cpu/detector/track_geometry_changes.cpp b/tutorials/src/cpu/detector/track_geometry_changes.cpp
index b79cfc971..aff49defc 100644
--- a/tutorials/src/cpu/detector/track_geometry_changes.cpp
+++ b/tutorials/src/cpu/detector/track_geometry_changes.cpp
@@ -44,9 +44,9 @@ int main() {
     auto geo_checker = detray::hash_tree(adj_mat);
 
     if (geo_checker.root() == root_hash) {
-        std::cout << "Geometry are links consistent" << std::endl;
+        std::cout << "Geometry links are consistent" << std::endl;
     } else {
-        std::cerr << "\nGeometry are linking has changed! Please check:\n"
+        std::cerr << "\nGeometry linking has changed! Please check:\n"
                   << graph.to_string() << std::endl;
     }
 }
diff --git a/utils/include/detray/detectors/create_telescope_detector.hpp b/utils/include/detray/detectors/create_telescope_detector.hpp
index ea122cc4e..439bcf77c 100644
--- a/utils/include/detray/detectors/create_telescope_detector.hpp
+++ b/utils/include/detray/detectors/create_telescope_detector.hpp
@@ -84,6 +84,7 @@ struct tel_det_config {
         return *this;
     }
     constexpr tel_det_config &positions(const std::vector<scalar> &dists) {
+        m_positions.clear();
         std::copy_if(dists.begin(), dists.end(),
                      std::back_inserter(m_positions),
                      [](scalar d) { return (d >= 0.f); });

From cbcbd4bed0191c20856dafa16fb99fd870903fce Mon Sep 17 00:00:00 2001
From: beomki-yeo <63090140+beomki-yeo@users.noreply.github.com>
Date: Tue, 10 Oct 2023 17:07:45 +0200
Subject: [PATCH 16/29] Update Version Number to v0.44.0

---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index ae4c97439..d189dda19 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -6,7 +6,7 @@
 
 # Set up the project.
 cmake_minimum_required( VERSION 3.11 )
-project( detray VERSION 0.43.0 LANGUAGES CXX )
+project( detray VERSION 0.44.0 LANGUAGES CXX )
 
 # Set up the used C++ standard(s).
 set( CMAKE_CXX_STANDARD 17 CACHE STRING "The (host) C++ standard to use" )

From c79e73b384becdf8bca37ea5ea4d76feee69ff5a Mon Sep 17 00:00:00 2001
From: Joana Niermann <53186085+niermann999@users.noreply.github.com>
Date: Wed, 11 Oct 2023 09:05:05 +0000
Subject: [PATCH 17/29] Add material scan and corresponding plotting tools. 
 (#561)

The material scanner is added to the validations suite and can shoot rays in uniform eta steps
through a detector and record the total encountered material for each ray.
The material is recorded either per radiation or interaction length
and as total thickness of the material vs. ray path length through the material.

In a second tool (implemented in python), the resulting material budget
can be plotted automatically, either as 2D eta-phi map or as a histogram
against eta. The plotting functionality has been abstracted into a
plot_factory to be reusable in other workflows.

The chain can be run with the following commands:

> ./bin/detray_material_validation --geometry_file toy_detector_geometry.json --material_file toy_detector_homogeneous_material.json --phi_steps 500 --eta_steps 500

and the plotting:

> python3 ../tests/validation/python/run_material_validation.py --input material_scan_toy_detector.csv --output_format pdf

Help messages are also available
---
 core/include/detray/materials/interaction.hpp |   1 -
 .../include/detray/materials/material_rod.hpp |   7 +-
 .../detray/materials/material_slab.hpp        |   1 -
 tests/validation/CMakeLists.txt               |   1 +
 .../validation/detector_material_scan.hpp     | 182 ++++++++++++++
 tests/validation/python/plot_material_scan.py | 168 +++++++++++++
 tests/validation/python/pyplot_factory.py     | 228 ++++++++++++++++++
 .../python/run_material_validation.py         | 120 +++++++++
 tests/validation/src/CMakeLists.txt           |   7 +-
 tests/validation/src/material_validation.cpp  | 116 +++++++++
 10 files changed, 826 insertions(+), 5 deletions(-)
 create mode 100644 tests/validation/include/detray/validation/detector_material_scan.hpp
 create mode 100644 tests/validation/python/plot_material_scan.py
 create mode 100644 tests/validation/python/pyplot_factory.py
 create mode 100644 tests/validation/python/run_material_validation.py
 create mode 100644 tests/validation/src/material_validation.cpp

diff --git a/core/include/detray/materials/interaction.hpp b/core/include/detray/materials/interaction.hpp
index 00ce600d8..a36a83251 100644
--- a/core/include/detray/materials/interaction.hpp
+++ b/core/include/detray/materials/interaction.hpp
@@ -12,7 +12,6 @@
 #include "detray/definitions/pdg_particle.hpp"
 #include "detray/definitions/qualifiers.hpp"
 #include "detray/definitions/units.hpp"
-#include "detray/intersection/intersection.hpp"
 #include "detray/materials/detail/relativistic_quantities.hpp"
 
 namespace detray {
diff --git a/core/include/detray/materials/material_rod.hpp b/core/include/detray/materials/material_rod.hpp
index 20a124c5a..8c12228f3 100644
--- a/core/include/detray/materials/material_rod.hpp
+++ b/core/include/detray/materials/material_rod.hpp
@@ -9,7 +9,6 @@
 
 // Project include(s)
 #include "detray/definitions/qualifiers.hpp"
-#include "detray/intersection/intersection.hpp"
 #include "detray/materials/material.hpp"
 #include "detray/materials/predefined_materials.hpp"
 
@@ -52,10 +51,14 @@ struct material_rod : public detail::homogeneous_material_tag {
     DETRAY_HOST_DEVICE
     constexpr const material_type& get_material() const { return m_material; }
 
-    /// Return the radius
+    /// @returns the radius
     DETRAY_HOST_DEVICE
     constexpr scalar_type radius() const { return m_radius; }
 
+    /// @returns the radius (alias function to keep interfaces homogeneous)
+    DETRAY_HOST_DEVICE
+    constexpr scalar_type thickness() const { return m_radius; }
+
     /// @returns the path segment through the material
     ///
     /// @param cos_inc_angle cosine of the track incidence angle
diff --git a/core/include/detray/materials/material_slab.hpp b/core/include/detray/materials/material_slab.hpp
index eba8a03d3..6faecee65 100644
--- a/core/include/detray/materials/material_slab.hpp
+++ b/core/include/detray/materials/material_slab.hpp
@@ -9,7 +9,6 @@
 
 // Project include(s)
 #include "detray/definitions/qualifiers.hpp"
-#include "detray/intersection/intersection.hpp"
 #include "detray/materials/material.hpp"
 #include "detray/materials/predefined_materials.hpp"
 
diff --git a/tests/validation/CMakeLists.txt b/tests/validation/CMakeLists.txt
index 5e885cc68..39727deed 100644
--- a/tests/validation/CMakeLists.txt
+++ b/tests/validation/CMakeLists.txt
@@ -3,6 +3,7 @@
 # (c) 2021-2023 CERN for the benefit of the ACTS project
 #
 # Mozilla Public License Version 2.0
+
 include( CMakeFindDependencyMacro )
 
 find_dependency( Boost COMPONENTS program_options )
diff --git a/tests/validation/include/detray/validation/detector_material_scan.hpp b/tests/validation/include/detray/validation/detector_material_scan.hpp
new file mode 100644
index 000000000..6570fcbb8
--- /dev/null
+++ b/tests/validation/include/detray/validation/detector_material_scan.hpp
@@ -0,0 +1,182 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/intersection/detail/trajectories.hpp"
+#include "detray/io/common/detail/file_handle.hpp"
+#include "detray/simulation/event_generator/track_generators.hpp"
+#include "detray/test/types.hpp"
+#include "tests/common/test_base/fixture_base.hpp"
+#include "tests/common/tools/particle_gun.hpp"
+
+// System include(s)
+#include <ios>
+#include <iostream>
+#include <string>
+
+namespace detray {
+
+/// @brief Test class that runs the material ray scan on a given detector.
+///
+/// @note The lifetime of the detector needs to be guaranteed.
+template <typename detector_t>
+class material_scan : public test::fixture_base<> {
+
+    using transform3_t = typename detector_t::transform3;
+    using scalar_t = typename detector_t::scalar_type;
+    using ray_t = detail::ray<transform3_t>;
+
+    public:
+    using fixture_type = test::fixture_base<>;
+
+    struct config : public fixture_type::configuration {
+        using trk_gen_config_t =
+            typename uniform_track_generator<ray_t>::configuration;
+
+        std::string m_name{"material_scan"};
+        trk_gen_config_t m_trk_gen_cfg{};
+
+        /// Getters
+        /// @{
+        const std::string &name() const { return m_name; }
+        trk_gen_config_t &track_generator() { return m_trk_gen_cfg; }
+        const trk_gen_config_t &track_generator() const {
+            return m_trk_gen_cfg;
+        }
+        /// @}
+
+        /// Setters
+        /// @{
+        config &name(const std::string n) {
+            m_name = n;
+            return *this;
+        }
+        /// @}
+    };
+
+    template <typename config_t>
+    explicit material_scan(const detector_t &det,
+                           const typename detector_t::name_map &names,
+                           const config_t &cfg = {})
+        : m_det{det}, m_names{names} {
+        m_cfg.name(cfg.name());
+        m_cfg.track_generator() = cfg.track_generator();
+    }
+
+    /// Run the ray scan
+    void TestBody() override {
+
+        std::size_t n_tracks{0u};
+        auto ray_generator =
+            uniform_track_generator<ray_t>(m_cfg.track_generator());
+
+        // Csv output file
+        std::string file_name{m_cfg.name() + "_" + m_names.at(0)};
+        detray::io::detail::file_handle outfile{
+            file_name, ".csv",
+            std::ios::out | std::ios::binary | std::ios::trunc};
+        *outfile << "eta,phi,mat_sX0,mat_sL0,mat_tX0,mat_tL0" << std::endl;
+
+        std::cout << "INFO: Running material scan on: " << m_names.at(0)
+                  << "\n(" << ray_generator.size() << " rays) ...\n"
+                  << std::endl;
+
+        scalar_t eta{}, phi{}, mat_sX0{}, mat_sL0{}, mat_tX0{}, mat_tL0{};
+        for (const auto ray : ray_generator) {
+
+            // Record all intersections and surfaces along the ray
+            const auto intersection_record =
+                particle_gun::shoot_particle(m_det, ray);
+
+            if (intersection_record.empty()) {
+                std::cout << "ERROR: Intersection trace empty for ray "
+                          << n_tracks << "/" << ray_generator.size() << ": "
+                          << ray << std::endl;
+                break;
+            }
+
+            eta = getter::eta(ray.dir());
+            phi = getter::phi(ray.dir());
+            // Total accumulated path length in X0 and L0, respectively
+            mat_sX0 = 0.f;
+            mat_sL0 = 0.f;
+            // Total accumulated material thickness in X0 and L0, respectively
+            mat_tX0 = 0.f;
+            mat_tL0 = 0.f;
+
+            // Record material for this ray
+            for (const auto &record : intersection_record) {
+
+                const auto sf = surface{m_det, record.second.sf_desc};
+
+                const auto [seg, t, mx0, ml0] =
+                    sf.template visit_material<get_material_params>(
+                        record.second.cos_incidence_angle,
+                        record.second.local[0]);
+
+                if (mx0 > 0.f) {
+                    mat_sX0 += seg / mx0;
+                    mat_tX0 += t / mx0;
+                } else {
+                    std::cout << "WARNING: Encountered invalid X_0: " << mx0
+                              << "\nOn surface: " << sf << std::endl;
+                }
+                if (ml0 > 0.f) {
+                    mat_sL0 += seg / ml0;
+                    mat_tL0 += t / ml0;
+                } else {
+                    std::cout << "WARNING: Encountered invalid L_0: " << ml0
+                              << "\nOn surface: " << sf << std::endl;
+                }
+            }
+
+            if (mat_sX0 == 0.f or mat_sL0 == 0.f or mat_tX0 == 0.f or
+                mat_tL0 == 0.f) {
+                std::cout << "WARNING: No material recorded for ray "
+                          << n_tracks << "/" << ray_generator.size() << ": "
+                          << ray << std::endl;
+            }
+
+            *outfile << eta << "," << phi << "," << mat_sX0 << "," << mat_sL0
+                     << "," << mat_tX0 << "," << mat_tL0 << std::endl;
+
+            ++n_tracks;
+        }
+    }
+
+    private:
+    /// @brief Functor to retrieve the material parameters of a given
+    /// intersection
+    struct get_material_params {
+        template <typename mat_group_t, typename index_t>
+        inline auto operator()(const mat_group_t &mat_group,
+                               const index_t &index,
+                               const scalar_t cos_inc_angle,
+                               const scalar_t approach) const {
+
+            const auto slab = mat_group[index];
+
+            const scalar_t seg{slab.path_segment(cos_inc_angle, approach)};
+            const scalar_t t{slab.thickness()};
+            const scalar_t mat_X0{slab.get_material().X0()};
+            const scalar_t mat_L0{slab.get_material().L0()};
+
+            return std::tuple(seg, t, mat_X0, mat_L0);
+        }
+    };
+
+    /// The configuration of this test
+    config m_cfg;
+    /// The detector to be checked
+    const detector_t &m_det;
+    /// Volume names
+    const typename detector_t::name_map &m_names;
+};
+
+}  // namespace detray
diff --git a/tests/validation/python/plot_material_scan.py b/tests/validation/python/plot_material_scan.py
new file mode 100644
index 000000000..2007456f9
--- /dev/null
+++ b/tests/validation/python/plot_material_scan.py
@@ -0,0 +1,168 @@
+# Detray library, part of the ACTS project (R&D line)
+#
+# (c) 2023 CERN for the benefit of the ACTS project
+#
+# Mozilla Public License Version 2.0
+
+# python includes
+import numpy as np
+import math
+import matplotlib.pyplot as plt
+
+
+""" Calculate edges of bins to plot the mateiral data """
+def get_n_bins(df):
+    # Find the number of ray directions
+    row_count = df.groupby(df['eta']).count()
+    yBins = row_count['phi'].max()
+    xBins = int(len(df['eta']) / yBins)
+    assert len(df['eta']) == xBins * yBins, "Could not infer the number of rays correctly"
+
+    # Get the axis spacing
+    x_range = np.max(df['eta']) - np.min(df['eta'])
+    xBinning = np.linspace(np.min(df['eta']) - 0.5 * x_range/xBins, np.max(df['eta']) + 0.5 * x_range/xBins, xBins + 1)
+
+    y_range = np.max(df['phi']) - np.min(df['phi'])
+    yBinning = np.linspace(np.min(df['phi']) - 0.5 * y_range/yBins, np.max(df['phi']) + 0.5 * y_range/yBins, yBins + 1)
+
+    return xBinning, yBinning
+
+
+""" Plot the material thickenss vs phi and eta in units of X_0 """
+def X0_vs_eta_phi(df, detector, plotFactory, format = "svg"):
+
+    # Histogram bin edges
+    xBinning, yBinning = get_n_bins(df)
+
+    # Plot the thickness of every material slab in units of X_0
+    hist_data = plotFactory.hist2D(
+                            x      = df["eta"],
+                            y      = df["phi"],
+                            z      = df['mat_tX0'],
+                            title  = r'\textbf{Material Scan - thickness / }$\mathbf{X_0}$',
+                            label  = detector,
+                            xLabel = r'$\mathbf{\eta}$',
+                            yLabel = r'$\mathbf{\phi}\,\mathrm{[rad]}$',
+                            zLabel = r'thickness / $X_0$',
+                            xBins = xBinning, yBins = yBinning,
+                            showStats = False)
+
+    plotFactory.write_plot(hist_data, "t_X0_map", format)
+
+    # Plot path length through material of the respective ray in units of X_0
+    hist_data = plotFactory.hist2D(
+                            x      = df["eta"],
+                            y      = df["phi"],
+                            z      = df['mat_sX0'],
+                            title  = r'\textbf{Material Scan - path length / }$\mathbf{X_0}$',
+                            label  = detector,
+                            xLabel = r'$\mathbf{\eta}$',
+                            yLabel = r'$\mathbf{\phi}\,\mathrm{[rad]}$',
+                            zLabel = r'path length / $X_0$',
+                            xBins = xBinning, yBins = yBinning,
+                            showStats = False)
+
+    plotFactory.write_plot(hist_data, "s_X0_map", format)
+
+
+""" Plot the material thickenss vs phi and eta in units of L_0 """
+def L0_vs_eta_phi(df, detector, plotFactory, format = "svg"):
+
+    # Histogram bin edges
+    xBinning, yBinning = get_n_bins(df)
+
+    # Plot the thickness of every material slab in units of L_0
+    hist_data = plotFactory.hist2D(
+                            x      = df["eta"],
+                            y      = df["phi"],
+                            z      = df['mat_tL0'],
+                            title  = r'\textbf{Material Scan - thickness /} $\mathbf{\Lambda_0}$',
+                            label  = detector,
+                            xLabel = r'$\mathbf{\eta}$',
+                            yLabel = r'$\mathbf{\phi}\,\mathrm{[rad]}$',
+                            zLabel = r'thickness / $\Lambda_0$',
+                            xBins = xBinning, yBins = yBinning,
+                            showStats = False)
+
+    plotFactory.write_plot(hist_data, "t_L0_map", format)
+
+    # Plot path length through material of the respective ray in units of L_0
+    hist_data = plotFactory.hist2D(
+                            x      = df["eta"],
+                            y      = df["phi"],
+                            z      = df['mat_sL0'],
+                            title  = r'\textbf{Material Scan - path length /} $\mathbf{\Lambda_0}$',
+                            label  = detector,
+                            xLabel = r'$\mathbf{\eta}$',
+                            yLabel = r'$\mathbf{\phi}\,\mathrm{[rad]}$',
+                            zLabel = r'path length / $\Lambda_0$',
+                            xBins = xBinning, yBins = yBinning,
+                            showStats = False)
+
+    plotFactory.write_plot(hist_data, "s_L0_map", format)
+
+
+""" Plot the material thickness in units of X_0 vs eta """
+def X0_vs_eta(df, detector, plotFactory, format = "svg"):
+
+    # Histogram bin edges
+    xBinning, _ = get_n_bins(df)
+
+    hist_data = plotFactory.hist1D(
+                            x      = df['eta'],
+                            w      = df['mat_tX0'],
+                            normalize = False,
+                            title  = r'\textbf{Material Scan - thickness / }$\mathbf{X_0}$',
+                            label  = rf'{detector}',
+                            xLabel = r'$\mathbf{\eta}$',
+                            yLabel = r'thickness / $X_0$',
+                            bins = xBinning,
+                            showStats = False)
+
+    plotFactory.write_plot(hist_data, "t_X0", format)
+
+    hist_data = plotFactory.hist1D(
+                            x      = df['eta'],
+                            w      = df['mat_sX0'],
+                            normalize = False,
+                            title  = r'\textbf{Material Scan - path length / }$\mathbf{X_0}$',
+                            label  = rf'{detector}',
+                            xLabel = r'$\mathbf{\eta}$',
+                            yLabel = r'path length / $X_0$',
+                            bins = xBinning,
+                            showStats = False)
+
+    plotFactory.write_plot(hist_data, "s_X0", format)
+
+
+""" Plot the material thickness in units of L_0 vs eta """
+def L0_vs_eta(df, detector, plotFactory, format = "svg"):
+
+    # Histogram bin edges
+    xBinning, _ = get_n_bins(df)
+
+    hist_data = plotFactory.hist1D(
+                            x      = df['eta'],
+                            w      = df['mat_tL0'],
+                            normalize = False,
+                            title  = r'\textbf{Material Scan - thickness / }$\mathbf{\Lambda_0}$',
+                            label  = rf'{detector}',
+                            xLabel = r'$\mathbf{\eta}$',
+                            yLabel = r'thickness / $\Lambda_0$',
+                            bins = xBinning,
+                            showStats = False)
+
+    plotFactory.write_plot(hist_data, "t_L0", format)
+
+    hist_data = plotFactory.hist1D(
+                            x      = df['eta'],
+                            w      = df['mat_sL0'],
+                            normalize = False,
+                            title  = r'\textbf{Material Scan - path length / }$\mathbf{\Lambda_0}$',
+                            label  = rf'{detector}',
+                            xLabel = r'$\mathbf{\eta}$',
+                            yLabel = r'path length / $\Lambda_0$',
+                            bins = xBinning,
+                            showStats = False)
+
+    plotFactory.write_plot(hist_data, "s_L0", format)
diff --git a/tests/validation/python/pyplot_factory.py b/tests/validation/python/pyplot_factory.py
new file mode 100644
index 000000000..1784bb731
--- /dev/null
+++ b/tests/validation/python/pyplot_factory.py
@@ -0,0 +1,228 @@
+# Detray library, part of the ACTS project (R&D line)
+#
+# (c) 2023 CERN for the benefit of the ACTS project
+#
+# Mozilla Public License Version 2.0
+
+# -*- coding: utf-8 -*-
+
+# python includes
+from collections import namedtuple
+import math
+import numpy as np
+
+# python based plotting
+import matplotlib.pyplot as plt
+import matplotlib.colors as mcolors
+
+#-------------------------------------------------------------------------------
+# Global identifiers
+#-------------------------------------------------------------------------------
+
+""" Pass plotting data between functions """
+plt_data  = namedtuple('plt_data', 'fig ax lgd data bins mu rms errors')
+
+#-------------------------------------------------------------------------------
+# Data Plotting
+#-------------------------------------------------------------------------------
+
+"""
+Plotter interface that uses pyplot/matplotlib.
+"""
+class pyplot_factory():
+
+    def __init__(self, outDir, logger, atlas_badge = ""):
+        self.name = 'Pyplot',
+        self.outputPrefix = outDir
+        self.logger = logger
+        self.atlas_badge = atlas_badge
+        self.badge_scale = 1.1
+
+
+    """ Add legend to a plot. Labbels must be defined. """
+    def add_legend(self, ax):
+        return ax.legend(loc="upper right")
+
+
+    """
+    Create a histogram from given input data. The normalization is achieved by 
+    dividing the bin count by the total number of observations. The error is 
+    calculated as the square root of the bin content.
+    """
+    def hist1D(self, x, w = None,
+               xLabel = 'x', yLabel = '', title = "",  label = "",
+               xMin   = None, xMax  = None, bins = 1,
+               color  = 'tab:blue', alpha = 0.75,
+               setLog    = False,
+               normalize = False,
+               showError = False,
+               showStats = True):
+
+        # Create fresh plot
+        fig = plt.figure(figsize = (8, 6))
+        ax = fig.add_subplot(1, 1, 1)
+
+        # Do calculations on data in the range of the histogram
+        if not xMin is None and not xMax is None:
+            x = x[np.where(x >= xMin)]
+            x = x[np.where(x <= xMax)]
+        else:
+            xMin = np.min(x)
+            xMax = np.max(x)
+
+        # Nothing left to do
+        if len(x) == 0:
+            self.logger.debug(rf" create hist: empty data {label}")
+            return plt_data(fig, ax, None, None, None, None, None, None)
+
+        # Histogram normalization
+        scale = 1./len(x) if normalize else 1.
+
+        # Fill data
+        data, bins, hist = ax.hist(x, weights = w,
+                                   range = (xMin, xMax),
+                                   bins = bins,
+                                   label=f"{label}  ({len(x)} entries)",
+                                   histtype  ='stepfilled',
+                                   density = normalize,
+                                   facecolor = mcolors.to_rgba(color, alpha),
+                                   edgecolor = color)
+
+        # Add some additional information
+        if showStats:
+            mean = np.mean(x, axis=0)
+            rms  = np.sqrt(np.mean(np.square(x)))
+
+            # Create empty plot with blank marker containing the extra label
+            newline = '\n'
+            ax.plot([], [], ' ', label= rf'mean = {mean:.2e}'
+                                        rf'{newline}RMS  = {rms:.2e}')
+        else:
+            mean = None
+            rms = None
+
+        # Refine plot
+        ax.set_title(title)
+        ax.set_xlabel(xLabel)
+        ax.set_ylabel(yLabel)
+        ax.grid(True, alpha = 0.25)
+
+        # Add legend
+        lgd = self.add_legend(ax)
+
+        # Calculate the bin error
+        binCenters = 0.5 * (bins[1:] + bins[:-1])
+        errors     = np.sqrt(scale * data)
+        if showError:
+            ax.errorbar(binCenters, data,
+                        yerr      = errors,
+                        fmt       = '.',
+                        linestyle = '',
+                        color     = color)
+
+        # Plot log scale
+        if setLog:
+            ax.set_yscale('log')
+
+        return plt_data(fig, ax, lgd, data, bins, mean, rms, errors)
+
+
+    """
+    Create a 2D histogram from given input data. If z values are given they will
+    be used as weights per bin.
+    """
+    def hist2D(self, x, y, z = None,
+                xLabel = 'x', yLabel = 'y', zLabel = '', title = "", label = "",
+                xMin   = None, xMax  = None, xBins = 1,
+                yMin   = None, yMax  = None, yBins = 1,
+                color  = 'tab:blue', alpha = 0.75,
+                setLog    = False,
+                showError = False,
+                showStats = True):
+
+        # Create fresh plot
+        fig = plt.figure(figsize = (8, 6))
+        ax = fig.add_subplot(1, 1, 1)
+
+        # Do calculations on data in the range of the histogram
+        if not xMin is None and not xMax is None:
+            x = x[np.where(x >= xMin)]
+            x = x[np.where(x <= xMax)]
+        else:
+            xMin = np.min(x)
+            xMax = np.max(x)
+
+        if not yMin is None and not yMax is None:
+            y = y[np.where(y >= yMin)]
+            y = y[np.where(y <= yMax)]
+        else:
+            yMin = np.min(y)
+            yMax = np.max(y)
+
+        # Nothing left to do
+        if len(x) == 0 or len(y) == 0:
+            self.logger.debug(rf" create hist: empty data {label}")
+            return plt_data(fig, ax, None, None, None, None, None, None)
+
+        # Fill data
+        data, xbins, ybins, hist = ax.hist2d(
+                                    x, y, weights = z,
+                                    range = [(xMin, xMax), (yMin, yMax)],
+                                    bins = (xBins, yBins),
+                                    label=f"{label}  ({len(x)*len(y)} entries)",
+                                    facecolor = mcolors.to_rgba(color, alpha),
+                                    edgecolor = None)
+
+        # Add some additional information
+        if showStats:
+            xMean = np.mean(x, axis=0)
+            xRms  = np.sqrt(np.mean(np.square(x)))
+            yMean = np.mean(y, axis=0)
+            yRms  = np.sqrt(np.mean(np.square(y)))
+
+            # Create empty plot with blank marker containing the extra label
+            newline = '\n'
+            ax.plot([], [], ' ', label= rf'xMean = {xMean:.2e}'
+                                        rf'{newline}xRMS  = {xRms:.2e}'
+                                        rf'yMean = {yMean:.2e}'
+                                        rf'{newline}yRMS  = {yRms:.2e}')
+
+        # Refine plot
+        ax.set_title(title)
+        ax.set_xlabel(xLabel)
+        ax.set_ylabel(yLabel)
+
+        # Add the colorbar
+        fig.colorbar(hist, label = zLabel)
+
+        return plt_data(fig, ax, None, data, None, None, None, None)
+
+
+    """ Safe a plot to disk """
+    def write_plot(self, plot_data, name = "plot", file_format = "svg",
+                   outPrefix = ""):
+        if (outPrefix == ""):
+            fileName = self.outputPrefix + name + "." + file_format
+        else:
+            fileName = outPrefix + name + "." + file_format
+
+        plot_data.fig.savefig(fileName, dpi=150)
+        plt.close(plot_data.fig)
+
+
+    """ Safe a plot as svg """
+    def write_svg(self, plot_data, name, outPrefix = ""):
+
+        self.write_plot(plot_data, name, ".svg", outPrefix)
+
+
+    """ Safe a plot as pdf """
+    def write_pdf(self, plot_data, name, outPrefix = ""):
+
+        self.write_plot(plot_data, name, ".pdf", outPrefix)
+
+
+    """ Safe a plot as png """
+    def write_png(self, plot_data, name, outPrefix = ""):
+
+        self.write_plot(plot_data, name, ".png", outPrefix)
diff --git a/tests/validation/python/run_material_validation.py b/tests/validation/python/run_material_validation.py
new file mode 100644
index 000000000..e93a5b0f8
--- /dev/null
+++ b/tests/validation/python/run_material_validation.py
@@ -0,0 +1,120 @@
+# Detray library, part of the ACTS project (R&D line)
+#
+# (c) 2023 CERN for the benefit of the ACTS project
+#
+# Mozilla Public License Version 2.0
+
+import plot_material_scan
+from pyplot_factory import pyplot_factory
+
+# python includes
+import argparse
+import logging
+import numpy as np
+import pandas as pd
+import os
+import sys
+from datetime import datetime
+import matplotlib.pyplot as plt
+
+
+plt.rc('text', usetex=True)
+plt.rc('text.latex', preamble=r'\usepackage{amsmath}')
+
+
+def __main__():
+
+#----------------------------------------------------------------arg parsing
+
+    parser = argparse.ArgumentParser(description = "Detray Material Validation")
+    parser.add_argument("--debug", "-d",
+                        help=("Enables debug output"), 
+                        action="store_true")
+    parser.add_argument("--logfile",
+                        help=("Write log in file"), 
+                        default = "", type=str)
+    parser.add_argument("--input", "-i",
+                        help=("Input material scan data file."),
+                        default = "", type=str)
+    parser.add_argument("--outdir", "-o",
+                        help=("Output directory for plots."),
+                        default = "./material_plots/", type=str)
+    parser.add_argument("--output_format", "-of",
+                        help=("Format of the plot files (svg|png|pdf)."),
+                        default = "png", type=str)
+
+    args = parser.parse_args()
+
+#---------------------------------------------------------------------config
+
+    # Check output path
+    if not os.path.isdir(args.outdir):
+        os.mkdir(args.outdir, 0o755)
+    outdir = args.outdir
+
+    # Set log level
+    logLevel = logging.INFO
+    if args.debug:
+        logLevel = logging.DEBUG
+
+    # Check logfile path
+    if args.logfile != "":
+        logDirName  = os.path.dirname(args.logfile)
+
+        if logDirName != "" and not os.path.isdir(logDirName):
+            os.mkdir(logDirName, 0o755)
+
+        if not os.path.isfile(args.logfile):
+            with open(args.logfile, 'x'): pass
+
+        # Write log in logfile
+        logging.basicConfig(filename=args.logfile, 
+                            format=("%(levelname)s (%(module)s):"
+                                    " %(message)s"), level=logLevel)
+    else:
+        # Write log to terminal
+        logging.basicConfig(format=("%(levelname)s (%(module)s):"
+                                    " %(message)s"), level=logLevel)
+
+    logging.info("\n--------------------------------------------------------\n"
+                 "Running material validation "+\
+                 str(datetime.now().strftime("%d/%m/%Y %H:%M"))+\
+                 "\n--------------------------------------------------------\n")
+
+    # Check input data files from material scan
+    if args.input == "":
+        logging.error(f"Please specify an input data file!")
+        sys.exit(1)
+
+    if not os.path.isfile(args.input):
+        logging.error(f"Data file does not exist! ({args.input})")
+        sys.exit(1)
+
+    if not args.output_format in ["svg", "png", "pdf"]:
+        logging.error(f"Unknown output file format: {out_format}")
+        sys.exit(1)
+
+    mat_scan_file = args.input
+    out_format = args.output_format
+
+#----------------------------------------------------------------prepare data
+
+    df = pd.read_csv(mat_scan_file)
+
+    plot_factory = pyplot_factory(outdir + "material_", logging)
+
+#------------------------------------------------------------------------run
+
+    # The histograms are not re-weighted (if the rays are not evenly distributed
+    # the material in some bins might be artificially high)!
+    plot_material_scan.X0_vs_eta_phi(df, "toy detector", plot_factory, out_format)
+    plot_material_scan.L0_vs_eta_phi(df, "toy detector", plot_factory, out_format)
+    plot_material_scan.X0_vs_eta(df, "toy detector", plot_factory, out_format)
+    plot_material_scan.L0_vs_eta(df, "toy detector", plot_factory, out_format)
+
+#-------------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    __main__()
+
+#------------------------------------------------------------------------------- 
diff --git a/tests/validation/src/CMakeLists.txt b/tests/validation/src/CMakeLists.txt
index ea1c0df72..b28206d1f 100644
--- a/tests/validation/src/CMakeLists.txt
+++ b/tests/validation/src/CMakeLists.txt
@@ -10,6 +10,11 @@ detray_add_executable(detector_validation
                       LINK_LIBRARIES GTest::gtest GTest::gtest_main 
                       detray_validation)
 
+detray_add_executable(material_validation
+                      "material_validation.cpp"
+                      LINK_LIBRARIES GTest::gtest GTest::gtest_main 
+                      detray_validation)
+
 # Build the CI tests
 detray_add_test(telescope_detector
                 "telescope_detector_validation.cpp"
@@ -21,4 +26,4 @@ detray_add_test(toy_detector
 
 detray_add_test(wire_chamber
                 "wire_chamber_validation.cpp"
-                LINK_LIBRARIES GTest::gtest GTest::gtest_main detray_validation)
\ No newline at end of file
+                LINK_LIBRARIES GTest::gtest GTest::gtest_main detray_validation)
diff --git a/tests/validation/src/material_validation.cpp b/tests/validation/src/material_validation.cpp
new file mode 100644
index 000000000..7e45d3b7e
--- /dev/null
+++ b/tests/validation/src/material_validation.cpp
@@ -0,0 +1,116 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+// Project include(s)
+#include "detray/core/detector.hpp"
+#include "detray/definitions/units.hpp"
+#include "detray/io/common/detector_reader.hpp"
+#include "detray/validation/detail/register_checks.hpp"
+#include "detray/validation/detector_material_scan.hpp"
+
+// Vecmem include(s)
+#include <vecmem/memory/host_memory_resource.hpp>
+
+// GTest include(s)
+#include <gtest/gtest.h>
+
+// Boost
+#include <boost/program_options.hpp>
+
+// System include(s)
+#include <sstream>
+#include <stdexcept>
+#include <string>
+
+namespace po = boost::program_options;
+using namespace detray;
+
+int main(int argc, char **argv) {
+
+    // Use the most general type to be able to read in all detector files
+    using detector_t = detray::detector<>;
+    using scalar_t = detector_t::scalar_type;
+
+    // Filter out the google test flags
+    ::testing::InitGoogleTest(&argc, argv);
+
+    // Options parsing
+    po::options_description desc("\ndetray validation options");
+
+    desc.add_options()("help", "produce help message")(
+        "geometry_file", po::value<std::string>(), "geometry input file")(
+        "material_file", po::value<std::string>(), "material input file")(
+        "bfield_file", po::value<std::string>(),
+        "magnetic field map input file")(
+        "phi_steps", po::value<std::size_t>()->default_value(50u),
+        "# phi steps for particle gun")(
+        "eta_steps", po::value<std::size_t>()->default_value(50u),
+        "# eta steps for particle gun");
+
+    po::variables_map vm;
+    po::store(po::parse_command_line(argc, argv, desc), vm);
+    po::notify(vm);
+
+    // Help message
+    if (vm.count("help")) {
+        std::cout << desc << std::endl;
+        return EXIT_FAILURE;
+    }
+
+    // Configs to be filled
+    detray::io::detector_reader_config reader_cfg{};
+    detray::material_scan<detector_t>::config mat_scan_cfg{};
+    mat_scan_cfg.track_generator().uniform_eta(true);
+
+    // Input files
+    if (vm.count("geometry_file")) {
+        reader_cfg.add_file(vm["geometry_file"].as<std::string>());
+    } else {
+        std::stringstream err_stream{};
+        err_stream << "Please specify a geometry input file!\n\n" << desc;
+
+        throw std::invalid_argument(err_stream.str());
+    }
+    if (vm.count("material_file")) {
+        reader_cfg.add_file(vm["material_file"].as<std::string>());
+    } else {
+        std::stringstream err_stream{};
+        err_stream << "Please specify a material input file!\n\n" << desc;
+
+        throw std::invalid_argument(err_stream.str());
+    }
+    if (vm.count("bfield_file")) {
+        reader_cfg.add_file(vm["bfield_file"].as<std::string>());
+    } else {
+        reader_cfg.bfield_vec(0.f, 0.f, 2.f * unit<scalar_t>::T);
+    }
+
+    // Particle gun
+    if (vm.count("phi_steps")) {
+        const std::size_t phi_steps{vm["phi_steps"].as<std::size_t>()};
+
+        mat_scan_cfg.track_generator().phi_steps(phi_steps);
+    }
+    if (vm.count("eta_steps")) {
+        const std::size_t eta_steps{vm["eta_steps"].as<std::size_t>()};
+
+        mat_scan_cfg.track_generator().eta_steps(eta_steps);
+        mat_scan_cfg.track_generator().eta_range(-4.f, 4.f);
+    }
+
+    vecmem::host_memory_resource host_mr;
+
+    const auto [det, names] =
+        detray::io::read_detector<detector_t>(host_mr, reader_cfg);
+
+    // Print the detector's material as recorded by a ray scan
+    detray::detail::register_checks<detray::material_scan>(det, names,
+                                                           mat_scan_cfg);
+
+    // Run the checks
+    return RUN_ALL_TESTS();
+}

From b1c00e1318c7b182892cc05ced74e7586f7a86a3 Mon Sep 17 00:00:00 2001
From: Joana Niermann <joana.niermann@cern.ch>
Date: Mon, 9 Oct 2023 13:35:34 +0200
Subject: [PATCH 18/29] Switch the CI builds to 'RelWithDebInfo' to trigger
 asserts and fix the asserts about missing sensitive surfaces in the detector
 building tests

---
 tests/unit_tests/cpu/core_detector.cpp        |  7 +++--
 .../unit_tests/cpu/tools_material_builder.cpp | 30 ++++++++++++++++---
 2 files changed, 30 insertions(+), 7 deletions(-)

diff --git a/tests/unit_tests/cpu/core_detector.cpp b/tests/unit_tests/cpu/core_detector.cpp
index 3ab0fdf50..832e88b38 100644
--- a/tests/unit_tests/cpu/core_detector.cpp
+++ b/tests/unit_tests/cpu/core_detector.cpp
@@ -723,6 +723,7 @@ GTEST_TEST(detray_tools, detector_builder) {
     auto portal_generator =
         std::make_shared<cuboid_portal_generator<detector_t>>(env);
 
+    vbuilder2->add_surfaces(trpz_factory, geo_ctx);
     vbuilder2->add_surfaces(portal_generator);
 
     // initial checks
@@ -753,14 +754,14 @@ GTEST_TEST(detray_tools, detector_builder) {
 
     // Check the acceleration data structure link (indirectly)
     EXPECT_EQ(vol0.n_max_candidates(), 3u);
-    EXPECT_EQ(vol1.n_max_candidates(), 6u);
+    EXPECT_EQ(vol1.n_max_candidates(), 9u);
 
-    EXPECT_EQ(d.surface_lookup().size(), 9u);
+    EXPECT_EQ(d.surface_lookup().size(), 12u);
     EXPECT_EQ(d.mask_store().template size<mask_id::e_portal_cylinder2>(), 0u);
     EXPECT_EQ(d.mask_store().template size<mask_id::e_portal_ring2>(), 0u);
     EXPECT_EQ(d.mask_store().template size<mask_id::e_annulus2>(), 0u);
     EXPECT_EQ(d.mask_store().template size<mask_id::e_cylinder2>(), 0u);
     EXPECT_EQ(d.mask_store().template size<mask_id::e_rectangle2>(), 3u);
     EXPECT_EQ(d.mask_store().template size<mask_id::e_ring2>(), 0u);
-    EXPECT_EQ(d.mask_store().template size<mask_id::e_trapezoid2>(), 3u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_trapezoid2>(), 6u);
 }
diff --git a/tests/unit_tests/cpu/tools_material_builder.cpp b/tests/unit_tests/cpu/tools_material_builder.cpp
index 233610f21..0ab1223d4 100644
--- a/tests/unit_tests/cpu/tools_material_builder.cpp
+++ b/tests/unit_tests/cpu/tools_material_builder.cpp
@@ -228,14 +228,22 @@ GTEST_TEST(detray_tools, decorator_material_builder) {
 GTEST_TEST(detray_tools, detector_builder_with_material) {
     using namespace detray;
 
+    using transform3 = typename detector_t::transform3;
     using mask_id = typename detector_t::masks::id;
     using material_id = typename detector_t::materials::id;
 
+    // Surface factories
+    using trapezoid_factory = surface_factory<detector_t, trapezoid2D<>>;
+
     // detector builder
     detector_builder<default_metadata> det_builder{};
+    auto geo_ctx = typename detector_t::geometry_context{};
 
     // Vanilla volume builder
     auto vbuilder = det_builder.new_volume(volume_id::e_cuboid);
+    const auto vol_idx{
+        static_cast<typename detector_t::surface_type::navigation_link>(
+            vbuilder->vol_index())};
 
     // Add material
     auto mv_builder =
@@ -245,6 +253,18 @@ GTEST_TEST(detray_tools, detector_builder_with_material) {
     typename detector_t::point3 t{0.f, 0.f, 20.f};
     mv_builder->add_volume_placement(t);
 
+    // Add a senstive surface
+    auto trpz_factory = std::make_unique<trapezoid_factory>();
+    // Add material to the surface
+    auto mat_sf_factory =
+        std::make_shared<material_factory<detector_t>>(std::move(trpz_factory));
+
+    mat_sf_factory->push_back({surface_id::e_sensitive,
+                               transform3(point3{0.f, 0.f, 1000.f}), vol_idx,
+                               std::vector<scalar>{1.f, 3.f, 2.f, 0.25f}});
+    mat_sf_factory->add_material(material_id::e_slab,
+                                 {1.f * unit<scalar>::mm, silicon<scalar>()});
+
     // Add a portal box around the cuboid volume with a min distance of 'env'
     constexpr auto env{0.1f * unit<detray::scalar>::mm};
     auto portal_generator =
@@ -253,8 +273,6 @@ GTEST_TEST(detray_tools, detector_builder_with_material) {
     // Add homogeneous material to every portal
     auto mat_portal_factory = std::make_shared<material_factory<detector_t>>(
         std::move(portal_generator));
-    mat_portal_factory->add_material(
-        material_id::e_slab, {1.f * unit<scalar>::mm, silicon<scalar>()});
     mat_portal_factory->add_material(
         material_id::e_slab, {2.f * unit<scalar>::mm, silicon<scalar>()});
     mat_portal_factory->add_material(
@@ -265,7 +283,10 @@ GTEST_TEST(detray_tools, detector_builder_with_material) {
         material_id::e_slab, {5.f * unit<scalar>::mm, silicon<scalar>()});
     mat_portal_factory->add_material(
         material_id::e_slab, {6.f * unit<scalar>::mm, silicon<scalar>()});
+    mat_portal_factory->add_material(
+        material_id::e_slab, {7.f * unit<scalar>::mm, silicon<scalar>()});
 
+    mv_builder->add_surfaces(mat_sf_factory, geo_ctx);
     mv_builder->add_surfaces(mat_portal_factory);
 
     //
@@ -285,9 +306,10 @@ GTEST_TEST(detray_tools, detector_builder_with_material) {
     EXPECT_TRUE(vol.transform() == trf);
     EXPECT_TRUE(d.transform_store()[0u] == trf);
 
-    EXPECT_EQ(d.surface_lookup().size(), 6u);
+    EXPECT_EQ(d.surface_lookup().size(), 7u);
     EXPECT_EQ(d.mask_store().template size<mask_id::e_rectangle2>(), 3u);
-    EXPECT_EQ(d.material_store().template size<material_id::e_slab>(), 6u);
+    EXPECT_EQ(d.mask_store().template size<mask_id::e_trapezoid2>(), 1u);
+    EXPECT_EQ(d.material_store().template size<material_id::e_slab>(), 7u);
 
     // Check the material links
     for (const auto [idx, sf_desc] :

From 181c684ab8f29164001644d11f4d071b671fc2e8 Mon Sep 17 00:00:00 2001
From: Joana Niermann <joana.niermann@cern.ch>
Date: Wed, 11 Oct 2023 17:48:05 +0200
Subject: [PATCH 19/29] Remove b-field from detector

---
 core/CMakeLists.txt                           |   2 +-
 core/include/detray/core/detector.hpp         | 208 +++---------------
 core/include/detray/propagator/rk_stepper.ipp |   9 +-
 .../grid/detail/axis_helpers.hpp              |   2 +-
 .../grid/detail/grid_helpers.hpp              |   2 +-
 .../include/detray/tools/detector_builder.hpp |  14 +-
 io/CMakeLists.txt                             |   2 +-
 io/include/detray/io/common/bfield_reader.hpp |  90 --------
 .../common/detail/detector_components_io.hpp  |   8 +-
 .../detray/io/common/detector_reader.hpp      |  36 +--
 .../detray/io/common/geometry_reader.hpp      |  10 +-
 io/include/detray/io/common/grid_reader.hpp   |  28 +--
 .../io/common/homogeneous_material_reader.hpp |   5 +-
 io/include/detray/io/common/io_interface.hpp  |   4 +-
 io/include/detray/io/common/read_bfield.hpp   |  54 +++++
 io/include/detray/io/json/json_reader.hpp     |  10 +-
 .../cuda/benchmark_propagator_cuda.cpp        |  19 +-
 .../cuda/benchmark_propagator_cuda_kernel.cu  |  12 +-
 .../cuda/benchmark_propagator_cuda_kernel.hpp |  16 +-
 .../common/test_base/propagator_test.hpp      |  23 +-
 tests/unit_tests/cpu/grid_grid_builder.cpp    |   1 -
 tests/unit_tests/cpu/line_stepper.cpp         |   1 -
 .../unit_tests/cpu/tools_guided_navigator.cpp |  16 +-
 tests/unit_tests/cpu/tools_particle_gun.cpp   |   1 -
 tests/unit_tests/cpu/tools_propagator.cpp     |  26 ++-
 tests/unit_tests/cpu/tools_stepper.cpp        |  24 +-
 .../unit_tests/device/cuda/detector_cuda.cpp  |   2 +-
 .../device/cuda/detector_cuda_kernel.cu       |  17 +-
 .../device/cuda/detector_cuda_kernel.hpp      |  24 +-
 .../unit_tests/device/cuda/navigator_cuda.cpp |   2 +-
 .../device/cuda/navigator_cuda_kernel.cu      |   4 +-
 .../device/cuda/navigator_cuda_kernel.hpp     |  11 +-
 .../device/cuda/propagator_cuda.cpp           |  29 +--
 .../device/cuda/propagator_cuda_kernel.cu     |  41 ++--
 .../device/cuda/propagator_cuda_kernel.hpp    |  27 ++-
 .../device/sycl/propagator_kernel.sycl        |  32 ++-
 .../device/sycl/propagator_sycl_kernel.hpp    |  29 ++-
 tests/unit_tests/io/CMakeLists.txt            |   3 -
 tests/unit_tests/io/io_bfield_reader.cpp      |  81 -------
 .../unit_tests/io/io_json_detector_reader.cpp |   6 +-
 .../detray/validation/detector_helix_scan.hpp |   9 +-
 .../detray/validation/helix_navigation.hpp    |  17 +-
 tests/validation/src/detector_validation.cpp  |   8 -
 tests/validation/src/material_validation.cpp  |   8 -
 .../src/telescope_detector_validation.cpp     |   5 +-
 .../src/toy_detector_validation.cpp           |   2 -
 .../src/wire_chamber_validation.cpp           |   1 -
 .../detray/tutorial/detector_metadata.hpp     |   3 +-
 .../tutorial/square_surface_generator.hpp     |   6 +-
 .../detector/build_predefined_detectors.cpp   |  12 +-
 .../src/cpu/detector/detector_to_dot.cpp      |   2 +-
 .../cpu/detector/do_it_yourself_detector.cpp  |   5 +-
 .../cpu/propagation/navigation_inspection.cpp |   5 +-
 tutorials/src/device/cuda/CMakeLists.txt      |   2 +-
 .../src/device/cuda/detector_construction.cpp |  24 +-
 .../src/device/cuda/detector_construction.cu  |   8 +-
 .../src/device/cuda/detector_construction.hpp |  11 +-
 tutorials/src/device/cuda/propagation.cpp     |  26 ++-
 tutorials/src/device/cuda/propagation.hpp     |  30 ++-
 .../src/device/cuda/propagation_kernel.cu     |  18 +-
 .../include/detray/detectors/bfield.hpp       |  24 +-
 .../detectors/create_telescope_detector.hpp   |  25 +--
 .../detray/detectors/create_toy_geometry.hpp  |  42 +---
 .../detray/detectors/create_wire_chamber.hpp  |  53 +----
 64 files changed, 395 insertions(+), 882 deletions(-)
 delete mode 100644 io/include/detray/io/common/bfield_reader.hpp
 create mode 100644 io/include/detray/io/common/read_bfield.hpp
 delete mode 100644 tests/unit_tests/io/io_bfield_reader.cpp
 rename core/include/detray/definitions/bfield_backends.hpp => utils/include/detray/detectors/bfield.hpp (54%)

diff --git a/core/CMakeLists.txt b/core/CMakeLists.txt
index 45e3c4e51..8a96cc649 100644
--- a/core/CMakeLists.txt
+++ b/core/CMakeLists.txt
@@ -33,7 +33,7 @@ file( GLOB _detray_core_private_headers
 detray_add_library( detray_core core
    ${_detray_core_public_headers} ${_detray_core_private_headers} )
 target_link_libraries( detray_core
-   INTERFACE covfie::core vecmem::core detray::Thrust )
+   INTERFACE vecmem::core detray::Thrust )
 
 # Generate a version header for the project.
 configure_file( "cmake/version.hpp.in"
diff --git a/core/include/detray/core/detector.hpp b/core/include/detray/core/detector.hpp
index 2c217bf41..9dbcd4391 100644
--- a/core/include/detray/core/detector.hpp
+++ b/core/include/detray/core/detector.hpp
@@ -11,7 +11,6 @@
 #include "detray/core/detail/container_buffers.hpp"
 #include "detray/core/detail/container_views.hpp"
 #include "detray/core/detector_metadata.hpp"
-#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/containers.hpp"
 #include "detray/definitions/qualifiers.hpp"
 #include "detray/geometry/detail/volume_descriptor.hpp"
@@ -32,7 +31,7 @@
 namespace detray {
 
 /// @brief Forward declaration of a detector view type
-template <typename device_bfield_bknd_t, typename metadata, typename bfield_t>
+template <typename metadata>
 struct detector_view;
 
 /// @brief The detector definition.
@@ -46,13 +45,11 @@ struct detector_view;
 /// @tparam container_t type collection of the underlying containers
 /// @tparam source_link the surface source link
 template <typename metadata_t = default_metadata,
-          typename bfield_t = covfie::field<bfield::const_bknd_t>,
           typename container_t = host_container_types>
 class detector {
 
     // Allow the building of the detector containers
-    friend class volume_builder_interface<
-        detector<metadata_t, bfield_t, container_t>>;
+    friend class volume_builder_interface<detector<metadata_t, container_t>>;
 
     public:
     /// Algebra types
@@ -65,8 +62,6 @@ class detector {
 
     using metadata = metadata_t;
 
-    using bfield_type = bfield_t;
-
     /// Raw container types
     template <typename T, std::size_t N>
     using array_type = typename container_t::template array_type<T, N>;
@@ -128,22 +123,15 @@ class detector {
     using volume_finder =
         typename metadata::template volume_finder<container_t>;
 
-    // TODO: Remove
-    template <typename device_bfield_t>
-    using detector_view_type =
-        detector_view<device_bfield_t, metadata, bfield_t>;
-
-    // TODO: rename back to 'view_type' etc, once covfie is wrapped in the
-    // container view/buffer formalism
     /// Detector view types
-    using view_t = dmulti_view<
+    using view_type = dmulti_view<
         dvector_view<volume_type>, typename transform_container::view_type,
         typename mask_container::view_type,
         typename material_container::view_type,
         typename surface_container::view_type, dvector_view<surface_type>,
         typename volume_finder::view_type>;
 
-    using const_view_t =
+    using const_view_type =
         dmulti_view<dvector_view<const volume_type>,
                     typename transform_container::const_view_type,
                     typename mask_container::const_view_type,
@@ -153,7 +141,7 @@ class detector {
                     typename volume_finder::const_view_type>;
 
     /// Detector buffer types
-    using buffer_t = dmulti_buffer<
+    using buffer_type = dmulti_buffer<
         dvector_buffer<volume_type>, typename transform_container::buffer_type,
         typename mask_container::buffer_type,
         typename material_container::buffer_type,
@@ -179,39 +167,20 @@ class detector {
           _surfaces(resource),
           _surface_lookup(&resource),
           _volume_finder(resource),
-          _resource(&resource),
-          _bfield() {}
-
-    /// @param resource memory resource for the allocation of members and
-    /// externally provided magnetic field @param field
-    DETRAY_HOST
-    detector(vecmem::memory_resource &resource, bfield_type &&field)
-        : _volumes(&resource),
-          _transforms(resource),
-          _masks(resource),
-          _materials(resource),
-          _surfaces(resource),
-          _surface_lookup(&resource),
-          _volume_finder(resource),
-          _resource(&resource),
-          _bfield(std::move(field)) {}
+          _resource(&resource) {}
 
     /// Constructor with detector_data
-    template <typename detector_data_type,
-              std::enable_if_t<!std::is_base_of_v<vecmem::memory_resource,
-                                                  detector_data_type>,
-                               bool> = true>
-    DETRAY_HOST_DEVICE explicit detector(detector_data_type &det_data)
-        : _volumes(detray::detail::get<0>(det_data._detector_data.m_view)),
-          _transforms(detray::detail::get<1>(det_data._detector_data.m_view)),
-          _masks(detray::detail::get<2>(det_data._detector_data.m_view)),
-          _materials(detray::detail::get<3>(det_data._detector_data.m_view)),
-          _surfaces(detray::detail::get<4>(det_data._detector_data.m_view)),
-          _surface_lookup(
-              detray::detail::get<5>(det_data._detector_data.m_view)),
-          _volume_finder(
-              detray::detail::get<6>(det_data._detector_data.m_view)),
-          _bfield(det_data._bfield_view) {}
+    template <typename detector_view_t,
+              typename std::enable_if_t<
+                  detail::is_device_view_v<detector_view_t>, bool> = true>
+    DETRAY_HOST_DEVICE explicit detector(detector_view_t &det_data)
+        : _volumes(detray::detail::get<0>(det_data.m_view)),
+          _transforms(detray::detail::get<1>(det_data.m_view)),
+          _masks(detray::detail::get<2>(det_data.m_view)),
+          _materials(detray::detail::get<3>(det_data.m_view)),
+          _surfaces(detray::detail::get<4>(det_data.m_view)),
+          _surface_lookup(detray::detail::get<5>(det_data.m_view)),
+          _volume_finder(detray::detail::get<6>(det_data.m_view)) {}
     /// @}
 
     /// Add a new volume and retrieve a reference to it.
@@ -542,14 +511,23 @@ class detector {
         return *std::max_element(n_candidates.begin(), n_candidates.end());
     }
 
-    /// @brief Add a bfield to the detector
-    DETRAY_HOST
-    void set_bfield(bfield_type &&field) {
-        _bfield = std::forward<bfield_type>(field);
+    /// @returns view of a detector
+    DETRAY_HOST auto get_data() -> view_type {
+        return view_type{
+            detray::get_data(_volumes),      detray::get_data(_transforms),
+            detray::get_data(_masks),        detray::get_data(_materials),
+            detray::get_data(_surfaces),     detray::get_data(_surface_lookup),
+            detray::get_data(_volume_finder)};
     }
 
-    DETRAY_HOST_DEVICE
-    inline const bfield_type &get_bfield() const { return _bfield; }
+    /// @returns const view of a detector
+    DETRAY_HOST auto get_data() const -> const_view_type {
+        return const_view_type{
+            detray::get_data(_volumes),      detray::get_data(_transforms),
+            detray::get_data(_masks),        detray::get_data(_materials),
+            detray::get_data(_surfaces),     detray::get_data(_surface_lookup),
+            detray::get_data(_volume_finder)};
+    }
 
     /// @param names maps a volume to its string representation.
     /// @returns a string representation of the detector.
@@ -618,128 +596,6 @@ class detector {
     /// The memory resource represents how and where (host, device, managed)
     /// the memory for the detector containers is allocated
     vecmem::memory_resource *_resource = nullptr;
-
-    /// Storage for magnetic field data
-    bfield_type _bfield;
-};
-
-/// @brief The detector data buffer
-///
-/// Contains the buffers for all detector components plus the covfie device
-/// field type, which is being copied to device when this type gets constructed
-template <typename device_bfield_bknd_t, typename metadata_t, typename bfield_t>
-struct detector_buffer {
-
-    using detector_type = detector<metadata_t, bfield_t, host_container_types>;
-
-    /// Automatic buffer creation with the given parameters
-    detector_buffer(detector_type &det, vecmem::memory_resource &mr,
-                    vecmem::copy &cpy,
-                    detray::copy cpy_type = detray::copy::sync,
-                    vecmem::data::buffer_type buff_type =
-                        vecmem::data::buffer_type::fixed_size)
-        : _detector_buffer(detray::get_buffer(detray::get_data(det.volumes()),
-                                              mr, cpy, cpy_type, buff_type),
-                           detray::get_buffer(det.transform_store(), mr, cpy,
-                                              cpy_type, buff_type),
-                           detray::get_buffer(det.mask_store(), mr, cpy,
-                                              cpy_type, buff_type),
-                           detray::get_buffer(det.material_store(), mr, cpy,
-                                              cpy_type, buff_type),
-                           detray::get_buffer(det.surface_store(), mr, cpy,
-                                              cpy_type, buff_type),
-                           detray::get_buffer(det.surface_lookup(), mr, cpy,
-                                              cpy_type, buff_type),
-                           detray::get_buffer(det.volume_search_grid(), mr, cpy,
-                                              cpy_type, buff_type)),
-          _bfield(det.get_bfield()) {}
-
-    /// Buffers were created manually
-    detector_buffer(
-        const detector_type &det,
-        detail::get_buffer_t<typename detector_type::volume_container>
-            &&vol_buffer,
-        typename detector_type::transform_container::buffer_type &&trf_buffer,
-        typename detector_type::mask_container::buffer_type &&msk_buffer,
-        typename detector_type::material_container::buffer_type &&mat_buffer,
-        typename detector_type::surface_container::buffer_type &&sf_buffer,
-        detail::get_buffer_t<typename detector_type::surface_lookup_container>
-            &&sf_lkp_buffer,
-        typename detector_type::volume_finder::buffer_type &&vgrd_buffer)
-        : _detector_buffer(std::move(vol_buffer), std::move(trf_buffer),
-                           std::move(msk_buffer), std::move(mat_buffer),
-                           std::move(sf_buffer), std::move(sf_lkp_buffer),
-                           std::move(vgrd_buffer)),
-          _bfield(det.get_bfield()) {}
-
-    /// Buffers for the vecemem types
-    typename detector_type::buffer_t _detector_buffer;
-    /// Covfie device field
-    covfie::field<device_bfield_bknd_t> _bfield;
-};
-
-/// @brief The detector view
-///
-/// Contains the views for all detector components, including the device view
-/// of the bfield
-template <typename device_bfield_bknd_t, typename metadata_t, typename bfield_t>
-struct detector_view {
-
-    using detector_type = detector<metadata_t, bfield_t, host_container_types>;
-
-    detector_view(detector_type &det)
-        : _detector_data(detray::get_data(det.volumes()),
-                         detray::get_data(det.transform_store()),
-                         detray::get_data(det.mask_store()),
-                         detray::get_data(det.material_store()),
-                         detray::get_data(det.surface_store()),
-                         detray::get_data(det.surface_lookup()),
-                         detray::get_data(det.volume_search_grid())),
-          _bfield_view(det.get_bfield()) {}
-
-    detector_view(
-        detector_buffer<device_bfield_bknd_t, metadata_t, bfield_t> &det_buff)
-        : _detector_data(detray::get_data(det_buff._detector_buffer)),
-          _bfield_view(det_buff._bfield) {}
-
-    /// Views for the vecmem types
-    typename detector_type::view_t _detector_data;
-    /// Covfie field view
-    covfie::field_view<device_bfield_bknd_t> _bfield_view;
 };
 
-/// Stand-alone function that @returns the detector view for transfer to
-/// device.
-///
-/// @param detector the detector to be tranferred
-template <typename device_bfield_bknd_t, typename metadata_t, typename bfield_t>
-inline detector_view<device_bfield_bknd_t, metadata_t, bfield_t> get_data(
-    detector<metadata_t, bfield_t, host_container_types> &det) {
-    return {det};
-}
-
-/// Stand-alone function that @returns the detector buffer for transfer to
-/// device.
-///
-/// @param detector the detector to be transferred
-template <typename device_bfield_bknd_t, typename metadata_t, typename bfield_t>
-inline detector_buffer<device_bfield_bknd_t, metadata_t, bfield_t> get_buffer(
-    detector<metadata_t, bfield_t, host_container_types> &det,
-    vecmem::memory_resource &mr, vecmem::copy &cpy,
-    detray::copy cpy_type = detray::copy::sync,
-    vecmem::data::buffer_type buff_type =
-        vecmem::data::buffer_type::fixed_size) {
-    return {det, mr, cpy, cpy_type, buff_type};
-}
-
-/// Stand-alone function that @returns the detector view for transfer to
-/// device.
-///
-/// @param detector the detector to be transferred
-template <typename device_bfield_bknd_t, typename metadata_t, typename bfield_t>
-inline detector_view<device_bfield_bknd_t, metadata_t, bfield_t> get_data(
-    detector_buffer<device_bfield_bknd_t, metadata_t, bfield_t> &det_buff) {
-    return {det_buff};
-}
-
 }  // namespace detray
diff --git a/core/include/detray/propagator/rk_stepper.ipp b/core/include/detray/propagator/rk_stepper.ipp
index 36f2678b6..3188d64e9 100644
--- a/core/include/detray/propagator/rk_stepper.ipp
+++ b/core/include/detray/propagator/rk_stepper.ipp
@@ -175,8 +175,7 @@ bool detray::rk_stepper<magnetic_field_t, transform3_t, constraint_t, policy_t,
     // First Runge-Kutta point
     const vector3 pos = stepping().pos();
     const vector3 dir = stepping().dir();
-    const typename magnetic_field_t::output_t bvec =
-        magnetic_field.at(pos[0], pos[1], pos[2]);
+    const auto bvec = magnetic_field.at(pos[0], pos[1], pos[2]);
     sd.b_first[0] = bvec[0];
     sd.b_first[1] = bvec[1];
     sd.b_first[2] = bvec[2];
@@ -190,8 +189,7 @@ bool detray::rk_stepper<magnetic_field_t, transform3_t, constraint_t, policy_t,
 
         // Second Runge-Kutta point
         const vector3 pos1 = pos + half_h * dir + h2 * 0.125f * sd.k1;
-        const typename magnetic_field_t::output_t bvec1 =
-            magnetic_field.at(pos1[0], pos1[1], pos1[2]);
+        const auto bvec1 = magnetic_field.at(pos1[0], pos1[1], pos1[2]);
         sd.b_middle[0] = bvec1[0];
         sd.b_middle[1] = bvec1[1];
         sd.b_middle[2] = bvec1[2];
@@ -202,8 +200,7 @@ bool detray::rk_stepper<magnetic_field_t, transform3_t, constraint_t, policy_t,
 
         // Last Runge-Kutta point
         const vector3 pos2 = pos + h * dir + h2 * 0.5f * sd.k3;
-        const typename magnetic_field_t::output_t bvec2 =
-            magnetic_field.at(pos2[0], pos2[1], pos2[2]);
+        const auto bvec2 = magnetic_field.at(pos2[0], pos2[1], pos2[2]);
         sd.b_last[0] = bvec2[0];
         sd.b_last[1] = bvec2[1];
         sd.b_last[2] = bvec2[2];
diff --git a/core/include/detray/surface_finders/grid/detail/axis_helpers.hpp b/core/include/detray/surface_finders/grid/detail/axis_helpers.hpp
index 76a575098..9376ff0bb 100644
--- a/core/include/detray/surface_finders/grid/detail/axis_helpers.hpp
+++ b/core/include/detray/surface_finders/grid/detail/axis_helpers.hpp
@@ -49,7 +49,7 @@ struct multi_axis_data {
     multi_axis_data() = default;
 
     /// Construct containers using a specific memory resources
-    DETRAY_HOST_DEVICE
+    DETRAY_HOST
     multi_axis_data(vecmem::memory_resource &resource)
         : m_axes_data(&resource), m_edges(&resource) {}
 
diff --git a/core/include/detray/surface_finders/grid/detail/grid_helpers.hpp b/core/include/detray/surface_finders/grid/detail/grid_helpers.hpp
index 9539d320c..9a3c4ed38 100644
--- a/core/include/detray/surface_finders/grid/detail/grid_helpers.hpp
+++ b/core/include/detray/surface_finders/grid/detail/grid_helpers.hpp
@@ -30,7 +30,7 @@ struct grid_data {
     grid_data() = default;
 
     /// Construct containers using a memory resources
-    DETRAY_HOST_DEVICE
+    DETRAY_HOST
     grid_data(vecmem::memory_resource &resource) : m_bin_data(&resource) {}
 
     /// Construct grid data from containers - move
diff --git a/core/include/detray/tools/detector_builder.hpp b/core/include/detray/tools/detector_builder.hpp
index 4cfe7afa8..57b033921 100644
--- a/core/include/detray/tools/detector_builder.hpp
+++ b/core/include/detray/tools/detector_builder.hpp
@@ -10,7 +10,6 @@
 // Project include(s).
 #include "detray/core/detector.hpp"
 #include "detray/core/detector_metadata.hpp"
-#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/geometry.hpp"
 #include "detray/tools/grid_factory.hpp"
 #include "detray/tools/volume_builder.hpp"
@@ -34,13 +33,11 @@ namespace detray {
 ///                          geometry data
 /// @tparam volume_data_t the data structure that holds the volume builders
 template <typename metadata = default_metadata,
-          typename bfield_bknd_t = bfield::const_bknd_t,
           template <typename> class volume_builder_t = volume_builder,
           template <typename...> class volume_data_t = std::vector>
 class detector_builder {
     public:
-    using detector_type =
-        detector<metadata, covfie::field<bfield_bknd_t>, host_container_types>;
+    using detector_type = detector<metadata, host_container_types>;
 
     /// Empty detector builder
     detector_builder() = default;
@@ -88,7 +85,6 @@ class detector_builder {
             vol_builder->build(det);
         }
 
-        det.set_bfield(std::move(m_bfield));
         det.set_volume_finder(std::move(m_vol_finder));
 
         // TODO: Add sorting, data deduplication etc. here later...
@@ -96,12 +92,6 @@ class detector_builder {
         return det;
     }
 
-    /// Assembles the detector, without a magnetic field
-    DETRAY_HOST
-    void set_bfield(typename detector_type::bfield_type&& field) {
-        m_bfield = std::forward<typename detector_type::bfield_type>(field);
-    }
-
     /// Put the volumes into a search data structure
     template <typename... Args>
     DETRAY_HOST void set_volume_finder(Args&&... /*args*/) {
@@ -133,8 +123,6 @@ class detector_builder {
         m_volumes{};
     /// Data structure to find volumes
     typename detector_type::volume_finder m_vol_finder{};
-    /// The detector bfield
-    typename detector_type::bfield_type m_bfield;
 };
 
 }  // namespace detray
diff --git a/io/CMakeLists.txt b/io/CMakeLists.txt
index dc894618e..b22a80892 100644
--- a/io/CMakeLists.txt
+++ b/io/CMakeLists.txt
@@ -16,7 +16,7 @@ file( GLOB _detray_io_public_headers
 detray_add_library( detray_io io
    ${_detray_io_public_headers} )
 target_link_libraries( detray_io INTERFACE
-   dfelibs::dfelibs nlohmann_json::nlohmann_json vecmem::core detray::core )
+   dfelibs::dfelibs nlohmann_json::nlohmann_json vecmem::core covfie::core detray::core )
 
 # Set up libraries using particular algebra plugins.
 detray_add_library( detray_io_array io_array )
diff --git a/io/include/detray/io/common/bfield_reader.hpp b/io/include/detray/io/common/bfield_reader.hpp
deleted file mode 100644
index 64831c365..000000000
--- a/io/include/detray/io/common/bfield_reader.hpp
+++ /dev/null
@@ -1,90 +0,0 @@
-/** Detray library, part of the ACTS project (R&D line)
- *
- * (c) 2023 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-#pragma once
-
-// Project include(s)
-#include "detray/io/common/detail/file_handle.hpp"
-#include "detray/io/common/io_interface.hpp"
-
-// Covfie include(s)
-#include <covfie/core/utility/binary_io.hpp>
-
-// System include(s)
-#include <ios>
-#include <string>
-
-namespace detray {
-
-/// @brief Function that reads the first 4 bytes of a potential bfield file and
-/// checks that it contains data for a covfie field
-inline bool check_covfie_file(const std::string& file_name) {
-
-    // Open binary file
-    io::detail::file_handle file{file_name,
-                                 std::ios_base::in | std::ios_base::binary};
-
-    // See "covfie/lib/core/utility/binary_io.hpp"
-    std::uint32_t hdr = covfie::utility::read_binary<std::uint32_t>(*file);
-
-    // Compare to magic bytes
-    return (hdr == covfie::utility::MAGIC_HEADER);
-}
-
-/// @brief Reader that constructs a covfie field from file input
-template <class detector_t>
-class covfie_file_reader : public reader_interface<detector_t> {
-
-    using base_type = reader_interface<detector_t>;
-
-    protected:
-    /// Tag the reader as magnetic field reader
-    inline static const std::string tag = "bfield";
-
-    public:
-    /// Same constructors for this class as for base_type
-    using base_type::base_type;
-
-    /// Covfie constructs the field directly from the input stream in
-    /// @param file
-    auto deserialize(io::detail::file_handle& file) const {
-        return typename detector_t::bfield_type(*file);
-    }
-};
-
-/// @brief Generic magnetic field reader
-template <class detector_t, template <class> class reader_t>
-class bfield_reader final : public reader_t<detector_t> {
-
-    using base_reader = reader_t<detector_t>;
-
-    public:
-    /// Default file ending for covfie input
-    bfield_reader() : base_reader{".cvf"} {}
-
-    /// Read from file with given extension @param ext
-    bfield_reader(const std::string& ext) : base_reader{ext} {}
-
-    /// Reads the geometry from file with the given name
-    virtual void read(
-        detector_builder<typename detector_t::metadata,
-                         typename detector_t::bfield_type::backend_t,
-                         volume_builder>& det_builder,
-        typename detector_t::name_map&, const std::string& file_name) override {
-
-        io::detail::file_handle file{file_name,
-                                     std::ios_base::binary | std::ios_base::in};
-
-        det_builder.set_bfield(base_reader::deserialize(file));
-    }
-};
-
-/// Read a covfie field from file and add it to a detray detector
-template <typename detector_t>
-using covfie_reader = bfield_reader<detector_t, covfie_file_reader>;
-
-}  // namespace detray
diff --git a/io/include/detray/io/common/detail/detector_components_io.hpp b/io/include/detray/io/common/detail/detector_components_io.hpp
index 4d7caa079..f33773ddc 100644
--- a/io/include/detray/io/common/detail/detector_components_io.hpp
+++ b/io/include/detray/io/common/detail/detector_components_io.hpp
@@ -107,11 +107,9 @@ class detector_component_readers final {
 
     /// Reads the full detector into @param det by calling the readers, while
     /// using the name map @param names for to write the volume names.
-    virtual void read(
-        detector_builder<typename detector_t::metadata,
-                         typename detector_t::bfield_type::backend_t,
-                         volume_builder>& det_builder,
-        typename detector_t::name_map& names) {
+    virtual void read(detector_builder<typename detector_t::metadata,
+                                       volume_builder>& det_builder,
+                      typename detector_t::name_map& names) {
 
         // We have to at least read a geometry
         assert(m_readers.size() != 0u &&
diff --git a/io/include/detray/io/common/detector_reader.hpp b/io/include/detray/io/common/detector_reader.hpp
index b5c8a5c07..56c4171fe 100644
--- a/io/include/detray/io/common/detector_reader.hpp
+++ b/io/include/detray/io/common/detector_reader.hpp
@@ -8,18 +8,12 @@
 #pragma once
 
 // Project include(s)
-#include "detray/io/common/bfield_reader.hpp"
 #include "detray/io/common/detail/detector_components_io.hpp"
 #include "detray/io/common/detail/type_traits.hpp"
 #include "detray/io/json/json_reader.hpp"
 #include "detray/tools/detector_builder.hpp"
 #include "detray/utils/consistency_checker.hpp"
 
-// Covfie include(s)
-#include <covfie/core/backend/primitive/constant.hpp>
-#include <covfie/core/field.hpp>
-#include <covfie/core/vector.hpp>
-
 // System include(s)
 #include <filesystem>
 #include <ios>
@@ -46,12 +40,6 @@ struct detector_reader_config {
     /// @{
     const std::vector<std::string>& files() const { return m_files; }
     bool do_check() const { return m_do_check; }
-    template <typename const_bfield_bknd_t>
-    auto bfield() const {
-        return covfie::field<const_bfield_bknd_t>(covfie::make_parameter_pack(
-            typename const_bfield_bknd_t::configuration_t{
-                m_bfield_vec[0], m_bfield_vec[1], m_bfield_vec[2]}));
-    }
     /// @}
 
     /// Setters
@@ -64,11 +52,6 @@ struct detector_reader_config {
         m_do_check = check;
         return *this;
     }
-    detector_reader_config& bfield_vec(const scalar x, const scalar y,
-                                       const scalar z) {
-        m_bfield_vec = {x, y, z};
-        return *this;
-    }
     /// @}
 };
 
@@ -125,15 +108,6 @@ auto assemble_reader(const io::detector_reader_config& cfg) noexcept(false) {
                                             header.tag +
                                             "' in input file: " + file_name);
             }
-
-            // This is the file type covfie uses
-        } else if (extension == ".cvf" and check_covfie_file(file_name)) {
-
-            if constexpr (not std::is_same_v<
-                              typename detector_t::bfield_type::backend_t,
-                              bfield::const_bknd_t>) {
-                readers.template add<covfie_reader>(file_name);
-            }
         } else {
             throw std::runtime_error("Unsupported file format '" + extension +
                                      "' for input file: " + file_name);
@@ -163,24 +137,16 @@ template <class detector_t, std::size_t CAP = 9u, std::size_t DIM = 2u,
 auto read_detector(vecmem::memory_resource& resc,
                    const detector_reader_config& cfg) noexcept(false) {
 
-    using bfield_bknd_t = typename detector_t::bfield_type::backend_t;
-
     // Map the volume names to their indices
     typename detector_t::name_map names{};
 
-    detector_builder<typename detector_t::metadata, bfield_bknd_t,
-                     volume_builder_t>
+    detector_builder<typename detector_t::metadata, volume_builder_t>
         det_builder;
 
     // Find all required readers
     auto [reader, det_name] =
         detray::detail::assemble_reader<detector_t, CAP, DIM>(cfg);
 
-    // Add a constant b-field (no bfield reader is added in this case)
-    if constexpr (std::is_same_v<bfield_bknd_t, bfield::const_bknd_t>) {
-        det_builder.set_bfield(cfg.template bfield<bfield_bknd_t>());
-    }
-
     // Read the data
     names.emplace(0u, std::move(det_name));
     reader.read(det_builder, names);
diff --git a/io/include/detray/io/common/geometry_reader.hpp b/io/include/detray/io/common/geometry_reader.hpp
index eed6f8924..c56a7cf67 100644
--- a/io/include/detray/io/common/geometry_reader.hpp
+++ b/io/include/detray/io/common/geometry_reader.hpp
@@ -64,12 +64,10 @@ class geometry_reader : public reader_interface<detector_t> {
     protected:
     /// Deserialize a detector @param det from its io payload @param det_data
     /// and add the volume names to @param name_map
-    static void deserialize(
-        detector_builder<typename detector_t::metadata,
-                         typename detector_t::bfield_type::backend_t,
-                         volume_builder>& det_builder,
-        typename detector_t::name_map& name_map,
-        const detector_payload& det_data) {
+    static void deserialize(detector_builder<typename detector_t::metadata,
+                                             volume_builder>& det_builder,
+                            typename detector_t::name_map& name_map,
+                            const detector_payload& det_data) {
 
         // Deserialize the volumes one-by-one
         for (const auto& vol_data : det_data.volumes) {
diff --git a/io/include/detray/io/common/grid_reader.hpp b/io/include/detray/io/common/grid_reader.hpp
index 5b819f9be..8de59bb61 100644
--- a/io/include/detray/io/common/grid_reader.hpp
+++ b/io/include/detray/io/common/grid_reader.hpp
@@ -62,9 +62,8 @@ class grid_reader : public reader_interface<detector_t> {
     /// Deserialize the detector grids @param grids_data from their IO
     /// payload
     static void deserialize(
-        detector_builder<typename detector_t::metadata,
-                         typename detector_t::bfield_type::backend_t,
-                         volume_builder> &det_builder,
+        detector_builder<typename detector_t::metadata, volume_builder>
+            &det_builder,
         typename detector_t::name_map &,
         const detector_grids_payload<content_t> &grids_data) {
 
@@ -95,7 +94,7 @@ class grid_reader : public reader_interface<detector_t> {
               typename binning_ts = types::type_list<>, typename... Ts>
     static void deserialize(std::queue<n_axis::bounds> &bound_ids,
                             std::queue<n_axis::binning> &binning_ids,
-                            Ts &&... data) {
+                            Ts &&...data) {
         using namespace n_axis;
 
         constexpr std::size_t n_bounds_types{types::size<bounds_ts>};
@@ -153,7 +152,7 @@ class grid_reader : public reader_interface<detector_t> {
     template <typename bounds_ts, typename binning_ts, typename... Ts,
               std::enable_if_t<types::size<bounds_ts> == Dim, bool> = true>
     static void deserialize(std::queue<n_axis::binning> &binning_ids,
-                            Ts &&... data) {
+                            Ts &&...data) {
 
         using namespace n_axis;
 
@@ -205,11 +204,9 @@ class grid_reader : public reader_interface<detector_t> {
               std::enable_if_t<types::size<bounds_ts> == Dim and
                                    types::size<binning_ts> == Dim,
                                bool> = true>
-    static void deserialize(
-        const grid_payload<content_t> &grid_data,
-        detector_builder<typename detector_t::metadata,
-                         typename detector_t::bfield_type::backend_t,
-                         volume_builder> &det_builder) {
+    static void deserialize(const grid_payload<content_t> &grid_data,
+                            detector_builder<typename detector_t::metadata,
+                                             volume_builder> &det_builder) {
 
         // Throw expection if the accelerator link type id is invalid
         auto print_error = [](io::detail::acc_type acc_link) -> void {
@@ -280,12 +277,11 @@ class grid_reader : public reader_interface<detector_t> {
               std::enable_if_t<sizeof...(bounds_ts) == Dim and
                                    sizeof...(binning_ts) == Dim,
                                bool> = true>
-    static void deserialize(
-        const grid_payload<content_t> &grid_data,
-        detector_builder<typename detector_t::metadata,
-                         typename detector_t::bfield_type::backend_t,
-                         volume_builder> &det_builder,
-        types::type_list<bounds_ts...>, types::type_list<binning_ts...>) {
+    static void deserialize(const grid_payload<content_t> &grid_data,
+                            detector_builder<typename detector_t::metadata,
+                                             volume_builder> &det_builder,
+                            types::type_list<bounds_ts...>,
+                            types::type_list<binning_ts...>) {
         // Assemble the grid type
         using populator_t = regular_attacher<bin_capacity>;
         using axes_t =
diff --git a/io/include/detray/io/common/homogeneous_material_reader.hpp b/io/include/detray/io/common/homogeneous_material_reader.hpp
index 24987896a..0133c8e2f 100644
--- a/io/include/detray/io/common/homogeneous_material_reader.hpp
+++ b/io/include/detray/io/common/homogeneous_material_reader.hpp
@@ -46,9 +46,8 @@ class homogeneous_material_reader : public reader_interface<detector_t> {
     /// Deserialize the detector material @param det_mat_data from its IO
     /// payload
     static void deserialize(
-        detector_builder<typename detector_t::metadata,
-                         typename detector_t::bfield_type::backend_t,
-                         volume_builder>& det_builder,
+        detector_builder<typename detector_t::metadata, volume_builder>&
+            det_builder,
         typename detector_t::name_map& /*name_map*/,
         const detector_homogeneous_material_payload& det_mat_data) {
         using mat_types = typename detector_t::material_container::value_types;
diff --git a/io/include/detray/io/common/io_interface.hpp b/io/include/detray/io/common/io_interface.hpp
index 318f6b028..218fb4da8 100644
--- a/io/include/detray/io/common/io_interface.hpp
+++ b/io/include/detray/io/common/io_interface.hpp
@@ -37,9 +37,7 @@ class reader_interface {
     /// does not keep the volume names, the name map is also passed and
     /// filled.
     virtual void read(
-        detector_builder<typename detector_t::metadata,
-                         typename detector_t::bfield_type::backend_t,
-                         volume_builder>&,
+        detector_builder<typename detector_t::metadata, volume_builder>&,
         typename detector_t::name_map&, const std::string&) = 0;
 
     protected:
diff --git a/io/include/detray/io/common/read_bfield.hpp b/io/include/detray/io/common/read_bfield.hpp
new file mode 100644
index 000000000..d8888b4c1
--- /dev/null
+++ b/io/include/detray/io/common/read_bfield.hpp
@@ -0,0 +1,54 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/io/common/detail/file_handle.hpp"
+
+// Covfie include(s)
+#include <covfie/core/utility/binary_io.hpp>
+
+// System include(s)
+#include <ios>
+#include <iostream>
+#include <stdexcept>
+#include <string>
+
+namespace detray::io {
+
+/// @brief Function that reads the first 4 bytes of a potential bfield file and
+/// checks that it contains data for a covfie field
+inline bool check_covfie_file(const std::string& file_name) {
+
+    // Open binary file
+    io::detail::file_handle file{file_name,
+                                 std::ios_base::in | std::ios_base::binary};
+
+    // See "covfie/lib/core/utility/binary_io.hpp"
+    std::uint32_t hdr = covfie::utility::read_binary<std::uint32_t>(*file);
+
+    // Compare to magic bytes
+    return (hdr == covfie::utility::MAGIC_HEADER);
+}
+
+/// @brief function that reads a covfie field from file
+template <typename bfield_t>
+inline bfield_t read_bfield(const std::string& file_name) {
+
+    if (not check_covfie_file(file_name)) {
+        throw std::runtime_error("Not a valid covfie file: " + file_name);
+    }
+
+    // Open binary file
+    io::detail::file_handle file{file_name,
+                                 std::ios_base::in | std::ios_base::binary};
+
+    return bfield_t(*file);
+}
+
+}  // namespace detray::io
diff --git a/io/include/detray/io/json/json_reader.hpp b/io/include/detray/io/json/json_reader.hpp
index c66912333..6c62a2b07 100644
--- a/io/include/detray/io/json/json_reader.hpp
+++ b/io/include/detray/io/json/json_reader.hpp
@@ -68,12 +68,10 @@ class json_reader final : public common_reader_t<detector_t, Args...> {
     json_reader() : base_reader(".json") {}
 
     /// Writes the geometry to file with a given name
-    virtual void read(
-        detector_builder<typename detector_t::metadata,
-                         typename detector_t::bfield_type::backend_t,
-                         volume_builder>& det_builder,
-        typename detector_t::name_map& name_map,
-        const std::string& file_name) override {
+    virtual void read(detector_builder<typename detector_t::metadata,
+                                       volume_builder>& det_builder,
+                      typename detector_t::name_map& name_map,
+                      const std::string& file_name) override {
 
         // Read json from file
         io::detail::file_handle file{file_name,
diff --git a/tests/benchmarks/cuda/benchmark_propagator_cuda.cpp b/tests/benchmarks/cuda/benchmark_propagator_cuda.cpp
index d962310cd..b1645c0c2 100644
--- a/tests/benchmarks/cuda/benchmark_propagator_cuda.cpp
+++ b/tests/benchmarks/cuda/benchmark_propagator_cuda.cpp
@@ -44,9 +44,10 @@ void fill_tracks(vecmem::vector<free_track_parameters<transform3>> &tracks,
 template <propagate_option opt>
 static void BM_PROPAGATOR_CPU(benchmark::State &state) {
 
-    // Create the toy geometry
-    auto [det, names] =
-        create_toy_geometry<field_type::backend_t>(host_mr, toy_cfg);
+    // Create the toy geometry and bfield
+    auto [det, names] = create_toy_geometry(host_mr, toy_cfg);
+    vector3 B{0.f, 0.f, 2.f * unit<scalar>::T};
+    auto bfield = bfield::create_const_field(B);
 
     // Create RK stepper
     rk_stepper_type s;
@@ -84,7 +85,7 @@ static void BM_PROPAGATOR_CPU(benchmark::State &state) {
                 tie(transporter_state, interactor_state, resetter_state);
 
             // Create the propagator state
-            propagator_host_type::state p_state(track, det.get_bfield(), det);
+            propagator_host_type::state p_state(track, bfield, det);
 
             // Run propagation
             if constexpr (opt == propagate_option::e_unsync) {
@@ -103,11 +104,12 @@ template <propagate_option opt>
 static void BM_PROPAGATOR_CUDA(benchmark::State &state) {
 
     // Create the toy geometry
-    auto [det, names] =
-        create_toy_geometry<field_type::backend_t>(bp_mng_mr, toy_cfg);
+    auto [det, names] = create_toy_geometry(bp_mng_mr, toy_cfg);
+    vector3 B{0.f, 0.f, 2.f * unit<scalar>::T};
+    auto bfield = bfield::create_const_field(B);
 
     // Get detector data
-    auto det_data = detray::get_data<field_type::backend_t>(det);
+    auto det_data = detray::get_data(det);
 
     // vecmem copy helper object
     vecmem::cuda::copy copy;
@@ -136,7 +138,8 @@ static void BM_PROPAGATOR_CUDA(benchmark::State &state) {
         copy.setup(candidates_buffer);
 
         // Run the propagator test for GPU device
-        propagator_benchmark(det_data, tracks_data, candidates_buffer, opt);
+        propagator_benchmark(det_data, bfield, tracks_data, candidates_buffer,
+                             opt);
     }
 
     state.counters["TracksPropagated"] = benchmark::Counter(
diff --git a/tests/benchmarks/cuda/benchmark_propagator_cuda_kernel.cu b/tests/benchmarks/cuda/benchmark_propagator_cuda_kernel.cu
index c852ba9a5..f512b625d 100644
--- a/tests/benchmarks/cuda/benchmark_propagator_cuda_kernel.cu
+++ b/tests/benchmarks/cuda/benchmark_propagator_cuda_kernel.cu
@@ -11,8 +11,8 @@
 namespace detray {
 
 __global__ void __launch_bounds__(256, 4) propagator_benchmark_kernel(
-    typename detector_host_type::detector_view_type<bfield::const_bknd_t>
-        det_data,
+    typename detector_host_type::view_type det_data,
+    covfie::field_view<bfield::const_bknd_t> field_data,
     vecmem::data::vector_view<free_track_parameters<transform3>> tracks_data,
     vecmem::data::jagged_vector_view<intersection_t> candidates_data,
     const propagate_option opt) {
@@ -45,7 +45,7 @@ __global__ void __launch_bounds__(256, 4) propagator_benchmark_kernel(
     auto actor_states =
         tie(transporter_state, interactor_state, resetter_state);
     // Create the propagator state
-    propagator_device_type::state p_state(tracks.at(gid), det.get_bfield(), det,
+    propagator_device_type::state p_state(tracks.at(gid), field_data, det,
                                           candidates.at(gid));
 
     // Run propagation
@@ -57,8 +57,8 @@ __global__ void __launch_bounds__(256, 4) propagator_benchmark_kernel(
 }
 
 void propagator_benchmark(
-    typename detector_host_type::detector_view_type<bfield::const_bknd_t>
-        det_data,
+    typename detector_host_type::view_type det_data,
+    covfie::field_view<bfield::const_bknd_t> field_data,
     vecmem::data::vector_view<free_track_parameters<transform3>>& tracks_data,
     vecmem::data::jagged_vector_view<intersection_t>& candidates_data,
     const propagate_option opt) {
@@ -69,7 +69,7 @@ void propagator_benchmark(
 
     // run the test kernel
     propagator_benchmark_kernel<<<block_dim, thread_dim>>>(
-        det_data, tracks_data, candidates_data, opt);
+        det_data, field_data, tracks_data, candidates_data, opt);
 
     // cuda error check
     DETRAY_CUDA_ERROR_CHECK(cudaGetLastError());
diff --git a/tests/benchmarks/cuda/benchmark_propagator_cuda_kernel.hpp b/tests/benchmarks/cuda/benchmark_propagator_cuda_kernel.hpp
index 7d631ef4d..ea332e933 100644
--- a/tests/benchmarks/cuda/benchmark_propagator_cuda_kernel.hpp
+++ b/tests/benchmarks/cuda/benchmark_propagator_cuda_kernel.hpp
@@ -9,8 +9,8 @@
 
 // Project include(s)
 #include "detray/definitions/algebra.hpp"
-#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/units.hpp"
+#include "detray/detectors/bfield.hpp"
 #include "detray/detectors/create_toy_geometry.hpp"
 #include "detray/propagator/actor_chain.hpp"
 #include "detray/propagator/actors/aborters.hpp"
@@ -27,19 +27,15 @@ using namespace detray;
 
 using transform3 = __plugin::transform3<scalar>;
 
-using detector_host_type =
-    detector<toy_metadata, covfie::field<bfield::const_bknd_t>,
-             host_container_types>;
-using detector_device_type =
-    detector<toy_metadata, covfie::field_view<bfield::const_bknd_t>,
-             device_container_types>;
+using detector_host_type = detector<toy_metadata, host_container_types>;
+using detector_device_type = detector<toy_metadata, device_container_types>;
 
 using intersection_t =
     intersection2D<typename detector_device_type::surface_type, transform3>;
 
 using navigator_host_type = navigator<detector_host_type>;
 using navigator_device_type = navigator<detector_device_type>;
-using field_type = detector_host_type::bfield_type;
+using field_type = bfield::const_field_t;
 using rk_stepper_type = rk_stepper<field_type::view_t, transform3>;
 using actor_chain_t = actor_chain<tuple, parameter_transporter<transform3>,
                                   pointwise_material_interactor<transform3>,
@@ -58,8 +54,8 @@ namespace detray {
 
 /// test function for propagator with single state
 void propagator_benchmark(
-    typename detector_host_type::detector_view_type<bfield::const_bknd_t>
-        det_data,
+    typename detector_host_type::view_type det_data,
+    typename field_type::view_t field_data,
     vecmem::data::vector_view<free_track_parameters<transform3>>& tracks_data,
     vecmem::data::jagged_vector_view<intersection_t>& candidates_data,
     const propagate_option opt);
diff --git a/tests/common/include/tests/common/test_base/propagator_test.hpp b/tests/common/include/tests/common/test_base/propagator_test.hpp
index ec7096a53..5ba29e966 100644
--- a/tests/common/include/tests/common/test_base/propagator_test.hpp
+++ b/tests/common/include/tests/common/test_base/propagator_test.hpp
@@ -9,8 +9,8 @@
 
 // Project include(s).
 #include "detray/definitions/algebra.hpp"
-#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/units.hpp"
+#include "detray/detectors/bfield.hpp"
 #include "detray/detectors/create_toy_geometry.hpp"
 #include "detray/propagator/actor_chain.hpp"
 #include "detray/propagator/actors/aborters.hpp"
@@ -36,18 +36,13 @@
 namespace detray {
 
 // Host detector type
-template <typename bfield_bknd_t>
-using detector_host_t =
-    detector<toy_metadata, covfie::field<bfield_bknd_t>, host_container_types>;
+using detector_host_t = detector<toy_metadata, host_container_types>;
 
 // Device detector type using views
-template <typename bfield_bknd_t>
-using detector_device_t =
-    detector<toy_metadata, covfie::field_view<bfield_bknd_t>,
-             device_container_types>;
+using detector_device_t = detector<toy_metadata, device_container_types>;
 
 // These types are identical in host and device code for all bfield types
-using transform3 = typename detector_host_t<bfield::const_bknd_t>::transform3;
+using transform3 = typename detector_host_t::transform3;
 using vector3_t = typename transform3::vector3;
 using matrix_operator = standard_matrix_operator<scalar>;
 using track_t = free_track_parameters<transform3>;
@@ -156,16 +151,16 @@ inline vecmem::vector<track_t> generate_tracks(
 /// Test function for propagator on the host
 template <typename bfield_bknd_t>
 inline auto run_propagation_host(vecmem::memory_resource *mr,
-                                 const detector_host_t<bfield_bknd_t> &det,
+                                 const detector_host_t &det,
+                                 covfie::field<bfield_bknd_t> &field,
                                  const vecmem::vector<track_t> &tracks)
     -> std::tuple<vecmem::jagged_vector<scalar>,
                   vecmem::jagged_vector<vector3_t>,
                   vecmem::jagged_vector<free_matrix>> {
 
     // Construct propagator from stepper and navigator
-    auto stepr = rk_stepper_t<
-        typename detector_host_t<bfield_bknd_t>::bfield_type::view_t>{};
-    auto nav = navigator_t<detector_host_t<bfield_bknd_t>>{};
+    auto stepr = rk_stepper_t<typename covfie::field<bfield_bknd_t>::view_t>{};
+    auto nav = navigator_t<detector_host_t>{};
 
     using propagator_host_t =
         propagator<decltype(stepr), decltype(nav), actor_chain_host_t>;
@@ -188,7 +183,7 @@ inline auto run_propagation_host(vecmem::memory_resource *mr,
             detray::tie(insp_state, pathlimit_state, transporter_state,
                         interactor_state, resetter_state);
 
-        typename propagator_host_t::state state(trk, det.get_bfield(), det);
+        typename propagator_host_t::state state(trk, field, det);
 
         state._stepping.template set_constraint<step::constraint::e_accuracy>(
             constrainted_step_size);
diff --git a/tests/unit_tests/cpu/grid_grid_builder.cpp b/tests/unit_tests/cpu/grid_grid_builder.cpp
index abda75aed..db985e79d 100644
--- a/tests/unit_tests/cpu/grid_grid_builder.cpp
+++ b/tests/unit_tests/cpu/grid_grid_builder.cpp
@@ -9,7 +9,6 @@
 
 // Detray include(s)
 #include "detray/core/detector.hpp"
-#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/indexing.hpp"
 #include "detray/detectors/toy_metadata.hpp"
 #include "detray/intersection/cylinder_portal_intersector.hpp"
diff --git a/tests/unit_tests/cpu/line_stepper.cpp b/tests/unit_tests/cpu/line_stepper.cpp
index 7bdeff45e..48ccf7c2f 100644
--- a/tests/unit_tests/cpu/line_stepper.cpp
+++ b/tests/unit_tests/cpu/line_stepper.cpp
@@ -8,7 +8,6 @@
 // Project include(s).
 #include "detray/propagator/line_stepper.hpp"
 
-#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/units.hpp"
 #include "detray/detectors/create_telescope_detector.hpp"
 #include "detray/masks/masks.hpp"
diff --git a/tests/unit_tests/cpu/tools_guided_navigator.cpp b/tests/unit_tests/cpu/tools_guided_navigator.cpp
index 88ab9e685..e4eaba151 100644
--- a/tests/unit_tests/cpu/tools_guided_navigator.cpp
+++ b/tests/unit_tests/cpu/tools_guided_navigator.cpp
@@ -5,11 +5,8 @@
  * Mozilla Public License Version 2.0
  */
 
-#include <gtest/gtest.h>
-
-#include <vecmem/memory/host_memory_resource.hpp>
-
 #include "detray/definitions/units.hpp"
+#include "detray/detectors/bfield.hpp"
 #include "detray/detectors/create_telescope_detector.hpp"
 #include "detray/masks/masks.hpp"
 #include "detray/masks/unbounded.hpp"
@@ -23,6 +20,12 @@
 #include "detray/tracks/tracks.hpp"
 #include "detray/utils/inspectors.hpp"
 
+// vecmem include(s)
+#include <vecmem/memory/host_memory_resource.hpp>
+
+// GTest include(s)
+#include <gtest/gtest.h>
+
 // This tests the construction and general methods of the navigator
 GTEST_TEST(detray_propagator, guided_navigator) {
     using namespace detray;
@@ -53,7 +56,7 @@ GTEST_TEST(detray_propagator, guided_navigator) {
         object_tracer<intersection_t, dvector, status::e_on_portal,
                       status::e_on_module>;
     using inspector_t = aggregate_inspector<object_tracer_t, print_inspector>;
-    using b_field_t = detector_t::bfield_type;
+    using b_field_t = bfield::const_field_t;
     using runge_kutta_stepper =
         rk_stepper<b_field_t::view_t, transform3_t, unconstrained_step,
                    guided_navigation>;
@@ -67,8 +70,7 @@ GTEST_TEST(detray_propagator, guided_navigator) {
     const vector3 mom{0.f, 0.f, 1.f};
     free_track_parameters<transform3_t> track(pos, 0.f, mom, -1.f);
     const vector3 B{0.f, 0.f, 1.f * unit<scalar>::T};
-    const b_field_t b_field(covfie::make_parameter_pack(
-        b_field_t::backend_t::configuration_t{B[0], B[1], B[2]}));
+    const b_field_t b_field = bfield::create_const_field(B);
 
     // Actors
     pathlimit_aborter::state pathlimit{200.f * unit<scalar>::cm};
diff --git a/tests/unit_tests/cpu/tools_particle_gun.cpp b/tests/unit_tests/cpu/tools_particle_gun.cpp
index b8c30be22..c6a6e3ceb 100644
--- a/tests/unit_tests/cpu/tools_particle_gun.cpp
+++ b/tests/unit_tests/cpu/tools_particle_gun.cpp
@@ -37,7 +37,6 @@ GTEST_TEST(detray_tools, particle_gun) {
     // Build the geometry
     vecmem::host_memory_resource host_mr;
     toy_det_config toy_cfg{};
-    toy_cfg.bfield_vec(B);
 
     auto [toy_det, names] = create_toy_geometry(host_mr, toy_cfg);
 
diff --git a/tests/unit_tests/cpu/tools_propagator.cpp b/tests/unit_tests/cpu/tools_propagator.cpp
index 3b0589007..5b6d35a8d 100644
--- a/tests/unit_tests/cpu/tools_propagator.cpp
+++ b/tests/unit_tests/cpu/tools_propagator.cpp
@@ -6,8 +6,8 @@
  */
 
 // Project include(s)
-#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/units.hpp"
+#include "detray/detectors/bfield.hpp"
 #include "detray/detectors/create_toy_geometry.hpp"
 #include "detray/geometry/surface.hpp"
 #include "detray/intersection/detail/trajectories.hpp"
@@ -170,10 +170,10 @@ class PropagatorWithRkStepper
 TEST_P(PropagatorWithRkStepper, rk4_propagator_const_bfield) {
 
     // Constant magnetic field type
-    using bfield_t = covfie::field<bfield::const_bknd_t>;
+    using bfield_t = bfield::const_field_t;
 
     // Toy detector
-    using detector_t = detector<toy_metadata, bfield_t>;
+    using detector_t = detector<toy_metadata>;
 
     // Runge-Kutta propagation
     using navigator_t = navigator<detector_t /*, navigation::print_inspector*/>;
@@ -191,9 +191,10 @@ TEST_P(PropagatorWithRkStepper, rk4_propagator_const_bfield) {
     using propagator_t = propagator<stepper_t, navigator_t, actor_chain_t>;
 
     // Build detector and magnetic field
-    toy_cfg.bfield_vec(std::get<2>(GetParam()));
     const auto [det, names] = create_toy_geometry(host_mr, toy_cfg);
 
+    const bfield_t bfield = bfield::create_const_field(std::get<2>(GetParam()));
+
     // Propagator is built from the stepper and navigator
     propagator_t p(stepper_t{}, navigator_t{});
 
@@ -228,8 +229,8 @@ TEST_P(PropagatorWithRkStepper, rk4_propagator_const_bfield) {
             transporter_state, interactor_state, resetter_state);
 
         // Init propagator states
-        propagator_t::state state(track, det.get_bfield(), det);
-        propagator_t::state lim_state(lim_track, det.get_bfield(), det);
+        propagator_t::state state(track, bfield, det);
+        propagator_t::state lim_state(lim_track, bfield, det);
 
         // Set step constraints
         state._stepping.template set_constraint<step::constraint::e_accuracy>(
@@ -270,10 +271,10 @@ TEST_P(PropagatorWithRkStepper, rk4_propagator_const_bfield) {
 TEST_P(PropagatorWithRkStepper, rk4_propagator_inhom_bfield) {
 
     // Magnetic field map using nearest neightbor interpolation
-    using bfield_t = covfie::field<bfield::inhom_bknd_t>;
+    using bfield_t = bfield::inhom_field_t;
 
     // Toy detector
-    using detector_t = detector<toy_metadata, bfield_t>;
+    using detector_t = detector<toy_metadata>;
 
     // Runge-Kutta propagation
     using navigator_t = navigator<detector_t /*, navigation::print_inspector*/>;
@@ -291,8 +292,9 @@ TEST_P(PropagatorWithRkStepper, rk4_propagator_inhom_bfield) {
     using propagator_t = propagator<stepper_t, navigator_t, actor_chain_t>;
 
     // Build detector and magnetic field
-    const auto [det, names] =
-        create_toy_geometry<bfield::inhom_bknd_t>(host_mr, toy_cfg);
+    const auto [det, names] = create_toy_geometry(host_mr, toy_cfg);
+    const bfield_t bfield = bfield::create_inhom_field();
+
     // Propagator is built from the stepper and navigator
     propagator_t p(stepper_t{}, navigator_t{});
 
@@ -323,8 +325,8 @@ TEST_P(PropagatorWithRkStepper, rk4_propagator_inhom_bfield) {
                      transporter_state, interactor_state, resetter_state);
 
         // Init propagator states
-        propagator_t::state state(track, det.get_bfield(), det);
-        propagator_t::state lim_state(lim_track, det.get_bfield(), det);
+        propagator_t::state state(track, bfield, det);
+        propagator_t::state lim_state(lim_track, bfield, det);
 
         // Set step constraints
         state._stepping.template set_constraint<step::constraint::e_accuracy>(
diff --git a/tests/unit_tests/cpu/tools_stepper.cpp b/tests/unit_tests/cpu/tools_stepper.cpp
index b05221c60..8cd6814cf 100644
--- a/tests/unit_tests/cpu/tools_stepper.cpp
+++ b/tests/unit_tests/cpu/tools_stepper.cpp
@@ -6,8 +6,8 @@
  */
 
 // detray include(s)
-#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/units.hpp"
+#include "detray/detectors/bfield.hpp"
 #include "detray/geometry/surface.hpp"
 #include "detray/intersection/detail/trajectories.hpp"
 #include "detray/io/common/detail/file_handle.hpp"
@@ -38,18 +38,6 @@ namespace {
 
 constexpr scalar tol{1e-3f};
 
-template <typename bfield_t>
-inline bfield_t load_field() {
-    detray::io::detail::file_handle file(
-        !std::getenv("DETRAY_BFIELD_FILE") ? ""
-                                           : std::getenv("DETRAY_BFIELD_FILE"),
-        std::ios_base::binary | std::ios_base::in);
-
-    bfield_t field(*file);
-
-    return field;
-}
-
 // dummy navigation struct
 struct nav_state {
     scalar operator()() const { return _step_size; }
@@ -150,12 +138,11 @@ GTEST_TEST(detray_propagator, rk_stepper) {
     using namespace step;
 
     // Constant magnetic field
-    using bfield_t = covfie::field<bfield::const_bknd_t>;
+    using bfield_t = bfield::const_field_t;
 
     vector3 B{1.f * unit<scalar>::T, 1.f * unit<scalar>::T,
               1.f * unit<scalar>::T};
-    bfield_t hom_bfield(covfie::make_parameter_pack(
-        typename bfield_t::backend_t::configuration_t{B[0], B[1], B[2]}));
+    const bfield_t hom_bfield = bfield::create_const_field(B);
 
     // RK stepper
     rk_stepper_t<bfield_t> rk_stepper;
@@ -256,10 +243,9 @@ GTEST_TEST(detray_propagator, rk_stepper) {
 TEST(detray_propagator, rk_stepper_inhomogeneous_bfield) {
     using namespace step;
 
-    using bfield_t = covfie::field<bfield::inhom_bknd_t>;
-
     // Read the magnetic field map
-    bfield_t inhom_bfield(load_field<bfield_t>());
+    using bfield_t = bfield::inhom_field_t;
+    bfield_t inhom_bfield = bfield::create_inhom_field();
 
     // RK stepper
     rk_stepper_t<bfield_t> rk_stepper;
diff --git a/tests/unit_tests/device/cuda/detector_cuda.cpp b/tests/unit_tests/device/cuda/detector_cuda.cpp
index 98ee47cb4..39d9abe9f 100644
--- a/tests/unit_tests/device/cuda/detector_cuda.cpp
+++ b/tests/unit_tests/device/cuda/detector_cuda.cpp
@@ -53,7 +53,7 @@ TEST(detector_cuda, detector) {
     vecmem::vector<cylinder_t> cylinders_device(cylinders_host.size(), &mng_mr);
 
     // get data object for toy detector
-    auto toy_det_data = detray::get_data<bfield::const_bknd_t>(toy_det);
+    auto toy_det_data = detray::get_data(toy_det);
 
     // get data object for device outputs
     auto volumes_data = vecmem::get_data(volumes_device);
diff --git a/tests/unit_tests/device/cuda/detector_cuda_kernel.cu b/tests/unit_tests/device/cuda/detector_cuda_kernel.cu
index 14e993071..cc939b938 100644
--- a/tests/unit_tests/device/cuda/detector_cuda_kernel.cu
+++ b/tests/unit_tests/device/cuda/detector_cuda_kernel.cu
@@ -12,7 +12,7 @@ namespace detray {
 
 // cuda kernel to copy sub-detector objects
 __global__ void detector_test_kernel(
-    typename detector_host_t::detector_view_type<bfield::const_bknd_t> det_data,
+    typename detector_host_t::view_type det_data,
     vecmem::data::vector_view<volume_t> volumes_data,
     vecmem::data::vector_view<surface_t> surfaces_data,
     vecmem::data::vector_view<transform3_t> transforms_data,
@@ -84,14 +84,13 @@ __global__ void detector_test_kernel(
 }
 
 /// implementation of the test function for detector
-void detector_test(
-    typename detector_host_t::detector_view_type<bfield::const_bknd_t> det_data,
-    vecmem::data::vector_view<volume_t> volumes_data,
-    vecmem::data::vector_view<surface_t> surfaces_data,
-    vecmem::data::vector_view<transform3_t> transforms_data,
-    vecmem::data::vector_view<rectangle_t> rectangles_data,
-    vecmem::data::vector_view<disc_t> discs_data,
-    vecmem::data::vector_view<cylinder_t> cylinders_data) {
+void detector_test(typename detector_host_t::view_type det_data,
+                   vecmem::data::vector_view<volume_t> volumes_data,
+                   vecmem::data::vector_view<surface_t> surfaces_data,
+                   vecmem::data::vector_view<transform3_t> transforms_data,
+                   vecmem::data::vector_view<rectangle_t> rectangles_data,
+                   vecmem::data::vector_view<disc_t> discs_data,
+                   vecmem::data::vector_view<cylinder_t> cylinders_data) {
 
     constexpr int block_dim = 1u;
     constexpr int thread_dim = 1u;
diff --git a/tests/unit_tests/device/cuda/detector_cuda_kernel.hpp b/tests/unit_tests/device/cuda/detector_cuda_kernel.hpp
index 503d4b1f9..9067e1b3f 100644
--- a/tests/unit_tests/device/cuda/detector_cuda_kernel.hpp
+++ b/tests/unit_tests/device/cuda/detector_cuda_kernel.hpp
@@ -10,7 +10,6 @@
 // Projetc include(s)
 #include "detray/core/detector.hpp"
 #include "detray/definitions/algebra.hpp"
-#include "detray/definitions/bfield_backends.hpp"
 #include "detray/detectors/toy_metadata.hpp"
 #include "detray/utils/ranges.hpp"
 
@@ -20,12 +19,8 @@ using namespace __plugin;
 namespace detray {
 
 // some useful type declarations
-using detector_host_t =
-    detector<toy_metadata, covfie::field<bfield::const_bknd_t>,
-             host_container_types>;
-using detector_device_t =
-    detector<toy_metadata, covfie::field_view<bfield::const_bknd_t>,
-             device_container_types>;
+using detector_host_t = detector<toy_metadata, host_container_types>;
+using detector_device_t = detector<toy_metadata, device_container_types>;
 
 using volume_t = typename detector_host_t::volume_type;
 using surface_t = typename detector_host_t::surface_type;
@@ -41,13 +36,12 @@ using disc_t = typename mask_defs::template get_type<disc_id>::type;
 using cylinder_t = typename mask_defs::template get_type<cylinder_id>::type;
 
 /// declaration of a test function for detector
-void detector_test(
-    typename detector_host_t::detector_view_type<bfield::const_bknd_t> det_data,
-    vecmem::data::vector_view<volume_t> volumes_data,
-    vecmem::data::vector_view<surface_t> surfaces_data,
-    vecmem::data::vector_view<transform3_t> transforms_data,
-    vecmem::data::vector_view<rectangle_t> rectangles_data,
-    vecmem::data::vector_view<disc_t> discs_data,
-    vecmem::data::vector_view<cylinder_t> cylinders_data);
+void detector_test(typename detector_host_t::view_type det_data,
+                   vecmem::data::vector_view<volume_t> volumes_data,
+                   vecmem::data::vector_view<surface_t> surfaces_data,
+                   vecmem::data::vector_view<transform3_t> transforms_data,
+                   vecmem::data::vector_view<rectangle_t> rectangles_data,
+                   vecmem::data::vector_view<disc_t> discs_data,
+                   vecmem::data::vector_view<cylinder_t> cylinders_data);
 
 }  // namespace detray
diff --git a/tests/unit_tests/device/cuda/navigator_cuda.cpp b/tests/unit_tests/device/cuda/navigator_cuda.cpp
index a622042b3..a9935b394 100644
--- a/tests/unit_tests/device/cuda/navigator_cuda.cpp
+++ b/tests/unit_tests/device/cuda/navigator_cuda.cpp
@@ -103,7 +103,7 @@ TEST(navigator_cuda, navigator) {
     copy.setup(position_records_buffer);
 
     // Get detector data
-    auto det_data = detray::get_data<bfield::const_bknd_t>(det);
+    auto det_data = detray::get_data(det);
 
     // Get tracks data
     auto tracks_data = vecmem::get_data(tracks_device);
diff --git a/tests/unit_tests/device/cuda/navigator_cuda_kernel.cu b/tests/unit_tests/device/cuda/navigator_cuda_kernel.cu
index d21255785..2cf6ccd90 100644
--- a/tests/unit_tests/device/cuda/navigator_cuda_kernel.cu
+++ b/tests/unit_tests/device/cuda/navigator_cuda_kernel.cu
@@ -11,7 +11,7 @@
 namespace detray {
 
 __global__ void navigator_test_kernel(
-    typename detector_host_t::detector_view_type<bfield::const_bknd_t> det_data,
+    typename detector_host_t::view_type det_data,
     vecmem::data::vector_view<free_track_parameters<transform3>> tracks_data,
     vecmem::data::jagged_vector_view<intersection_t> candidates_data,
     vecmem::data::jagged_vector_view<dindex> volume_records_data,
@@ -63,7 +63,7 @@ __global__ void navigator_test_kernel(
 }
 
 void navigator_test(
-    typename detector_host_t::detector_view_type<bfield::const_bknd_t> det_data,
+    typename detector_host_t::view_type det_data,
     vecmem::data::vector_view<free_track_parameters<transform3>>& tracks_data,
     vecmem::data::jagged_vector_view<intersection_t>& candidates_data,
     vecmem::data::jagged_vector_view<dindex>& volume_records_data,
diff --git a/tests/unit_tests/device/cuda/navigator_cuda_kernel.hpp b/tests/unit_tests/device/cuda/navigator_cuda_kernel.hpp
index 2adeb8e9e..3602b124f 100644
--- a/tests/unit_tests/device/cuda/navigator_cuda_kernel.hpp
+++ b/tests/unit_tests/device/cuda/navigator_cuda_kernel.hpp
@@ -9,7 +9,6 @@
 
 // Project include(s)
 #include "detray/definitions/algebra.hpp"
-#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/units.hpp"
 #include "detray/detectors/create_toy_geometry.hpp"
 #include "detray/propagator/line_stepper.hpp"
@@ -21,12 +20,8 @@ using namespace detray;
 using transform3 = __plugin::transform3<scalar>;
 
 // some useful type declarations
-using detector_host_t =
-    detector<toy_metadata, covfie::field<bfield::const_bknd_t>,
-             host_container_types>;
-using detector_device_t =
-    detector<toy_metadata, covfie::field_view<bfield::const_bknd_t>,
-             device_container_types>;
+using detector_host_t = detector<toy_metadata, host_container_types>;
+using detector_device_t = detector<toy_metadata, device_container_types>;
 
 using intersection_t =
     intersection2D<typename detector_device_t::surface_type, transform3>;
@@ -60,7 +55,7 @@ namespace detray {
 
 /// test function for navigator with single state
 void navigator_test(
-    typename detector_host_t::detector_view_type<bfield::const_bknd_t> det_data,
+    typename detector_host_t::view_type det_data,
     vecmem::data::vector_view<free_track_parameters<transform3>>& tracks_data,
     vecmem::data::jagged_vector_view<intersection_t>& candidates_data,
     vecmem::data::jagged_vector_view<dindex>& volume_records_data,
diff --git a/tests/unit_tests/device/cuda/propagator_cuda.cpp b/tests/unit_tests/device/cuda/propagator_cuda.cpp
index e3337df8f..30af1ecee 100644
--- a/tests/unit_tests/device/cuda/propagator_cuda.cpp
+++ b/tests/unit_tests/device/cuda/propagator_cuda.cpp
@@ -6,6 +6,7 @@
  */
 
 // Project include(s)
+#include "detray/detectors/bfield.hpp"
 #include "propagator_cuda_kernel.hpp"
 
 // Vecmem include(s)
@@ -26,15 +27,15 @@ TEST_P(CudaPropConstBFieldMng, propagator) {
     // VecMem memory resource(s)
     vecmem::cuda::managed_memory_resource mng_mr;
 
-    // Set the magnetic field
+    // Get the magnetic field
     const vector3_t B = GetParam();
+    auto field = bfield::create_const_field(B);
 
     // Create the toy geometry
-    toy_cfg.bfield_vec(B);
     auto [det, names] = create_toy_geometry(mng_mr, toy_cfg);
 
     run_propagation_test<bfield::const_bknd_t>(
-        &mng_mr, det, detray::get_data<bfield::const_bknd_t>(det));
+        &mng_mr, det, detray::get_data(det), std::move(field));
 }
 
 class CudaPropConstBFieldCpy : public ::testing::TestWithParam<vector3_t> {};
@@ -48,18 +49,17 @@ TEST_P(CudaPropConstBFieldCpy, propagator) {
 
     vecmem::cuda::copy cuda_cpy;
 
-    // Set the magnetic field
+    // Get the magnetic field
     const vector3_t B = GetParam();
+    auto field = bfield::create_const_field(B);
 
     // Create the toy geometry
-    toy_cfg.bfield_vec(B);
     auto [det, names] = create_toy_geometry(host_mr, toy_cfg);
 
-    auto det_buff =
-        detray::get_buffer<bfield::const_bknd_t>(det, dev_mr, cuda_cpy);
+    auto det_buff = detray::get_buffer(det, dev_mr, cuda_cpy);
 
-    run_propagation_test<bfield::const_bknd_t>(&mng_mr, det,
-                                               detray::get_data(det_buff));
+    run_propagation_test<bfield::const_bknd_t>(
+        &mng_mr, det, detray::get_data(det_buff), std::move(field));
 }
 
 INSTANTIATE_TEST_SUITE_P(CudaPropagatorValidation1, CudaPropConstBFieldMng,
@@ -112,13 +112,14 @@ TEST(CudaPropagatorValidation10, inhomogeneous_bfield_cpy) {
 
     vecmem::cuda::copy cuda_cpy;
 
+    // Get the magnetic field
+    auto field = bfield::create_inhom_field();
+
     // Create the toy geometry with inhomogeneous bfield from file
-    auto [det, names] =
-        create_toy_geometry<bfield::inhom_bknd_t>(host_mr, toy_cfg);
+    auto [det, names] = create_toy_geometry(host_mr, toy_cfg);
 
-    auto det_buff =
-        detray::get_buffer<bfield::cuda::inhom_bknd_t>(det, dev_mr, cuda_cpy);
+    auto det_buff = detray::get_buffer(det, dev_mr, cuda_cpy);
 
     run_propagation_test<bfield::cuda::inhom_bknd_t>(
-        &mng_mr, det, detray::get_data(det_buff));
+        &mng_mr, det, detray::get_data(det_buff), std::move(field));
 }
diff --git a/tests/unit_tests/device/cuda/propagator_cuda_kernel.cu b/tests/unit_tests/device/cuda/propagator_cuda_kernel.cu
index a8bd87997..e44f29d0d 100644
--- a/tests/unit_tests/device/cuda/propagator_cuda_kernel.cu
+++ b/tests/unit_tests/device/cuda/propagator_cuda_kernel.cu
@@ -12,7 +12,8 @@ namespace detray {
 
 template <typename bfield_bknd_t, typename detector_t>
 __global__ void propagator_test_kernel(
-    typename detector_t::template detector_view_type<bfield_bknd_t> det_data,
+    typename detector_t::view_type det_data,
+    covfie::field_view<bfield_bknd_t> field_data,
     vecmem::data::vector_view<track_t> tracks_data,
     vecmem::data::jagged_vector_view<intersection_t<detector_t>>
         candidates_data,
@@ -22,7 +23,7 @@ __global__ void propagator_test_kernel(
 
     int gid = threadIdx.x + blockIdx.x * blockDim.x;
 
-    detector_device_t<bfield_bknd_t> det(det_data);
+    detector_device_t det(det_data);
     vecmem::device_vector<track_t> tracks(tracks_data);
     vecmem::jagged_device_vector<intersection_t<detector_t>> candidates(
         candidates_data);
@@ -35,9 +36,8 @@ __global__ void propagator_test_kernel(
         return;
     }
 
-    auto stepr =
-        rk_stepper_t<typename detector_device_t<bfield_bknd_t>::bfield_type>{};
-    auto nav = navigator_t<detector_device_t<bfield_bknd_t>>{};
+    auto stepr = rk_stepper_t<covfie::field_view<bfield_bknd_t>>{};
+    auto nav = navigator_t<detector_device_t>{};
 
     // Create propagator
     using propagator_device_t =
@@ -57,8 +57,8 @@ __global__ void propagator_test_kernel(
         ::detray::tie(insp_state, aborter_state, transporter_state,
                       interactor_state, resetter_state);
     // Create the propagator state
-    typename propagator_device_t::state state(tracks[gid], det.get_bfield(),
-                                              det, candidates.at(gid));
+    typename propagator_device_t::state state(tracks[gid], field_data, det,
+                                              candidates.at(gid));
 
     state._stepping.set_tolerance(rk_tolerance);
 
@@ -72,7 +72,8 @@ __global__ void propagator_test_kernel(
 /// Launch the device kernel
 template <typename bfield_bknd_t, typename detector_t>
 void propagator_test(
-    typename detector_t::template detector_view_type<bfield_bknd_t> det_view,
+    typename detector_t::view_type det_view,
+    covfie::field_view<bfield_bknd_t> field_data,
     vecmem::data::vector_view<track_t>& tracks_data,
     vecmem::data::jagged_vector_view<intersection_t<detector_t>>&
         candidates_data,
@@ -85,9 +86,9 @@ void propagator_test(
 
     // run the test kernel
     propagator_test_kernel<bfield_bknd_t, detector_t>
-        <<<block_dim, thread_dim>>>(det_view, tracks_data, candidates_data,
-                                    path_lengths_data, positions_data,
-                                    jac_transports_data);
+        <<<block_dim, thread_dim>>>(det_view, field_data, tracks_data,
+                                    candidates_data, path_lengths_data,
+                                    positions_data, jac_transports_data);
 
     // cuda error check
     DETRAY_CUDA_ERROR_CHECK(cudaGetLastError());
@@ -95,25 +96,19 @@ void propagator_test(
 }
 
 /// Explicit instantiation for a constant magnetic field
-template void
-propagator_test<bfield::const_bknd_t, detector_host_t<bfield::const_bknd_t>>(
-    detector_host_t<bfield::const_bknd_t>::template detector_view_type<
-        bfield::const_bknd_t>,
+template void propagator_test<bfield::const_bknd_t, detector_host_t>(
+    detector_host_t::view_type, covfie::field_view<bfield::const_bknd_t>,
     vecmem::data::vector_view<track_t>&,
-    vecmem::data::jagged_vector_view<
-        intersection_t<detector_host_t<bfield::const_bknd_t>>>&,
+    vecmem::data::jagged_vector_view<intersection_t<detector_host_t>>&,
     vecmem::data::jagged_vector_view<scalar>&,
     vecmem::data::jagged_vector_view<vector3_t>&,
     vecmem::data::jagged_vector_view<free_matrix>&);
 
 /// Explicit instantiation for an inhomogeneous magnetic field
-template void propagator_test<bfield::cuda::inhom_bknd_t,
-                              detector_host_t<bfield::inhom_bknd_t>>(
-    detector_host_t<bfield::inhom_bknd_t>::template detector_view_type<
-        bfield::cuda::inhom_bknd_t>,
+template void propagator_test<bfield::cuda::inhom_bknd_t, detector_host_t>(
+    detector_host_t::view_type, covfie::field_view<bfield::cuda::inhom_bknd_t>,
     vecmem::data::vector_view<track_t>&,
-    vecmem::data::jagged_vector_view<
-        intersection_t<detector_host_t<bfield::inhom_bknd_t>>>&,
+    vecmem::data::jagged_vector_view<intersection_t<detector_host_t>>&,
     vecmem::data::jagged_vector_view<scalar>&,
     vecmem::data::jagged_vector_view<vector3_t>&,
     vecmem::data::jagged_vector_view<free_matrix>&);
diff --git a/tests/unit_tests/device/cuda/propagator_cuda_kernel.hpp b/tests/unit_tests/device/cuda/propagator_cuda_kernel.hpp
index 718684df3..8200fe648 100644
--- a/tests/unit_tests/device/cuda/propagator_cuda_kernel.hpp
+++ b/tests/unit_tests/device/cuda/propagator_cuda_kernel.hpp
@@ -7,6 +7,7 @@
 
 #pragma once
 
+// Project include(s)
 #include "tests/common/test_base/propagator_test.hpp"
 
 // Vecmem include(s)
@@ -31,7 +32,7 @@ using inhom_bknd_t = covfie::backend::affine<
 /// Launch the propagation test kernel
 template <typename bfield_bknd_t, typename detector_t>
 void propagator_test(
-    typename detector_t::template detector_view_type<bfield_bknd_t>,
+    typename detector_t::view_type, covfie::field_view<bfield_bknd_t>,
     vecmem::data::vector_view<track_t> &,
     vecmem::data::jagged_vector_view<intersection_t<detector_t>> &,
     vecmem::data::jagged_vector_view<scalar> &,
@@ -42,8 +43,8 @@ void propagator_test(
 template <typename bfield_bknd_t, typename detector_t>
 inline auto run_propagation_device(
     vecmem::memory_resource *mr, detector_t &det,
-    typename detector_t::template detector_view_type<bfield_bknd_t> det_view,
-    dvector<track_t> &tracks,
+    typename detector_t::view_type det_view,
+    covfie::field_view<bfield_bknd_t> field_data, dvector<track_t> &tracks,
     const vecmem::jagged_vector<vector3_t> &host_positions)
     -> std::tuple<vecmem::jagged_vector<scalar>,
                   vecmem::jagged_vector<vector3_t>,
@@ -80,8 +81,8 @@ inline auto run_propagation_device(
 
     // Run the propagator test for GPU device
     propagator_test<bfield_bknd_t, detector_t>(
-        det_view, tracks_data, candidates_buffer, path_lengths_buffer,
-        positions_buffer, jac_transports_buffer);
+        det_view, field_data, tracks_data, candidates_buffer,
+        path_lengths_buffer, positions_buffer, jac_transports_buffer);
 
     vecmem::jagged_vector<scalar> device_path_lengths(mr);
     vecmem::jagged_vector<vector3_t> device_positions(mr);
@@ -97,10 +98,11 @@ inline auto run_propagation_device(
 }
 
 /// Test chain for the propagator
-template <typename bfield_bknd_t, typename detector_t>
-inline auto run_propagation_test(
-    vecmem::memory_resource *mr, detector_t &det,
-    typename detector_t::template detector_view_type<bfield_bknd_t> det_view) {
+template <typename device_bfield_bknd_t, typename host_bfield_bknd_t,
+          typename detector_t>
+inline auto run_propagation_test(vecmem::memory_resource *mr, detector_t &det,
+                                 typename detector_t::view_type det_view,
+                                 covfie::field<host_bfield_bknd_t> &&field) {
 
     // Create the vector of initial track parameterizations
     auto tracks_host = generate_tracks(mr);
@@ -108,12 +110,13 @@ inline auto run_propagation_test(
 
     // Host propagation
     auto &&[host_path_lengths, host_positions, host_jac_transports] =
-        run_propagation_host(mr, det, tracks_host);
+        run_propagation_host(mr, det, field, tracks_host);
 
     // Device propagation (device backend specific implementation)
+    covfie::field<device_bfield_bknd_t> device_field(field);
     auto &&[device_path_lengths, device_positions, device_jac_transports] =
-        run_propagation_device<bfield_bknd_t>(mr, det, det_view, tracks_device,
-                                              host_positions);
+        run_propagation_device<device_bfield_bknd_t>(
+            mr, det, det_view, device_field, tracks_device, host_positions);
 
     // Check the results
     compare_propagation_results(host_positions, device_positions,
diff --git a/tests/unit_tests/device/sycl/propagator_kernel.sycl b/tests/unit_tests/device/sycl/propagator_kernel.sycl
index 22dec4175..739c9c781 100644
--- a/tests/unit_tests/device/sycl/propagator_kernel.sycl
+++ b/tests/unit_tests/device/sycl/propagator_kernel.sycl
@@ -13,7 +13,8 @@ namespace detray {
 /// Test function for propagator
 template <typename bfield_bknd_t, typename detector_t>
 void propagator_test(
-    typename detector_t::template detector_view_type<bfield_bknd_t> det_data,
+    typename detector_t::view_type det_data,
+    covfie::field_view<bfield_bknd_t> field_data,
     vecmem::data::vector_view<track_t>& tracks_data,
     vecmem::data::jagged_vector_view<intersection_t<detector_t>>&
         candidates_data,
@@ -35,7 +36,7 @@ void propagator_test(
                                      path_lengths_data, positions_data,
                                      jac_transports_data](
                                         ::sycl::nd_item<1> item) {
-                detector_device_t<bfield_bknd_t> dev_det(det_data);
+                detector_device_t dev_det(det_data);
 
                 vecmem::device_vector<track_t> tracks(tracks_data);
                 vecmem::jagged_device_vector<intersection_t<detector_t>>
@@ -52,9 +53,8 @@ void propagator_test(
                     return;
                 }
 
-                auto stepr = rk_stepper_t<
-                    typename detector_device_t<bfield_bknd_t>::bfield_type>{};
-                auto nav = navigator_t<detector_device_t<bfield_bknd_t>>{};
+                auto stepr = rk_stepper_t<covfie::field_view<bfield_bknd_t>>{};
+                auto nav = navigator_t<detector_device_t>{};
 
                 // Create propagator
                 using propagator_device_t =
@@ -78,8 +78,7 @@ void propagator_test(
                                   interactor_state, resetter_state);
                 // Create the propagator state
                 typename propagator_device_t::state state(
-                    tracks[gid], dev_det.get_bfield(), dev_det,
-                    candidates.at(gid));
+                    tracks[gid], field_data, dev_det, candidates.at(gid));
 
                 state._stepping.set_tolerance(rk_tolerance);
 
@@ -94,26 +93,21 @@ void propagator_test(
 }
 
 /// Explicit instantiation for a constant magnetic field
-template void
-propagator_test<bfield::const_bknd_t, detector_host_t<bfield::const_bknd_t>>(
-    detector_host_t<bfield::const_bknd_t>::template detector_view_type<
-        bfield::const_bknd_t>,
+template void propagator_test<bfield::const_bknd_t>(
+    detector_host_t::view_type, covfie::field_view<bfield::const_bknd_t>,
     vecmem::data::vector_view<track_t>&,
-    vecmem::data::jagged_vector_view<
-        intersection_t<detector_host_t<bfield::const_bknd_t>>>&,
+    vecmem::data::jagged_vector_view<intersection_t<detector_host_t>>&,
     vecmem::data::jagged_vector_view<scalar>&,
     vecmem::data::jagged_vector_view<vector3_t>&,
     vecmem::data::jagged_vector_view<free_matrix>&,
     detray::sycl::queue_wrapper);
 
 /// Explicit instantiation for an inhomogeneous magnetic field
-/*template void propagator_test<bfield::sycl::inhom_bknd_t,
-                              detector_host_t<bfield::inhom_bknd_t>>(
-    detector_host_t<bfield::inhom_bknd_t>::detector_view_type<
-        bfield::sycl::inhom_bknd_t>,
+/*template void propagator_test<bfield::sycl::inhom_bknd_t, detector_host_t>(
+    detector_host_t::view_type,
+    covfie::field_view<bfield::sycl::inhom_bknd_t>,
     vecmem::data::vector_view<track_t>&,
-    vecmem::data::jagged_vector_view<
-        intersection_t<detector_host_t<bfield::inhom_bknd_t>>>&,
+    vecmem::data::jagged_vector_view<intersection_t<detector_host_t>>&,
     vecmem::data::jagged_vector_view<scalar>&,
     vecmem::data::jagged_vector_view<vector3_t>&,
     vecmem::data::jagged_vector_view<free_matrix>&,
diff --git a/tests/unit_tests/device/sycl/propagator_sycl_kernel.hpp b/tests/unit_tests/device/sycl/propagator_sycl_kernel.hpp
index cedc4db9a..3fd35cd1a 100644
--- a/tests/unit_tests/device/sycl/propagator_sycl_kernel.hpp
+++ b/tests/unit_tests/device/sycl/propagator_sycl_kernel.hpp
@@ -19,7 +19,7 @@ namespace detray {
 /// Launch the propagation test kernel
 template <typename bfield_bknd_t, typename detector_t>
 void propagator_test(
-    typename detector_t::template detector_view_type<bfield_bknd_t>,
+    typename detector_t::view_type, covfie::field_view<bfield_bknd_t>,
     vecmem::data::vector_view<track_t> &,
     vecmem::data::jagged_vector_view<intersection_t<detector_t>> &,
     vecmem::data::jagged_vector_view<scalar> &,
@@ -30,8 +30,9 @@ void propagator_test(
 template <typename bfield_bknd_t, typename detector_t>
 inline auto run_propagation_device(
     vecmem::memory_resource *mr, detector_t &det,
-    typename detector_t::template detector_view_type<bfield_bknd_t> det_view,
-    sycl::queue_wrapper queue, dvector<track_t> &tracks,
+    typename detector_t::view_type det_view,
+    covfie::field_view<bfield_bknd_t> field_data, sycl::queue_wrapper queue,
+    dvector<track_t> &tracks,
     const vecmem::jagged_vector<vector3_t> &host_positions)
     -> std::tuple<vecmem::jagged_vector<scalar>,
                   vecmem::jagged_vector<vector3_t>,
@@ -68,8 +69,8 @@ inline auto run_propagation_device(
 
     // Run the propagator test for GPU device
     propagator_test<bfield_bknd_t, detector_t>(
-        det_view, tracks_data, candidates_buffer, path_lengths_buffer,
-        positions_buffer, jac_transports_buffer, queue);
+        det_view, field_data, tracks_data, candidates_buffer,
+        path_lengths_buffer, positions_buffer, jac_transports_buffer, queue);
 
     vecmem::jagged_vector<scalar> device_path_lengths(mr);
     vecmem::jagged_vector<vector3_t> device_positions(mr);
@@ -85,10 +86,12 @@ inline auto run_propagation_device(
 }
 
 /// Test chain for the propagator
-template <typename bfield_bknd_t, typename detector_t>
-inline auto run_propagation_test(
-    vecmem::memory_resource *mr, ::sycl::queue *q, detector_t &det,
-    typename detector_t::template detector_view_type<bfield_bknd_t> det_view) {
+template <typename device_bfield_bknd_t, typename host_bfield_bknd_t,
+          typename detector_t>
+inline auto run_propagation_test(vecmem::memory_resource *mr, ::sycl::queue *q,
+                                 detector_t &det,
+                                 typename detector_t::view_type det_view,
+                                 covfie::field<host_bfield_bknd_t> &field) {
 
     // Create the vector of initial track parameterizations
     auto tracks_host = generate_tracks(mr);
@@ -96,14 +99,16 @@ inline auto run_propagation_test(
 
     // Host propagation
     auto &&[host_path_lengths, host_positions, host_jac_transports] =
-        run_propagation_host(mr, det, tracks_host);
+        run_propagation_host(mr, det, field, tracks_host);
 
     // Device propagation
     detray::sycl::queue_wrapper queue(q);
 
+    covfie::field<device_bfield_bknd_t> device_field(field);
     auto &&[device_path_lengths, device_positions, device_jac_transports] =
-        run_propagation_device<bfield_bknd_t>(mr, det, det_view, queue,
-                                              tracks_device, host_positions);
+        run_propagation_device<device_bfield_bknd_t>(
+            mr, det, det_view, device_field, queue, tracks_device,
+            host_positions);
 
     // Check the results
     compare_propagation_results(host_positions, device_positions,
diff --git a/tests/unit_tests/io/CMakeLists.txt b/tests/unit_tests/io/CMakeLists.txt
index 60e0e1a6f..d12af50fb 100644
--- a/tests/unit_tests/io/CMakeLists.txt
+++ b/tests/unit_tests/io/CMakeLists.txt
@@ -15,6 +15,3 @@ detray_add_test( io_reader
     "io_json_detector_reader.cpp"
     LINK_LIBRARIES GTest::gtest_main vecmem::core detray::core_array
     detray::io_array detray::test detray_tests_common detray::utils_array)
-detray_add_test( io_bfield_reader
-   "io_bfield_reader.cpp"
-   LINK_LIBRARIES GTest::gtest_main detray::core_array detray::io_array detray::utils_array covfie::core vecmem::core )
diff --git a/tests/unit_tests/io/io_bfield_reader.cpp b/tests/unit_tests/io/io_bfield_reader.cpp
deleted file mode 100644
index d1a7b3c09..000000000
--- a/tests/unit_tests/io/io_bfield_reader.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/** Detray library, part of the ACTS project (R&D line)
- *
- * (c) 2023 CERN for the benefit of the ACTS project
- *
- * Mozilla Public License Version 2.0
- */
-
-// Project include(s)
-#include "detray/definitions/algebra.hpp"
-#include "detray/definitions/bfield_backends.hpp"
-#include "detray/detectors/create_toy_geometry.hpp"
-#include "detray/io/common/bfield_reader.hpp"
-#include "detray/io/common/detector_reader.hpp"
-
-// Vecmem include(s)
-#include <vecmem/memory/host_memory_resource.hpp>
-
-// GTest include(s)
-#include <gtest/gtest.h>
-
-#include <iostream>
-
-using namespace detray;
-
-/// Test the reading of a magnetic field from file
-TEST(io, bfield_reader) {
-
-    // Magnetic field map using nearest neightbor interpolation
-    using bfield_t = covfie::field<bfield::inhom_bknd_t>;
-
-    // Toy detector
-    using detector_t = detector<toy_metadata, bfield_t>;
-
-    // Empty volume name map
-    typename detector_t::name_map volume_name_map = {{0u, "toy_detector"}};
-
-    // Toy detector with inhomogeneous bfield
-    vecmem::host_memory_resource host_mr;
-    detector_builder<toy_metadata, bfield::inhom_bknd_t> toy_builder;
-
-    // Read the bfield from file into the detector
-    covfie_reader<detector_t> bf_reader;
-    bf_reader.read(toy_builder, volume_name_map,
-                   !std::getenv("DETRAY_BFIELD_FILE")
-                       ? ""
-                       : std::getenv("DETRAY_BFIELD_FILE"));
-    auto det = toy_builder.build(host_mr);
-
-    // Test the field
-    const bfield_t& bf = det.get_bfield();
-    bfield_t::view_t bv(bf);
-
-    auto field_strength = [&bv](float x, float y, float z) {
-        return std::sqrt(std::pow(bv.at(x, y, z)[0], 2) +
-                         std::pow(bv.at(x, y, z)[1], 2) +
-                         std::pow(bv.at(x, y, z)[2], 2));
-    };
-
-    // Sample some field strengths
-    constexpr scalar tol{1e-7f};
-    float x = -5000.0f, y = 3200.0f, z = -7700.0f;
-    ASSERT_NEAR(field_strength(x, y, z), 0.668426511f * unit<scalar>::T, tol);
-    x = -2400.0f, y = 7500.0f, z = 6500.0f;
-    ASSERT_NEAR(field_strength(x, y, z), 0.597449579f * unit<scalar>::T, tol);
-    x = -1000.0f, y = -4300.0f, z = 2700.0f;
-    ASSERT_NEAR(field_strength(x, y, z), 0.41904773f * unit<scalar>::T, tol);
-    x = 6100.0f, y = 4800.0f, z = -4300.0f;
-    ASSERT_NEAR(field_strength(x, y, z), 0.439638488f * unit<scalar>::T, tol);
-    x = -7800.0f, y = -8400.0f, z = 9000.0f;
-    ASSERT_NEAR(field_strength(x, y, z), 0.061408468f * unit<scalar>::T, tol);
-    x = 6900.0f, y = -8800.0f, z = -4900.0f;
-    ASSERT_NEAR(field_strength(x, y, z), 0.087212384f * unit<scalar>::T, tol);
-    x = -9600.0f, y = 8600.0f, z = 3000.0f;
-    ASSERT_NEAR(field_strength(x, y, z), 0.026944387f * unit<scalar>::T, tol);
-    x = 6400.0f, y = -3200.0f, z = -6400.0f;
-    ASSERT_NEAR(field_strength(x, y, z), 0.629775357f * unit<scalar>::T, tol);
-    x = 200.0f, y = -4000.0f, z = 1700.0f;
-    ASSERT_NEAR(field_strength(x, y, z), 0.004898979f * unit<scalar>::T, tol);
-    x = 400.0f, y = -7100.0f, z = -11700.0f;
-    ASSERT_NEAR(field_strength(x, y, z), 0.293974489f * unit<scalar>::T, tol);
-}
diff --git a/tests/unit_tests/io/io_json_detector_reader.cpp b/tests/unit_tests/io/io_json_detector_reader.cpp
index c2f5b1ca9..eb953c717 100644
--- a/tests/unit_tests/io/io_json_detector_reader.cpp
+++ b/tests/unit_tests/io/io_json_detector_reader.cpp
@@ -185,8 +185,7 @@ TEST(io, json_toy_geometry) {
 /// Test the reading and writing of a toy detector geometry
 TEST(io, json_toy_detector_reader) {
 
-    using detector_t =
-        detector<toy_metadata, covfie::field<bfield::inhom_bknd_t>>;
+    using detector_t = detector<toy_metadata>;
 
     // Toy detector
     vecmem::host_memory_resource host_mr;
@@ -203,8 +202,7 @@ TEST(io, json_toy_detector_reader) {
     reader_cfg.do_check(true)
         .add_file("toy_detector_geometry.json")
         .add_file("toy_detector_homogeneous_material.json")
-        .add_file("toy_detector_surface_grids.json")
-        .add_file(toy_cfg.bfield_file());
+        .add_file("toy_detector_surface_grids.json");
 
     const auto [det, names] =
         io::read_detector<detector_t, 1u>(host_mr, reader_cfg);
diff --git a/tests/validation/include/detray/validation/detector_helix_scan.hpp b/tests/validation/include/detray/validation/detector_helix_scan.hpp
index dab052a89..4988ae1d9 100644
--- a/tests/validation/include/detray/validation/detector_helix_scan.hpp
+++ b/tests/validation/include/detray/validation/detector_helix_scan.hpp
@@ -77,7 +77,6 @@ class helix_scan : public test::fixture_base<> {
 
     /// Run the helix scan
     void TestBody() override {
-        using b_field_t = typename detector_t::bfield_type;
         using scalar_t = typename detector_t::scalar_type;
         using nav_link_t = typename detector_t::surface_type::navigation_link;
 
@@ -87,11 +86,9 @@ class helix_scan : public test::fixture_base<> {
         dindex start_index{0u};
 
         // B-field vector for helix
-        const auto &origin = m_cfg.track_generator().origin();
-        typename b_field_t::view_t bfield_view{m_det.get_bfield()};
-        const typename b_field_t::output_t bvec =
-            bfield_view.at(origin[0], origin[1], origin[2]);
-        const typename fixture_type::point3 B{bvec[0], bvec[1], bvec[2]};
+        const typename fixture_type::point3 B{0.f * unit<scalar_t>::T,
+                                              0.f * unit<scalar_t>::T,
+                                              2.f * unit<scalar_t>::T};
 
         // Iterate through uniformly distributed momentum directions
         std::size_t n_tracks{0u};
diff --git a/tests/validation/include/detray/validation/helix_navigation.hpp b/tests/validation/include/detray/validation/helix_navigation.hpp
index c1503d5cc..a1c98d9c4 100644
--- a/tests/validation/include/detray/validation/helix_navigation.hpp
+++ b/tests/validation/include/detray/validation/helix_navigation.hpp
@@ -8,6 +8,7 @@
 #pragma once
 
 // Project include(s)
+#include "detray/detectors/bfield.hpp"
 #include "detray/intersection/detail/trajectories.hpp"
 #include "detray/propagator/actor_chain.hpp"
 #include "detray/propagator/actors/aborters.hpp"
@@ -99,8 +100,8 @@ class helix_navigation : public test::fixture_base<> {
         // Navigation with inspection
         using navigator_t = navigator<detector_t, inspector_t, intersection_t>;
         // Runge-Kutta stepper
-        using b_field_t = typename detector_t::bfield_type;
-        using stepper_t = rk_stepper<typename b_field_t::view_t, transform3_t>;
+        using bfield_t = bfield::const_field_t;
+        using stepper_t = rk_stepper<typename bfield_t::view_t, transform3_t>;
         // Propagator with pathlimit aborter
         using actor_chain_t = actor_chain<dtuple, pathlimit_aborter>;
         using propagator_t = propagator<stepper_t, navigator_t, actor_chain_t>;
@@ -109,11 +110,10 @@ class helix_navigation : public test::fixture_base<> {
         propagator_t prop(stepper_t{}, navigator_t{});
 
         // B-field vector for helix
-        const auto &origin = m_cfg.track_generator().origin();
-        typename b_field_t::view_t bfield_view{m_det.get_bfield()};
-        const typename b_field_t::output_t bvec =
-            bfield_view.at(origin[0], origin[1], origin[2]);
-        const typename fixture_type::point3 B{bvec[0], bvec[1], bvec[2]};
+        const typename fixture_type::point3 B{0.f * unit<scalar_t>::T,
+                                              0.f * unit<scalar_t>::T,
+                                              2.f * unit<scalar_t>::T};
+        bfield_t hom_bfield = bfield::create_const_field(B);
 
         // Iterate through uniformly distributed momentum directions
         std::size_t n_tracks{0u};
@@ -144,8 +144,7 @@ class helix_navigation : public test::fixture_base<> {
                                                              unit<scalar_t>::m};
             auto actor_states = std::tie(pathlimit_aborter_state);
 
-            typename propagator_t::state propagation(track, m_det.get_bfield(),
-                                                     m_det);
+            typename propagator_t::state propagation(track, hom_bfield, m_det);
 
             // Access to navigation information
             auto &inspector = propagation._navigation.inspector();
diff --git a/tests/validation/src/detector_validation.cpp b/tests/validation/src/detector_validation.cpp
index 17ac7442c..e1eff3caa 100644
--- a/tests/validation/src/detector_validation.cpp
+++ b/tests/validation/src/detector_validation.cpp
@@ -50,8 +50,6 @@ int main(int argc, char **argv) {
         "write_ray_scan", "writes the ray scan intersections to file")(
         "geometry_file", po::value<std::string>(), "geometry input file")(
         "material_file", po::value<std::string>(), "material input file")(
-        "bfield_file", po::value<std::string>(),
-        "magnetic field map input file")(
         "phi_steps", po::value<std::size_t>()->default_value(50u),
         "# phi steps for particle gun")(
         "theta_steps", po::value<std::size_t>()->default_value(50u),
@@ -102,12 +100,6 @@ int main(int argc, char **argv) {
     if (vm.count("material_file")) {
         reader_cfg.add_file(vm["material_file"].as<std::string>());
     }
-    if (vm.count("bfield_file")) {
-        // reader_cfg.add_file(vm["bfield_file"].as<std::string>());
-        throw std::invalid_argument("Reading of bfield file not implemented");
-    } else {
-        reader_cfg.bfield_vec(0.f, 0.f, 2.f * unit<scalar_t>::T);
-    }
 
     // Particle gun
     if (vm.count("phi_steps")) {
diff --git a/tests/validation/src/material_validation.cpp b/tests/validation/src/material_validation.cpp
index 7e45d3b7e..9606204e0 100644
--- a/tests/validation/src/material_validation.cpp
+++ b/tests/validation/src/material_validation.cpp
@@ -33,7 +33,6 @@ int main(int argc, char **argv) {
 
     // Use the most general type to be able to read in all detector files
     using detector_t = detray::detector<>;
-    using scalar_t = detector_t::scalar_type;
 
     // Filter out the google test flags
     ::testing::InitGoogleTest(&argc, argv);
@@ -44,8 +43,6 @@ int main(int argc, char **argv) {
     desc.add_options()("help", "produce help message")(
         "geometry_file", po::value<std::string>(), "geometry input file")(
         "material_file", po::value<std::string>(), "material input file")(
-        "bfield_file", po::value<std::string>(),
-        "magnetic field map input file")(
         "phi_steps", po::value<std::size_t>()->default_value(50u),
         "# phi steps for particle gun")(
         "eta_steps", po::value<std::size_t>()->default_value(50u),
@@ -83,11 +80,6 @@ int main(int argc, char **argv) {
 
         throw std::invalid_argument(err_stream.str());
     }
-    if (vm.count("bfield_file")) {
-        reader_cfg.add_file(vm["bfield_file"].as<std::string>());
-    } else {
-        reader_cfg.bfield_vec(0.f, 0.f, 2.f * unit<scalar_t>::T);
-    }
 
     // Particle gun
     if (vm.count("phi_steps")) {
diff --git a/tests/validation/src/telescope_detector_validation.cpp b/tests/validation/src/telescope_detector_validation.cpp
index 8399c43d0..a260bc2fa 100644
--- a/tests/validation/src/telescope_detector_validation.cpp
+++ b/tests/validation/src/telescope_detector_validation.cpp
@@ -36,10 +36,7 @@ int main(int argc, char **argv) {
 
     tel_det_config<rectangle2D<>> tel_cfg{20.f * unit<scalar_t>::mm,
                                           20.f * unit<scalar_t>::mm};
-    tel_cfg.n_surfaces(10u)
-        .length(500.f * unit<scalar_t>::mm)
-        .bfield_vec(0.f * unit<scalar_t>::T, 0.f * unit<scalar_t>::T,
-                    2.f * unit<scalar_t>::T);
+    tel_cfg.n_surfaces(10u).length(500.f * unit<scalar_t>::mm);
 
     vecmem::host_memory_resource host_mr;
 
diff --git a/tests/validation/src/toy_detector_validation.cpp b/tests/validation/src/toy_detector_validation.cpp
index 31c81a822..6ddacddb5 100644
--- a/tests/validation/src/toy_detector_validation.cpp
+++ b/tests/validation/src/toy_detector_validation.cpp
@@ -33,8 +33,6 @@ int main(int argc, char **argv) {
     //
     toy_det_config toy_cfg{};
     toy_cfg.n_brl_layers(4u).n_edc_layers(7u);
-    toy_cfg.bfield_vec(
-        {0.f * unit<scalar>::T, 0.f * unit<scalar>::T, 2.f * unit<scalar>::T});
 
     using toy_detector_t = detector<toy_metadata>;
     using scalar_t = typename toy_detector_t::scalar_type;
diff --git a/tests/validation/src/wire_chamber_validation.cpp b/tests/validation/src/wire_chamber_validation.cpp
index b7e8a20d6..b47e3b915 100644
--- a/tests/validation/src/wire_chamber_validation.cpp
+++ b/tests/validation/src/wire_chamber_validation.cpp
@@ -38,7 +38,6 @@ int main(int argc, char **argv) {
 
     wire_chamber_config wire_chamber_cfg{};
     wire_chamber_cfg.half_z(500.f * unit<scalar>::mm);
-    wire_chamber_cfg.bfield_vec(0.f, 0.f, 2.f * unit<scalar>::T);
 
     auto [det, names] = create_wire_chamber(host_mr, wire_chamber_cfg);
 
diff --git a/tutorials/include/detray/tutorial/detector_metadata.hpp b/tutorials/include/detray/tutorial/detector_metadata.hpp
index 13aee548c..17f928f83 100644
--- a/tutorials/include/detray/tutorial/detector_metadata.hpp
+++ b/tutorials/include/detray/tutorial/detector_metadata.hpp
@@ -32,8 +32,7 @@
 /// navigation.
 /// In this example detector design, volumes do not contain other volumes, so
 /// the volume lookup is done using a uniform grid.
-/// Furthermore, the detector will contain homogeneous material on its surfaces
-/// and a constant B-field.
+/// Furthermore, the detector will contain homogeneous material on its surfaces.
 namespace detray {
 
 namespace tutorial {
diff --git a/tutorials/include/detray/tutorial/square_surface_generator.hpp b/tutorials/include/detray/tutorial/square_surface_generator.hpp
index 3a391acae..8b8c5e4b6 100644
--- a/tutorials/include/detray/tutorial/square_surface_generator.hpp
+++ b/tutorials/include/detray/tutorial/square_surface_generator.hpp
@@ -25,12 +25,10 @@ namespace detray::tutorial {
 
 /// @brief Generates a sequence of square surfaces for the example detector
 class square_surface_generator final
-    : public surface_factory_interface<detector<
-          tutorial::my_metadata, covfie::field<bfield::const_bknd_t>>> {
+    : public surface_factory_interface<detector<tutorial::my_metadata>> {
 
     public:
-    using detector_t =
-        detector<tutorial::my_metadata, covfie::field<bfield::const_bknd_t>>;
+    using detector_t = detector<tutorial::my_metadata>;
     using scalar_t = typename detector_t::scalar_type;
 
     /// Generate @param n square surfaces with half length @param hl .
diff --git a/tutorials/src/cpu/detector/build_predefined_detectors.cpp b/tutorials/src/cpu/detector/build_predefined_detectors.cpp
index 008e0366e..f0b909133 100644
--- a/tutorials/src/cpu/detector/build_predefined_detectors.cpp
+++ b/tutorials/src/cpu/detector/build_predefined_detectors.cpp
@@ -6,7 +6,6 @@
  */
 
 // Project include(s)
-#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/units.hpp"
 #include "detray/detectors/create_telescope_detector.hpp"
 #include "detray/detectors/create_toy_geometry.hpp"
@@ -106,7 +105,7 @@ int main(int argc, char** argv) {
     //
     // Case 1: Defaults: Straight telescope in z-direction,
     //         10 rectangle surfaces, 500mm in length, modules evenly spaced,
-    //         no B-field, silicon material (80mm)
+    //         silicon material (80mm)
     const auto [tel_det1, tel_names1] =
         detray::create_telescope_detector<detray::rectangle2D<>>(host_mr);
 
@@ -116,8 +115,7 @@ int main(int argc, char** argv) {
 
     //
     // Case 2: Straight telescope in z-direction, 15 trapezoid surfaces, 2000mm
-    //         in length, modules evenly spaced, no B-field,
-    //         silicon material (80mm)
+    //         in length, modules evenly spaced, silicon material (80mm)
     detray::tel_det_config trp_cfg{trapezoid};
     trp_cfg.n_surfaces(15).length(2000.f * detray::unit<detray::scalar>::mm);
 
@@ -130,7 +128,7 @@ int main(int argc, char** argv) {
 
     //
     // Case 3: Straight telescope in x-direction, 11 rectangle surfaces, 2000mm
-    //         in length, modules places according to 'positions', no B-field,
+    //         in length, modules places according to 'positions',
     //         silicon material (80mm)
 
     // Pilot trajectory in x-direction
@@ -150,7 +148,7 @@ int main(int argc, char** argv) {
     //
     // Case 4: Bent telescope along helical track, 11 trapezoid surfaces,
     //         modules spaced according to given positions,
-    //         constant B-field, silicon material (80mm)
+    //         silicon material (80mm)
 
     // Pilot track in x-direction
     detray::free_track_parameters<detray::tutorial::transform3> y_track{
@@ -163,7 +161,7 @@ int main(int argc, char** argv) {
     helix_t helix(y_track, &B_z);
 
     detray::tel_det_config htrp_cfg{trapezoid, helix};
-    htrp_cfg.positions(positions).bfield_vec(B_z);
+    htrp_cfg.positions(positions);
 
     const auto [tel_det4, tel_names4] =
         detray::create_telescope_detector(host_mr, htrp_cfg);
diff --git a/tutorials/src/cpu/detector/detector_to_dot.cpp b/tutorials/src/cpu/detector/detector_to_dot.cpp
index fecb0e68c..f9894c687 100644
--- a/tutorials/src/cpu/detector/detector_to_dot.cpp
+++ b/tutorials/src/cpu/detector/detector_to_dot.cpp
@@ -34,7 +34,7 @@ int main(int argc, char** argv) {
         throw std::runtime_error("Please specify an input file name!");
     }
 
-    // Read a toy detector with constant bfield (default)
+    // Read a toy detector
     using detector_t = detray::detector<detray::toy_metadata>;
 
     // Create an empty detector to be filled
diff --git a/tutorials/src/cpu/detector/do_it_yourself_detector.cpp b/tutorials/src/cpu/detector/do_it_yourself_detector.cpp
index d40502204..e41d1144d 100644
--- a/tutorials/src/cpu/detector/do_it_yourself_detector.cpp
+++ b/tutorials/src/cpu/detector/do_it_yourself_detector.cpp
@@ -7,7 +7,6 @@
 
 // Project include(s)
 #include "detray/core/detector.hpp"
-#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/geometry.hpp"
 #include "detray/definitions/units.hpp"
 #include "detray/detectors/create_toy_geometry.hpp"
@@ -32,9 +31,7 @@
 int main() {
 
     // The new detector type
-    using detector_t =
-        detray::detector<detray::tutorial::my_metadata,
-                         covfie::field<detray::bfield::const_bknd_t>>;
+    using detector_t = detray::detector<detray::tutorial::my_metadata>;
 
     // First, create an empty detector in in host memory to be filled
     vecmem::host_memory_resource host_mr;
diff --git a/tutorials/src/cpu/propagation/navigation_inspection.cpp b/tutorials/src/cpu/propagation/navigation_inspection.cpp
index 344dfde38..741f4db33 100644
--- a/tutorials/src/cpu/propagation/navigation_inspection.cpp
+++ b/tutorials/src/cpu/propagation/navigation_inspection.cpp
@@ -6,7 +6,6 @@
  */
 
 // Project include(s)
-#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/units.hpp"
 #include "detray/detectors/create_toy_geometry.hpp"
 #include "detray/intersection/detail/trajectories.hpp"  // ray
@@ -32,9 +31,7 @@
 /// of the encountered surfaces (using the navigation inspectors)
 int main() {
     // Toy detector
-    using toy_detector_t =
-        detray::detector<detray::toy_metadata,
-                         covfie::field<detray::bfield::const_bknd_t>>;
+    using toy_detector_t = detray::detector<detray::toy_metadata>;
 
     /// Type that holds the intersection information
     using intersection_t =
diff --git a/tutorials/src/device/cuda/CMakeLists.txt b/tutorials/src/device/cuda/CMakeLists.txt
index 408c1b692..ad1245b0e 100644
--- a/tutorials/src/device/cuda/CMakeLists.txt
+++ b/tutorials/src/device/cuda/CMakeLists.txt
@@ -26,6 +26,6 @@ detray_add_tutorial( propagation_cuda
    "propagation.cpp"
    "propagation.hpp"
    "propagation_kernel.cu"
-   LINK_LIBRARIES vecmem::cuda detray::core_array covfie::core
+   LINK_LIBRARIES vecmem::cuda detray::core_array covfie::core covfie::cuda
                   detray::tutorial detray::utils)
 target_compile_definitions(detray_tutorial_propagation_cuda PRIVATE array=array)
diff --git a/tutorials/src/device/cuda/detector_construction.cpp b/tutorials/src/device/cuda/detector_construction.cpp
index 6bb1a9f26..481af92a7 100644
--- a/tutorials/src/device/cuda/detector_construction.cpp
+++ b/tutorials/src/device/cuda/detector_construction.cpp
@@ -8,6 +8,8 @@
 // Project include(s)
 #include "detector_construction.hpp"
 
+#include "detray/detectors/bfield.hpp"
+
 // Vecmem include(s)
 #include <vecmem/memory/cuda/device_memory_resource.hpp>
 #include <vecmem/memory/cuda/managed_memory_resource.hpp>
@@ -36,7 +38,7 @@ int main() {
     auto [det_mng, names_mng] = detray::create_toy_geometry(mng_mr);
 
     // Get the view onto the detector data directly
-    auto det_mng_data = detray::get_data<detray::bfield::const_bknd_t>(det_mng);
+    auto det_mng_data = detray::get_data(det_mng);
 
     // Pass the view and call the kernel
     std::cout << "Using CUDA unified memory:" << std::endl;
@@ -50,17 +52,16 @@ int main() {
     auto [det_host, names_host] = detray::create_toy_geometry(host_mr);
 
     // Copy the detector data to device (synchronous copy, fixed size buffers)
-    auto det_fixed_buff = detray::get_buffer<detray::bfield::const_bknd_t>(
-        det_host, dev_mr, cuda_cpy);
+    auto det_fixed_buff = detray::get_buffer(det_host, dev_mr, cuda_cpy);
 
     // Get the detector view from the buffer and call the kernel
     std::cout << "\nSynchronous copy, fixed size buffers:" << std::endl;
     detray::tutorial::print(detray::get_data(det_fixed_buff));
 
     // Copy the data to device in resizable buffers (synchronous copy)
-    auto det_resz_buff = detray::get_buffer<detray::bfield::const_bknd_t>(
-        det_host, dev_mr, cuda_cpy, detray::copy::sync,
-        vecmem::data::buffer_type::resizable);
+    auto det_resz_buff =
+        detray::get_buffer(det_host, dev_mr, cuda_cpy, detray::copy::sync,
+                           vecmem::data::buffer_type::resizable);
 
     std::cout << "\nSynchronous copy, resizable buffers:" << std::endl;
     detray::tutorial::print(detray::get_data(det_resz_buff));
@@ -94,13 +95,10 @@ int main() {
                                          vecmem::data::buffer_type::fixed_size);
 
     // Assemble the detector buffer
-    auto det_custom_buff =
-        detray::detector_buffer<detray::bfield::const_bknd_t,
-                                detray::toy_metadata,
-                                covfie::field<detray::bfield::const_bknd_t>>(
-            det_host, std::move(vol_buff), std::move(trf_buff),
-            std::move(msk_buff), std::move(mat_buff), std::move(sf_buff),
-            std::move(sf_lkp_buff), std::move(vgrid_buff));
+    auto det_custom_buff = typename decltype(det_host)::buffer_type(
+        std::move(vol_buff), std::move(trf_buff), std::move(msk_buff),
+        std::move(mat_buff), std::move(sf_buff), std::move(sf_lkp_buff),
+        std::move(vgrid_buff));
 
     std::cout << "\nCustom buffer setup:" << std::endl;
     detray::tutorial::print(detray::get_data(det_custom_buff));
diff --git a/tutorials/src/device/cuda/detector_construction.cu b/tutorials/src/device/cuda/detector_construction.cu
index 9fc07fe03..c9b52d09f 100644
--- a/tutorials/src/device/cuda/detector_construction.cu
+++ b/tutorials/src/device/cuda/detector_construction.cu
@@ -12,9 +12,7 @@ namespace detray::tutorial {
 
 /// Kernel that runs the entire propagation loop
 __global__ void print_kernel(
-    typename detray::tutorial::detector_host_t::detector_view_type<
-        bfield::const_bknd_t>
-        det_data) {
+    typename detray::tutorial::detector_host_t::view_type det_data) {
 
     int gid = threadIdx.x + blockIdx.x * blockDim.x;
 
@@ -43,9 +41,7 @@ __global__ void print_kernel(
            det.surface_store().get<acc_id::e_cylinder2_grid>().size());
 }
 
-void print(typename detray::tutorial::detector_host_t::detector_view_type<
-           bfield::const_bknd_t>
-               det_data) {
+void print(typename detray::tutorial::detector_host_t::view_type det_data) {
 
     // run the tutorial kernel
     print_kernel<<<1, 1>>>(det_data);
diff --git a/tutorials/src/device/cuda/detector_construction.hpp b/tutorials/src/device/cuda/detector_construction.hpp
index f3c8147d4..7a4304d2e 100644
--- a/tutorials/src/device/cuda/detector_construction.hpp
+++ b/tutorials/src/device/cuda/detector_construction.hpp
@@ -8,7 +8,6 @@
 #pragma once
 
 // Project include(s).
-#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/units.hpp"
 #include "detray/detectors/create_toy_geometry.hpp"
 #include "detray/tutorial/types.hpp"
@@ -16,18 +15,14 @@
 namespace detray::tutorial {
 
 // Detector
-using detector_host_t =
-    detector<detray::toy_metadata, covfie::field<bfield::const_bknd_t>,
-             host_container_types>;
+using detector_host_t = detector<detray::toy_metadata, host_container_types>;
 using detector_device_t =
-    detector<detray::toy_metadata, covfie::field_view<bfield::const_bknd_t>,
-             device_container_types>;
+    detector<detray::toy_metadata, device_container_types>;
 
 using mask_id = typename detector_host_t::masks::id;
 using acc_id = typename detector_host_t::sf_finders::id;
 
 /// Detector construction tutorial function (prints some detector statistics)
-void print(typename detector_host_t::detector_view_type<bfield::const_bknd_t>
-               det_data);
+void print(typename detector_host_t::view_type det_data);
 
 }  // namespace detray::tutorial
diff --git a/tutorials/src/device/cuda/propagation.cpp b/tutorials/src/device/cuda/propagation.cpp
index 0135e21e3..0ab090dab 100644
--- a/tutorials/src/device/cuda/propagation.cpp
+++ b/tutorials/src/device/cuda/propagation.cpp
@@ -16,23 +16,22 @@
 
 #include "vecmem/utils/cuda/copy.hpp"
 
-// System
-
 /// Prepare the data and move it to device
 int main() {
     // VecMem memory resource(s)
     vecmem::cuda::managed_memory_resource mng_mr;
 
-    // Set the magnetic field vector
-    const auto B =
-        detray::tutorial::vector3{0. * detray::unit<detray::scalar>::T,
-                                  0. * detray::unit<detray::scalar>::T,
-                                  2. * detray::unit<detray::scalar>::T};
+    // Set the magnetic field
+
+    // Define the name of the input file: use detray unittest data in this case
+    const std::string field_file = !std::getenv("DETRAY_BFIELD_FILE")
+                                       ? ""
+                                       : std::getenv("DETRAY_BFIELD_FILE");
+    detray::tutorial::field_host_t bfield =
+        detray::io::read_bfield<detray::bfield::inhom_field_t>(field_file);
 
     // Create the toy geometry
     detray::toy_det_config toy_cfg{};
-    toy_cfg.bfield_vec(B);
-
     auto [det, names] = detray::create_toy_geometry(mng_mr, toy_cfg);
 
     // Create the vector of initial track parameters
@@ -59,9 +58,13 @@ int main() {
     }
 
     // Get data for device
-    auto det_data = detray::get_data<detray::bfield::const_bknd_t>(det);
+    auto det_data = detray::get_data(det);
     auto tracks_data = detray::get_data(tracks);
 
+    // Get the device bfield
+    detray::tutorial::field_device_t device_field(bfield);
+    detray::tutorial::field_device_t::view_t device_field_view(device_field);
+
     // Create navigator candidates buffer
     vecmem::copy copy;  //< Helper object for performing memory copies.
     auto candidates_buffer =
@@ -69,5 +72,6 @@ int main() {
     copy.setup(candidates_buffer);
 
     // Run the propagator test for GPU device
-    detray::tutorial::propagation(det_data, tracks_data, candidates_buffer);
+    detray::tutorial::propagation(det_data, device_field_view, tracks_data,
+                                  candidates_buffer);
 }
diff --git a/tutorials/src/device/cuda/propagation.hpp b/tutorials/src/device/cuda/propagation.hpp
index 0ca1a07f3..452175abb 100644
--- a/tutorials/src/device/cuda/propagation.hpp
+++ b/tutorials/src/device/cuda/propagation.hpp
@@ -8,8 +8,8 @@
 #pragma once
 
 // Project include(s).
-#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/units.hpp"
+#include "detray/detectors/bfield.hpp"
 #include "detray/detectors/create_toy_geometry.hpp"
 #include "detray/propagator/actor_chain.hpp"
 #include "detray/propagator/actors/aborters.hpp"
@@ -22,23 +22,32 @@
 #include "detray/tracks/tracks.hpp"
 #include "detray/tutorial/types.hpp"
 
+// Covfie include(s)
+#include <covfie/cuda/backend/primitive/cuda_device_array.hpp>
+
 namespace detray::tutorial {
 
 // Detector
-using detector_host_t =
-    detector<detray::toy_metadata, covfie::field<bfield::const_bknd_t>,
-             host_container_types>;
+using detector_host_t = detector<detray::toy_metadata, host_container_types>;
 using detector_device_t =
-    detector<detray::toy_metadata, covfie::field_view<bfield::const_bknd_t>,
-             device_container_types>;
+    detector<detray::toy_metadata, device_container_types>;
 
 // Navigator
 using navigator_t = navigator<detector_device_t>;
 using intersection_t = navigator_t::intersection_type;
 
-// Stepper
-using field_t = detector_host_t::bfield_type;
-using stepper_t = rk_stepper<field_t::view_t, detray::tutorial::transform3>;
+// Magnetic field types
+using inhom_cuda_bknd_t = covfie::backend::affine<
+    covfie::backend::nearest_neighbour<covfie::backend::strided<
+        covfie::vector::ulong3,
+        covfie::backend::cuda_device_array<
+            covfie::vector::vector_d<detray::scalar, 3>>>>>;
+using field_host_t = covfie::field<detray::bfield::inhom_bknd_t>;
+using field_device_t = covfie::field<inhom_cuda_bknd_t>;
+
+// Stepper (only running device propagation, so need the device field type)
+using stepper_t =
+    rk_stepper<field_device_t::view_t, detray::tutorial::transform3>;
 
 // Actors
 using actor_chain_t =
@@ -52,7 +61,8 @@ using propagator_t = propagator<stepper_t, navigator_t, actor_chain_t>;
 
 /// Propagation tutorial function
 void propagation(
-    typename detector_host_t::detector_view_type<bfield::const_bknd_t> det_data,
+    typename detector_host_t::view_type det_data,
+    covfie::field_view<inhom_cuda_bknd_t> field_data,
     const vecmem::data::vector_view<
         free_track_parameters<detray::tutorial::transform3>>
         tracks_data,
diff --git a/tutorials/src/device/cuda/propagation_kernel.cu b/tutorials/src/device/cuda/propagation_kernel.cu
index 4f768a280..832eff174 100644
--- a/tutorials/src/device/cuda/propagation_kernel.cu
+++ b/tutorials/src/device/cuda/propagation_kernel.cu
@@ -16,9 +16,8 @@ inline constexpr detray::scalar path_limit{2.f *
 
 /// Kernel that runs the entire propagation loop
 __global__ void propagation_kernel(
-    typename detray::tutorial::detector_host_t::detector_view_type<
-        bfield::const_bknd_t>
-        det_data,
+    typename detray::tutorial::detector_host_t::view_type det_data,
+    covfie::field_view<detray::tutorial::inhom_cuda_bknd_t> field_data,
     const vecmem::data::vector_view<
         detray::free_track_parameters<detray::tutorial::transform3>>
         tracks_data,
@@ -41,8 +40,6 @@ __global__ void propagation_kernel(
     // Setup of the avigator cache
     vecmem::jagged_device_vector<detray::tutorial::intersection_t> candidates(
         candidates_data);
-    // Setup of the device b-field
-    detray::tutorial::detector_device_t::bfield_type B_field = det.get_bfield();
 
     // Create propagator from a stepper and a navigator
     detray::tutorial::propagator_t p(detray::tutorial::stepper_t{},
@@ -61,7 +58,7 @@ __global__ void propagation_kernel(
                                     interactor_state, resetter_state);
 
     // Create the propagator state for the track
-    detray::tutorial::propagator_t::state state(tracks[gid], B_field, det,
+    detray::tutorial::propagator_t::state state(tracks[gid], field_data, det,
                                                 candidates.at(gid));
 
     // Run propagation
@@ -69,9 +66,8 @@ __global__ void propagation_kernel(
 }
 
 void propagation(
-    typename detray::tutorial::detector_host_t::detector_view_type<
-        bfield::const_bknd_t>
-        det_data,
+    typename detray::tutorial::detector_host_t::view_type det_data,
+    covfie::field_view<detray::tutorial::inhom_cuda_bknd_t> field_data,
     const vecmem::data::vector_view<
         detray::free_track_parameters<detray::tutorial::transform3>>
         tracks_data,
@@ -82,8 +78,8 @@ void propagation(
     int block_dim = tracks_data.size() / thread_dim + 1;
 
     // run the tutorial kernel
-    propagation_kernel<<<block_dim, thread_dim>>>(det_data, tracks_data,
-                                                  candidates_data);
+    propagation_kernel<<<block_dim, thread_dim>>>(det_data, field_data,
+                                                  tracks_data, candidates_data);
 
     // cuda error check
     DETRAY_CUDA_ERROR_CHECK(cudaGetLastError());
diff --git a/core/include/detray/definitions/bfield_backends.hpp b/utils/include/detray/detectors/bfield.hpp
similarity index 54%
rename from core/include/detray/definitions/bfield_backends.hpp
rename to utils/include/detray/detectors/bfield.hpp
index 10abb8b16..0216913eb 100644
--- a/core/include/detray/definitions/bfield_backends.hpp
+++ b/utils/include/detray/detectors/bfield.hpp
@@ -9,6 +9,7 @@
 
 // Project include(s)
 #include "detray/definitions/algebra.hpp"
+#include "detray/io/common/read_bfield.hpp"
 
 // Covfie include(s)
 #include <covfie/core/backend/primitive/constant.hpp>
@@ -16,19 +17,36 @@
 #include <covfie/core/backend/transformer/nearest_neighbour.hpp>
 #include <covfie/core/backend/transformer/strided.hpp>
 #include <covfie/core/field.hpp>
-#include <covfie/core/field_view.hpp>
 
 namespace detray::bfield {
 
-// Constant bfield (host and device)
+/// Constant bfield (host and device)
 using const_bknd_t =
     covfie::backend::constant<covfie::vector::vector_d<scalar, 3>,
                               covfie::vector::vector_d<scalar, 3>>;
 
-// Inhomogeneous field (host)
+using const_field_t = covfie::field<const_bknd_t>;
+
+/// Inhomogeneous field (host)
 using inhom_bknd_t = covfie::backend::affine<
     covfie::backend::nearest_neighbour<covfie::backend::strided<
         covfie::vector::ulong3,
         covfie::backend::array<covfie::vector::vector_d<scalar, 3>>>>>;
 
+using inhom_field_t = covfie::field<inhom_bknd_t>;
+
+/// @returns a constant covfie field constructed from the field vector @param B
+inline const_field_t create_const_field(
+    const __plugin::vector3<detray::scalar> &B) {
+    return const_field_t{covfie::make_parameter_pack(
+        const_bknd_t::configuration_t{B[0], B[1], B[2]})};
+}
+
+/// @returns a constant covfie field constructed from the field vector @param B
+inline inhom_field_t create_inhom_field() {
+    return io::read_bfield<inhom_field_t>(
+        !std::getenv("DETRAY_BFIELD_FILE") ? ""
+                                           : std::getenv("DETRAY_BFIELD_FILE"));
+}
+
 }  // namespace detray::bfield
diff --git a/utils/include/detray/detectors/create_telescope_detector.hpp b/utils/include/detray/detectors/create_telescope_detector.hpp
index 439bcf77c..94bd799da 100644
--- a/utils/include/detray/detectors/create_telescope_detector.hpp
+++ b/utils/include/detray/detectors/create_telescope_detector.hpp
@@ -9,7 +9,6 @@
 
 // Project include(s)
 #include "detray/core/detector.hpp"
-#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/units.hpp"
 #include "detray/detectors/telescope_metadata.hpp"
 #include "detray/masks/masks.hpp"
@@ -46,7 +45,7 @@ struct tel_det_config {
     template <
         typename... Args,
         std::enable_if_t<(std::is_same_v<Args, scalar> || ...), bool> = true>
-    tel_det_config(Args &&... args) : m_mask(0u, std::forward<Args>(args)...) {}
+    tel_det_config(Args &&...args) : m_mask(0u, std::forward<Args>(args)...) {}
 
     /// Mask of the test surfaces
     mask<mask_shape_t> m_mask;
@@ -64,8 +63,6 @@ struct tel_det_config {
     trajectory_t m_trajectory{};
     /// Safety envelope between the test surfaces and the portals
     scalar m_envelope{0.1f * unit<scalar>::mm};
-    /// Field vector for an homogenoues b-field
-    vector3 m_bfield_vec{0.f, 0.f, 2.f * unit<scalar>::T};
 
     /// Setters
     /// @{
@@ -108,14 +105,6 @@ struct tel_det_config {
         m_envelope = e;
         return *this;
     }
-    tel_det_config &bfield_vec(const vector3 &field_vec) {
-        m_bfield_vec = field_vec;
-        return *this;
-    }
-    tel_det_config &bfield_vec(const scalar x, const scalar y, const scalar z) {
-        m_bfield_vec = {x, y, z};
-        return *this;
-    }
     /// @}
 
     /// Getters
@@ -130,7 +119,6 @@ struct tel_det_config {
     constexpr scalar mat_thickness() const { return m_thickness; }
     const trajectory_t &pilot_track() const { return m_trajectory; }
     constexpr scalar envelope() const { return m_envelope; }
-    constexpr const vector3 &bfield_vec() const { return m_bfield_vec; }
     /// @}
 };
 
@@ -426,7 +414,6 @@ inline void create_telescope(context_t &ctx, volume_t &volume,
 /// @tparam trajectory_t the type of the pilot trajectory
 ///
 /// @param resource the memory resource for the detector containers
-/// @param bfield
 ///
 /// @returns a complete detector object
 template <typename mask_shape_t = rectangle2D<>,
@@ -438,8 +425,7 @@ inline auto create_telescope_detector(
 
     // detector type
     using detector_t =
-        detector<telescope_metadata<mask_shape_t>,
-                 covfie::field<bfield::const_bknd_t>, host_container_types>;
+        detector<telescope_metadata<mask_shape_t>, host_container_types>;
 
     // Detector and volume names
     typename detector_t::name_map name_map = {{0u, "telescope_detector"},
@@ -467,13 +453,8 @@ inline auto create_telescope_detector(
     assert((positions.size() < 20u) &&
            "Due to WIP, please choose less than 20 surfaces for now");
 
-    const auto &B = cfg.bfield_vec();
-    auto bfield =
-        covfie::field<bfield::const_bknd_t>{covfie::make_parameter_pack(
-            bfield::const_bknd_t::configuration_t{B[0], B[1], B[2]})};
-
     // create empty detector
-    detector_t det(resource, std::move(bfield));
+    detector_t det(resource);
 
     typename detector_t::geometry_context ctx{};
 
diff --git a/utils/include/detray/detectors/create_toy_geometry.hpp b/utils/include/detray/detectors/create_toy_geometry.hpp
index e60887adc..70334397b 100644
--- a/utils/include/detray/detectors/create_toy_geometry.hpp
+++ b/utils/include/detray/detectors/create_toy_geometry.hpp
@@ -9,7 +9,6 @@
 
 // Project include(s)
 #include "detray/core/detector.hpp"
-#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/math.hpp"
 #include "detray/definitions/units.hpp"
 #include "detray/detectors/detector_helper.hpp"
@@ -47,12 +46,6 @@ struct toy_det_config {
     unsigned int m_n_brl_layers{4u};
     /// No. of endcap layers (on either side) the detector should be built with
     unsigned int m_n_edc_layers{3u};
-    /// Field vector for an homogenoues b-field
-    vector3 m_bfield_vec{0.f, 0.f, 2.f * unit<scalar>::T};
-    /// Input file name for the covfie b-field
-    std::string m_bfield_file{!std::getenv("DETRAY_BFIELD_FILE")
-                                  ? ""
-                                  : std::getenv("DETRAY_BFIELD_FILE")};
 
     /// Setters
     /// @{
@@ -64,26 +57,12 @@ struct toy_det_config {
         m_n_edc_layers = n;
         return *this;
     }
-    toy_det_config &bfield_vec(const vector3 &field_vec) {
-        m_bfield_vec = field_vec;
-        return *this;
-    }
-    toy_det_config &bfield_vec(const scalar x, const scalar y, const scalar z) {
-        m_bfield_vec = {x, y, z};
-        return *this;
-    }
-    toy_det_config &bfield_file(const std::string &file_name) {
-        m_bfield_file = file_name;
-        return *this;
-    }
     /// @}
 
     /// Getters
     /// @{
     constexpr unsigned int n_brl_layers() const { return m_n_brl_layers; }
     constexpr unsigned int n_edc_layers() const { return m_n_edc_layers; }
-    constexpr const vector3 &bfield_vec() const { return m_bfield_vec; }
-    const std::string &bfield_file() const { return m_bfield_file; }
     /// @}
 };
 
@@ -925,19 +904,15 @@ inline void add_barrel_detector(
 /// present when an endcap detector is built to have the barrel region radius
 /// match the endcap diameter.
 ///
-/// @tparam bfield_bknd_t the type of magnetic field to construct
-///
 /// @param resource vecmem memory resource to use for container allocations
 /// @param cfg toy detector configuration
 ///
 /// @returns a complete detector object
-template <typename bfield_bknd_t = bfield::const_bknd_t>
 inline auto create_toy_geometry(vecmem::memory_resource &resource,
                                 const toy_det_config &cfg = {}) {
 
     // detector type
-    using detector_t = detector<toy_metadata, covfie::field<bfield_bknd_t>,
-                                host_container_types>;
+    using detector_t = detector<toy_metadata, host_container_types>;
 
     // Detector and volume names
     typename detector_t::name_map name_map = {{0u, "toy_detector"}};
@@ -1034,21 +1009,6 @@ inline auto create_toy_geometry(vecmem::memory_resource &resource,
     // create empty detector
     detector_t det(resource);
 
-    // Constant b-field: 2T in z-direction as default
-    if constexpr (std::is_same_v<bfield_bknd_t, bfield::const_bknd_t>) {
-        const vector3 &B = cfg.bfield_vec();
-        auto bfield = covfie::field<bfield_bknd_t>(covfie::make_parameter_pack(
-            bfield::const_bknd_t::configuration_t{B[0], B[1], B[2]}));
-        det.set_bfield(std::move(bfield));
-    }
-    // Read b-field map from file
-    else {
-        detray::io::detail::file_handle file(cfg.bfield_file(),
-                                             std::ios::binary | std::ios::in);
-
-        det.set_bfield(covfie::field<bfield_bknd_t>(*file));
-    }
-
     // geometry context object
     typename detector_t::geometry_context ctx0{};
 
diff --git a/utils/include/detray/detectors/create_wire_chamber.hpp b/utils/include/detray/detectors/create_wire_chamber.hpp
index 4be903867..bb05f17bc 100644
--- a/utils/include/detray/detectors/create_wire_chamber.hpp
+++ b/utils/include/detray/detectors/create_wire_chamber.hpp
@@ -10,13 +10,10 @@
 // Project include(s)
 #include "detray/core/detector.hpp"
 #include "detray/core/detector_metadata.hpp"
-#include "detray/definitions/bfield_backends.hpp"
 #include "detray/definitions/units.hpp"
 #include "detray/detectors/detector_helper.hpp"
-#include "detray/io/common/detail/file_handle.hpp"
 #include "detray/masks/masks.hpp"
 #include "detray/materials/predefined_materials.hpp"
-#include "detray/tools/bounding_volume.hpp"
 #include "detray/tools/grid_builder.hpp"
 #include "detray/utils/axis_rotation.hpp"
 #include "detray/utils/unit_vectors.hpp"
@@ -43,14 +40,6 @@ struct wire_chamber_config {
     /// Half z of cylinder chamber
     scalar m_half_z{1000.f * unit<scalar>::mm};
 
-    /// Field vector for an homogenoues b-field
-    vector3 m_bfield_vec{0.f, 0.f, 2.f * unit<scalar>::T};
-
-    /// Input file name for the covfie b-field
-    std::string m_bfield_file{!std::getenv("DETRAY_BFIELD_FILE")
-                                  ? ""
-                                  : std::getenv("DETRAY_BFIELD_FILE")};
-
     constexpr wire_chamber_config &n_layers(const unsigned int n) {
         m_n_layers = n;
         return *this;
@@ -61,36 +50,16 @@ struct wire_chamber_config {
         return *this;
     }
 
-    wire_chamber_config &bfield_vec(const vector3 &field_vec) {
-        m_bfield_vec = field_vec;
-        return *this;
-    }
-
-    wire_chamber_config &bfield_vec(const scalar x, const scalar y,
-                                    const scalar z) {
-        m_bfield_vec = {x, y, z};
-        return *this;
-    }
-
-    wire_chamber_config &bfield_file(const std::string &file_name) {
-        m_bfield_file = file_name;
-        return *this;
-    }
-
     constexpr unsigned int n_layers() const { return m_n_layers; }
     constexpr scalar half_z() const { return m_half_z; }
-    constexpr const vector3 &bfield_vec() const { return m_bfield_vec; }
-    const std::string &bfield_file() const { return m_bfield_file; }
 
 };  // wire chamber config
 
-template <typename bfield_bknd_t = bfield::const_bknd_t>
-auto create_wire_chamber(vecmem::memory_resource &resource,
-                         const wire_chamber_config &cfg) {
+inline auto create_wire_chamber(vecmem::memory_resource &resource,
+                                const wire_chamber_config &cfg) {
 
     // Detector type
-    using detector_t = detector<default_metadata, covfie::field<bfield_bknd_t>,
-                                host_container_types>;
+    using detector_t = detector<default_metadata, host_container_types>;
 
     using nav_link_t = typename detector_t::surface_type::navigation_link;
     using mask_id = typename detector_t::surface_type::mask_id;
@@ -112,22 +81,6 @@ auto create_wire_chamber(vecmem::memory_resource &resource,
     // Create detector
     detector_t det(resource);
 
-    // B field
-    // Constant b-field: 2T in z-direction as default
-    if constexpr (std::is_same_v<bfield_bknd_t, bfield::const_bknd_t>) {
-        const vector3 &B = cfg.bfield_vec();
-        auto bfield = covfie::field<bfield_bknd_t>(covfie::make_parameter_pack(
-            bfield::const_bknd_t::configuration_t{B[0], B[1], B[2]}));
-        det.set_bfield(std::move(bfield));
-    }
-    // Read b-field map from file
-    else {
-        detray::io::detail::file_handle file(cfg.bfield_file(),
-                                             std::ios::binary | std::ios::in);
-
-        det.set_bfield(covfie::field<bfield_bknd_t>(*file));
-    }
-
     // Detector and volume names
     typename detector_t::name_map name_map = {{0u, "wire_chamber"}};
 

From 263d79b9560f76bfd46e43063d3748eae3667e91 Mon Sep 17 00:00:00 2001
From: beomki-yeo <beomki.yeo@gmail.com>
Date: Mon, 16 Oct 2023 14:33:01 +0200
Subject: [PATCH 20/29] Extended fixes and updates

---
 .github/workflows/builds.yml                  |  2 +-
 io/include/detray/io/common/grid_reader.hpp   |  4 +--
 .../cuda/benchmark_propagator_cuda.cpp        |  1 +
 .../cuda/benchmark_propagator_cuda_kernel.hpp |  2 +-
 .../common/test_base/propagator_test.hpp      |  8 +++---
 .../unit_tests/device/cuda/navigator_cuda.cpp | 10 ++++---
 .../device/cuda/navigator_cuda_kernel.hpp     |  3 ++-
 .../device/cuda/propagator_cuda.cpp           |  7 ++---
 tests/unit_tests/device/sycl/propagator.sycl  | 26 ++++++++++---------
 .../device/sycl/propagator_kernel.sycl        | 11 ++++----
 tutorials/CMakeLists.txt                      |  9 +++----
 tutorials/src/device/cuda/CMakeLists.txt      | 14 +++++-----
 .../src/device/cuda/detector_construction.cpp |  1 +
 .../src/device/cuda/detector_construction.hpp |  3 ++-
 tutorials/src/device/cuda/propagation.cpp     | 25 ++++++++----------
 tutorials/src/device/cuda/propagation.hpp     | 23 +++++-----------
 .../src/device/cuda/propagation_kernel.cu     |  4 +--
 .../detectors/create_telescope_detector.hpp   |  2 +-
 18 files changed, 74 insertions(+), 81 deletions(-)

diff --git a/.github/workflows/builds.yml b/.github/workflows/builds.yml
index 46b05ef86..c64f03ba7 100644
--- a/.github/workflows/builds.yml
+++ b/.github/workflows/builds.yml
@@ -57,7 +57,7 @@ jobs:
         SCALAR_TYPE: ["float", "double"]
         PLATFORM:
           - NAME: "HOST"
-            CONTAINER: "ghcr.io/acts-project/ubuntu2004:v30"
+            CONTAINER: "ghcr.io/acts-project/ubuntu2004:v43"
             OPTIONS: -DDETRAY_EIGEN_PLUGIN=ON -DDETRAY_SMATRIX_PLUGIN=ON -DDETRAY_VC_PLUGIN=ON
 
     # The system to run on.
diff --git a/io/include/detray/io/common/grid_reader.hpp b/io/include/detray/io/common/grid_reader.hpp
index 8de59bb61..35cc104f0 100644
--- a/io/include/detray/io/common/grid_reader.hpp
+++ b/io/include/detray/io/common/grid_reader.hpp
@@ -94,7 +94,7 @@ class grid_reader : public reader_interface<detector_t> {
               typename binning_ts = types::type_list<>, typename... Ts>
     static void deserialize(std::queue<n_axis::bounds> &bound_ids,
                             std::queue<n_axis::binning> &binning_ids,
-                            Ts &&...data) {
+                            Ts &&... data) {
         using namespace n_axis;
 
         constexpr std::size_t n_bounds_types{types::size<bounds_ts>};
@@ -152,7 +152,7 @@ class grid_reader : public reader_interface<detector_t> {
     template <typename bounds_ts, typename binning_ts, typename... Ts,
               std::enable_if_t<types::size<bounds_ts> == Dim, bool> = true>
     static void deserialize(std::queue<n_axis::binning> &binning_ids,
-                            Ts &&...data) {
+                            Ts &&... data) {
 
         using namespace n_axis;
 
diff --git a/tests/benchmarks/cuda/benchmark_propagator_cuda.cpp b/tests/benchmarks/cuda/benchmark_propagator_cuda.cpp
index b1645c0c2..7b38b8f0b 100644
--- a/tests/benchmarks/cuda/benchmark_propagator_cuda.cpp
+++ b/tests/benchmarks/cuda/benchmark_propagator_cuda.cpp
@@ -7,6 +7,7 @@
 
 // Project include(s)
 #include "benchmark_propagator_cuda_kernel.hpp"
+#include "detray/detectors/create_toy_geometry.hpp"
 #include "detray/simulation/event_generator/track_generators.hpp"
 
 // Vecmem include(s)
diff --git a/tests/benchmarks/cuda/benchmark_propagator_cuda_kernel.hpp b/tests/benchmarks/cuda/benchmark_propagator_cuda_kernel.hpp
index ea332e933..223ccc097 100644
--- a/tests/benchmarks/cuda/benchmark_propagator_cuda_kernel.hpp
+++ b/tests/benchmarks/cuda/benchmark_propagator_cuda_kernel.hpp
@@ -11,7 +11,7 @@
 #include "detray/definitions/algebra.hpp"
 #include "detray/definitions/units.hpp"
 #include "detray/detectors/bfield.hpp"
-#include "detray/detectors/create_toy_geometry.hpp"
+#include "detray/detectors/toy_metadata.hpp"
 #include "detray/propagator/actor_chain.hpp"
 #include "detray/propagator/actors/aborters.hpp"
 #include "detray/propagator/actors/parameter_resetter.hpp"
diff --git a/tests/common/include/tests/common/test_base/propagator_test.hpp b/tests/common/include/tests/common/test_base/propagator_test.hpp
index 5ba29e966..b1286696a 100644
--- a/tests/common/include/tests/common/test_base/propagator_test.hpp
+++ b/tests/common/include/tests/common/test_base/propagator_test.hpp
@@ -11,7 +11,7 @@
 #include "detray/definitions/algebra.hpp"
 #include "detray/definitions/units.hpp"
 #include "detray/detectors/bfield.hpp"
-#include "detray/detectors/create_toy_geometry.hpp"
+#include "detray/detectors/toy_metadata.hpp"
 #include "detray/propagator/actor_chain.hpp"
 #include "detray/propagator/actors/aborters.hpp"
 #include "detray/propagator/actors/parameter_resetter.hpp"
@@ -44,6 +44,7 @@ using detector_device_t = detector<toy_metadata, device_container_types>;
 // These types are identical in host and device code for all bfield types
 using transform3 = typename detector_host_t::transform3;
 using vector3_t = typename transform3::vector3;
+using point3_t = typename transform3::point3;
 using matrix_operator = standard_matrix_operator<scalar>;
 using track_t = free_track_parameters<transform3>;
 using free_matrix = typename track_t::covariance_type;
@@ -59,9 +60,6 @@ using constraints_t = constrained_step<>;
 template <typename bfield_view_t>
 using rk_stepper_t = rk_stepper<bfield_view_t, transform3, constraints_t>;
 
-// Detector configuration
-toy_det_config toy_cfg{};
-
 // Geomery navigation configurations
 constexpr unsigned int theta_steps{10u};
 constexpr unsigned int phi_steps{10u};
@@ -229,7 +227,7 @@ inline void compare_propagation_results(
             const vector3_t &device_pos = device_positions[i][j];
 
             auto relative_error =
-                static_cast<point3>(1. / host_pl * (host_pos - device_pos));
+                static_cast<point3_t>(1. / host_pl * (host_pos - device_pos));
 
             ASSERT_NEAR(getter::norm(relative_error), 0.f, is_close);
         }
diff --git a/tests/unit_tests/device/cuda/navigator_cuda.cpp b/tests/unit_tests/device/cuda/navigator_cuda.cpp
index a9935b394..78cecd6c9 100644
--- a/tests/unit_tests/device/cuda/navigator_cuda.cpp
+++ b/tests/unit_tests/device/cuda/navigator_cuda.cpp
@@ -5,13 +5,17 @@
  * Mozilla Public License Version 2.0
  */
 
-#include <gtest/gtest.h>
+// Project include(s)
+#include "detray/detectors/create_toy_geometry.hpp"
+#include "navigator_cuda_kernel.hpp"
 
+// vecmem include(s)
 #include <vecmem/memory/cuda/device_memory_resource.hpp>
 #include <vecmem/memory/cuda/managed_memory_resource.hpp>
+#include <vecmem/utils/cuda/copy.hpp>
 
-#include "navigator_cuda_kernel.hpp"
-#include "vecmem/utils/cuda/copy.hpp"
+// GTest include(s)
+#include <gtest/gtest.h>
 
 TEST(navigator_cuda, navigator) {
 
diff --git a/tests/unit_tests/device/cuda/navigator_cuda_kernel.hpp b/tests/unit_tests/device/cuda/navigator_cuda_kernel.hpp
index 3602b124f..8da848f6f 100644
--- a/tests/unit_tests/device/cuda/navigator_cuda_kernel.hpp
+++ b/tests/unit_tests/device/cuda/navigator_cuda_kernel.hpp
@@ -10,7 +10,7 @@
 // Project include(s)
 #include "detray/definitions/algebra.hpp"
 #include "detray/definitions/units.hpp"
-#include "detray/detectors/create_toy_geometry.hpp"
+#include "detray/detectors/toy_metadata.hpp"
 #include "detray/propagator/line_stepper.hpp"
 #include "detray/propagator/navigator.hpp"
 #include "detray/simulation/event_generator/track_generators.hpp"
@@ -18,6 +18,7 @@
 using namespace detray;
 
 using transform3 = __plugin::transform3<scalar>;
+using point3 = __plugin::point3<scalar>;
 
 // some useful type declarations
 using detector_host_t = detector<toy_metadata, host_container_types>;
diff --git a/tests/unit_tests/device/cuda/propagator_cuda.cpp b/tests/unit_tests/device/cuda/propagator_cuda.cpp
index 30af1ecee..9acf3ddaa 100644
--- a/tests/unit_tests/device/cuda/propagator_cuda.cpp
+++ b/tests/unit_tests/device/cuda/propagator_cuda.cpp
@@ -7,6 +7,7 @@
 
 // Project include(s)
 #include "detray/detectors/bfield.hpp"
+#include "detray/detectors/create_toy_geometry.hpp"
 #include "propagator_cuda_kernel.hpp"
 
 // Vecmem include(s)
@@ -32,7 +33,7 @@ TEST_P(CudaPropConstBFieldMng, propagator) {
     auto field = bfield::create_const_field(B);
 
     // Create the toy geometry
-    auto [det, names] = create_toy_geometry(mng_mr, toy_cfg);
+    auto [det, names] = create_toy_geometry(mng_mr);
 
     run_propagation_test<bfield::const_bknd_t>(
         &mng_mr, det, detray::get_data(det), std::move(field));
@@ -54,7 +55,7 @@ TEST_P(CudaPropConstBFieldCpy, propagator) {
     auto field = bfield::create_const_field(B);
 
     // Create the toy geometry
-    auto [det, names] = create_toy_geometry(host_mr, toy_cfg);
+    auto [det, names] = create_toy_geometry(host_mr);
 
     auto det_buff = detray::get_buffer(det, dev_mr, cuda_cpy);
 
@@ -116,7 +117,7 @@ TEST(CudaPropagatorValidation10, inhomogeneous_bfield_cpy) {
     auto field = bfield::create_inhom_field();
 
     // Create the toy geometry with inhomogeneous bfield from file
-    auto [det, names] = create_toy_geometry(host_mr, toy_cfg);
+    auto [det, names] = create_toy_geometry(host_mr);
 
     auto det_buff = detray::get_buffer(det, dev_mr, cuda_cpy);
 
diff --git a/tests/unit_tests/device/sycl/propagator.sycl b/tests/unit_tests/device/sycl/propagator.sycl
index 05c0bd5bd..d56a3cb42 100644
--- a/tests/unit_tests/device/sycl/propagator.sycl
+++ b/tests/unit_tests/device/sycl/propagator.sycl
@@ -6,6 +6,7 @@
  */
 
 // Project include(s)
+#include "detray/detectors/create_toy_geometry.hpp"
 #include "propagator_sycl_kernel.hpp"
 
 // Vecmem include(s)
@@ -43,14 +44,16 @@ TEST_P(SyclPropConstBFieldMng, propagator) {
     vecmem::sycl::shared_memory_resource shared_mr;
 
     // Set the magnetic field
-    const vector3 B = GetParam();
+    const vector3_t B = GetParam();
+    auto field = bfield::create_const_field(B);
 
     // Create the toy geometry
-    toy_cfg.bfield_vec(B);
-    auto [det, names] = create_toy_geometry(shared_mr, toy_cfg);
+    auto [det, names] = create_toy_geometry(shared_mr);
 
-    run_propagation_test<bfield::const_bknd_t>(
-        &shared_mr, &q, det, detray::get_data<bfield::const_bknd_t>(det));
+    auto det_view = detray::get_data(det);
+
+    run_propagation_test<bfield::const_bknd_t>(&shared_mr, &q, det, det_view,
+                                               field);
 }
 
 class SyclPropConstBFieldCpy : public ::testing::TestWithParam<vector3_t> {};
@@ -71,17 +74,16 @@ TEST_P(SyclPropConstBFieldCpy, propagator) {
     vecmem::sycl::copy sycl_cpy(q_wrapper);
 
     // Set the magnetic field
-    const vector3 B = GetParam();
+    const vector3_t B = GetParam();
+    auto field = bfield::create_const_field(B);
 
     // Create the toy geometry
-    toy_cfg.bfield_vec(B);
-    auto [det, names] = create_toy_geometry(host_mr, toy_cfg);
+    auto [det, names] = create_toy_geometry(host_mr);
 
-    auto det_buff =
-        detray::get_buffer<bfield::const_bknd_t>(det, dev_mr, sycl_cpy);
+    auto det_buff = detray::get_buffer(det, dev_mr, sycl_cpy);
 
-    run_propagation_test<bfield::const_bknd_t>(&shared_mr, &q, det,
-                                               detray::get_data(det_buff));
+    run_propagation_test<bfield::const_bknd_t>(
+        &shared_mr, &q, det, detray::get_data(det_buff), field);
 }
 
 INSTANTIATE_TEST_SUITE_P(SyclPropagatorValidation1, SyclPropConstBFieldMng,
diff --git a/tests/unit_tests/device/sycl/propagator_kernel.sycl b/tests/unit_tests/device/sycl/propagator_kernel.sycl
index 739c9c781..1e0f5d043 100644
--- a/tests/unit_tests/device/sycl/propagator_kernel.sycl
+++ b/tests/unit_tests/device/sycl/propagator_kernel.sycl
@@ -32,9 +32,9 @@ void propagator_test(
 
     reinterpret_cast<::sycl::queue*>(queue.queue())
         ->submit([&](::sycl::handler& h) {
-            h.parallel_for(ndrange, [det_data, tracks_data, candidates_data,
-                                     path_lengths_data, positions_data,
-                                     jac_transports_data](
+            h.parallel_for(ndrange, [det_data, field_data, tracks_data,
+                                     candidates_data, path_lengths_data,
+                                     positions_data, jac_transports_data](
                                         ::sycl::nd_item<1> item) {
                 detector_device_t dev_det(det_data);
 
@@ -43,7 +43,8 @@ void propagator_test(
                     candidates(candidates_data);
                 vecmem::jagged_device_vector<scalar> path_lengths(
                     path_lengths_data);
-                vecmem::jagged_device_vector<vector3> positions(positions_data);
+                vecmem::jagged_device_vector<vector3_t> positions(
+                    positions_data);
                 vecmem::jagged_device_vector<free_matrix> jac_transports(
                     jac_transports_data);
 
@@ -93,7 +94,7 @@ void propagator_test(
 }
 
 /// Explicit instantiation for a constant magnetic field
-template void propagator_test<bfield::const_bknd_t>(
+template void propagator_test<bfield::const_bknd_t, detector_host_t>(
     detector_host_t::view_type, covfie::field_view<bfield::const_bknd_t>,
     vecmem::data::vector_view<track_t>&,
     vecmem::data::jagged_vector_view<intersection_t<detector_host_t>>&,
diff --git a/tutorials/CMakeLists.txt b/tutorials/CMakeLists.txt
index 9a7e2df0d..83731b4d4 100644
--- a/tutorials/CMakeLists.txt
+++ b/tutorials/CMakeLists.txt
@@ -11,12 +11,9 @@ include( detray-compiler-options-cpp )
 file( GLOB _detray_tutorial_headers
    RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
    "include/detray/tutorials/*.hpp" )
-add_library( detray_tutorial INTERFACE "${_detray_tutorial_headers}" )
-add_library( detray::tutorial ALIAS detray_tutorial )
-target_include_directories( detray_tutorial
-   INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/include" )
-target_link_libraries( detray_tutorial INTERFACE
-   vecmem::core detray::core )
+
+detray_add_library( detray_tutorial tutorial ${_detray_tutorial_headers})
+target_link_libraries( detray_tutorial INTERFACE vecmem::core detray::core )
 unset( _detray_tutorial_headers )
 
 # Include all of the code-holding sub-directories.
diff --git a/tutorials/src/device/cuda/CMakeLists.txt b/tutorials/src/device/cuda/CMakeLists.txt
index ad1245b0e..2fc286db5 100644
--- a/tutorials/src/device/cuda/CMakeLists.txt
+++ b/tutorials/src/device/cuda/CMakeLists.txt
@@ -22,10 +22,10 @@ detray_add_tutorial( detector_construction_cuda
                   detray::tutorial detray::utils)
 target_compile_definitions(detray_tutorial_detector_construction_cuda PRIVATE array=array)
 
-detray_add_tutorial( propagation_cuda
-   "propagation.cpp"
-   "propagation.hpp"
-   "propagation_kernel.cu"
-   LINK_LIBRARIES vecmem::cuda detray::core_array covfie::core covfie::cuda
-                  detray::tutorial detray::utils)
-target_compile_definitions(detray_tutorial_propagation_cuda PRIVATE array=array)
+#detray_add_tutorial( propagation_cuda
+#   "propagation.cpp"
+#   "propagation.hpp"
+#   "propagation_kernel.cu"
+#   LINK_LIBRARIES vecmem::cuda detray::core_array covfie::core covfie::cuda
+#                  detray::tutorial detray::utils)
+#target_compile_definitions(detray_tutorial_propagation_cuda PRIVATE array=array)
diff --git a/tutorials/src/device/cuda/detector_construction.cpp b/tutorials/src/device/cuda/detector_construction.cpp
index 481af92a7..23324e1bc 100644
--- a/tutorials/src/device/cuda/detector_construction.cpp
+++ b/tutorials/src/device/cuda/detector_construction.cpp
@@ -9,6 +9,7 @@
 #include "detector_construction.hpp"
 
 #include "detray/detectors/bfield.hpp"
+#include "detray/detectors/create_toy_geometry.hpp"
 
 // Vecmem include(s)
 #include <vecmem/memory/cuda/device_memory_resource.hpp>
diff --git a/tutorials/src/device/cuda/detector_construction.hpp b/tutorials/src/device/cuda/detector_construction.hpp
index 7a4304d2e..23a199217 100644
--- a/tutorials/src/device/cuda/detector_construction.hpp
+++ b/tutorials/src/device/cuda/detector_construction.hpp
@@ -8,8 +8,9 @@
 #pragma once
 
 // Project include(s).
+#include "detray/core/detector.hpp"
 #include "detray/definitions/units.hpp"
-#include "detray/detectors/create_toy_geometry.hpp"
+#include "detray/detectors/toy_metadata.hpp"
 #include "detray/tutorial/types.hpp"
 
 namespace detray::tutorial {
diff --git a/tutorials/src/device/cuda/propagation.cpp b/tutorials/src/device/cuda/propagation.cpp
index 0ab090dab..5fa882c06 100644
--- a/tutorials/src/device/cuda/propagation.cpp
+++ b/tutorials/src/device/cuda/propagation.cpp
@@ -8,6 +8,7 @@
 // Project include(s)
 #include "propagation.hpp"
 
+#include "detray/detectors/create_toy_geometry.hpp"
 #include "detray/simulation/event_generator/track_generators.hpp"
 
 // Vecmem include(s)
@@ -16,23 +17,23 @@
 
 #include "vecmem/utils/cuda/copy.hpp"
 
+// System
+
 /// Prepare the data and move it to device
 int main() {
     // VecMem memory resource(s)
     vecmem::cuda::managed_memory_resource mng_mr;
 
-    // Set the magnetic field
+    // Create the bfield
+    const auto B =
+        detray::tutorial::vector3{0. * detray::unit<detray::scalar>::T,
+                                  0. * detray::unit<detray::scalar>::T,
+                                  2. * detray::unit<detray::scalar>::T};
 
-    // Define the name of the input file: use detray unittest data in this case
-    const std::string field_file = !std::getenv("DETRAY_BFIELD_FILE")
-                                       ? ""
-                                       : std::getenv("DETRAY_BFIELD_FILE");
-    detray::tutorial::field_host_t bfield =
-        detray::io::read_bfield<detray::bfield::inhom_field_t>(field_file);
+    detray::tutorial::field_t bfield = detray::bfield::create_const_field(B);
 
     // Create the toy geometry
-    detray::toy_det_config toy_cfg{};
-    auto [det, names] = detray::create_toy_geometry(mng_mr, toy_cfg);
+    auto [det, names] = detray::create_toy_geometry(mng_mr);
 
     // Create the vector of initial track parameters
     vecmem::vector<detray::free_track_parameters<detray::tutorial::transform3>>
@@ -61,10 +62,6 @@ int main() {
     auto det_data = detray::get_data(det);
     auto tracks_data = detray::get_data(tracks);
 
-    // Get the device bfield
-    detray::tutorial::field_device_t device_field(bfield);
-    detray::tutorial::field_device_t::view_t device_field_view(device_field);
-
     // Create navigator candidates buffer
     vecmem::copy copy;  //< Helper object for performing memory copies.
     auto candidates_buffer =
@@ -72,6 +69,6 @@ int main() {
     copy.setup(candidates_buffer);
 
     // Run the propagator test for GPU device
-    detray::tutorial::propagation(det_data, device_field_view, tracks_data,
+    detray::tutorial::propagation(det_data, bfield, tracks_data,
                                   candidates_buffer);
 }
diff --git a/tutorials/src/device/cuda/propagation.hpp b/tutorials/src/device/cuda/propagation.hpp
index 452175abb..6c8e1c07f 100644
--- a/tutorials/src/device/cuda/propagation.hpp
+++ b/tutorials/src/device/cuda/propagation.hpp
@@ -8,9 +8,10 @@
 #pragma once
 
 // Project include(s).
+#include "detray/core/detector.hpp"
 #include "detray/definitions/units.hpp"
 #include "detray/detectors/bfield.hpp"
-#include "detray/detectors/create_toy_geometry.hpp"
+#include "detray/detectors/toy_metadata.hpp"
 #include "detray/propagator/actor_chain.hpp"
 #include "detray/propagator/actors/aborters.hpp"
 #include "detray/propagator/actors/parameter_resetter.hpp"
@@ -22,9 +23,6 @@
 #include "detray/tracks/tracks.hpp"
 #include "detray/tutorial/types.hpp"
 
-// Covfie include(s)
-#include <covfie/cuda/backend/primitive/cuda_device_array.hpp>
-
 namespace detray::tutorial {
 
 // Detector
@@ -36,18 +34,9 @@ using detector_device_t =
 using navigator_t = navigator<detector_device_t>;
 using intersection_t = navigator_t::intersection_type;
 
-// Magnetic field types
-using inhom_cuda_bknd_t = covfie::backend::affine<
-    covfie::backend::nearest_neighbour<covfie::backend::strided<
-        covfie::vector::ulong3,
-        covfie::backend::cuda_device_array<
-            covfie::vector::vector_d<detray::scalar, 3>>>>>;
-using field_host_t = covfie::field<detray::bfield::inhom_bknd_t>;
-using field_device_t = covfie::field<inhom_cuda_bknd_t>;
-
-// Stepper (only running device propagation, so need the device field type)
-using stepper_t =
-    rk_stepper<field_device_t::view_t, detray::tutorial::transform3>;
+// Stepper
+using field_t = detray::bfield::const_field_t;
+using stepper_t = rk_stepper<field_t::view_t, detray::tutorial::transform3>;
 
 // Actors
 using actor_chain_t =
@@ -62,7 +51,7 @@ using propagator_t = propagator<stepper_t, navigator_t, actor_chain_t>;
 /// Propagation tutorial function
 void propagation(
     typename detector_host_t::view_type det_data,
-    covfie::field_view<inhom_cuda_bknd_t> field_data,
+    typename field_t::view_t field_data,
     const vecmem::data::vector_view<
         free_track_parameters<detray::tutorial::transform3>>
         tracks_data,
diff --git a/tutorials/src/device/cuda/propagation_kernel.cu b/tutorials/src/device/cuda/propagation_kernel.cu
index 832eff174..d832925c1 100644
--- a/tutorials/src/device/cuda/propagation_kernel.cu
+++ b/tutorials/src/device/cuda/propagation_kernel.cu
@@ -17,7 +17,7 @@ inline constexpr detray::scalar path_limit{2.f *
 /// Kernel that runs the entire propagation loop
 __global__ void propagation_kernel(
     typename detray::tutorial::detector_host_t::view_type det_data,
-    covfie::field_view<detray::tutorial::inhom_cuda_bknd_t> field_data,
+    typename detray::tutorial::field_t::view_t field_data,
     const vecmem::data::vector_view<
         detray::free_track_parameters<detray::tutorial::transform3>>
         tracks_data,
@@ -67,7 +67,7 @@ __global__ void propagation_kernel(
 
 void propagation(
     typename detray::tutorial::detector_host_t::view_type det_data,
-    covfie::field_view<detray::tutorial::inhom_cuda_bknd_t> field_data,
+    typename detray::tutorial::field_t::view_t field_data,
     const vecmem::data::vector_view<
         detray::free_track_parameters<detray::tutorial::transform3>>
         tracks_data,
diff --git a/utils/include/detray/detectors/create_telescope_detector.hpp b/utils/include/detray/detectors/create_telescope_detector.hpp
index 94bd799da..76f824011 100644
--- a/utils/include/detray/detectors/create_telescope_detector.hpp
+++ b/utils/include/detray/detectors/create_telescope_detector.hpp
@@ -45,7 +45,7 @@ struct tel_det_config {
     template <
         typename... Args,
         std::enable_if_t<(std::is_same_v<Args, scalar> || ...), bool> = true>
-    tel_det_config(Args &&...args) : m_mask(0u, std::forward<Args>(args)...) {}
+    tel_det_config(Args &&... args) : m_mask(0u, std::forward<Args>(args)...) {}
 
     /// Mask of the test surfaces
     mask<mask_shape_t> m_mask;

From 842a31de61477ce7ada55de2d093189d279f1f2f Mon Sep 17 00:00:00 2001
From: beomki-yeo <beomki.yeo@gmail.com>
Date: Wed, 18 Oct 2023 13:59:22 +0200
Subject: [PATCH 21/29] Remove covfie library from detector construction
 tutorial

---
 tutorials/src/device/cuda/CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tutorials/src/device/cuda/CMakeLists.txt b/tutorials/src/device/cuda/CMakeLists.txt
index 2fc286db5..4f632690d 100644
--- a/tutorials/src/device/cuda/CMakeLists.txt
+++ b/tutorials/src/device/cuda/CMakeLists.txt
@@ -18,7 +18,7 @@ detray_add_tutorial( detector_construction_cuda
    "detector_construction.cpp"
    "detector_construction.hpp"
    "detector_construction.cu"
-   LINK_LIBRARIES vecmem::cuda detray::core_array covfie::core
+   LINK_LIBRARIES vecmem::cuda detray::core_array
                   detray::tutorial detray::utils)
 target_compile_definitions(detray_tutorial_detector_construction_cuda PRIVATE array=array)
 

From 3e947cd01b3d76e9cb160c7f7e906c57b9ff855a Mon Sep 17 00:00:00 2001
From: beomki-yeo <beomki.yeo@gmail.com>
Date: Wed, 18 Oct 2023 15:10:48 +0200
Subject: [PATCH 22/29] Disable detector construction tuto

---
 tutorials/src/device/cuda/CMakeLists.txt | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/tutorials/src/device/cuda/CMakeLists.txt b/tutorials/src/device/cuda/CMakeLists.txt
index 4f632690d..91849c0b1 100644
--- a/tutorials/src/device/cuda/CMakeLists.txt
+++ b/tutorials/src/device/cuda/CMakeLists.txt
@@ -14,13 +14,13 @@ enable_language(CUDA)
 include(detray-compiler-options-cuda)
 
 # Examples using the array algebra plugin.
-detray_add_tutorial( detector_construction_cuda
-   "detector_construction.cpp"
-   "detector_construction.hpp"
-   "detector_construction.cu"
-   LINK_LIBRARIES vecmem::cuda detray::core_array
-                  detray::tutorial detray::utils)
-target_compile_definitions(detray_tutorial_detector_construction_cuda PRIVATE array=array)
+#detray_add_tutorial( detector_construction_cuda
+#   "detector_construction.cpp"
+#   "detector_construction.hpp"
+#   "detector_construction.cu"
+#   LINK_LIBRARIES vecmem::cuda detray::core_array
+#                  detray::tutorial detray::utils)
+#target_compile_definitions(detray_tutorial_detector_construction_cuda PRIVATE array=array)
 
 #detray_add_tutorial( propagation_cuda
 #   "propagation.cpp"

From 0de1c16da3579d8913f2b3adc56607031bf3dc02 Mon Sep 17 00:00:00 2001
From: Joana Niermann <joana.niermann@cern.ch>
Date: Wed, 18 Oct 2023 14:37:15 +0200
Subject: [PATCH 23/29] Silencing the covfie warnings for the tutorial the same
 way as for the unittests. Also switches the propagation tutorial to use an
 inhomogeneous bfield (the ODD solenoid field).

---
 tutorials/CMakeLists.txt                      |  1 +
 tutorials/src/device/cuda/CMakeLists.txt      | 28 +++++++++----------
 .../src/device/cuda/detector_construction.cpp |  1 -
 tutorials/src/device/cuda/propagation.cpp     | 16 ++++-------
 tutorials/src/device/cuda/propagation.hpp     | 23 +++++++++++++--
 .../src/device/cuda/propagation_kernel.cu     |  4 +--
 utils/include/detray/detectors/bfield.hpp     |  6 ++--
 7 files changed, 46 insertions(+), 33 deletions(-)

diff --git a/tutorials/CMakeLists.txt b/tutorials/CMakeLists.txt
index 83731b4d4..b714631c3 100644
--- a/tutorials/CMakeLists.txt
+++ b/tutorials/CMakeLists.txt
@@ -6,6 +6,7 @@
 
 # Set the common C++ flags.
 include( detray-compiler-options-cpp )
+include_directories( SYSTEM $<TARGET_PROPERTY:covfie::core,INTERFACE_INCLUDE_DIRECTORIES> )
 
 # Set up a tutorial library, which showcases how to use detray components.
 file( GLOB _detray_tutorial_headers
diff --git a/tutorials/src/device/cuda/CMakeLists.txt b/tutorials/src/device/cuda/CMakeLists.txt
index 91849c0b1..08b787d64 100644
--- a/tutorials/src/device/cuda/CMakeLists.txt
+++ b/tutorials/src/device/cuda/CMakeLists.txt
@@ -14,18 +14,18 @@ enable_language(CUDA)
 include(detray-compiler-options-cuda)
 
 # Examples using the array algebra plugin.
-#detray_add_tutorial( detector_construction_cuda
-#   "detector_construction.cpp"
-#   "detector_construction.hpp"
-#   "detector_construction.cu"
-#   LINK_LIBRARIES vecmem::cuda detray::core_array
-#                  detray::tutorial detray::utils)
-#target_compile_definitions(detray_tutorial_detector_construction_cuda PRIVATE array=array)
+detray_add_tutorial( detector_construction_cuda
+   "detector_construction.cpp"
+   "detector_construction.hpp"
+   "detector_construction.cu"
+   LINK_LIBRARIES vecmem::cuda detray::core_array detray::tutorial
+                  detray::utils)
+target_compile_definitions(detray_tutorial_detector_construction_cuda PRIVATE array=array)
 
-#detray_add_tutorial( propagation_cuda
-#   "propagation.cpp"
-#   "propagation.hpp"
-#   "propagation_kernel.cu"
-#   LINK_LIBRARIES vecmem::cuda detray::core_array covfie::core covfie::cuda
-#                  detray::tutorial detray::utils)
-#target_compile_definitions(detray_tutorial_propagation_cuda PRIVATE array=array)
+detray_add_tutorial( propagation_cuda
+   "propagation.cpp"
+   "propagation.hpp"
+   "propagation_kernel.cu"
+   LINK_LIBRARIES vecmem::cuda detray::core_array covfie::core covfie::cuda
+                  detray::tutorial detray::utils)
+target_compile_definitions(detray_tutorial_propagation_cuda PRIVATE array=array)
diff --git a/tutorials/src/device/cuda/detector_construction.cpp b/tutorials/src/device/cuda/detector_construction.cpp
index 23324e1bc..af853dae7 100644
--- a/tutorials/src/device/cuda/detector_construction.cpp
+++ b/tutorials/src/device/cuda/detector_construction.cpp
@@ -8,7 +8,6 @@
 // Project include(s)
 #include "detector_construction.hpp"
 
-#include "detray/detectors/bfield.hpp"
 #include "detray/detectors/create_toy_geometry.hpp"
 
 // Vecmem include(s)
diff --git a/tutorials/src/device/cuda/propagation.cpp b/tutorials/src/device/cuda/propagation.cpp
index 5fa882c06..35e23ceb3 100644
--- a/tutorials/src/device/cuda/propagation.cpp
+++ b/tutorials/src/device/cuda/propagation.cpp
@@ -14,8 +14,7 @@
 // Vecmem include(s)
 #include <vecmem/memory/cuda/device_memory_resource.hpp>
 #include <vecmem/memory/cuda/managed_memory_resource.hpp>
-
-#include "vecmem/utils/cuda/copy.hpp"
+#include <vecmem/utils/cuda/copy.hpp>
 
 // System
 
@@ -24,13 +23,8 @@ int main() {
     // VecMem memory resource(s)
     vecmem::cuda::managed_memory_resource mng_mr;
 
-    // Create the bfield
-    const auto B =
-        detray::tutorial::vector3{0. * detray::unit<detray::scalar>::T,
-                                  0. * detray::unit<detray::scalar>::T,
-                                  2. * detray::unit<detray::scalar>::T};
-
-    detray::tutorial::field_t bfield = detray::bfield::create_const_field(B);
+    // Create the host bfield
+    auto bfield = detray::bfield::create_inhom_field();
 
     // Create the toy geometry
     auto [det, names] = detray::create_toy_geometry(mng_mr);
@@ -60,6 +54,8 @@ int main() {
 
     // Get data for device
     auto det_data = detray::get_data(det);
+    covfie::field<detray::tutorial::bfield::cuda::inhom_bknd_t> device_bfield(
+        bfield);
     auto tracks_data = detray::get_data(tracks);
 
     // Create navigator candidates buffer
@@ -69,6 +65,6 @@ int main() {
     copy.setup(candidates_buffer);
 
     // Run the propagator test for GPU device
-    detray::tutorial::propagation(det_data, bfield, tracks_data,
+    detray::tutorial::propagation(det_data, device_bfield, tracks_data,
                                   candidates_buffer);
 }
diff --git a/tutorials/src/device/cuda/propagation.hpp b/tutorials/src/device/cuda/propagation.hpp
index 6c8e1c07f..bced2dea8 100644
--- a/tutorials/src/device/cuda/propagation.hpp
+++ b/tutorials/src/device/cuda/propagation.hpp
@@ -23,8 +23,22 @@
 #include "detray/tracks/tracks.hpp"
 #include "detray/tutorial/types.hpp"
 
+// Covfie include(s)
+#include <covfie/cuda/backend/primitive/cuda_device_array.hpp>
+
 namespace detray::tutorial {
 
+namespace bfield::cuda {
+
+// Inhomogeneous field (cuda)
+using inhom_bknd_t = covfie::backend::affine<
+    covfie::backend::nearest_neighbour<covfie::backend::strided<
+        covfie::vector::ulong3,
+        covfie::backend::cuda_device_array<
+            covfie::vector::vector_d<detray::scalar, 3>>>>>;
+
+}  // namespace bfield::cuda
+
 // Detector
 using detector_host_t = detector<detray::toy_metadata, host_container_types>;
 using detector_device_t =
@@ -35,8 +49,11 @@ using navigator_t = navigator<detector_device_t>;
 using intersection_t = navigator_t::intersection_type;
 
 // Stepper
-using field_t = detray::bfield::const_field_t;
-using stepper_t = rk_stepper<field_t::view_t, detray::tutorial::transform3>;
+using host_field_t = covfie::field<detray::bfield::inhom_bknd_t>;
+using device_field_t =
+    covfie::field<detray::tutorial::bfield::cuda::inhom_bknd_t>;
+using stepper_t =
+    rk_stepper<device_field_t::view_t, detray::tutorial::transform3>;
 
 // Actors
 using actor_chain_t =
@@ -51,7 +68,7 @@ using propagator_t = propagator<stepper_t, navigator_t, actor_chain_t>;
 /// Propagation tutorial function
 void propagation(
     typename detector_host_t::view_type det_data,
-    typename field_t::view_t field_data,
+    typename device_field_t::view_t field_data,
     const vecmem::data::vector_view<
         free_track_parameters<detray::tutorial::transform3>>
         tracks_data,
diff --git a/tutorials/src/device/cuda/propagation_kernel.cu b/tutorials/src/device/cuda/propagation_kernel.cu
index d832925c1..d5dbafe53 100644
--- a/tutorials/src/device/cuda/propagation_kernel.cu
+++ b/tutorials/src/device/cuda/propagation_kernel.cu
@@ -17,7 +17,7 @@ inline constexpr detray::scalar path_limit{2.f *
 /// Kernel that runs the entire propagation loop
 __global__ void propagation_kernel(
     typename detray::tutorial::detector_host_t::view_type det_data,
-    typename detray::tutorial::field_t::view_t field_data,
+    typename detray::tutorial::device_field_t::view_t field_data,
     const vecmem::data::vector_view<
         detray::free_track_parameters<detray::tutorial::transform3>>
         tracks_data,
@@ -67,7 +67,7 @@ __global__ void propagation_kernel(
 
 void propagation(
     typename detray::tutorial::detector_host_t::view_type det_data,
-    typename detray::tutorial::field_t::view_t field_data,
+    typename detray::tutorial::device_field_t::view_t field_data,
     const vecmem::data::vector_view<
         detray::free_track_parameters<detray::tutorial::transform3>>
         tracks_data,
diff --git a/utils/include/detray/detectors/bfield.hpp b/utils/include/detray/detectors/bfield.hpp
index 0216913eb..2415226cd 100644
--- a/utils/include/detray/detectors/bfield.hpp
+++ b/utils/include/detray/detectors/bfield.hpp
@@ -22,8 +22,8 @@ namespace detray::bfield {
 
 /// Constant bfield (host and device)
 using const_bknd_t =
-    covfie::backend::constant<covfie::vector::vector_d<scalar, 3>,
-                              covfie::vector::vector_d<scalar, 3>>;
+    covfie::backend::constant<covfie::vector::vector_d<detray::scalar, 3>,
+                              covfie::vector::vector_d<detray::scalar, 3>>;
 
 using const_field_t = covfie::field<const_bknd_t>;
 
@@ -31,7 +31,7 @@ using const_field_t = covfie::field<const_bknd_t>;
 using inhom_bknd_t = covfie::backend::affine<
     covfie::backend::nearest_neighbour<covfie::backend::strided<
         covfie::vector::ulong3,
-        covfie::backend::array<covfie::vector::vector_d<scalar, 3>>>>>;
+        covfie::backend::array<covfie::vector::vector_d<detray::scalar, 3>>>>>;
 
 using inhom_field_t = covfie::field<inhom_bknd_t>;
 

From 78c4adbf83754a3f0a3a1ac9185c4603831c734d Mon Sep 17 00:00:00 2001
From: beomki-yeo <beomki.yeo@gmail.com>
Date: Thu, 19 Oct 2023 16:03:18 +0200
Subject: [PATCH 24/29] Add b field type declaration in stepper

---
 core/include/detray/propagator/rk_stepper.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/core/include/detray/propagator/rk_stepper.hpp b/core/include/detray/propagator/rk_stepper.hpp
index b91a2e0e9..1e929110d 100644
--- a/core/include/detray/propagator/rk_stepper.hpp
+++ b/core/include/detray/propagator/rk_stepper.hpp
@@ -42,6 +42,7 @@ class rk_stepper final
         typename base_type::free_track_parameters_type;
     using bound_track_parameters_type =
         typename base_type::bound_track_parameters_type;
+    using magnetic_field_type = magnetic_field_t;
 
     DETRAY_HOST_DEVICE
     rk_stepper() {}

From feb511fc261522da375e825463d9ae42f044f94e Mon Sep 17 00:00:00 2001
From: Joana Niermann <joana.niermann@cern.ch>
Date: Thu, 19 Oct 2023 10:52:27 +0200
Subject: [PATCH 25/29] Add device container specializations for the view type
 handling

---
 .../detray/core/detail/container_buffers.hpp  | 13 ++++++++
 .../detray/core/detail/container_views.hpp    | 32 +++++++++++++++++--
 core/include/detray/core/detector.hpp         |  9 ++++++
 .../common/test_base/propagator_test.hpp      | 19 ++++-------
 .../device/cuda/propagator_cuda_kernel.cu     | 24 ++++++++++----
 .../device/cuda/propagator_cuda_kernel.hpp    |  2 ++
 .../device/sycl/propagator_kernel.sycl        | 27 ++++++++++++----
 .../device/sycl/propagator_sycl_kernel.hpp    |  2 ++
 8 files changed, 101 insertions(+), 27 deletions(-)

diff --git a/core/include/detray/core/detail/container_buffers.hpp b/core/include/detray/core/detail/container_buffers.hpp
index 0c5f3998f..e2e9d82d8 100644
--- a/core/include/detray/core/detail/container_buffers.hpp
+++ b/core/include/detray/core/detail/container_buffers.hpp
@@ -126,6 +126,19 @@ struct has_buffer<const vecmem::vector<T>, void> : public std::true_type {
     using type = vecmem::data::vector_buffer<const T>;
 };
 
+/// Specialization of the buffer getter for @c vecmem::device_vector
+template <typename T>
+struct has_buffer<vecmem::device_vector<T>, void> : public std::true_type {
+    using type = vecmem::data::vector_buffer<T>;
+};
+
+/// Specialization of the buffer getter for @c vecmem::device_vector - const
+template <typename T>
+struct has_buffer<const vecmem::device_vector<T>, void>
+    : public std::true_type {
+    using type = vecmem::data::vector_buffer<const T>;
+};
+
 template <class T>
 inline constexpr bool has_buffer_v = has_buffer<T>::value;
 
diff --git a/core/include/detray/core/detail/container_views.hpp b/core/include/detray/core/detail/container_views.hpp
index e49ccae97..833221f2b 100644
--- a/core/include/detray/core/detail/container_views.hpp
+++ b/core/include/detray/core/detail/container_views.hpp
@@ -169,12 +169,26 @@ struct detail::has_view<vecmem::vector<T>, void> : public std::true_type {
     using type = dvector_view<T>;
 };
 
-/// Specialization of the view getter for @c vecmem::vector
+/// Specialization of the view getter for @c vecmem::vector - const
 template <typename T>
 struct detail::has_view<const vecmem::vector<T>, void> : public std::true_type {
     using type = dvector_view<const T>;
 };
 
+/// Specialization of the view getter for @c vecmem::device_vector
+template <typename T>
+struct detail::has_view<vecmem::device_vector<T>, void>
+    : public std::true_type {
+    using type = dvector_view<T>;
+};
+
+/// Specialization of the view getter for @c vecmem::device_vector - const
+template <typename T>
+struct detail::has_view<const vecmem::device_vector<T>, void>
+    : public std::true_type {
+    using type = dvector_view<const T>;
+};
+
 /// Specialized view for @c vecmem::jagged_vector containers
 template <typename T>
 using djagged_vector_view = vecmem::data::jagged_vector_view<T>;
@@ -198,13 +212,27 @@ struct detail::has_view<vecmem::jagged_vector<T>, void>
     using type = djagged_vector_view<T>;
 };
 
-/// Specialization of the view getter for @c vecmem::jagged_vector
+/// Specialization of the view getter for @c vecmem::jagged_vector - const
 template <typename T>
 struct detail::has_view<const vecmem::jagged_vector<T>, void>
     : public std::true_type {
     using type = djagged_vector_view<const T>;
 };
 
+/// Specialization of the view getter for @c vecmem::jagged_device_vector
+template <typename T>
+struct detail::has_view<vecmem::jagged_device_vector<T>, void>
+    : public std::true_type {
+    using type = djagged_vector_view<T>;
+};
+
+/// Specialization of the view getter for @c vecmem::jagged_device_vector
+/// - const
+template <typename T>
+struct detail::has_view<const vecmem::jagged_device_vector<T>, void>
+    : public std::true_type {
+    using type = djagged_vector_view<const T>;
+};
 /// @}
 
 }  // namespace detray
diff --git a/core/include/detray/core/detector.hpp b/core/include/detray/core/detector.hpp
index 9dbcd4391..10d06c311 100644
--- a/core/include/detray/core/detector.hpp
+++ b/core/include/detray/core/detector.hpp
@@ -131,6 +131,9 @@ class detector {
         typename surface_container::view_type, dvector_view<surface_type>,
         typename volume_finder::view_type>;
 
+    static_assert(detail::is_device_view_v<view_type>,
+                  "Detector view type ill-formed");
+
     using const_view_type =
         dmulti_view<dvector_view<const volume_type>,
                     typename transform_container::const_view_type,
@@ -140,6 +143,9 @@ class detector {
                     dvector_view<const surface_type>,
                     typename volume_finder::const_view_type>;
 
+    static_assert(detail::is_device_view_v<const_view_type>,
+                  "Detector const view type ill-formed");
+
     /// Detector buffer types
     using buffer_type = dmulti_buffer<
         dvector_buffer<volume_type>, typename transform_container::buffer_type,
@@ -148,6 +154,9 @@ class detector {
         typename surface_container::buffer_type, dvector_buffer<surface_type>,
         typename volume_finder::buffer_type>;
 
+    static_assert(detail::is_buffer_v<buffer_type>,
+                  "Detector buffer type ill-formed");
+
     detector() = delete;
     // The detector holds a lot of data and should never be copied
     detector(const detector &) = delete;
diff --git a/tests/common/include/tests/common/test_base/propagator_test.hpp b/tests/common/include/tests/common/test_base/propagator_test.hpp
index b1286696a..98fe1fc69 100644
--- a/tests/common/include/tests/common/test_base/propagator_test.hpp
+++ b/tests/common/include/tests/common/test_base/propagator_test.hpp
@@ -10,8 +10,6 @@
 // Project include(s).
 #include "detray/definitions/algebra.hpp"
 #include "detray/definitions/units.hpp"
-#include "detray/detectors/bfield.hpp"
-#include "detray/detectors/toy_metadata.hpp"
 #include "detray/propagator/actor_chain.hpp"
 #include "detray/propagator/actors/aborters.hpp"
 #include "detray/propagator/actors/parameter_resetter.hpp"
@@ -27,6 +25,9 @@
 // Vecmem include(s)
 #include <vecmem/memory/memory_resource.hpp>
 
+// Covfie include(s)
+#include <covfie/core/field.hpp>
+
 // GTest include(s).
 #include <gtest/gtest.h>
 
@@ -35,14 +36,8 @@
 
 namespace detray {
 
-// Host detector type
-using detector_host_t = detector<toy_metadata, host_container_types>;
-
-// Device detector type using views
-using detector_device_t = detector<toy_metadata, device_container_types>;
-
 // These types are identical in host and device code for all bfield types
-using transform3 = typename detector_host_t::transform3;
+using transform3 = __plugin::transform3<detray::scalar>;
 using vector3_t = typename transform3::vector3;
 using point3_t = typename transform3::point3;
 using matrix_operator = standard_matrix_operator<scalar>;
@@ -147,9 +142,9 @@ inline vecmem::vector<track_t> generate_tracks(
 }
 
 /// Test function for propagator on the host
-template <typename bfield_bknd_t>
+template <typename bfield_bknd_t, typename host_detector_t>
 inline auto run_propagation_host(vecmem::memory_resource *mr,
-                                 const detector_host_t &det,
+                                 const host_detector_t &det,
                                  covfie::field<bfield_bknd_t> &field,
                                  const vecmem::vector<track_t> &tracks)
     -> std::tuple<vecmem::jagged_vector<scalar>,
@@ -158,7 +153,7 @@ inline auto run_propagation_host(vecmem::memory_resource *mr,
 
     // Construct propagator from stepper and navigator
     auto stepr = rk_stepper_t<typename covfie::field<bfield_bknd_t>::view_t>{};
-    auto nav = navigator_t<detector_host_t>{};
+    auto nav = navigator_t<host_detector_t>{};
 
     using propagator_host_t =
         propagator<decltype(stepr), decltype(nav), actor_chain_host_t>;
diff --git a/tests/unit_tests/device/cuda/propagator_cuda_kernel.cu b/tests/unit_tests/device/cuda/propagator_cuda_kernel.cu
index e44f29d0d..98c8bf5f3 100644
--- a/tests/unit_tests/device/cuda/propagator_cuda_kernel.cu
+++ b/tests/unit_tests/device/cuda/propagator_cuda_kernel.cu
@@ -22,6 +22,12 @@ __global__ void propagator_test_kernel(
     vecmem::data::jagged_vector_view<free_matrix> jac_transports_data) {
 
     int gid = threadIdx.x + blockIdx.x * blockDim.x;
+    using detector_device_t =
+        detector<typename detector_t::metadata, device_container_types>;
+
+    static_assert(std::is_same_v<typename detector_t::view_type,
+                                 typename detector_device_t::view_type>,
+                  "Host and device detector views do not match");
 
     detector_device_t det(det_data);
     vecmem::device_vector<track_t> tracks(tracks_data);
@@ -96,19 +102,25 @@ void propagator_test(
 }
 
 /// Explicit instantiation for a constant magnetic field
-template void propagator_test<bfield::const_bknd_t, detector_host_t>(
-    detector_host_t::view_type, covfie::field_view<bfield::const_bknd_t>,
+template void propagator_test<bfield::const_bknd_t,
+                              detector<toy_metadata, host_container_types>>(
+    detector<toy_metadata, host_container_types>::view_type,
+    covfie::field_view<bfield::const_bknd_t>,
     vecmem::data::vector_view<track_t>&,
-    vecmem::data::jagged_vector_view<intersection_t<detector_host_t>>&,
+    vecmem::data::jagged_vector_view<
+        intersection_t<detector<toy_metadata, host_container_types>>>&,
     vecmem::data::jagged_vector_view<scalar>&,
     vecmem::data::jagged_vector_view<vector3_t>&,
     vecmem::data::jagged_vector_view<free_matrix>&);
 
 /// Explicit instantiation for an inhomogeneous magnetic field
-template void propagator_test<bfield::cuda::inhom_bknd_t, detector_host_t>(
-    detector_host_t::view_type, covfie::field_view<bfield::cuda::inhom_bknd_t>,
+template void propagator_test<bfield::cuda::inhom_bknd_t,
+                              detector<toy_metadata, host_container_types>>(
+    detector<toy_metadata, host_container_types>::view_type,
+    covfie::field_view<bfield::cuda::inhom_bknd_t>,
     vecmem::data::vector_view<track_t>&,
-    vecmem::data::jagged_vector_view<intersection_t<detector_host_t>>&,
+    vecmem::data::jagged_vector_view<
+        intersection_t<detector<toy_metadata, host_container_types>>>&,
     vecmem::data::jagged_vector_view<scalar>&,
     vecmem::data::jagged_vector_view<vector3_t>&,
     vecmem::data::jagged_vector_view<free_matrix>&);
diff --git a/tests/unit_tests/device/cuda/propagator_cuda_kernel.hpp b/tests/unit_tests/device/cuda/propagator_cuda_kernel.hpp
index 8200fe648..7274e0ce9 100644
--- a/tests/unit_tests/device/cuda/propagator_cuda_kernel.hpp
+++ b/tests/unit_tests/device/cuda/propagator_cuda_kernel.hpp
@@ -8,6 +8,8 @@
 #pragma once
 
 // Project include(s)
+#include "detray/detectors/bfield.hpp"
+#include "detray/detectors/toy_metadata.hpp"
 #include "tests/common/test_base/propagator_test.hpp"
 
 // Vecmem include(s)
diff --git a/tests/unit_tests/device/sycl/propagator_kernel.sycl b/tests/unit_tests/device/sycl/propagator_kernel.sycl
index 1e0f5d043..f605f3f51 100644
--- a/tests/unit_tests/device/sycl/propagator_kernel.sycl
+++ b/tests/unit_tests/device/sycl/propagator_kernel.sycl
@@ -36,6 +36,15 @@ void propagator_test(
                                      candidates_data, path_lengths_data,
                                      positions_data, jac_transports_data](
                                         ::sycl::nd_item<1> item) {
+                using detector_device_t =
+                    detector<typename detector_t::metadata,
+                             device_container_types>;
+
+                static_assert(
+                    std::is_same_v<typename detector_t::view_type,
+                                   typename detector_device_t::view_type>,
+                    "Host and device detector views do not match");
+
                 detector_device_t dev_det(det_data);
 
                 vecmem::device_vector<track_t> tracks(tracks_data);
@@ -94,22 +103,26 @@ void propagator_test(
 }
 
 /// Explicit instantiation for a constant magnetic field
-template void propagator_test<bfield::const_bknd_t, detector_host_t>(
-    detector_host_t::view_type, covfie::field_view<bfield::const_bknd_t>,
+template void propagator_test<bfield::const_bknd_t,
+                              detector<toy_metadata, host_container_types>>(
+    detector<toy_metadata, host_container_types>::view_type,
+    covfie::field_view<bfield::const_bknd_t>,
     vecmem::data::vector_view<track_t>&,
-    vecmem::data::jagged_vector_view<intersection_t<detector_host_t>>&,
+    vecmem::data::jagged_vector_view<
+        intersection_t<detector<toy_metadata, host_container_types>>>&,
     vecmem::data::jagged_vector_view<scalar>&,
     vecmem::data::jagged_vector_view<vector3_t>&,
     vecmem::data::jagged_vector_view<free_matrix>&,
     detray::sycl::queue_wrapper);
 
 /// Explicit instantiation for an inhomogeneous magnetic field
-/*template void propagator_test<bfield::sycl::inhom_bknd_t, detector_host_t>(
-    detector_host_t::view_type,
+/*template void propagator_test<bfield::sycl::inhom_bknd_t,
+   detector<toy_metadata, host_container_types>>( detector<toy_metadata,
+   host_container_types>::view_type,
     covfie::field_view<bfield::sycl::inhom_bknd_t>,
     vecmem::data::vector_view<track_t>&,
-    vecmem::data::jagged_vector_view<intersection_t<detector_host_t>>&,
-    vecmem::data::jagged_vector_view<scalar>&,
+    vecmem::data::jagged_vector_view<intersection_t<detector<toy_metadata,
+   host_container_types>>>&, vecmem::data::jagged_vector_view<scalar>&,
     vecmem::data::jagged_vector_view<vector3_t>&,
     vecmem::data::jagged_vector_view<free_matrix>&,
     detray::sycl::queue_wrapper);*/
diff --git a/tests/unit_tests/device/sycl/propagator_sycl_kernel.hpp b/tests/unit_tests/device/sycl/propagator_sycl_kernel.hpp
index 3fd35cd1a..4f631ed27 100644
--- a/tests/unit_tests/device/sycl/propagator_sycl_kernel.hpp
+++ b/tests/unit_tests/device/sycl/propagator_sycl_kernel.hpp
@@ -8,6 +8,8 @@
 #pragma once
 
 // Project include(s)
+#include "detray/detectors/bfield.hpp"
+#include "detray/detectors/toy_metadata.hpp"
 #include "queue_wrapper.hpp"
 #include "tests/common/test_base/propagator_test.hpp"
 

From f67f95803f2ea42fb422f510d32a1eda1344e313 Mon Sep 17 00:00:00 2001
From: Joana Niermann <53186085+niermann999@users.noreply.github.com>
Date: Tue, 24 Oct 2023 15:57:30 +0000
Subject: [PATCH 26/29] ref: rename surface store (#574)

After the merging of the surface acceleration structures with the surface vector did not work, this PR restores the naming of the data stores. Also correctly passes the source links on to the surfaces in the geometry IO and restricts the type ids to 8bits
---
 core/include/detray/core/detector.hpp         | 147 ++++++++--------
 .../include/detray/core/detector_metadata.hpp |  16 +-
 .../geometry/detail/surface_descriptor.hpp    |   5 +-
 .../geometry/detail/volume_descriptor.hpp     |  12 +-
 .../detray/geometry/detail/volume_kernels.hpp |  11 +-
 .../detray/geometry/detector_volume.hpp       |   6 +-
 core/include/detray/geometry/volume_graph.hpp |   1 -
 .../detray/tools/cuboid_portal_generator.hpp  |   2 +-
 core/include/detray/tools/grid_builder.hpp    |  10 +-
 .../include/detray/tools/material_factory.hpp |   2 +-
 core/include/detray/tools/surface_factory.hpp |  12 +-
 .../tools/surface_factory_interface.hpp       |  16 +-
 core/include/detray/tools/volume_builder.hpp  |  10 +-
 .../detray/tools/volume_builder_interface.hpp |   4 +-
 .../detray/utils/consistency_checker.hpp      |   4 +-
 .../detray/io/common/geometry_reader.hpp      |  31 ++--
 .../detray/io/common/geometry_writer.hpp      |   6 +-
 io/include/detray/io/common/grid_reader.hpp   |   2 +-
 io/include/detray/io/common/grid_writer.hpp   |   8 +-
 io/include/detray/io/common/payloads.hpp      |   2 +-
 .../tests/common/test_toy_detector.hpp        | 164 +++++++++---------
 tests/unit_tests/cpu/core_detector.cpp        |  37 ++--
 tests/unit_tests/cpu/geometry_volume.cpp      |  19 +-
 tests/unit_tests/cpu/grid_grid_builder.cpp    |  10 +-
 .../device/cuda/detector_cuda_kernel.cu       |   6 +-
 .../detray/tutorial/detector_metadata.hpp     |  14 +-
 .../tutorial/square_surface_generator.hpp     |   2 +-
 .../src/device/cuda/detector_construction.cpp |  16 +-
 .../src/device/cuda/detector_construction.cu  |   6 +-
 .../src/device/cuda/detector_construction.hpp |   2 +-
 .../detectors/create_telescope_detector.hpp   |   4 +-
 .../detray/detectors/create_toy_geometry.hpp  |  42 ++---
 .../detray/detectors/create_wire_chamber.hpp  |  11 +-
 .../detray/detectors/detector_helper.hpp      |   4 +-
 .../include/detray/detectors/itk_metadata.hpp |  16 +-
 .../detray/detectors/telescope_metadata.hpp   |  16 +-
 .../include/detray/detectors/toy_metadata.hpp |  16 +-
 37 files changed, 353 insertions(+), 339 deletions(-)

diff --git a/core/include/detray/core/detector.hpp b/core/include/detray/core/detector.hpp
index 10d06c311..db42792e9 100644
--- a/core/include/detray/core/detector.hpp
+++ b/core/include/detray/core/detector.hpp
@@ -76,6 +76,13 @@ class detector {
     /// In case the detector needs to be printed
     using name_map = std::map<dindex, std::string>;
 
+    /// The surface takes a mask (defines the local coordinates and the surface
+    /// extent), its material, a link to an element in the transform container
+    /// to define its placement and a source link to the object it represents.
+    using surface_type = typename metadata::surface_type;
+    using surface_container = vector_type<surface_type>;
+    using surface_lookup_container = surface_container;
+
     /// Forward the alignable transform container (surface placements) and
     /// the geo context (e.g. for alignment)
     using transform_container =
@@ -98,24 +105,14 @@ class detector {
 
     /// Surface Finders: structures that enable neigborhood searches in the
     /// detector geometry during navigation. Can be different in each volume
-    using surface_container =
-        typename metadata::template surface_finder_store<tuple_type,
-                                                         container_t>;
-    using sf_finders = typename surface_container::value_types;
-    using sf_finder_link = typename surface_container::single_link;
-
-    // TODO: Move to the following to volume builder
-
-    /// The surface takes a mask (defines the local coordinates and the surface
-    /// extent), its material, a link to an element in the transform container
-    /// to define its placement and a source link to the object it represents.
-    using surface_type = typename metadata::surface_type;
-    using surface_lookup_container = vector_type<surface_type>;
+    using accelerator_container =
+        typename metadata::template accelerator_store<tuple_type, container_t>;
+    using accel = typename accelerator_container::value_types;
+    using accel_link = typename accelerator_container::single_link;
 
-    using surface_container_t = vector_type<surface_type>;
     /// Volume type
     using geo_obj_ids = typename metadata::geo_objects;
-    using volume_type = volume_descriptor<geo_obj_ids, sf_finder_link>;
+    using volume_type = volume_descriptor<geo_obj_ids, accel_link>;
     using volume_container = vector_type<volume_type>;
 
     /// Volume finder definition: Make volume index available from track
@@ -124,35 +121,37 @@ class detector {
         typename metadata::template volume_finder<container_t>;
 
     /// Detector view types
-    using view_type = dmulti_view<
-        dvector_view<volume_type>, typename transform_container::view_type,
-        typename mask_container::view_type,
-        typename material_container::view_type,
-        typename surface_container::view_type, dvector_view<surface_type>,
-        typename volume_finder::view_type>;
+    using view_type =
+        dmulti_view<dvector_view<volume_type>, dvector_view<surface_type>,
+                    typename transform_container::view_type,
+                    typename mask_container::view_type,
+                    typename material_container::view_type,
+                    typename accelerator_container::view_type,
+                    typename volume_finder::view_type>;
 
     static_assert(detail::is_device_view_v<view_type>,
                   "Detector view type ill-formed");
 
     using const_view_type =
         dmulti_view<dvector_view<const volume_type>,
+                    dvector_view<const surface_type>,
                     typename transform_container::const_view_type,
                     typename mask_container::const_view_type,
                     typename material_container::const_view_type,
-                    typename surface_container::const_view_type,
-                    dvector_view<const surface_type>,
+                    typename accelerator_container::const_view_type,
                     typename volume_finder::const_view_type>;
 
     static_assert(detail::is_device_view_v<const_view_type>,
                   "Detector const view type ill-formed");
 
     /// Detector buffer types
-    using buffer_type = dmulti_buffer<
-        dvector_buffer<volume_type>, typename transform_container::buffer_type,
-        typename mask_container::buffer_type,
-        typename material_container::buffer_type,
-        typename surface_container::buffer_type, dvector_buffer<surface_type>,
-        typename volume_finder::buffer_type>;
+    using buffer_type =
+        dmulti_buffer<dvector_buffer<volume_type>, dvector_buffer<surface_type>,
+                      typename transform_container::buffer_type,
+                      typename mask_container::buffer_type,
+                      typename material_container::buffer_type,
+                      typename accelerator_container::buffer_type,
+                      typename volume_finder::buffer_type>;
 
     static_assert(detail::is_buffer_v<buffer_type>,
                   "Detector buffer type ill-formed");
@@ -170,11 +169,11 @@ class detector {
     DETRAY_HOST
     explicit detector(vecmem::memory_resource &resource)
         : _volumes(&resource),
+          _surfaces(&resource),
           _transforms(resource),
           _masks(resource),
           _materials(resource),
-          _surfaces(resource),
-          _surface_lookup(&resource),
+          _accelerators(resource),
           _volume_finder(resource),
           _resource(&resource) {}
 
@@ -184,18 +183,18 @@ class detector {
                   detail::is_device_view_v<detector_view_t>, bool> = true>
     DETRAY_HOST_DEVICE explicit detector(detector_view_t &det_data)
         : _volumes(detray::detail::get<0>(det_data.m_view)),
-          _transforms(detray::detail::get<1>(det_data.m_view)),
-          _masks(detray::detail::get<2>(det_data.m_view)),
-          _materials(detray::detail::get<3>(det_data.m_view)),
-          _surfaces(detray::detail::get<4>(det_data.m_view)),
-          _surface_lookup(detray::detail::get<5>(det_data.m_view)),
+          _surfaces(detray::detail::get<1>(det_data.m_view)),
+          _transforms(detray::detail::get<2>(det_data.m_view)),
+          _masks(detray::detail::get<3>(det_data.m_view)),
+          _materials(detray::detail::get<4>(det_data.m_view)),
+          _accelerators(detray::detail::get<5>(det_data.m_view)),
           _volume_finder(detray::detail::get<6>(det_data.m_view)) {}
     /// @}
 
     /// Add a new volume and retrieve a reference to it.
     ///
     /// @param id the shape id for the volume
-    /// @param sf_finder_link of the volume, where to entry the surface finder
+    /// @param accel_link of the volume, where to entry the surface finder
     ///
     /// @return non-const reference to the new volume
     DETRAY_HOST
@@ -264,13 +263,15 @@ class detector {
 
     /// @returns access to the surface finder container
     DETRAY_HOST_DEVICE
-    inline auto surface_store() const -> const surface_container & {
-        return _surfaces;
+    inline auto accelerator_store() const -> const accelerator_container & {
+        return _accelerators;
     }
 
     /// @returns access to the surface finder container
     DETRAY_HOST_DEVICE
-    inline auto surface_store() -> surface_container & { return _surfaces; }
+    inline auto accelerator_store() -> accelerator_container & {
+        return _accelerators;
+    }
 
     /// @returns all portals - const
     /// @note Depending on the detector type, this can also contain other
@@ -278,7 +279,7 @@ class detector {
     DETRAY_HOST_DEVICE
     inline const auto &portals() const {
         // In case of portals, we know where they live
-        return _surfaces.template get<sf_finders::id::e_brute_force>().all();
+        return _accelerators.template get<accel::id::e_brute_force>().all();
     }
 
     /// @returns all portals - non-const
@@ -286,7 +287,7 @@ class detector {
     /// surfaces
     DETRAY_HOST_DEVICE
     inline auto &portals() {
-        return _surfaces.template get<sf_finders::id::e_brute_force>().all();
+        return _accelerators.template get<accel::id::e_brute_force>().all();
     }
 
     /// @returns the portals of a given volume @param v - const
@@ -299,8 +300,7 @@ class detector {
             v.template link<geo_obj_ids::e_portal>().index()};
 
         const auto &pt_coll =
-            _surfaces
-                .template get<sf_finders::id::e_brute_force>()[pt_coll_idx];
+            _accelerators.template get<accel::id::e_brute_force>()[pt_coll_idx];
 
         return pt_coll.all();
     }
@@ -308,41 +308,41 @@ class detector {
     /// @return the sub-volumes of the detector - const access
     DETRAY_HOST_DEVICE
     inline auto surface_lookup() const -> const vector_type<surface_type> & {
-        return _surface_lookup;
+        return _surfaces;
     }
 
     /// @return the sub-volumes of the detector - non-const access
     DETRAY_HOST_DEVICE
     inline auto surface_lookup() -> vector_type<surface_type> & {
-        return _surface_lookup;
+        return _surfaces;
     }
 
     /// @returns a surface using its barcode - const
     DETRAY_HOST_DEVICE
     constexpr auto surface(geometry::barcode bcd) const
         -> const surface_type & {
-        return _surface_lookup[bcd.index()];
+        return _surfaces[bcd.index()];
     }
 
     /// @returns the overall number of surfaces in the detector
     DETRAY_HOST_DEVICE
     constexpr auto n_surfaces() const -> dindex {
-        return static_cast<dindex>(_surface_lookup.size());
+        return static_cast<dindex>(_surfaces.size());
     }
 
     /// Add a new surface to the lookup according to its index.
     DETRAY_HOST
     constexpr auto add_surface_to_lookup(const surface_type sf) -> void {
-        if (_surface_lookup.size() < sf.index() + 1) {
-            _surface_lookup.resize(sf.index() + 1);
+        if (_surfaces.size() < sf.index() + 1) {
+            _surfaces.resize(sf.index() + 1);
         }
-        _surface_lookup.at(sf.index()) = sf;
+        _surfaces.at(sf.index()) = sf;
     }
 
     /// Append new portals(surfaces) to the detector
     DETRAY_HOST
-    inline void append_portals(surface_container_t &&new_surfaces) {
-        _surfaces.template push_back<sf_finders::id::e_brute_force>(
+    inline void append_portals(surface_container &&new_surfaces) {
+        _accelerators.template push_back<accel::id::e_brute_force>(
             std::move(new_surfaces));
     }
 
@@ -415,7 +415,7 @@ class detector {
     template <geo_obj_ids surface_id = static_cast<geo_obj_ids>(0)>
     DETRAY_HOST auto add_objects_per_volume(
         const geometry_context ctx, volume_type &vol,
-        surface_container_t &surfaces_per_vol, mask_container &masks_per_vol,
+        surface_container &surfaces_per_vol, mask_container &masks_per_vol,
         transform_container &trfs_per_vol) noexcept(false) -> void {
 
         // Append transforms
@@ -437,13 +437,13 @@ class detector {
         }
 
         // Append surfaces to base surface collection
-        _surfaces.template push_back<sf_finders::id::e_default>(
+        _accelerators.template push_back<accel::id::e_default>(
             surfaces_per_vol);
 
         // Update the surface link in a volume
         vol.template set_link<surface_id>(
-            sf_finders::id::e_default,
-            _surfaces.template size<sf_finders::id::e_default>() - 1);
+            accel::id::e_default,
+            _accelerators.template size<accel::id::e_default>() - 1);
 
         // Append mask and material container
         _masks.append(std::move(masks_per_vol));
@@ -464,7 +464,7 @@ class detector {
     DETRAY_HOST
     auto add_objects_per_volume(
         const geometry_context ctx, volume_type &vol,
-        surface_container_t &surfaces_per_vol, mask_container &masks_per_vol,
+        surface_container &surfaces_per_vol, mask_container &masks_per_vol,
         transform_container &trfs_per_vol,
         material_container &materials_per_vol) noexcept(false) -> void {
 
@@ -523,18 +523,18 @@ class detector {
     /// @returns view of a detector
     DETRAY_HOST auto get_data() -> view_type {
         return view_type{
-            detray::get_data(_volumes),      detray::get_data(_transforms),
-            detray::get_data(_masks),        detray::get_data(_materials),
-            detray::get_data(_surfaces),     detray::get_data(_surface_lookup),
+            detray::get_data(_volumes),      detray::get_data(_surfaces),
+            detray::get_data(_transforms),   detray::get_data(_masks),
+            detray::get_data(_materials),    detray::get_data(_accelerators),
             detray::get_data(_volume_finder)};
     }
 
     /// @returns const view of a detector
     DETRAY_HOST auto get_data() const -> const_view_type {
         return const_view_type{
-            detray::get_data(_volumes),      detray::get_data(_transforms),
-            detray::get_data(_masks),        detray::get_data(_materials),
-            detray::get_data(_surfaces),     detray::get_data(_surface_lookup),
+            detray::get_data(_volumes),      detray::get_data(_surfaces),
+            detray::get_data(_transforms),   detray::get_data(_masks),
+            detray::get_data(_materials),    detray::get_data(_accelerators),
             detray::get_data(_volume_finder)};
     }
 
@@ -546,11 +546,10 @@ class detector {
 
         ss << "[>] Detector '" << names.at(0) << "' has " << _volumes.size()
            << " volumes." << std::endl;
-        ss << " local surface finders." << std::endl;
 
         for (const auto [i, v] : detray::views::enumerate(_volumes)) {
             ss << "[>>] Volume at index " << i << ": " << std::endl;
-            ss << " - name: '" << v.name(names) << "'" << std::endl;
+            ss << " - name: '" << names.at(v.index() + 1u) << "'" << std::endl;
 
             ss << "     contains    "
                << v.template n_objects<geo_obj_ids::e_sensitive>()
@@ -560,12 +559,12 @@ class detector {
                << v.template n_objects<geo_obj_ids::e_portal>() << " portals "
                << std::endl;
 
-            ss << "                 " << _surfaces.n_collections()
+            ss << "                 " << _accelerators.n_collections()
                << " surface finders " << std::endl;
 
-            if (v.sf_finder_index() != dindex_invalid) {
-                ss << "  sf finder id " << v.sf_finder_type()
-                   << "  sf finders idx " << v.sf_finder_index() << std::endl;
+            if (v.accel_index() != dindex_invalid) {
+                ss << "  sf finder id " << v.accel_type() << "  sf finders idx "
+                   << v.accel_index() << std::endl;
             }
         }
 
@@ -584,6 +583,9 @@ class detector {
     /// Contains the detector sub-volumes.
     volume_container _volumes;
 
+    /// Lookup for surfaces from barcodes
+    surface_lookup_container _surfaces;
+
     /// Keeps all of the transform data in contiguous memory
     transform_container _transforms;
 
@@ -594,10 +596,7 @@ class detector {
     material_container _materials;
 
     /// All surface finder data structures that are used in the detector volumes
-    surface_container _surfaces;
-
-    /// Lookup for surfaces from barcodes
-    surface_lookup_container _surface_lookup;
+    accelerator_container _accelerators;
 
     /// Search structure for volumes
     volume_finder _volume_finder;
diff --git a/core/include/detray/core/detector_metadata.hpp b/core/include/detray/core/detector_metadata.hpp
index da5140f80..c26346286 100644
--- a/core/include/detray/core/detector_metadata.hpp
+++ b/core/include/detray/core/detector_metadata.hpp
@@ -124,7 +124,7 @@ struct default_metadata {
 
     /// Give your mask types a name (needs to be consecutive and has to match
     /// the types position in the mask store!)
-    enum class mask_ids {
+    enum class mask_ids : std::uint8_t {
         e_rectangle2 = 0,
         e_portal_rectangle2 = 0,
         e_trapezoid2 = 1,
@@ -163,7 +163,7 @@ unbounded_cell, unmasked_plane*/>;
     /// Give your material types a name (needs to be consecutive and has to
     /// match the types position in the mask store!)
     /// @TODO: Add the material grid types for every surface shape
-    enum class material_ids {
+    enum class material_ids : std::uint8_t {
         e_slab = 0,
         e_rod = 1,
         // ... material map types
@@ -180,7 +180,7 @@ unbounded_cell, unmasked_plane*/>;
     using transform_link = typename transform_store<>::link_type;
     using mask_link = typename mask_store<>::single_link;
     using material_link = typename material_store<>::single_link;
-    using source_link = dindex;
+    using source_link = std::uint64_t;
     /// Surface type used for sensitives, passives and portals
     using surface_type =
         surface_descriptor<mask_link, material_link, transform_link, nav_link,
@@ -189,7 +189,7 @@ unbounded_cell, unmasked_plane*/>;
     /// How to index the constituent objects (surfaces) in a volume
     /// If they share the same index value here, they will be added into the
     /// same acceleration data structure (brute force is always at 0)
-    enum geo_objects : std::size_t {
+    enum geo_objects : std::uint8_t {
         e_portal = 0,     // Brute force search
         e_sensitive = 1,  // Grid accelerated search (can be different types)
         e_passive = 0,    // Brute force search
@@ -198,7 +198,7 @@ unbounded_cell, unmasked_plane*/>;
     };
 
     /// Acceleration data structures
-    enum class sf_finder_ids {
+    enum class accel_ids : std::uint8_t {
         e_brute_force = 0,     // test all surfaces in a volume (brute force)
         e_disc_grid = 1,       // e.g. endcap layers
         e_cylinder2_grid = 2,  // e.g. barrel layers
@@ -213,13 +213,13 @@ unbounded_cell, unmasked_plane*/>;
     /// How a volume links to the accelration data structures
     /// In this case: One link for portals/passives and one sensitive surfaces
     using object_link_type =
-        dmulti_index<dtyped_index<sf_finder_ids, dindex>, geo_objects::e_size>;
+        dmulti_index<dtyped_index<accel_ids, dindex>, geo_objects::e_size>;
 
     /// How to store the acceleration data structures
     template <template <typename...> class tuple_t = dtuple,
               typename container_t = host_container_types>
-    using surface_finder_store =
-        multi_store<sf_finder_ids, empty_context, tuple_t,
+    using accelerator_store =
+        multi_store<accel_ids, empty_context, tuple_t,
                     brute_force_collection<surface_type, container_t>,
                     grid_collection<disc_sf_grid<surface_type, container_t>>,
                     grid_collection<
diff --git a/core/include/detray/geometry/detail/surface_descriptor.hpp b/core/include/detray/geometry/detail/surface_descriptor.hpp
index 9c4515d13..277b2315c 100644
--- a/core/include/detray/geometry/detail/surface_descriptor.hpp
+++ b/core/include/detray/geometry/detail/surface_descriptor.hpp
@@ -31,7 +31,8 @@ namespace detray {
 template <typename mask_link_t = dtyped_index<dindex, dindex>,
           typename material_link_t = dtyped_index<dindex, dindex>,
           typename transform_link_t = dindex,
-          typename navigation_link_t = dindex, typename source_link_t = dindex>
+          typename navigation_link_t = dindex,
+          typename source_link_t = std::uint64_t>
 class surface_descriptor {
 
     public:
@@ -79,7 +80,7 @@ class surface_descriptor {
                                  const mask_link &mask,
                                  const material_link &material,
                                  const dindex volume, const source_link &src,
-                                 surface_id sf_id)
+                                 const surface_id sf_id)
         : _mask(mask), _material(material), _trf(trf), _src(src) {
         m_barcode = geometry::barcode{}.set_volume(volume).set_id(sf_id);
     }
diff --git a/core/include/detray/geometry/detail/volume_descriptor.hpp b/core/include/detray/geometry/detail/volume_descriptor.hpp
index 357073b02..6dc7dd974 100644
--- a/core/include/detray/geometry/detail/volume_descriptor.hpp
+++ b/core/include/detray/geometry/detail/volume_descriptor.hpp
@@ -77,19 +77,19 @@ class volume_descriptor {
 
     /// @returns link to all acceleration data structures - const access
     DETRAY_HOST_DEVICE constexpr auto full_link() const -> const link_type & {
-        return m_sf_finder_links;
+        return m_accel_links;
     }
 
     /// @returns acc data structure link for a specific type of object - const
     template <ID obj_id>
     DETRAY_HOST_DEVICE constexpr auto link() const -> const link_t & {
-        return detail::get<obj_id>(m_sf_finder_links);
+        return detail::get<obj_id>(m_accel_links);
     }
 
     /// Set surface finder link from @param link
     template <ID obj_id>
     DETRAY_HOST constexpr auto set_link(const link_t link) -> void {
-        detail::get<obj_id>(m_sf_finder_links) = link;
+        detail::get<obj_id>(m_accel_links) = link;
     }
 
     /// Set surface finder link from @param id and @param index of the
@@ -99,7 +99,7 @@ class volume_descriptor {
     DETRAY_HOST constexpr auto set_link(const typename link_t::id_type id,
                                         const typename link_t::index_type index)
         -> void {
-        detail::get<obj_id>(m_sf_finder_links) = link_t{id, index};
+        detail::get<obj_id>(m_accel_links) = link_t{id, index};
     }
 
     /// Equality operator
@@ -108,7 +108,7 @@ class volume_descriptor {
     DETRAY_HOST_DEVICE
     constexpr auto operator==(const volume_descriptor &rhs) const -> bool {
         return (m_id == rhs.m_id && m_index == rhs.m_index &&
-                m_sf_finder_links == rhs.m_sf_finder_links);
+                m_accel_links == rhs.m_accel_links);
     }
 
     private:
@@ -122,7 +122,7 @@ class volume_descriptor {
     dindex m_transform{dindex_invalid};
 
     /// Links for every object type to an acceleration data structure
-    link_type m_sf_finder_links{};
+    link_type m_accel_links{};
 };
 
 }  // namespace detray
diff --git a/core/include/detray/geometry/detail/volume_kernels.hpp b/core/include/detray/geometry/detail/volume_kernels.hpp
index d22f73afd..d7c325a0b 100644
--- a/core/include/detray/geometry/detail/volume_kernels.hpp
+++ b/core/include/detray/geometry/detail/volume_kernels.hpp
@@ -19,10 +19,9 @@ struct surface_getter {
 
     /// Call operator that forwards the neighborhood search call in a volume
     /// to a surface finder data structure
-    template <typename sf_finder_group_t, typename sf_finder_index_t,
-              typename... Args>
-    DETRAY_HOST_DEVICE inline void operator()(const sf_finder_group_t &group,
-                                              const sf_finder_index_t index,
+    template <typename accel_group_t, typename accel_index_t, typename... Args>
+    DETRAY_HOST_DEVICE inline void operator()(const accel_group_t &group,
+                                              const accel_index_t index,
                                               Args &&... args) const {
 
         // Run over the surfaces in a single acceleration data structure
@@ -38,10 +37,10 @@ struct neighborhood_getter {
 
     /// Call operator that forwards the neighborhood search call in a volume
     /// to a surface finder data structure
-    template <typename sf_finder_group_t, typename sf_finder_index_t,
+    template <typename accel_group_t, typename accel_index_t,
               typename detector_t, typename track_t, typename... Args>
     DETRAY_HOST_DEVICE inline void operator()(
-        const sf_finder_group_t &group, const sf_finder_index_t index,
+        const accel_group_t &group, const accel_index_t index,
         const detector_t &det, const typename detector_t::volume_type &volume,
         const track_t &track, Args &&... args) const {
 
diff --git a/core/include/detray/geometry/detector_volume.hpp b/core/include/detray/geometry/detector_volume.hpp
index f129400b1..3c6dac986 100644
--- a/core/include/detray/geometry/detector_volume.hpp
+++ b/core/include/detray/geometry/detector_volume.hpp
@@ -132,7 +132,7 @@ class detector_volume {
         unsigned int n = 0u) const -> unsigned int {
         // Get the index of the surface collection with type index 'I'
         constexpr auto sf_col_id{
-            static_cast<typename detector_t::sf_finders::id>(I)};
+            static_cast<typename detector_t::accel::id>(I)};
         const auto &link{
             m_desc
                 .template link<static_cast<typename descr_t::object_id>(I)>()};
@@ -141,7 +141,7 @@ class detector_volume {
         // number of candidates that we can expect from it
         if (not link.is_invalid()) {
             const unsigned int n_max{
-                m_detector.surface_store()
+                m_detector.accelerator_store()
                     .template get<sf_col_id>()[detail::get<1>(link)]
                     .n_max_candidates()};
             // @todo: Remove when local navigation becomes available !!!!
@@ -245,7 +245,7 @@ class detector_volume {
         if (not link.is_invalid()) {
             // Run over the surfaces in a single acceleration data structure
             // and apply the functor to the resulting neighborhood
-            m_detector.surface_store().template visit<functor_t>(
+            m_detector.accelerator_store().template visit<functor_t>(
                 link, std::forward<Args>(args)...);
         }
         // Check the next surface type
diff --git a/core/include/detray/geometry/volume_graph.hpp b/core/include/detray/geometry/volume_graph.hpp
index aeba52ab9..6448afbd0 100644
--- a/core/include/detray/geometry/volume_graph.hpp
+++ b/core/include/detray/geometry/volume_graph.hpp
@@ -56,7 +56,6 @@ class volume_graph {
     public:
     using geo_obj_ids = typename detector_t::geo_obj_ids;
     using volume_container_t = vector_t<typename detector_t::volume_type>;
-    using surface_container_t = typename detector_t::surface_container;
     using mask_container_t = typename detector_t::mask_container;
 
     /// @brief Builds a graph node from the detector collections on the fly.
diff --git a/core/include/detray/tools/cuboid_portal_generator.hpp b/core/include/detray/tools/cuboid_portal_generator.hpp
index 7954d7268..930f3904f 100644
--- a/core/include/detray/tools/cuboid_portal_generator.hpp
+++ b/core/include/detray/tools/cuboid_portal_generator.hpp
@@ -79,7 +79,7 @@ class cuboid_portal_generator final
     /// @param ctx the geometry context (not needed for portals).
     DETRAY_HOST
     auto operator()(typename detector_t::volume_type &volume,
-                    typename detector_t::surface_container_t &surfaces,
+                    typename detector_t::surface_container &surfaces,
                     typename detector_t::transform_container &transforms,
                     typename detector_t::mask_container &masks,
                     typename detector_t::geometry_context ctx = {}) const
diff --git a/core/include/detray/tools/grid_builder.hpp b/core/include/detray/tools/grid_builder.hpp
index b97958124..0da37dca8 100644
--- a/core/include/detray/tools/grid_builder.hpp
+++ b/core/include/detray/tools/grid_builder.hpp
@@ -108,8 +108,8 @@ class grid_builder final : public volume_decorator<detector_t> {
         // Take the surfaces that should be filled into the grid out of the
         // brute force finder
         const auto vol_idx{vol_ptr->index()};
-        constexpr auto bf_id{detector_t::sf_finders::id::e_brute_force};
-        auto &bf_search = det.surface_store().template get<bf_id>();
+        constexpr auto bf_id{detector_t::accel::id::e_brute_force};
+        auto &bf_search = det.accelerator_store().template get<bf_id>();
 
         // Grid has not been filled previously, fill it automatically
         if (m_grid.size() == 0u) {
@@ -169,11 +169,11 @@ class grid_builder final : public volume_decorator<detector_t> {
         }
 
         // Add the grid to the detector and link it to its volume
-        constexpr auto gid{detector_t::sf_finders::template get_id<grid_t>()};
-        det.surface_store().template push_back<gid>(m_grid);
+        constexpr auto gid{detector_t::accel::template get_id<grid_t>()};
+        det.accelerator_store().template push_back<gid>(m_grid);
         vol_ptr->template set_link<
             detector_t::volume_type::object_id::e_sensitive>(
-            gid, det.surface_store().template size<gid>() - 1);
+            gid, det.accelerator_store().template size<gid>() - 1);
 
         return vol_ptr;
     }
diff --git a/core/include/detray/tools/material_factory.hpp b/core/include/detray/tools/material_factory.hpp
index f4f22bbc3..65d4eae21 100644
--- a/core/include/detray/tools/material_factory.hpp
+++ b/core/include/detray/tools/material_factory.hpp
@@ -187,7 +187,7 @@ class material_factory final : public factory_decorator<detector_t> {
     /// @param material material store of the volume builder that the new
     ///                 materials get added to.
     DETRAY_HOST
-    auto operator()(typename detector_t::surface_container_t &surfaces,
+    auto operator()(typename detector_t::surface_container &surfaces,
                     typename detector_t::material_container &materials) {
 
         // This builder is only called on a homogeneous material description
diff --git a/core/include/detray/tools/surface_factory.hpp b/core/include/detray/tools/surface_factory.hpp
index 37f2173d6..5efcade06 100644
--- a/core/include/detray/tools/surface_factory.hpp
+++ b/core/include/detray/tools/surface_factory.hpp
@@ -88,13 +88,14 @@ class surface_factory : public surface_factory_interface<detector_t> {
     DETRAY_HOST
     void push_back(surface_data_t &&sf_data) override {
 
-        auto [type, vlink, index, bounds, trf] = sf_data.get_data();
+        auto [type, vlink, index, source, bounds, trf] = sf_data.get_data();
 
         assert(bounds.size() == mask_shape_t::boundaries::e_size);
 
         m_types.push_back(type);
         m_volume_link.push_back(vlink);
         m_indices.push_back(index);
+        m_sources.push_back(source);
         m_bounds.push_back(std::move(bounds));
         m_transforms.push_back(trf);
     }
@@ -108,6 +109,7 @@ class surface_factory : public surface_factory_interface<detector_t> {
 
         m_volume_link.reserve(n_surfaces);
         m_indices.reserve(n_surfaces);
+        m_sources.reserve(n_surfaces);
         m_bounds.reserve(n_surfaces);
         m_transforms.reserve(n_surfaces);
 
@@ -123,6 +125,7 @@ class surface_factory : public surface_factory_interface<detector_t> {
         m_types.clear();
         m_volume_link.clear();
         m_indices.clear();
+        m_sources.clear();
         m_bounds.clear();
         m_transforms.clear();
     }
@@ -139,7 +142,7 @@ class surface_factory : public surface_factory_interface<detector_t> {
     DETRAY_HOST
     auto operator()([[maybe_unused]] typename detector_t::volume_type &volume,
                     [[maybe_unused]]
-                    typename detector_t::surface_container_t &surfaces,
+                    typename detector_t::surface_container &surfaces,
                     [[maybe_unused]]
                     typename detector_t::transform_container &transforms,
                     [[maybe_unused]] typename detector_t::mask_container &masks,
@@ -209,7 +212,7 @@ class surface_factory : public surface_factory_interface<detector_t> {
                 this->insert_in_container(
                     surfaces,
                     {trf_idx, mask_link, material_link, volume.index(),
-                     dindex_invalid, m_types[idx]},
+                     m_sources[idx], m_types[idx]},
                     sf_idx);
             }
         }
@@ -225,6 +228,7 @@ class surface_factory : public surface_factory_interface<detector_t> {
         assert(m_bounds.size() == m_types.size());
         assert(m_bounds.size() == m_volume_link.size());
         assert(m_bounds.size() == m_indices.size());
+        assert(m_bounds.size() == m_sources.size());
         assert(m_bounds.size() == m_transforms.size());
     }
 
@@ -235,6 +239,8 @@ class surface_factory : public surface_factory_interface<detector_t> {
     /// Indices of surfaces for the placement in container
     /// (counted as "volume-local": 0 to n_sf_in_volume)
     std::vector<dindex> m_indices{};
+    /// Source links of surfaces
+    std::vector<std::uint64_t> m_sources{};
     /// Mask boundaries of surfaces
     std::vector<std::vector<scalar_t>> m_bounds{};
     /// Transforms of surfaces
diff --git a/core/include/detray/tools/surface_factory_interface.hpp b/core/include/detray/tools/surface_factory_interface.hpp
index 4154fe7aa..03c33f3d5 100644
--- a/core/include/detray/tools/surface_factory_interface.hpp
+++ b/core/include/detray/tools/surface_factory_interface.hpp
@@ -43,10 +43,12 @@ class surface_data {
         const surface_id type, const typename detector_t::transform3 &trf,
         navigation_link volume_link,
         const std::vector<typename detector_t::scalar_type> &mask_boundaries,
-        const dindex idx = dindex_invalid)
+        const dindex idx = dindex_invalid,
+        const std::uint64_t source = detail::invalid_value<std::uint64_t>())
         : m_type{type},
           m_volume_link{volume_link},
           m_index{idx},
+          m_source{source},
           m_boundaries{mask_boundaries},
           m_transform{trf} {}
 
@@ -54,9 +56,10 @@ class surface_data {
     DETRAY_HOST
     auto get_data()
         -> std::tuple<surface_id &, navigation_link &, dindex &,
+                      std::uint64_t &,
                       std::vector<typename detector_t::scalar_type> &,
                       typename detector_t::transform3 &> {
-        return std::tie(m_type, m_volume_link, m_index, m_boundaries,
+        return std::tie(m_type, m_volume_link, m_index, m_source, m_boundaries,
                         m_transform);
     }
 
@@ -68,8 +71,9 @@ class surface_data {
     /// The position of the surface in the detector containers, used to match
     /// the surface to e.g. its material
     dindex m_index;
-    // Simple tuple of all mask types in the detector. Only one entry is filled
-    // with the mask that corresponds to this specific surface.
+    /// Source link (ACTS geoID)
+    std::uint64_t m_source;
+    /// Vector of mask boundary values
     std::vector<typename detector_t::scalar_type> m_boundaries;
     /// The surface placement
     typename detector_t::transform3 m_transform;
@@ -109,7 +113,7 @@ class surface_factory_interface {
     DETRAY_HOST
     virtual auto operator()(
         typename detector_t::volume_type &volume,
-        typename detector_t::surface_container_t &surfaces,
+        typename detector_t::surface_container &surfaces,
         typename detector_t::transform_container &transforms,
         typename detector_t::mask_container &masks,
         typename detector_t::geometry_context ctx = {}) const
@@ -178,7 +182,7 @@ class factory_decorator : public surface_factory_interface<detector_t> {
 
     DETRAY_HOST
     auto operator()(typename detector_t::volume_type &volume,
-                    typename detector_t::surface_container_t &surfaces,
+                    typename detector_t::surface_container &surfaces,
                     typename detector_t::transform_container &transforms,
                     typename detector_t::mask_container &masks,
                     typename detector_t::geometry_context ctx = {}) const
diff --git a/core/include/detray/tools/volume_builder.hpp b/core/include/detray/tools/volume_builder.hpp
index caf50f4d2..bd9ccfeb6 100644
--- a/core/include/detray/tools/volume_builder.hpp
+++ b/core/include/detray/tools/volume_builder.hpp
@@ -47,7 +47,7 @@ class volume_builder : public volume_builder_interface<detector_t> {
         // force method that will at least contain the portals
         m_volume
             .template set_link<static_cast<typename volume_type::object_id>(0)>(
-                detector_t::sf_finders::id::e_default, 0);
+                detector_t::accel::id::e_default, 0);
     };
 
     /// Adds the @param name of the volume to a @param name_map
@@ -129,7 +129,7 @@ class volume_builder : public volume_builder_interface<detector_t> {
 
     protected:
     /// @returns Access to the surface descriptor data
-    typename detector_t::surface_container_t& surfaces() override {
+    typename detector_t::surface_container& surfaces() override {
         return m_surfaces;
     }
 
@@ -176,10 +176,10 @@ class volume_builder : public volume_builder_interface<detector_t> {
         // surfaces are filled into the default brute_force accelerator.
         // For the other accelerators (grid etc.) there need to be dedicated
         // builders
-        constexpr auto default_acc_id{detector_t::sf_finders::id::e_default};
+        constexpr auto default_acc_id{detector_t::accel::id::e_default};
         m_volume.template set_link<surface_id>(
             default_acc_id,
-            det.surface_store().template size<default_acc_id>() - 1u);
+            det.accelerator_store().template size<default_acc_id>() - 1u);
 
         // Append masks
         det.append_masks(std::move(m_masks));
@@ -195,7 +195,7 @@ class volume_builder : public volume_builder_interface<detector_t> {
 
     /// Data of conatined surfaces
     /// @{
-    typename detector_t::surface_container_t m_surfaces{};
+    typename detector_t::surface_container m_surfaces{};
     typename detector_t::transform_container m_transforms{};
     typename detector_t::mask_container m_masks{};
     /// @}
diff --git a/core/include/detray/tools/volume_builder_interface.hpp b/core/include/detray/tools/volume_builder_interface.hpp
index 32a54e1fa..6327ff4c1 100644
--- a/core/include/detray/tools/volume_builder_interface.hpp
+++ b/core/include/detray/tools/volume_builder_interface.hpp
@@ -82,7 +82,7 @@ class volume_builder_interface {
     protected:
     /// Access to builder data
     /// @{
-    virtual typename detector_t::surface_container_t &surfaces() = 0;
+    virtual typename detector_t::surface_container &surfaces() = 0;
     virtual typename detector_t::transform_container &transforms() = 0;
     virtual typename detector_t::mask_container &masks() = 0;
     /// @}
@@ -153,7 +153,7 @@ class volume_decorator : public volume_builder_interface<detector_t> {
     /// @}
 
     protected:
-    typename detector_t::surface_container_t &surfaces() override {
+    typename detector_t::surface_container &surfaces() override {
         return m_builder->surfaces();
     }
     typename detector_t::transform_container &transforms() override {
diff --git a/core/include/detray/utils/consistency_checker.hpp b/core/include/detray/utils/consistency_checker.hpp
index 26b91ab92..f11770e6d 100644
--- a/core/include/detray/utils/consistency_checker.hpp
+++ b/core/include/detray/utils/consistency_checker.hpp
@@ -166,8 +166,8 @@ inline void check_empty(const detector_t &det) {
 
     // Check for empty acceleration data structure collections (e.g. grids)
     detail::report_empty(
-        det.surface_store(), "acceleration data structures store",
-        std::make_index_sequence<detector_t::sf_finders::n_types>{});
+        det.accelerator_store(), "acceleration data structures store",
+        std::make_index_sequence<detector_t::accel::n_types>{});
 
     // Check volume search data structure
     if (not find_volumes(det.volume_search_grid())) {
diff --git a/io/include/detray/io/common/geometry_reader.hpp b/io/include/detray/io/common/geometry_reader.hpp
index c56a7cf67..6996c0652 100644
--- a/io/include/detray/io/common/geometry_reader.hpp
+++ b/io/include/detray/io/common/geometry_reader.hpp
@@ -99,26 +99,25 @@ class geometry_reader : public reader_interface<detector_t> {
                 const auto key{mask_data.shape};
                 if (auto search = factories.find(key);
                     search == factories.end()) {
-                    factories[key] =
-                        std::move(init_factory<mask_shape::n_shapes>(
-                            mask_data.shape, sf_data.type));
+                    factories[key] = std::move(
+                        init_factory<mask_shape::n_shapes>(mask_data.shape));
                 }
 
                 // Add the data to the factory
                 factories.at(key)->push_back(deserialize(sf_data));
             }
 
-            // Add the portals to the volume first
+            // Add all portals and surfaces to the volume
             typename detector_t::geometry_context geo_ctx{};
             for (auto [key, pt_factory] : pt_factories) {
                 vbuilder->add_surfaces(pt_factory, geo_ctx);
             }
-            // Add all other surfaces next
             for (auto [key, sf_factory] : sf_factories) {
                 vbuilder->add_surfaces(sf_factory, geo_ctx);
             }
         }
 
+        // @TODO: Implement voume finder IO
         det_builder.template set_volume_finder();
     }
 
@@ -162,10 +161,13 @@ class geometry_reader : public reader_interface<detector_t> {
                                      ? *(sf_data.index_in_coll)
                                      : detail::invalid_value<std::size_t>()};
 
-        return {sf_data.type, deserialize(sf_data.transform),
+        return {sf_data.type,
+                deserialize(sf_data.transform),
                 static_cast<nav_link_t>(
                     base_type::deserialize(sf_data.mask.volume_link)),
-                std::move(mask_boundaries), static_cast<dindex>(sf_idx)};
+                std::move(mask_boundaries),
+                static_cast<dindex>(sf_idx),
+                sf_data.source};
     }
 
     private:
@@ -174,12 +176,11 @@ class geometry_reader : public reader_interface<detector_t> {
     ///
     /// @return the corresponding surface factory.
     template <mask_shape I>
-    static sf_factory_ptr_t init_factory(
-        const mask_shape shape_id, [[maybe_unused]] const surface_id sf_type) {
+    static sf_factory_ptr_t init_factory(const mask_shape shape_id) {
+
         // Shape index of surface data found
         if (shape_id == I) {
-            // Get the corresponding mask shape type and its type id in the
-            // detector
+            // Get the corresponding mask shape type
             using mask_info_t = mask_info<I>;
             using shape_t = typename mask_info_t::type;
 
@@ -192,7 +193,7 @@ class geometry_reader : public reader_interface<detector_t> {
         constexpr int current_id{static_cast<int>(I)};
         if constexpr (current_id > 0) {
             return init_factory<static_cast<mask_shape>(current_id - 1)>(
-                shape_id, sf_type);
+                shape_id);
         }
         // Test some edge cases
         if (shape_id == mask_shape::unknown) {
@@ -202,10 +203,10 @@ class geometry_reader : public reader_interface<detector_t> {
             throw std::invalid_argument(
                 "Given shape id could not be matched to a mask type: " +
                 std::to_string(static_cast<std::int64_t>(shape_id)));
-
-            // Cannot be reached
-            return {nullptr};
         }
+
+        // Cannot be reached
+        return {nullptr};
     }
 };
 
diff --git a/io/include/detray/io/common/geometry_writer.hpp b/io/include/detray/io/common/geometry_writer.hpp
index bfe44fb99..6204fc693 100644
--- a/io/include/detray/io/common/geometry_writer.hpp
+++ b/io/include/detray/io/common/geometry_writer.hpp
@@ -119,7 +119,7 @@ class geometry_writer : public writer_interface<detector_t> {
         sf_data.transform = serialize(sf.transform({}));
         sf_data.mask = sf.template visit_mask<get_mask_payload>();
         sf_data.material = sf.template visit_material<get_material_payload>();
-        sf_data.source = base_type::serialize(sf.source());
+        sf_data.source = sf.source();
 
         return sf_data;
     }
@@ -157,8 +157,8 @@ class geometry_writer : public writer_interface<detector_t> {
         for (unsigned int i = 1u; i < link.size(); ++i) {
             const auto& l = link[i];
             if (not l.is_invalid()) {
-                const auto aclp =
-                    det.surface_store().template visit<get_acc_link_payload>(l);
+                const auto aclp = det.accelerator_store()
+                                      .template visit<get_acc_link_payload>(l);
                 vol_data.acc_links->push_back(aclp);
             }
         }
diff --git a/io/include/detray/io/common/grid_reader.hpp b/io/include/detray/io/common/grid_reader.hpp
index 35cc104f0..83838b5e0 100644
--- a/io/include/detray/io/common/grid_reader.hpp
+++ b/io/include/detray/io/common/grid_reader.hpp
@@ -295,7 +295,7 @@ class grid_reader : public reader_interface<detector_t> {
 
         // The compiler will instantiate this function for all possible types of
         // grids: Only proceed, if the grid type is known by the detector
-        if constexpr (detector_t::sf_finders::template is_defined<grid_t>()) {
+        if constexpr (detector_t::accel::template is_defined<grid_t>()) {
 
             // Decorate the current volume builder with the grid
             using grid_builder_t =
diff --git a/io/include/detray/io/common/grid_writer.hpp b/io/include/detray/io/common/grid_writer.hpp
index 33adf559a..497aad44b 100644
--- a/io/include/detray/io/common/grid_writer.hpp
+++ b/io/include/detray/io/common/grid_writer.hpp
@@ -57,7 +57,7 @@ class grid_writer : public writer_interface<detector_t> {
 
         header_data.sub_header.emplace();
         auto& grid_sub_header = header_data.sub_header.value();
-        grid_sub_header.n_grids = get_n_grids(det.surface_store());
+        grid_sub_header.n_grids = get_n_grids(det.accelerator_store());
 
         return header_data;
     }
@@ -85,7 +85,7 @@ class grid_writer : public writer_interface<detector_t> {
                 }
 
                 // If the accelerator is a grid, insert the payload
-                det.surface_store().template visit<get_grid_payload>(
+                det.accelerator_store().template visit<get_grid_payload>(
                     acc_link, vol_desc.index(), grids_data);
             }
         }
@@ -206,10 +206,10 @@ class grid_writer : public writer_interface<detector_t> {
     /// Retrieve number of overall grids in detector
     template <std::size_t I = 0u>
     static std::size_t get_n_grids(
-        const typename detector_t::surface_container& store,
+        const typename detector_t::accelerator_container& store,
         std::size_t n = 0u) {
 
-        using store_t = typename detector_t::surface_container;
+        using store_t = typename detector_t::accelerator_container;
         constexpr auto coll_id{store_t::value_types::to_id(I)};
         using accel_t = typename store_t::template get_type<coll_id>;
 
diff --git a/io/include/detray/io/common/payloads.hpp b/io/include/detray/io/common/payloads.hpp
index 73f12cc0f..ab4147716 100644
--- a/io/include/detray/io/common/payloads.hpp
+++ b/io/include/detray/io/common/payloads.hpp
@@ -89,7 +89,7 @@ struct surface_payload {
     transform_payload transform{};
     mask_payload mask{};
     std::optional<material_link_payload> material;
-    single_link_payload source{};
+    std::uint64_t source{};
     // Write the surface barcode as an additional information
     std::uint64_t barcode{std::numeric_limits<std::uint64_t>::max()};
     detray::surface_id type{detray::surface_id::e_sensitive};
diff --git a/tests/common/include/tests/common/test_toy_detector.hpp b/tests/common/include/tests/common/test_toy_detector.hpp
index 790d7b643..1de3ed221 100644
--- a/tests/common/include/tests/common/test_toy_detector.hpp
+++ b/tests/common/include/tests/common/test_toy_detector.hpp
@@ -19,7 +19,7 @@
 
 namespace detray {
 
-/// Functor that returns the volume/sf_finder links of a particluar mask
+/// Functor that returns the volume/accel links of a particluar mask
 /// instance in the mask container of a detector
 struct volume_link_getter {
 
@@ -66,8 +66,8 @@ inline bool test_toy_detector(
     using mask_link_t = typename detector_t::surface_type::mask_link;
     using material_ids = typename detector_t::materials::id;
     using material_link_t = typename detector_t::surface_type::material_link;
-    using sf_finder_ids = typename detector_t::sf_finders::id;
-    using sf_finder_link_t = typename volume_t::link_type::index_type;
+    using accel_ids = typename detector_t::accel::id;
+    using accel_link_t = typename volume_t::link_type::index_type;
 
     EXPECT_EQ(names.at(0u), "toy_detector");
 
@@ -77,7 +77,7 @@ inline bool test_toy_detector(
     geo_context_t ctx{};
     auto& volumes = toy_det.volumes();
     auto& surfaces = toy_det.surface_lookup();
-    auto& sf_finders = toy_det.surface_store();
+    auto& accel = toy_det.accelerator_store();
     auto& transforms = toy_det.transform_store();
     auto& masks = toy_det.mask_store();
     auto& materials = toy_det.material_store();
@@ -93,8 +93,8 @@ inline bool test_toy_detector(
     // Link to outer world (leaving detector)
     constexpr auto leaving_world{detail::invalid_value<nav_link_t>()};
     const bool has_grids =
-        (sf_finders.template size<sf_finder_ids::e_cylinder2_grid>() != 0u) ||
-        (sf_finders.template size<sf_finder_ids::e_disc_grid>() != 0u);
+        (accel.template size<accel_ids::e_cylinder2_grid>() != 0u) ||
+        (accel.template size<accel_ids::e_disc_grid>() != 0u);
     const bool has_material =
         (materials.template size<material_ids::e_slab>() != 0);
 
@@ -106,11 +106,10 @@ inline bool test_toy_detector(
     EXPECT_EQ(masks.template size<mask_ids::e_trapezoid2>(), 648u);
     EXPECT_EQ(masks.template size<mask_ids::e_portal_cylinder2>(), 52u);
     EXPECT_EQ(masks.template size<mask_ids::e_portal_ring2>(), 52u);
-    EXPECT_EQ(sf_finders.template size<sf_finder_ids::e_brute_force>(), 20u);
+    EXPECT_EQ(accel.template size<accel_ids::e_brute_force>(), 20u);
     if (has_grids) {
-        EXPECT_EQ(sf_finders.template size<sf_finder_ids::e_cylinder2_grid>(),
-                  4);
-        EXPECT_EQ(sf_finders.template size<sf_finder_ids::e_disc_grid>(), 6);
+        EXPECT_EQ(accel.template size<accel_ids::e_cylinder2_grid>(), 4);
+        EXPECT_EQ(accel.template size<accel_ids::e_disc_grid>(), 6);
     }
     if (has_material) {
         EXPECT_EQ(materials.template size<material_ids::e_slab>(), 3244u);
@@ -128,10 +127,10 @@ inline bool test_toy_detector(
     auto test_volume_links = [&](decltype(volumes.begin())& vol_itr,
                                  const dindex vol_index,
                                  const darray<dindex, 1>& range,
-                                 const sf_finder_link_t& /*sf_finder_link*/) {
+                                 const accel_link_t& /*accel_link*/) {
         EXPECT_EQ(vol_itr->index(), vol_index);
         EXPECT_EQ(vol_itr->template link<geo_obj_ids::e_portal>().id(),
-                  sf_finder_ids::e_brute_force);
+                  accel_ids::e_brute_force);
         EXPECT_EQ(vol_itr->template link<geo_obj_ids::e_portal>().index(),
                   range[0]);
     };
@@ -223,21 +222,22 @@ inline bool test_toy_detector(
     /// Test the detectors acceleration data structures.
     ///
     /// @param vol_itr iterator over the volume descriptors
-    /// @param sf_finder_store the detectors acceleration data structure store
+    /// @param accel_store the detectors acceleration data structure store
     /// @param pt_range index range of the portals in the surface lookup
     /// @param sf_range index range of the surfaces in the surface lookup
-    auto test_sf_finders =
+    auto test_accel =
         [has_grids](
             decltype(volumes.begin())& vol_itr,
-            const typename detector_t::surface_container& sf_finder_store,
+            const typename detector_t::accelerator_container& accel_store,
             const darray<dindex, 2>& pt_range,
             const darray<dindex, 2>& sf_range = {0u, 0u}) {
             // Link to the acceleration data structures the volume holds
             const auto& link = vol_itr->full_link();
 
             // Test the portal search
-            const auto& bf_finder = sf_finder_store.template get<
-                sf_finder_ids::e_brute_force>()[link[0].index()];
+            const auto& bf_finder =
+                accel_store
+                    .template get<accel_ids::e_brute_force>()[link[0].index()];
 
             // This means no grids, all surfaces are in the brute force method
             if (not has_grids) {
@@ -249,13 +249,13 @@ inline bool test_toy_detector(
 
                 // Test the module search if grids were filled
                 if (not link[1].is_invalid()) {
-                    if (link[1].id() == sf_finder_ids::e_cylinder2_grid) {
-                        const auto& cyl_grid = sf_finder_store.template get<
-                            sf_finder_ids::e_cylinder2_grid>()[link[1].index()];
+                    if (link[1].id() == accel_ids::e_cylinder2_grid) {
+                        const auto& cyl_grid = accel_store.template get<
+                            accel_ids::e_cylinder2_grid>()[link[1].index()];
                         test_finder(cyl_grid, vol_itr->index(), sf_range);
                     } else {
-                        const auto& disc_grid = sf_finder_store.template get<
-                            sf_finder_ids::e_disc_grid>()[link[1].index()];
+                        const auto& disc_grid = accel_store.template get<
+                            accel_ids::e_disc_grid>()[link[1].index()];
                         test_finder(disc_grid, vol_itr->index(), sf_range);
                     }
                 }
@@ -270,10 +270,10 @@ inline bool test_toy_detector(
     auto vol_itr = volumes.begin();
     EXPECT_EQ(names.at(vol_itr->index() + 1), "beampipe_0");
     darray<dindex, 1> index = {0u};
-    sf_finder_link_t sf_finder_link{sf_finder_ids::e_brute_force, 0u};
+    accel_link_t accel_link{accel_ids::e_brute_force, 0u};
 
     // Test the links in the volumes
-    test_volume_links(vol_itr, 0u, index, sf_finder_link);
+    test_volume_links(vol_itr, 0u, index, accel_link);
 
     // Check links of portals
     // cylinder portals
@@ -306,7 +306,7 @@ inline bool test_toy_detector(
                       {vol_itr->index()});
 
     // Check link of surfaces in surface finder
-    test_sf_finders(vol_itr, sf_finders, {0u, 16u});
+    test_accel(vol_itr, accel, {0u, 16u});
 
     //
     // neg endcap (layer 3)
@@ -317,10 +317,10 @@ inline bool test_toy_detector(
     EXPECT_EQ(names.at(vol_itr->index() + 1), "endcap_1");
     range = {16u, 128u};
     index = {1u};
-    sf_finder_link = {sf_finder_ids::e_disc_grid, 0u};
+    accel_link = {accel_ids::e_disc_grid, 0u};
 
     // Test the links in the volumes
-    test_volume_links(vol_itr, 1u, index, sf_finder_link);
+    test_volume_links(vol_itr, 1u, index, accel_link);
 
     // Check links of portals
     // cylinder portals
@@ -347,7 +347,7 @@ inline bool test_toy_detector(
                       {vol_itr->index()});
 
     // Check link of surfaces in surface finder
-    test_sf_finders(vol_itr, sf_finders, {16u, 20u}, range);
+    test_accel(vol_itr, accel, {16u, 20u}, range);
 
     //
     // gap
@@ -358,10 +358,10 @@ inline bool test_toy_detector(
     EXPECT_EQ(names.at(vol_itr->index() + 1), "gap_2");
     range = {128u, 132u};
     index = {2u};
-    sf_finder_link = {sf_finder_ids::e_brute_force, 0u};
+    accel_link = {accel_ids::e_brute_force, 0u};
 
     // Test the links in the volumes
-    test_volume_links(vol_itr, 2u, index, sf_finder_link);
+    test_volume_links(vol_itr, 2u, index, accel_link);
 
     // Check links of portals
     // cylinder portals
@@ -379,7 +379,7 @@ inline bool test_toy_detector(
                       {material_ids::e_slab, 130u}, portal_mat, {1u, 3u});
 
     // Check link of surfaces in surface finder
-    test_sf_finders(vol_itr, sf_finders, {128u, 132u});
+    test_accel(vol_itr, accel, {128u, 132u});
 
     //
     // neg endcap (layer 2)
@@ -390,10 +390,10 @@ inline bool test_toy_detector(
     EXPECT_EQ(names.at(vol_itr->index() + 1), "endcap_3");
     range = {132u, 244u};
     index = {3u};
-    sf_finder_link = {sf_finder_ids::e_disc_grid, 1u};
+    accel_link = {accel_ids::e_disc_grid, 1u};
 
     // Test the links in the volumes
-    test_volume_links(vol_itr, 3u, index, sf_finder_link);
+    test_volume_links(vol_itr, 3u, index, accel_link);
 
     // Check links of portals
     // cylinder portals
@@ -419,7 +419,7 @@ inline bool test_toy_detector(
                       {vol_itr->index()});
 
     // Check link of surfaces in surface finder
-    test_sf_finders(vol_itr, sf_finders, {132u, 136u}, range);
+    test_accel(vol_itr, accel, {132u, 136u}, range);
 
     //
     // gap
@@ -430,10 +430,10 @@ inline bool test_toy_detector(
     EXPECT_EQ(names.at(vol_itr->index() + 1), "gap_4");
     range = {244u, 248u};
     index = {4u};
-    sf_finder_link = {sf_finder_ids::e_brute_force, 0u};
+    accel_link = {accel_ids::e_brute_force, 0u};
 
     // Test the links in the volumes
-    test_volume_links(vol_itr, 4u, index, sf_finder_link);
+    test_volume_links(vol_itr, 4u, index, accel_link);
 
     // Check links of portals
     // cylinder portals
@@ -451,7 +451,7 @@ inline bool test_toy_detector(
                       {material_ids::e_slab, 246u}, portal_mat, {3u, 5u});
 
     // Check link of surfaces in surface finder
-    test_sf_finders(vol_itr, sf_finders, {244u, 248u});
+    test_accel(vol_itr, accel, {244u, 248u});
 
     //
     // neg endcap (layer 1)
@@ -462,10 +462,10 @@ inline bool test_toy_detector(
     EXPECT_EQ(names.at(vol_itr->index() + 1), "endcap_5");
     range = {248u, 360u};
     index = {5u};
-    sf_finder_link = {sf_finder_ids::e_disc_grid, 2u};
+    accel_link = {accel_ids::e_disc_grid, 2u};
 
     // Test the links in the volumes
-    test_volume_links(vol_itr, 5u, index, sf_finder_link);
+    test_volume_links(vol_itr, 5u, index, accel_link);
 
     // Check links of portals
     // cylinder portals
@@ -491,7 +491,7 @@ inline bool test_toy_detector(
                       {vol_itr->index()});
 
     // Check link of surfaces in surface finder
-    test_sf_finders(vol_itr, sf_finders, {248u, 252u}, range);
+    test_accel(vol_itr, accel, {248u, 252u}, range);
 
     //
     // gap
@@ -502,10 +502,10 @@ inline bool test_toy_detector(
     EXPECT_EQ(names.at(vol_itr->index() + 1), "connector_gap_6");
     range = {360u, 370u};
     index = {6u};
-    sf_finder_link = {sf_finder_ids::e_brute_force, 0u};
+    accel_link = {accel_ids::e_brute_force, 0u};
 
     // Test the links in the volumes
-    test_volume_links(vol_itr, 6u, index, sf_finder_link);
+    test_volume_links(vol_itr, 6u, index, accel_link);
 
     // Check links of portals
     // cylinder portals
@@ -524,7 +524,7 @@ inline bool test_toy_detector(
                       {5u, 7u, 8u, 9u, 10u, 11u, 12u, 13u});
 
     // Check link of surfaces in surface finder
-    test_sf_finders(vol_itr, sf_finders, {360u, 370u});
+    test_accel(vol_itr, accel, {360u, 370u});
 
     //
     // barrel
@@ -539,10 +539,10 @@ inline bool test_toy_detector(
     EXPECT_EQ(names.at(vol_itr->index() + 1), "barrel_7");
     range = {370u, 598u};
     index = {7u};
-    sf_finder_link = {sf_finder_ids::e_cylinder2_grid, 0u};
+    accel_link = {accel_ids::e_cylinder2_grid, 0u};
 
     // Test the links in the volumes
-    test_volume_links(vol_itr, 7u, index, sf_finder_link);
+    test_volume_links(vol_itr, 7u, index, accel_link);
 
     // Check links of portals
     // cylinder portals
@@ -568,7 +568,7 @@ inline bool test_toy_detector(
                       {vol_itr->index()});
 
     // Check link of surfaces in surface finder
-    test_sf_finders(vol_itr, sf_finders, {370u, 374u}, range);
+    test_accel(vol_itr, accel, {370u, 374u}, range);
 
     //
     // gap
@@ -579,10 +579,10 @@ inline bool test_toy_detector(
     EXPECT_EQ(names.at(vol_itr->index() + 1), "gap_8");
     range = {598u, 602u};
     index = {8u};
-    sf_finder_link = {sf_finder_ids::e_brute_force, 0u};
+    accel_link = {accel_ids::e_brute_force, 0u};
 
     // Test the links in the volumes
-    test_volume_links(vol_itr, 8u, index, sf_finder_link);
+    test_volume_links(vol_itr, 8u, index, accel_link);
 
     // Check links of portals
     // cylinder portals
@@ -599,7 +599,7 @@ inline bool test_toy_detector(
                       {material_ids::e_slab, 600u}, portal_mat, {6u, 14u});
 
     // Check link of surfaces in surface finder
-    test_sf_finders(vol_itr, sf_finders, {598u, 602u});
+    test_accel(vol_itr, accel, {598u, 602u});
 
     //
     // second layer
@@ -610,10 +610,10 @@ inline bool test_toy_detector(
     EXPECT_EQ(names.at(vol_itr->index() + 1), "barrel_9");
     range = {602u, 1054u};
     index = {9u};
-    sf_finder_link = {sf_finder_ids::e_cylinder2_grid, 1u};
+    accel_link = {accel_ids::e_cylinder2_grid, 1u};
 
     // Test the links in the volumes
-    test_volume_links(vol_itr, 9u, index, sf_finder_link);
+    test_volume_links(vol_itr, 9u, index, accel_link);
 
     // Check links of portals
     // cylinder portals
@@ -639,7 +639,7 @@ inline bool test_toy_detector(
                       {vol_itr->index()});
 
     // Check link of surfaces in surface finder
-    test_sf_finders(vol_itr, sf_finders, {602u, 606u}, range);
+    test_accel(vol_itr, accel, {602u, 606u}, range);
 
     //
     // gap
@@ -650,10 +650,10 @@ inline bool test_toy_detector(
     EXPECT_EQ(names.at(vol_itr->index() + 1), "gap_10");
     range = {1054u, 1058u};
     index = {10u};
-    sf_finder_link = {sf_finder_ids::e_brute_force, 0u};
+    accel_link = {accel_ids::e_brute_force, 0u};
 
     // Test the links in the volumes
-    test_volume_links(vol_itr, 10u, index, sf_finder_link);
+    test_volume_links(vol_itr, 10u, index, accel_link);
 
     // Check links of portals
     // cylinder portals
@@ -670,7 +670,7 @@ inline bool test_toy_detector(
                       {material_ids::e_slab, 1056u}, portal_mat, {6u, 14u});
 
     // Check link of surfaces in surface finder
-    test_sf_finders(vol_itr, sf_finders, {1054u, 1058u});
+    test_accel(vol_itr, accel, {1054u, 1058u});
 
     //
     // third layer
@@ -681,10 +681,10 @@ inline bool test_toy_detector(
     EXPECT_EQ(names.at(vol_itr->index() + 1), "barrel_11");
     range = {1058u, 1790u};
     index = {11u};
-    sf_finder_link = {sf_finder_ids::e_cylinder2_grid, 2u};
+    accel_link = {accel_ids::e_cylinder2_grid, 2u};
 
     // Test the links in the volumes
-    test_volume_links(vol_itr, 11u, index, sf_finder_link);
+    test_volume_links(vol_itr, 11u, index, accel_link);
 
     // Check links of portals
     // cylinder portals
@@ -710,7 +710,7 @@ inline bool test_toy_detector(
                       {vol_itr->index()});
 
     // Check link of surfaces in surface finder
-    test_sf_finders(vol_itr, sf_finders, {1058u, 1062u}, range);
+    test_accel(vol_itr, accel, {1058u, 1062u}, range);
 
     //
     // gap
@@ -721,10 +721,10 @@ inline bool test_toy_detector(
     EXPECT_EQ(names.at(vol_itr->index() + 1), "gap_12");
     range = {1790u, 1794u};
     index = {12u};
-    sf_finder_link = {sf_finder_ids::e_brute_force, 0u};
+    accel_link = {accel_ids::e_brute_force, 0u};
 
     // Test the links in the volumes
-    test_volume_links(vol_itr, 12u, index, sf_finder_link);
+    test_volume_links(vol_itr, 12u, index, accel_link);
 
     // Check links of portals
     // cylinder portals
@@ -741,7 +741,7 @@ inline bool test_toy_detector(
                       {material_ids::e_slab, 1792u}, portal_mat, {6u, 14u});
 
     // Check link of surfaces in surface finder
-    test_sf_finders(vol_itr, sf_finders, {1790u, 1794u});
+    test_accel(vol_itr, accel, {1790u, 1794u});
 
     //
     // fourth layer
@@ -752,10 +752,10 @@ inline bool test_toy_detector(
     EXPECT_EQ(names.at(vol_itr->index() + 1), "barrel_13");
     range = {1794u, 2890u};
     index = {13u};
-    sf_finder_link = {sf_finder_ids::e_cylinder2_grid, 3u};
+    accel_link = {accel_ids::e_cylinder2_grid, 3u};
 
     // Test the links in the volumes
-    test_volume_links(vol_itr, 13u, index, sf_finder_link);
+    test_volume_links(vol_itr, 13u, index, accel_link);
 
     // Check links of portals
     // cylinder portals
@@ -782,7 +782,7 @@ inline bool test_toy_detector(
                       {vol_itr->index()});
 
     // Check link of surfaces in surface finder
-    test_sf_finders(vol_itr, sf_finders, {1794u, 1798u}, range);
+    test_accel(vol_itr, accel, {1794u, 1798u}, range);
 
     //
     // positive endcap
@@ -797,10 +797,10 @@ inline bool test_toy_detector(
     EXPECT_EQ(names.at(vol_itr->index() + 1), "connector_gap_14");
     range = {2890u, 2900u};
     index = {14u};
-    sf_finder_link = {sf_finder_ids::e_brute_force, 0u};
+    accel_link = {accel_ids::e_brute_force, 0u};
 
     // Test the links in the volumes
-    test_volume_links(vol_itr, 14u, index, sf_finder_link);
+    test_volume_links(vol_itr, 14u, index, accel_link);
 
     // Check links of portals
     // cylinder portals
@@ -819,7 +819,7 @@ inline bool test_toy_detector(
                       {15u, 7u, 8u, 9u, 10u, 11u, 12u, 13u});
 
     // Check link of surfaces in surface finder
-    test_sf_finders(vol_itr, sf_finders, {2890u, 2900u});
+    test_accel(vol_itr, accel, {2890u, 2900u});
 
     //
     // pos endcap (layer 1)
@@ -830,10 +830,10 @@ inline bool test_toy_detector(
     EXPECT_EQ(names.at(vol_itr->index() + 1), "endcap_15");
     range = {2900u, 3012u};
     index = {15u};
-    sf_finder_link = {sf_finder_ids::e_disc_grid, 3u};
+    accel_link = {accel_ids::e_disc_grid, 3u};
 
     // Test the links in the volumes
-    test_volume_links(vol_itr, 15u, index, sf_finder_link);
+    test_volume_links(vol_itr, 15u, index, accel_link);
 
     // Check links of portals
     // cylinder portals
@@ -859,7 +859,7 @@ inline bool test_toy_detector(
                       {vol_itr->index()});
 
     // Check link of surfaces in surface finder
-    test_sf_finders(vol_itr, sf_finders, {2900u, 2904u}, range);
+    test_accel(vol_itr, accel, {2900u, 2904u}, range);
 
     //
     // gap
@@ -870,10 +870,10 @@ inline bool test_toy_detector(
     EXPECT_EQ(names.at(vol_itr->index() + 1), "gap_16");
     range = {3012u, 3016u};
     index = {16u};
-    sf_finder_link = {sf_finder_ids::e_brute_force, 0u};
+    accel_link = {accel_ids::e_brute_force, 0u};
 
     // Test the links in the volumes
-    test_volume_links(vol_itr, 16u, index, sf_finder_link);
+    test_volume_links(vol_itr, 16u, index, accel_link);
 
     // Check links of portals
     // cylinder portals
@@ -891,7 +891,7 @@ inline bool test_toy_detector(
                       {material_ids::e_slab, 3014u}, portal_mat, {15u, 17u});
 
     // Check link of surfaces in surface finder
-    test_sf_finders(vol_itr, sf_finders, {3012u, 3016u});
+    test_accel(vol_itr, accel, {3012u, 3016u});
 
     //
     // pos endcap (layer 2)
@@ -902,10 +902,10 @@ inline bool test_toy_detector(
     EXPECT_EQ(names.at(vol_itr->index() + 1), "endcap_17");
     range = {3016u, 3128u};
     index = {17u};
-    sf_finder_link = {sf_finder_ids::e_disc_grid, 4u};
+    accel_link = {accel_ids::e_disc_grid, 4u};
 
     // Test the links in the volumes
-    test_volume_links(vol_itr, 17u, index, sf_finder_link);
+    test_volume_links(vol_itr, 17u, index, accel_link);
 
     // Check links of portals
     // cylinder portals
@@ -931,7 +931,7 @@ inline bool test_toy_detector(
                       {vol_itr->index()});
 
     // Check link of surfaces in surface finder
-    test_sf_finders(vol_itr, sf_finders, {3016u, 3020u}, range);
+    test_accel(vol_itr, accel, {3016u, 3020u}, range);
 
     //
     // gap
@@ -942,10 +942,10 @@ inline bool test_toy_detector(
     EXPECT_EQ(names.at(vol_itr->index() + 1), "gap_18");
     range = {3128u, 3132u};
     index = {18u};
-    sf_finder_link = {sf_finder_ids::e_brute_force, 0u};
+    accel_link = {accel_ids::e_brute_force, 0u};
 
     // Test the links in the volumes
-    test_volume_links(vol_itr, 18u, index, sf_finder_link);
+    test_volume_links(vol_itr, 18u, index, accel_link);
 
     // Check links of portals
     // cylinder portals
@@ -963,7 +963,7 @@ inline bool test_toy_detector(
                       {material_ids::e_slab, 3130u}, portal_mat, {17u, 19u});
 
     // Check link of surfaces in surface finder
-    test_sf_finders(vol_itr, sf_finders, {3128u, 3132u});
+    test_accel(vol_itr, accel, {3128u, 3132u});
 
     //
     // pos endcap (layer 3)
@@ -974,10 +974,10 @@ inline bool test_toy_detector(
     EXPECT_EQ(names.at(vol_itr->index() + 1), "endcap_19");
     range = {3132u, 3244u};
     index = {19u};
-    sf_finder_link = {sf_finder_ids::e_disc_grid, 5u};
+    accel_link = {accel_ids::e_disc_grid, 5u};
 
     // Test the links in the volumes
-    test_volume_links(vol_itr, 19u, index, sf_finder_link);
+    test_volume_links(vol_itr, 19u, index, accel_link);
 
     // Check links of portals
     // cylinder portals
@@ -1004,7 +1004,7 @@ inline bool test_toy_detector(
                       {vol_itr->index()});
 
     // Check link of surfaces in surface finder
-    test_sf_finders(vol_itr, sf_finders, {3132u, 3136u}, range);
+    test_accel(vol_itr, accel, {3132u, 3136u}, range);
 
     return true;
 }
diff --git a/tests/unit_tests/cpu/core_detector.cpp b/tests/unit_tests/cpu/core_detector.cpp
index 832e88b38..5d551b27a 100644
--- a/tests/unit_tests/cpu/core_detector.cpp
+++ b/tests/unit_tests/cpu/core_detector.cpp
@@ -46,7 +46,7 @@ void prefill_detector(detector_t& d,
     detray::empty_context empty_ctx{};
     vecmem::memory_resource* host_mr = d.resource();
     typename detector_t::transform_container trfs(*host_mr);
-    typename detector_t::surface_container_t surfaces{};
+    typename detector_t::surface_container surfaces{};
     typename detector_t::mask_container masks(*host_mr);
     typename detector_t::material_container materials(*host_mr);
 
@@ -138,7 +138,7 @@ GTEST_TEST(detray_core, detector) {
     using detector_t = detector<>;
     using mask_id = typename detector_t::masks::id;
     using material_id = typename detector_t::materials::id;
-    using finder_id = typename detector_t::sf_finders::id;
+    using finder_id = typename detector_t::accel::id;
 
     vecmem::host_memory_resource host_mr;
     detector_t d(host_mr);
@@ -159,14 +159,16 @@ GTEST_TEST(detray_core, detector) {
     EXPECT_TRUE(d.mask_store().template empty<mask_id::e_cell_wire>());
     EXPECT_TRUE(d.material_store().template empty<material_id::e_slab>());
     EXPECT_TRUE(d.material_store().template empty<material_id::e_rod>());
-    EXPECT_TRUE(d.surface_store().template empty<finder_id::e_brute_force>());
-    EXPECT_TRUE(d.surface_store().template empty<finder_id::e_disc_grid>());
     EXPECT_TRUE(
-        d.surface_store().template empty<finder_id::e_cylinder2_grid>());
-    EXPECT_TRUE(d.surface_store().template empty<finder_id::e_irr_disc_grid>());
+        d.accelerator_store().template empty<finder_id::e_brute_force>());
+    EXPECT_TRUE(d.accelerator_store().template empty<finder_id::e_disc_grid>());
     EXPECT_TRUE(
-        d.surface_store().template empty<finder_id::e_irr_cylinder2_grid>());
-    EXPECT_TRUE(d.surface_store().template empty<finder_id::e_default>());
+        d.accelerator_store().template empty<finder_id::e_cylinder2_grid>());
+    EXPECT_TRUE(
+        d.accelerator_store().template empty<finder_id::e_irr_disc_grid>());
+    EXPECT_TRUE(d.accelerator_store()
+                    .template empty<finder_id::e_irr_cylinder2_grid>());
+    EXPECT_TRUE(d.accelerator_store().template empty<finder_id::e_default>());
 
     // Add some geometrical data
     prefill_detector(d, geo_ctx);
@@ -187,15 +189,18 @@ GTEST_TEST(detray_core, detector) {
     EXPECT_EQ(d.mask_store().template size<mask_id::e_cell_wire>(), 0u);
     EXPECT_EQ(d.material_store().template size<material_id::e_slab>(), 2u);
     EXPECT_EQ(d.material_store().template size<material_id::e_rod>(), 1u);
-    EXPECT_EQ(d.surface_store().template size<finder_id::e_brute_force>(), 1u);
-    EXPECT_EQ(d.surface_store().template size<finder_id::e_disc_grid>(), 0u);
-    EXPECT_EQ(d.surface_store().template size<finder_id::e_cylinder2_grid>(),
+    EXPECT_EQ(d.accelerator_store().template size<finder_id::e_brute_force>(),
+              1u);
+    EXPECT_EQ(d.accelerator_store().template size<finder_id::e_disc_grid>(),
               0u);
-    EXPECT_EQ(d.surface_store().template size<finder_id::e_irr_disc_grid>(),
+    EXPECT_EQ(
+        d.accelerator_store().template size<finder_id::e_cylinder2_grid>(), 0u);
+    EXPECT_EQ(d.accelerator_store().template size<finder_id::e_irr_disc_grid>(),
               0u);
     EXPECT_EQ(
-        d.surface_store().template size<finder_id::e_irr_cylinder2_grid>(), 0u);
-    EXPECT_EQ(d.surface_store().template size<finder_id::e_default>(), 1u);
+        d.accelerator_store().template size<finder_id::e_irr_cylinder2_grid>(),
+        0u);
+    EXPECT_EQ(d.accelerator_store().template size<finder_id::e_default>(), 1u);
 }
 
 /// This tests the functionality of a surface factory
@@ -398,7 +403,7 @@ GTEST_TEST(detray_tools, detector_volume_construction) {
     using transform3 = typename detector_t::transform3;
     using geo_obj_id = typename detector_t::geo_obj_ids;
     using mask_id = typename detector_t::masks::id;
-    using sf_finder_id = typename detector_t::sf_finders::id;
+    using accel_id = typename detector_t::accel::id;
 
     // Surface factories
     using portal_cylinder_factory =
@@ -557,7 +562,7 @@ GTEST_TEST(detray_tools, detector_volume_construction) {
     EXPECT_TRUE(d.transform_store()[first_trf] == trf);
 
     // Check the acceleration data structure link
-    dtyped_index<sf_finder_id, dindex> acc_link{sf_finder_id::e_default, 1u};
+    dtyped_index<accel_id, dindex> acc_link{accel_id::e_default, 1u};
     ASSERT_TRUE(vol.full_link().size() == geo_obj_id::e_size);
     EXPECT_EQ(vol.link<geo_obj_id::e_portal>(), acc_link);
     EXPECT_EQ(vol.link<geo_obj_id::e_passive>(), acc_link);
diff --git a/tests/unit_tests/cpu/geometry_volume.cpp b/tests/unit_tests/cpu/geometry_volume.cpp
index c9c3a41f3..977f308bb 100644
--- a/tests/unit_tests/cpu/geometry_volume.cpp
+++ b/tests/unit_tests/cpu/geometry_volume.cpp
@@ -25,7 +25,7 @@ enum geo_objects : unsigned int {
 };
 
 // surface finder ids for testing
-enum sf_finder_ids : unsigned int {
+enum accel_ids : unsigned int {
     e_default = 0,
     e_grid = 1,
 };
@@ -36,23 +36,22 @@ enum sf_finder_ids : unsigned int {
 GTEST_TEST(detray_geometry, detector_volume) {
     using namespace detray;
 
-    using sf_finder_link_t = dtyped_index<sf_finder_ids, dindex>;
-    using volume_t = volume_descriptor<geo_objects, sf_finder_link_t>;
+    using accel_link_t = dtyped_index<accel_ids, dindex>;
+    using volume_t = volume_descriptor<geo_objects, accel_link_t>;
 
     // Check construction, setters and getters
     volume_t v1(volume_id::e_cylinder);
     v1.set_index(12345u);
-    v1.template set_link<geo_objects::e_portal>({sf_finder_ids::e_default, 1u});
-    v1.template set_link<geo_objects::e_sensitive>(
-        {sf_finder_ids::e_grid, 12u});
+    v1.template set_link<geo_objects::e_portal>({accel_ids::e_default, 1u});
+    v1.template set_link<geo_objects::e_sensitive>({accel_ids::e_grid, 12u});
 
     ASSERT_TRUE(v1.id() == volume_id::e_cylinder);
     ASSERT_TRUE(v1.index() == 12345u);
     ASSERT_TRUE(v1.template link<geo_objects::e_portal>().id() ==
-                sf_finder_ids::e_default);
+                accel_ids::e_default);
     ASSERT_TRUE(v1.template link<geo_objects::e_portal>().index() == 1u);
     ASSERT_TRUE(v1.template link<geo_objects::e_sensitive>().id() ==
-                sf_finder_ids::e_grid);
+                accel_ids::e_grid);
     ASSERT_TRUE(v1.template link<geo_objects::e_sensitive>().index() == 12u);
 
     // Check copy constructor
@@ -60,9 +59,9 @@ GTEST_TEST(detray_geometry, detector_volume) {
     ASSERT_EQ(v2.id(), volume_id::e_cylinder);
     ASSERT_EQ(v2.index(), 12345u);
     ASSERT_TRUE(v2.template link<geo_objects::e_portal>().id() ==
-                sf_finder_ids::e_default);
+                accel_ids::e_default);
     ASSERT_TRUE(v2.template link<geo_objects::e_portal>().index() == 1u);
     ASSERT_TRUE(v2.template link<geo_objects::e_sensitive>().id() ==
-                sf_finder_ids::e_grid);
+                accel_ids::e_grid);
     ASSERT_TRUE(v2.template link<geo_objects::e_sensitive>().index() == 12u);
 }
diff --git a/tests/unit_tests/cpu/grid_grid_builder.cpp b/tests/unit_tests/cpu/grid_grid_builder.cpp
index db985e79d..26128be8b 100644
--- a/tests/unit_tests/cpu/grid_grid_builder.cpp
+++ b/tests/unit_tests/cpu/grid_grid_builder.cpp
@@ -156,7 +156,7 @@ GTEST_TEST(detray_tools, decorator_grid_builder) {
 
     using transform3 = typename detector_t::transform3;
     using geo_obj_id = typename detector_t::geo_obj_ids;
-    using acc_ids = typename detector_t::sf_finders::id;
+    using acc_ids = typename detector_t::accel::id;
     using mask_id = typename detector_t::masks::id;
 
     // cylinder grid type of the toy detector
@@ -278,8 +278,8 @@ GTEST_TEST(detray_tools, decorator_grid_builder) {
 
     // check the portals in the detector
     const auto& bf_finder =
-        d.surface_store()
-            .template get<detector_t::sf_finders::id::e_brute_force>()[0];
+        d.accelerator_store()
+            .template get<detector_t::accel::id::e_brute_force>()[0];
     for (const auto& sf : bf_finder.all()) {
         EXPECT_TRUE((sf.id() == surface_id::e_portal) or
                     (sf.id() == surface_id::e_passive));
@@ -288,8 +288,8 @@ GTEST_TEST(detray_tools, decorator_grid_builder) {
 
     // check the sensitive surfaces in the grid
     const auto& cyl_grid =
-        d.surface_store()
-            .template get<detector_t::sf_finders::id::e_cylinder2_grid>()[0];
+        d.accelerator_store()
+            .template get<detector_t::accel::id::e_cylinder2_grid>()[0];
     dindex trf_idx{3u};
     for (const auto& sf : cyl_grid.all()) {
         EXPECT_TRUE(sf.is_sensitive());
diff --git a/tests/unit_tests/device/cuda/detector_cuda_kernel.cu b/tests/unit_tests/device/cuda/detector_cuda_kernel.cu
index cc939b938..683d53160 100644
--- a/tests/unit_tests/device/cuda/detector_cuda_kernel.cu
+++ b/tests/unit_tests/device/cuda/detector_cuda_kernel.cu
@@ -69,9 +69,9 @@ __global__ void detector_test_kernel(
     }
 
     // print output test for surface finder
-    /*auto& sf_finder_device = det_device.sf_finders_store();
-    for (unsigned int i_s = 0u; i_s < sf_finder_device.size(); i_s++) {
-        auto& grid = sf_finder_device[i_s];
+    /*auto& accel_device = det_device.accelerator_store();
+    for (unsigned int i_s = 0u; i_s < accel_device.size(); i_s++) {
+        auto& grid = accel_device[i_s];
         for (unsigned int i = 0u; i < grid.axis_p0().bins(); i++) {
             for (unsigned int j = 0u; j < grid.axis_p1().bins(); j++) {
                 const auto& bin = grid.bin(i, j);
diff --git a/tutorials/include/detray/tutorial/detector_metadata.hpp b/tutorials/include/detray/tutorial/detector_metadata.hpp
index 17f928f83..5dccd1af7 100644
--- a/tutorials/include/detray/tutorial/detector_metadata.hpp
+++ b/tutorials/include/detray/tutorial/detector_metadata.hpp
@@ -68,7 +68,7 @@ struct my_metadata {
     /// How to index the constituent objects in a volume
     /// If they share the same index value here, they will be added into the
     /// same acceleration data structure in every respective volume
-    enum geo_objects : std::size_t {
+    enum geo_objects : std::uint8_t {
         e_surface = 0u,  //< This detector keeps all surfaces in the same
                          //  acceleration data structure (id 0)
         e_size = 1u
@@ -88,7 +88,7 @@ struct my_metadata {
     /// good idea to have the most common types in the first tuple entries, in
     /// order to minimize the depth of the 'unrolling' before a mask is found
     /// in the tuple
-    enum class mask_ids {
+    enum class mask_ids : std::uint8_t {
         e_square2 = 0,
         e_trapezoid2 = 1,
         e_portal_rectangle2 = 2
@@ -104,7 +104,7 @@ struct my_metadata {
                             trapezoid, rectangle>;
 
     /// Similar to the mask store, there is a material store, which
-    enum class material_ids {
+    enum class material_ids : std::uint8_t {
         e_slab = 0,
         e_none = 1,
     };
@@ -122,14 +122,14 @@ struct my_metadata {
     using transform_link = typename transform_store<>::link_type;
     using mask_link = typename mask_store<>::single_link;
     using material_link = typename material_store<>::single_link;
-    using source_link = dindex;
+    using source_link = std::uint64_t;
     using surface_type =
         surface_descriptor<mask_link, material_link, transform_link, nav_link,
                            source_link>;
 
     /// The acceleration data structures live in another tuple that needs to
     /// indexed correctly
-    enum class sf_finder_ids {
+    enum class accel_ids : std::uint8_t {
         e_brute_force = 0,  //< test all surfaces in a volume (brute force)
         e_default = e_brute_force,
     };
@@ -140,8 +140,8 @@ struct my_metadata {
     /// ( @c empty_context )
     template <template <typename...> class tuple_t = dtuple,
               typename container_t = host_container_types>
-    using surface_finder_store =
-        multi_store<sf_finder_ids, empty_context, tuple_t,
+    using accelerator_store =
+        multi_store<accel_ids, empty_context, tuple_t,
                     brute_force_collection<surface_type, container_t>>;
 
     /// Data structure that allows to find the current detector volume from a
diff --git a/tutorials/include/detray/tutorial/square_surface_generator.hpp b/tutorials/include/detray/tutorial/square_surface_generator.hpp
index 8b8c5e4b6..0b4fe3629 100644
--- a/tutorials/include/detray/tutorial/square_surface_generator.hpp
+++ b/tutorials/include/detray/tutorial/square_surface_generator.hpp
@@ -60,7 +60,7 @@ class square_surface_generator final
     /// @param ctx the geometry context.
     DETRAY_HOST
     auto operator()(typename detector_t::volume_type &volume,
-                    typename detector_t::surface_container_t &surfaces,
+                    typename detector_t::surface_container &surfaces,
                     typename detector_t::transform_container &transforms,
                     typename detector_t::mask_container &masks,
                     typename detector_t::geometry_context ctx = {}) const
diff --git a/tutorials/src/device/cuda/detector_construction.cpp b/tutorials/src/device/cuda/detector_construction.cpp
index af853dae7..4d024aea4 100644
--- a/tutorials/src/device/cuda/detector_construction.cpp
+++ b/tutorials/src/device/cuda/detector_construction.cpp
@@ -74,6 +74,9 @@ int main() {
     auto vol_buff = detray::get_buffer(det_host.volumes(), dev_mr, cuda_cpy,
                                        detray::copy::sync,
                                        vecmem::data::buffer_type::fixed_size);
+    auto sf_buff = detray::get_buffer(det_host.surface_lookup(), dev_mr,
+                                      cuda_cpy, detray::copy::sync,
+                                      vecmem::data::buffer_type::fixed_size);
     // Use resizable buffer and asynchronous copy for alignment
     auto trf_buff = detray::get_buffer(det_host.transform_store(), dev_mr,
                                        cuda_cpy, detray::copy::async,
@@ -84,20 +87,17 @@ int main() {
     auto mat_buff = detray::get_buffer(det_host.material_store(), dev_mr,
                                        cuda_cpy, detray::copy::sync,
                                        vecmem::data::buffer_type::fixed_size);
-    auto sf_buff = detray::get_buffer(det_host.surface_store(), dev_mr,
-                                      cuda_cpy, detray::copy::sync,
-                                      vecmem::data::buffer_type::fixed_size);
-    auto sf_lkp_buff = detray::get_buffer(
-        det_host.surface_lookup(), dev_mr, cuda_cpy, detray::copy::sync,
-        vecmem::data::buffer_type::fixed_size);
+    auto acc_buff = detray::get_buffer(det_host.accelerator_store(), dev_mr,
+                                       cuda_cpy, detray::copy::sync,
+                                       vecmem::data::buffer_type::fixed_size);
     auto vgrid_buff = detray::get_buffer(det_host.volume_search_grid(), dev_mr,
                                          cuda_cpy, detray::copy::sync,
                                          vecmem::data::buffer_type::fixed_size);
 
     // Assemble the detector buffer
     auto det_custom_buff = typename decltype(det_host)::buffer_type(
-        std::move(vol_buff), std::move(trf_buff), std::move(msk_buff),
-        std::move(mat_buff), std::move(sf_buff), std::move(sf_lkp_buff),
+        std::move(vol_buff), std::move(sf_buff), std::move(trf_buff),
+        std::move(msk_buff), std::move(mat_buff), std::move(acc_buff),
         std::move(vgrid_buff));
 
     std::cout << "\nCustom buffer setup:" << std::endl;
diff --git a/tutorials/src/device/cuda/detector_construction.cu b/tutorials/src/device/cuda/detector_construction.cu
index c9b52d09f..85668d61a 100644
--- a/tutorials/src/device/cuda/detector_construction.cu
+++ b/tutorials/src/device/cuda/detector_construction.cu
@@ -34,11 +34,11 @@ __global__ void print_kernel(
     printf("Number of portal cylinders: %d\n",
            det.mask_store().get<mask_id::e_portal_cylinder2>().size());
     printf("Number of portal collections: %d\n",
-           det.surface_store().get<acc_id::e_brute_force>().size());
+           det.accelerator_store().get<acc_id::e_brute_force>().size());
     printf("Number of disc grids: %d\n",
-           det.surface_store().get<acc_id::e_disc_grid>().size());
+           det.accelerator_store().get<acc_id::e_disc_grid>().size());
     printf("Number of cylinder grids: %d\n",
-           det.surface_store().get<acc_id::e_cylinder2_grid>().size());
+           det.accelerator_store().get<acc_id::e_cylinder2_grid>().size());
 }
 
 void print(typename detray::tutorial::detector_host_t::view_type det_data) {
diff --git a/tutorials/src/device/cuda/detector_construction.hpp b/tutorials/src/device/cuda/detector_construction.hpp
index 23a199217..c5656907e 100644
--- a/tutorials/src/device/cuda/detector_construction.hpp
+++ b/tutorials/src/device/cuda/detector_construction.hpp
@@ -21,7 +21,7 @@ using detector_device_t =
     detector<detray::toy_metadata, device_container_types>;
 
 using mask_id = typename detector_host_t::masks::id;
-using acc_id = typename detector_host_t::sf_finders::id;
+using acc_id = typename detector_host_t::accel::id;
 
 /// Detector construction tutorial function (prints some detector statistics)
 void print(typename detector_host_t::view_type det_data);
diff --git a/utils/include/detray/detectors/create_telescope_detector.hpp b/utils/include/detray/detectors/create_telescope_detector.hpp
index 76f824011..030c474c9 100644
--- a/utils/include/detray/detectors/create_telescope_detector.hpp
+++ b/utils/include/detray/detectors/create_telescope_detector.hpp
@@ -460,12 +460,12 @@ inline auto create_telescope_detector(
 
     // The telescope detector has only one volume with default placement
     auto &vol = det.new_volume(volume_id::e_cuboid,
-                               {detector_t::sf_finders::id::e_default, 0u});
+                               {detector_t::accel::id::e_default, 0u});
     vol.set_transform(det.transform_store().size());
     det.transform_store().emplace_back();
 
     // Add module surfaces to volume
-    typename detector_t::surface_container_t surfaces(&resource);
+    typename detector_t::surface_container surfaces(&resource);
     typename detector_t::mask_container masks(resource);
     typename detector_t::material_container materials(resource);
     typename detector_t::transform_container transforms(resource);
diff --git a/utils/include/detray/detectors/create_toy_geometry.hpp b/utils/include/detray/detectors/create_toy_geometry.hpp
index 70334397b..1cff20810 100644
--- a/utils/include/detray/detectors/create_toy_geometry.hpp
+++ b/utils/include/detray/detectors/create_toy_geometry.hpp
@@ -179,7 +179,7 @@ template <
     std::enable_if_t<
         std::is_invocable_v<factory_t, typename detector_t::geometry_context &,
                             typename detector_t::volume_type &,
-                            typename detector_t::surface_container_t &,
+                            typename detector_t::surface_container &,
                             typename detector_t::mask_container &,
                             typename detector_t::material_container &,
                             typename detector_t::transform_container &>,
@@ -192,10 +192,10 @@ inline void add_cylinder_grid(const typename detector_t::geometry_context &ctx,
     using geo_obj_ids = typename detector_t::geo_obj_ids;
 
     constexpr auto cyl_id = detector_t::masks::id::e_portal_cylinder2;
-    constexpr auto grid_id = detector_t::sf_finders::id::e_cylinder2_grid;
+    constexpr auto grid_id = detector_t::accel::id::e_cylinder2_grid;
 
     using cyl_grid_t =
-        typename detector_t::surface_container::template get_type<grid_id>;
+        typename detector_t::accelerator_container::template get_type<grid_id>;
     auto gbuilder =
         grid_builder<detector_t, cyl_grid_t, detray::detail::fill_by_pos>{
             nullptr};
@@ -217,7 +217,7 @@ inline void add_cylinder_grid(const typename detector_t::geometry_context &ctx,
     const cyl_mask_t cyl_mask{mask_values, 0u};
 
     // Create the sensitive surfaces
-    typename detector_t::surface_container_t surfaces(&resource);
+    typename detector_t::surface_container surfaces(&resource);
     typename detector_t::mask_container masks(resource);
     typename detector_t::material_container materials(resource);
     typename detector_t::transform_container transforms(resource);
@@ -253,9 +253,9 @@ inline void add_cylinder_grid(const typename detector_t::geometry_context &ctx,
                        det.transform_store(), det.mask_store(), ctx);
     assert(gbuilder.get().all().size() == surfaces.size());
 
-    det.surface_store().template push_back<grid_id>(gbuilder.get());
+    det.accelerator_store().template push_back<grid_id>(gbuilder.get());
     vol.template set_link<geo_obj_ids::e_sensitive>(
-        grid_id, det.surface_store().template size<grid_id>() - 1u);
+        grid_id, det.accelerator_store().template size<grid_id>() - 1u);
 }
 
 /// Helper function that creates a surface grid of trapezoidal endcap modules.
@@ -270,7 +270,7 @@ template <
     std::enable_if_t<
         std::is_invocable_v<factory_t, typename detector_t::geometry_context &,
                             typename detector_t::volume_type &,
-                            typename detector_t::surface_container_t &,
+                            typename detector_t::surface_container &,
                             typename detector_t::mask_container &,
                             typename detector_t::material_container &,
                             typename detector_t::transform_container &>,
@@ -283,10 +283,10 @@ inline void add_disc_grid(const typename detector_t::geometry_context &ctx,
     using geo_obj_ids = typename detector_t::geo_obj_ids;
 
     constexpr auto disc_id = detector_t::masks::id::e_portal_ring2;
-    constexpr auto grid_id = detector_t::sf_finders::id::e_disc_grid;
+    constexpr auto grid_id = detector_t::accel::id::e_disc_grid;
 
     using disc_grid_t =
-        typename detector_t::surface_container::template get_type<grid_id>;
+        typename detector_t::accelerator_container::template get_type<grid_id>;
     auto gbuilder =
         grid_builder<detector_t, disc_grid_t, detray::detail::fill_by_pos>{
             nullptr};
@@ -297,7 +297,7 @@ inline void add_disc_grid(const typename detector_t::geometry_context &ctx,
         det.mask_store().template get<disc_id>().at(portal_mask_idx);
 
     // Create the sensitive surfaces
-    typename detector_t::surface_container_t surfaces(&resource);
+    typename detector_t::surface_container surfaces(&resource);
     typename detector_t::mask_container masks(resource);
     typename detector_t::material_container materials(resource);
     typename detector_t::transform_container transforms(resource);
@@ -333,9 +333,9 @@ inline void add_disc_grid(const typename detector_t::geometry_context &ctx,
                        det.transform_store(), det.mask_store(), ctx);
     assert(gbuilder.get().all().size() == surfaces.size());
 
-    det.surface_store().template push_back<grid_id>(gbuilder.get());
+    det.accelerator_store().template push_back<grid_id>(gbuilder.get());
     vol.template set_link<geo_obj_ids::e_sensitive>(
-        grid_id, det.surface_store().template size<grid_id>() - 1u);
+        grid_id, det.accelerator_store().template size<grid_id>() - 1u);
 }
 
 /** Helper method for positioning of modules in an endcap ring
@@ -541,7 +541,7 @@ inline void add_beampipe(
                                     : edc_lay_sizes[n_edc_layers - 1u].second};
     scalar min_z{-max_z};
 
-    typename detector_t::surface_container_t surfaces(&resource);
+    typename detector_t::surface_container surfaces(&resource);
     typename detector_t::mask_container masks(resource);
     typename detector_t::material_container materials(resource);
     typename detector_t::transform_container transforms(resource);
@@ -553,9 +553,9 @@ inline void add_beampipe(
     det.transform_store().emplace_back(ctx);
 
     beampipe.template set_link<object_id::e_portal>(
-        detector_t::sf_finders::id::e_default, 0u);
+        detector_t::accel::id::e_default, 0u);
     beampipe.template set_link<object_id::e_passive>(
-        detector_t::sf_finders::id::e_default, 0u);
+        detector_t::accel::id::e_default, 0u);
 
     // This is the beampipe surface
     dindex volume_link{beampipe_idx};
@@ -657,14 +657,14 @@ inline void add_endcap_barrel_connection(
     const scalar edc_disc_z{side < 0 ? min_z : max_z};
     const scalar brl_disc_z{side < 0 ? max_z : min_z};
 
-    typename detector_t::surface_container_t surfaces(&resource);
+    typename detector_t::surface_container surfaces(&resource);
     typename detector_t::mask_container masks(resource);
     typename detector_t::material_container materials(resource);
     typename detector_t::transform_container transforms(resource);
 
-    auto &connector_gap = det.new_volume(volume_id::e_cylinder,
-                                         {detector_t::sf_finders::id::e_default,
-                                          detail::invalid_value<dindex>()});
+    auto &connector_gap = det.new_volume(
+        volume_id::e_cylinder,
+        {detector_t::accel::id::e_default, detail::invalid_value<dindex>()});
     dindex connector_gap_idx{det.volumes().back().index()};
     names[connector_gap_idx + 1u] =
         "connector_gap_" + std::to_string(connector_gap_idx);
@@ -982,7 +982,7 @@ inline auto create_toy_geometry(vecmem::memory_resource &resource,
 
         void operator()(const typename detector_t::geometry_context &ctx,
                         typename detector_t::volume_type &volume,
-                        typename detector_t::surface_container_t &surfaces,
+                        typename detector_t::surface_container &surfaces,
                         typename detector_t::mask_container &masks,
                         typename detector_t::material_container &materials,
                         typename detector_t::transform_container &transforms) {
@@ -997,7 +997,7 @@ inline auto create_toy_geometry(vecmem::memory_resource &resource,
 
         void operator()(const typename detector_t::geometry_context &ctx,
                         typename detector_t::volume_type &volume,
-                        typename detector_t::surface_container_t &surfaces,
+                        typename detector_t::surface_container &surfaces,
                         typename detector_t::mask_container &masks,
                         typename detector_t::material_container &materials,
                         typename detector_t::transform_container &transforms) {
diff --git a/utils/include/detray/detectors/create_wire_chamber.hpp b/utils/include/detray/detectors/create_wire_chamber.hpp
index bb05f17bc..e77cdc4b5 100644
--- a/utils/include/detray/detectors/create_wire_chamber.hpp
+++ b/utils/include/detray/detectors/create_wire_chamber.hpp
@@ -130,7 +130,7 @@ inline auto create_wire_chamber(vecmem::memory_resource &resource,
         auto mask_volume_link{static_cast<nav_link_t>(volume_idx)};
 
         // Containers per volume
-        typename detector_t::surface_container_t surfaces(&resource);
+        typename detector_t::surface_container surfaces(&resource);
         typename detector_t::mask_container masks(resource);
         typename detector_t::material_container materials(resource);
         typename detector_t::transform_container transforms(resource);
@@ -212,10 +212,11 @@ inline auto create_wire_chamber(vecmem::memory_resource &resource,
         // Get relevant ids
         using geo_obj_ids = typename detector_t::geo_obj_ids;
         constexpr auto cyl_id = detector_t::masks::id::e_portal_cylinder2;
-        constexpr auto grid_id = detector_t::sf_finders::id::e_cylinder2_grid;
+        constexpr auto grid_id = detector_t::accel::id::e_cylinder2_grid;
 
         using cyl_grid_t =
-            typename detector_t::surface_container::template get_type<grid_id>;
+            typename detector_t::accelerator_container::template get_type<
+                grid_id>;
         auto gbuilder =
             grid_builder<detector_t, cyl_grid_t, detray::detail::fill_by_pos>{
                 nullptr};
@@ -241,9 +242,9 @@ inline auto create_wire_chamber(vecmem::memory_resource &resource,
         gbuilder.fill_grid(detector_volume{det, vol}, det.surface_lookup(),
                            det.transform_store(), det.mask_store(), ctx0);
 
-        det.surface_store().template push_back<grid_id>(gbuilder.get());
+        det.accelerator_store().template push_back<grid_id>(gbuilder.get());
         vol.template set_link<geo_obj_ids::e_sensitive>(
-            grid_id, det.surface_store().template size<grid_id>() - 1u);
+            grid_id, det.accelerator_store().template size<grid_id>() - 1u);
 
         // Add volume grid
         // TODO: Fill it
diff --git a/utils/include/detray/detectors/detector_helper.hpp b/utils/include/detray/detectors/detector_helper.hpp
index 7061ce96b..189293ee8 100644
--- a/utils/include/detray/detectors/detector_helper.hpp
+++ b/utils/include/detray/detectors/detector_helper.hpp
@@ -169,13 +169,13 @@ struct detector_helper {
         const scalar_t upper_z{std::max(lay_neg_z, lay_pos_z)};
 
         // Add module surfaces to volume
-        typename detector_t::surface_container_t surfaces(&resource);
+        typename detector_t::surface_container surfaces(&resource);
         typename detector_t::mask_container masks(resource);
         typename detector_t::material_container materials(resource);
         typename detector_t::transform_container transforms(resource);
 
         auto &cyl_volume = det.new_volume(
-            volume_id::e_cylinder, {detector_t::sf_finders::id::e_default, 0u});
+            volume_id::e_cylinder, {detector_t::accel::id::e_default, 0u});
 
         // volume placement
         cyl_volume.set_transform(det.transform_store().size());
diff --git a/utils/include/detray/detectors/itk_metadata.hpp b/utils/include/detray/detectors/itk_metadata.hpp
index 47e4987fc..797fda097 100644
--- a/utils/include/detray/detectors/itk_metadata.hpp
+++ b/utils/include/detray/detectors/itk_metadata.hpp
@@ -69,7 +69,7 @@ struct itk_metadata {
     /// good idea to have the most common types in the first tuple entries, in
     /// order to minimize the depth of the 'unrolling' before a mask is found
     /// in the tuple
-    enum class mask_ids {
+    enum class mask_ids : std::uint8_t {
         e_rectangle2 = 0,
         e_annulus2 = 1,
         e_portal_cylinder2 = 2,
@@ -86,7 +86,7 @@ struct itk_metadata {
                             rectangle, annulus, cylinder_portal, disc_portal>;
 
     /// Similar to the mask store, there is a material store, which
-    enum class material_ids {
+    enum class material_ids : std::uint8_t {
         e_slab = 0,
         e_none = 1,
     };
@@ -104,7 +104,7 @@ struct itk_metadata {
     using transform_link = typename transform_store<>::link_type;
     using mask_link = typename mask_store<>::single_link;
     using material_link = typename material_store<>::single_link;
-    using source_link = dindex;
+    using source_link = std::uint64_t;
     /// Surface type used for sensitives, passives and portals
     using surface_type =
         surface_descriptor<mask_link, material_link, transform_link, nav_link,
@@ -113,7 +113,7 @@ struct itk_metadata {
     /// How to index the constituent objects in a volume
     /// If they share the same index value here, they will be added into the
     /// same acceleration data structure in every respective volume
-    enum geo_objects : unsigned int {
+    enum geo_objects : std::uint8_t {
         e_surface = 0u,  //< This detector keeps all surfaces in the same
         e_portal = 0u,   //  acceleration data structure (id 0)
         e_passive = 0u,
@@ -122,7 +122,7 @@ struct itk_metadata {
 
     /// The acceleration data structures live in another tuple that needs to be
     /// indexed correctly:
-    enum class sf_finder_ids {
+    enum class accel_ids : std::uint8_t {
         e_brute_force = 0,  //< test all surfaces in a volume (brute force)
         e_default = e_brute_force,
     };
@@ -130,7 +130,7 @@ struct itk_metadata {
     /// How a volume finds its constituent objects in the detector containers
     /// In this case: One range for sensitive/passive surfaces, one for portals
     using object_link_type =
-        dmulti_index<dtyped_index<sf_finder_ids, dindex>, geo_objects::e_size>;
+        dmulti_index<dtyped_index<accel_ids, dindex>, geo_objects::e_size>;
 
     /// The tuple store that hold the acceleration data structures for all
     /// volumes. Every collection of accelerationdata structures defines its
@@ -138,8 +138,8 @@ struct itk_metadata {
     /// ( @c empty_context )
     template <template <typename...> class tuple_t = dtuple,
               typename container_t = host_container_types>
-    using surface_finder_store =
-        multi_store<sf_finder_ids, empty_context, tuple_t,
+    using accelerator_store =
+        multi_store<accel_ids, empty_context, tuple_t,
                     brute_force_collection<surface_type, container_t>>;
 
     /// Data structure that allows to find the current detector volume from a
diff --git a/utils/include/detray/detectors/telescope_metadata.hpp b/utils/include/detray/detectors/telescope_metadata.hpp
index c76184273..6c4d30eb3 100644
--- a/utils/include/detray/detectors/telescope_metadata.hpp
+++ b/utils/include/detray/detectors/telescope_metadata.hpp
@@ -45,7 +45,7 @@ struct telescope_metadata {
 
     /// Rectangles are always needed as portals (but the yhave the same type as
     /// module rectangles). Only one additional mask shape is allowed
-    enum class mask_ids {
+    enum class mask_ids : std::uint8_t {
         e_rectangle2 = 0,
         e_portal_rectangle2 = 0,
         e_annulus2 = 1,
@@ -78,7 +78,7 @@ struct telescope_metadata {
                             rectangle, mask<mask_shape_t, nav_link>>>;
 
     /// Material type ids
-    enum class material_ids {
+    enum class material_ids : std::uint8_t {
         e_slab = 0,
         e_rod = 0,
         e_none = 1,
@@ -99,14 +99,14 @@ struct telescope_metadata {
     using transform_link = typename transform_store<>::link_type;
     using mask_link = typename mask_store<>::single_link;
     using material_link = typename material_store<>::single_link;
-    using source_link = dindex;
+    using source_link = std::uint64_t;
     /// Surface type used for sensitives, passives and portals
     using surface_type =
         surface_descriptor<mask_link, material_link, transform_link, nav_link,
                            source_link>;
 
     /// No grids/other acceleration data structure, everything is brute forced
-    enum geo_objects : std::size_t {
+    enum geo_objects : std::uint8_t {
         e_sensitive = 0,
         e_portal = 0,
         e_size = 1,
@@ -114,20 +114,20 @@ struct telescope_metadata {
     };
 
     /// Acceleration data structures
-    enum class sf_finder_ids {
+    enum class accel_ids {
         e_brute_force = 0,  // test all surfaces in a volume (brute force)
         e_default = e_brute_force,
     };
 
     /// One link for all surfaces (in the brute force method)
     using object_link_type =
-        dmulti_index<dtyped_index<sf_finder_ids, dindex>, geo_objects::e_size>;
+        dmulti_index<dtyped_index<accel_ids, dindex>, geo_objects::e_size>;
 
     /// How to store the brute force search data structure
     template <template <typename...> class tuple_t = dtuple,
               typename container_t = host_container_types>
-    using surface_finder_store =
-        multi_store<sf_finder_ids, empty_context, tuple_t,
+    using accelerator_store =
+        multi_store<accel_ids, empty_context, tuple_t,
                     brute_force_collection<surface_type, container_t>>;
 
     /// Volume search (only one volume exists)
diff --git a/utils/include/detray/detectors/toy_metadata.hpp b/utils/include/detray/detectors/toy_metadata.hpp
index 8858536ca..e792144de 100644
--- a/utils/include/detray/detectors/toy_metadata.hpp
+++ b/utils/include/detray/detectors/toy_metadata.hpp
@@ -67,7 +67,7 @@ struct toy_metadata {
                                          vector_t, geometry_context>;
 
     /// Mask type ids
-    enum class mask_ids {
+    enum class mask_ids : std::uint8_t {
         e_rectangle2 = 0,
         e_trapezoid2 = 1,
         e_portal_cylinder2 = 2,
@@ -83,7 +83,7 @@ struct toy_metadata {
                             rectangle, trapezoid, cylinder_portal, disc_portal>;
 
     /// Material type ids
-    enum class material_ids {
+    enum class material_ids : std::uint8_t {
         e_slab = 0,
         e_none = 1,
     };
@@ -98,14 +98,14 @@ struct toy_metadata {
     using transform_link = typename transform_store<>::link_type;
     using mask_link = typename mask_store<>::single_link;
     using material_link = typename material_store<>::single_link;
-    using source_link = dindex;
+    using source_link = std::uint64_t;
     /// Surface type used for sensitives, passives and portals
     using surface_type =
         surface_descriptor<mask_link, material_link, transform_link, nav_link,
                            source_link>;
 
     /// Portals and passives in the brute froce search, sensitives in the grids
-    enum geo_objects : std::size_t {
+    enum geo_objects : std::uint8_t {
         e_sensitive = 1,
         e_portal = 0,
         e_passive = 0,
@@ -114,7 +114,7 @@ struct toy_metadata {
     };
 
     /// Acceleration data structures
-    enum class sf_finder_ids {
+    enum class accel_ids : std::uint8_t {
         e_brute_force = 0,     // test all surfaces in a volume (brute force)
         e_disc_grid = 1,       // endcap
         e_cylinder2_grid = 2,  // barrel
@@ -123,13 +123,13 @@ struct toy_metadata {
 
     /// One link for portals/passives and one sensitive surfaces
     using object_link_type =
-        dmulti_index<dtyped_index<sf_finder_ids, dindex>, geo_objects::e_size>;
+        dmulti_index<dtyped_index<accel_ids, dindex>, geo_objects::e_size>;
 
     /// How to store the acceleration data structures
     template <template <typename...> class tuple_t = dtuple,
               typename container_t = host_container_types>
-    using surface_finder_store = multi_store<
-        sf_finder_ids, empty_context, tuple_t,
+    using accelerator_store = multi_store<
+        accel_ids, empty_context, tuple_t,
         brute_force_collection<surface_type, container_t>,
         grid_collection<disc_sf_grid<surface_type, container_t>>,
         grid_collection<cylinder_sf_grid<surface_type, container_t>>>;

From b160d6077e7166aa008dde3787db1b4372ade6ae Mon Sep 17 00:00:00 2001
From: Joana Niermann <53186085+niermann999@users.noreply.github.com>
Date: Tue, 24 Oct 2023 21:20:18 +0000
Subject: [PATCH 27/29] feat: implement plotting of ray scan positions in
 python (#567)

Add functionality to output the positions of the ray surface intersections, as well as python tools to plot them in an xy - and an rz view. The data can both be plotted for the ray and the helix scan, which needs to be turned on by the --write_scan_data option.
---
 .../unit_tests/io/io_json_detector_reader.cpp |   2 +-
 .../detray/validation/detector_helix_scan.hpp |  27 ++++
 .../detray/validation/detector_ray_scan.hpp   |  30 +++-
 tests/validation/python/plot_helpers.py       |  30 ++++
 tests/validation/python/plot_material_scan.py |  74 ++++-----
 tests/validation/python/plot_ray_scan.py      | 147 ++++++++++++++++++
 tests/validation/python/pyplot_factory.py     |  89 +++++++++--
 .../python/run_material_validation.py         |  13 +-
 .../python/run_ray_scan_validation.py         | 137 ++++++++++++++++
 tests/validation/src/detector_validation.cpp  |  50 ++++--
 tests/validation/src/material_validation.cpp  |  33 +++-
 11 files changed, 567 insertions(+), 65 deletions(-)
 create mode 100644 tests/validation/python/plot_helpers.py
 create mode 100644 tests/validation/python/plot_ray_scan.py
 create mode 100644 tests/validation/python/run_ray_scan_validation.py

diff --git a/tests/unit_tests/io/io_json_detector_reader.cpp b/tests/unit_tests/io/io_json_detector_reader.cpp
index eb953c717..2e674432c 100644
--- a/tests/unit_tests/io/io_json_detector_reader.cpp
+++ b/tests/unit_tests/io/io_json_detector_reader.cpp
@@ -87,7 +87,7 @@ TEST(io, json_telescope_detector_reader) {
     tel_det_config<rectangle2D<>> tel_cfg{rec2};
     tel_cfg.positions(positions);
 
-    // Wire chamber
+    // Telescope detector
     vecmem::host_memory_resource host_mr;
     auto [telescope_det, telescope_names] =
         create_telescope_detector(host_mr, tel_cfg);
diff --git a/tests/validation/include/detray/validation/detector_helix_scan.hpp b/tests/validation/include/detray/validation/detector_helix_scan.hpp
index 4988ae1d9..661f3f99a 100644
--- a/tests/validation/include/detray/validation/detector_helix_scan.hpp
+++ b/tests/validation/include/detray/validation/detector_helix_scan.hpp
@@ -8,7 +8,9 @@
 #pragma once
 
 // Project include(s)
+#include "detray/geometry/surface.hpp"
 #include "detray/intersection/detail/trajectories.hpp"
+#include "detray/io/common/detail/file_handle.hpp"
 #include "detray/simulation/event_generator/track_generators.hpp"
 #include "detray/test/types.hpp"
 #include "tests/common/test_base/fixture_base.hpp"
@@ -81,6 +83,7 @@ class helix_scan : public test::fixture_base<> {
         using nav_link_t = typename detector_t::surface_type::navigation_link;
 
         constexpr auto leaving_world{detail::invalid_value<nav_link_t>()};
+        typename detector_t::geometry_context gctx{};
 
         // Index of the volume that the helix origin lies in
         dindex start_index{0u};
@@ -96,6 +99,14 @@ class helix_scan : public test::fixture_base<> {
             uniform_track_generator<free_track_parameters_t>(
                 m_cfg.track_generator());
 
+        detray::io::detail::file_handle outfile{
+            m_cfg.name(), ".csv",
+            std::ios::out | std::ios::binary | std::ios::trunc};
+
+        if (m_cfg.write_intersections()) {
+            *outfile << "index,type,x,y,z," << std::endl;
+        }
+
         std::cout << "INFO: Running helix scan on: " << m_names.at(0) << "\n("
                   << trk_state_generator.size() << " helices) ...\n"
                   << std::endl;
@@ -113,6 +124,22 @@ class helix_scan : public test::fixture_base<> {
             const auto intersection_record = particle_gun::shoot_particle(
                 m_det, helix, 14.9f * unit<scalar_t>::um);
 
+            // Csv output
+            if (m_cfg.write_intersections()) {
+                for (const auto &single_ir : intersection_record) {
+                    const auto &intersection = single_ir.second;
+                    const auto sf =
+                        detray::surface{m_det, intersection.sf_desc};
+                    auto glob_pos = sf.local_to_global(gctx, intersection.local,
+                                                       helix.dir());
+                    *outfile
+                        << n_tracks << ","
+                        << static_cast<int>(intersection.sf_desc.barcode().id())
+                        << "," << glob_pos[0] << "," << glob_pos[1] << ","
+                        << glob_pos[2] << "," << std::endl;
+                }
+            }
+
             // Create a trace of the volume indices that were encountered
             // and check that portal intersections are connected
             auto [portal_trace, surface_trace] =
diff --git a/tests/validation/include/detray/validation/detector_ray_scan.hpp b/tests/validation/include/detray/validation/detector_ray_scan.hpp
index a64130c01..2cdccaace 100644
--- a/tests/validation/include/detray/validation/detector_ray_scan.hpp
+++ b/tests/validation/include/detray/validation/detector_ray_scan.hpp
@@ -8,8 +8,10 @@
 #pragma once
 
 // Project include(s)
+#include "detray/geometry/surface.hpp"
 #include "detray/geometry/volume_graph.hpp"
 #include "detray/intersection/detail/trajectories.hpp"
+#include "detray/io/common/detail/file_handle.hpp"
 #include "detray/simulation/event_generator/track_generators.hpp"
 #include "detray/test/types.hpp"
 #include "tests/common/test_base/fixture_base.hpp"
@@ -112,6 +114,7 @@ class ray_scan : public test::fixture_base<> {
         using nav_link_t = typename detector_t::surface_type::navigation_link;
 
         constexpr auto leaving_world{detail::invalid_value<nav_link_t>()};
+        typename detector_t::geometry_context gctx{};
 
         // Get the volume adjaceny matrix from ray scan
         volume_graph graph(m_det);
@@ -128,16 +131,41 @@ class ray_scan : public test::fixture_base<> {
         auto ray_generator =
             uniform_track_generator<ray_t>(m_cfg.track_generator());
 
+        // Csv output file
+        detray::io::detail::file_handle outfile{
+            m_cfg.name(), ".csv",
+            std::ios::out | std::ios::binary | std::ios::trunc};
+
+        if (m_cfg.write_intersections()) {
+            *outfile << "index,type,x,y,z," << std::endl;
+        }
+
         std::cout << "INFO: Running ray scan on: " << m_names.at(0) << "\n("
                   << ray_generator.size() << " rays) ...\n"
                   << std::endl;
 
-        for (const auto ray : ray_generator) {
+        for (const auto &ray : ray_generator) {
 
             // Record all intersections and surfaces along the ray
             const auto intersection_record =
                 particle_gun::shoot_particle(m_det, ray);
 
+            // Csv output
+            if (m_cfg.write_intersections()) {
+                for (const auto &single_ir : intersection_record) {
+                    const auto &intersection = single_ir.second;
+                    const auto sf =
+                        detray::surface{m_det, intersection.sf_desc};
+                    auto glob_pos =
+                        sf.local_to_global(gctx, intersection.local, ray.dir());
+                    *outfile
+                        << n_tracks << ","
+                        << static_cast<int>(intersection.sf_desc.barcode().id())
+                        << "," << glob_pos[0] << "," << glob_pos[1] << ","
+                        << glob_pos[2] << "," << std::endl;
+                }
+            }
+
             // Create a trace of the volume indices that were encountered
             // and check that portal intersections are connected
             auto [portal_trace, surface_trace] =
diff --git a/tests/validation/python/plot_helpers.py b/tests/validation/python/plot_helpers.py
new file mode 100644
index 000000000..960eccca7
--- /dev/null
+++ b/tests/validation/python/plot_helpers.py
@@ -0,0 +1,30 @@
+# Detray library, part of the ACTS project (R&D line)
+#
+# (c) 2023 CERN for the benefit of the ACTS project
+#
+# Mozilla Public License Version 2.0
+
+from collections import namedtuple
+
+#-------------------------------------------------------------------------------
+# Common helpers for plotting measurement data
+#-------------------------------------------------------------------------------
+
+""" Filter the data in a data frame by a given prescription """
+def filter_data(data, filter = lambda df: [], variables = []):
+    dataColl = []
+
+    # Get global data
+    if len(filter(data)) == 0:
+        for var in variables:
+            dataColl.append(data[var].to_numpy())
+
+    # Filtered data
+    else:
+        filtered = data.loc[filter]
+        for var in variables:
+            dataColl.append(filtered[var].to_numpy())
+
+    return tuple(dataColl)
+
+#-------------------------------------------------------------------------------
diff --git a/tests/validation/python/plot_material_scan.py b/tests/validation/python/plot_material_scan.py
index 2007456f9..f057375d9 100644
--- a/tests/validation/python/plot_material_scan.py
+++ b/tests/validation/python/plot_material_scan.py
@@ -4,6 +4,8 @@
 #
 # Mozilla Public License Version 2.0
 
+from pyplot_factory import get_legend_options
+
 # python includes
 import numpy as np
 import math
@@ -29,7 +31,7 @@ def get_n_bins(df):
 
 
 """ Plot the material thickenss vs phi and eta in units of X_0 """
-def X0_vs_eta_phi(df, detector, plotFactory, format = "svg"):
+def X0_vs_eta_phi(df, detector, plotFactory,  out_format =  "pdf"):
 
     # Histogram bin edges
     xBinning, yBinning = get_n_bins(df)
@@ -39,34 +41,32 @@ def X0_vs_eta_phi(df, detector, plotFactory, format = "svg"):
                             x      = df["eta"],
                             y      = df["phi"],
                             z      = df['mat_tX0'],
-                            title  = r'\textbf{Material Scan - thickness / }$\mathbf{X_0}$',
                             label  = detector,
-                            xLabel = r'$\mathbf{\eta}$',
-                            yLabel = r'$\mathbf{\phi}\,\mathrm{[rad]}$',
+                            xLabel = r'$\eta$',
+                            yLabel = r'$\phi\,\mathrm{[rad]}$',
                             zLabel = r'thickness / $X_0$',
                             xBins = xBinning, yBins = yBinning,
                             showStats = False)
 
-    plotFactory.write_plot(hist_data, "t_X0_map", format)
+    plotFactory.write_plot(hist_data, "t_X0_map",  out_format)
 
     # Plot path length through material of the respective ray in units of X_0
     hist_data = plotFactory.hist2D(
                             x      = df["eta"],
                             y      = df["phi"],
                             z      = df['mat_sX0'],
-                            title  = r'\textbf{Material Scan - path length / }$\mathbf{X_0}$',
                             label  = detector,
-                            xLabel = r'$\mathbf{\eta}$',
-                            yLabel = r'$\mathbf{\phi}\,\mathrm{[rad]}$',
+                            xLabel = r'$\eta$',
+                            yLabel = r'$\phi\,\mathrm{[rad]}$',
                             zLabel = r'path length / $X_0$',
                             xBins = xBinning, yBins = yBinning,
                             showStats = False)
 
-    plotFactory.write_plot(hist_data, "s_X0_map", format)
+    plotFactory.write_plot(hist_data, "s_X0_map",  out_format)
 
 
 """ Plot the material thickenss vs phi and eta in units of L_0 """
-def L0_vs_eta_phi(df, detector, plotFactory, format = "svg"):
+def L0_vs_eta_phi(df, detector, plotFactory,  out_format =  "pdf"):
 
     # Histogram bin edges
     xBinning, yBinning = get_n_bins(df)
@@ -76,93 +76,95 @@ def L0_vs_eta_phi(df, detector, plotFactory, format = "svg"):
                             x      = df["eta"],
                             y      = df["phi"],
                             z      = df['mat_tL0'],
-                            title  = r'\textbf{Material Scan - thickness /} $\mathbf{\Lambda_0}$',
                             label  = detector,
-                            xLabel = r'$\mathbf{\eta}$',
-                            yLabel = r'$\mathbf{\phi}\,\mathrm{[rad]}$',
+                            xLabel = r'$\eta$',
+                            yLabel = r'$\phi\,\mathrm{[rad]}$',
                             zLabel = r'thickness / $\Lambda_0$',
                             xBins = xBinning, yBins = yBinning,
                             showStats = False)
 
-    plotFactory.write_plot(hist_data, "t_L0_map", format)
+    plotFactory.write_plot(hist_data, "t_L0_map",  out_format)
 
     # Plot path length through material of the respective ray in units of L_0
     hist_data = plotFactory.hist2D(
                             x      = df["eta"],
                             y      = df["phi"],
                             z      = df['mat_sL0'],
-                            title  = r'\textbf{Material Scan - path length /} $\mathbf{\Lambda_0}$',
                             label  = detector,
-                            xLabel = r'$\mathbf{\eta}$',
-                            yLabel = r'$\mathbf{\phi}\,\mathrm{[rad]}$',
+                            xLabel = r'$\eta$',
+                            yLabel = r'$\phi\,\mathrm{[rad]}$',
                             zLabel = r'path length / $\Lambda_0$',
                             xBins = xBinning, yBins = yBinning,
                             showStats = False)
 
-    plotFactory.write_plot(hist_data, "s_L0_map", format)
+    plotFactory.write_plot(hist_data, "s_L0_map",  out_format)
 
 
 """ Plot the material thickness in units of X_0 vs eta """
-def X0_vs_eta(df, detector, plotFactory, format = "svg"):
+def X0_vs_eta(df, detector, plotFactory,  out_format =  "pdf"):
 
     # Histogram bin edges
     xBinning, _ = get_n_bins(df)
+    lgd_ops = get_legend_options()
+    lgd_ops._replace(loc = 'upper center')
 
     hist_data = plotFactory.hist1D(
                             x      = df['eta'],
                             w      = df['mat_tX0'],
                             normalize = False,
-                            title  = r'\textbf{Material Scan - thickness / }$\mathbf{X_0}$',
                             label  = rf'{detector}',
-                            xLabel = r'$\mathbf{\eta}$',
+                            xLabel = r'$\eta$',
                             yLabel = r'thickness / $X_0$',
                             bins = xBinning,
-                            showStats = False)
+                            showStats = False,
+                            lgd_ops = lgd_ops)
 
-    plotFactory.write_plot(hist_data, "t_X0", format)
+    plotFactory.write_plot(hist_data, "t_X0",  out_format)
 
     hist_data = plotFactory.hist1D(
                             x      = df['eta'],
                             w      = df['mat_sX0'],
                             normalize = False,
-                            title  = r'\textbf{Material Scan - path length / }$\mathbf{X_0}$',
                             label  = rf'{detector}',
-                            xLabel = r'$\mathbf{\eta}$',
+                            xLabel = r'$\eta$',
                             yLabel = r'path length / $X_0$',
                             bins = xBinning,
-                            showStats = False)
+                            showStats = False,
+                            lgd_ops = lgd_ops)
 
-    plotFactory.write_plot(hist_data, "s_X0", format)
+    plotFactory.write_plot(hist_data, "s_X0",  out_format)
 
 
 """ Plot the material thickness in units of L_0 vs eta """
-def L0_vs_eta(df, detector, plotFactory, format = "svg"):
+def L0_vs_eta(df, detector, plotFactory,  out_format =  "pdf"):
 
     # Histogram bin edges
     xBinning, _ = get_n_bins(df)
+    lgd_ops = get_legend_options()
+    lgd_ops._replace(loc = 'upper center')
 
     hist_data = plotFactory.hist1D(
                             x      = df['eta'],
                             w      = df['mat_tL0'],
                             normalize = False,
-                            title  = r'\textbf{Material Scan - thickness / }$\mathbf{\Lambda_0}$',
                             label  = rf'{detector}',
-                            xLabel = r'$\mathbf{\eta}$',
+                            xLabel = r'$\eta$',
                             yLabel = r'thickness / $\Lambda_0$',
                             bins = xBinning,
-                            showStats = False)
+                            showStats = False,
+                            lgd_ops = lgd_ops)
 
-    plotFactory.write_plot(hist_data, "t_L0", format)
+    plotFactory.write_plot(hist_data, "t_L0",  out_format)
 
     hist_data = plotFactory.hist1D(
                             x      = df['eta'],
                             w      = df['mat_sL0'],
                             normalize = False,
-                            title  = r'\textbf{Material Scan - path length / }$\mathbf{\Lambda_0}$',
                             label  = rf'{detector}',
-                            xLabel = r'$\mathbf{\eta}$',
+                            xLabel = r'$\eta$',
                             yLabel = r'path length / $\Lambda_0$',
                             bins = xBinning,
-                            showStats = False)
+                            showStats = False,
+                            lgd_ops = lgd_ops)
 
-    plotFactory.write_plot(hist_data, "s_L0", format)
+    plotFactory.write_plot(hist_data, "s_L0",  out_format)
diff --git a/tests/validation/python/plot_ray_scan.py b/tests/validation/python/plot_ray_scan.py
new file mode 100644
index 000000000..7359591af
--- /dev/null
+++ b/tests/validation/python/plot_ray_scan.py
@@ -0,0 +1,147 @@
+# Detray library, part of the ACTS project (R&D line)
+#
+# (c) 2023 CERN for the benefit of the ACTS project
+#
+# Mozilla Public License Version 2.0
+
+import plot_helpers
+from pyplot_factory import legend_options
+
+# python includes
+import numpy as np
+
+""" Plot the intersection points of the detector with the rays - xy view """
+def intersection_points_xy(opts, df, detector, scan_type, plotFactory,  out_format = "png"):
+
+    n_rays = np.max(df['index']) + 1
+    tracks = "rays" if scan_type == "ray" else "helices"
+
+    # Reduce data to the requested z-range (50mm tolerance)
+    min_z = opts.z_range[0]
+    max_z = opts.z_range[1]
+    assert min_z < max_z, "xy plotting range: min z must be smaller that max z"
+    sensitive_range = lambda data: ((data['z'] > min_z) & (data['z'] < max_z) & (data['type'] == 1))
+    portal_range = lambda data: ((data['z'] > min_z) & (data['z'] < max_z) & (data['type'] == 0))
+    passive_range = lambda data: ((data['z'] > min_z) & (data['z'] < max_z) & (data['type'] == 2))
+
+    senstive_x, senstive_y = plot_helpers.filter_data(
+                                                data      = df,
+                                                filter    = sensitive_range,
+                                                variables = ['x', 'y'])
+
+    # Plot the xy coordinates of the filtered intersections points
+    lgd_ops = legend_options('upper center', 4, 0.4, 0.005)
+    hist_data = plotFactory.scatter(
+                            figsize = (8, 8),
+                            x       = senstive_x,
+                            y       = senstive_y,
+                            xLabel  = r'$x\,\mathrm{[mm]}$',
+                            yLabel  = r'$y\,\mathrm{[mm]}$',
+                            label   = "sensitives",
+                            color   = 'C5',
+                            showStats = lambda x, y: f"{n_rays} {tracks}",
+                            lgd_ops = lgd_ops)
+
+    # Portal surfaces
+    if not opts.hide_portals:
+        portal_x, portal_y = plot_helpers.filter_data(
+                                                data      = df,
+                                                filter    = portal_range,
+                                                variables = ['x', 'y'])
+
+        plotFactory.highlight_region(hist_data, portal_x, portal_y, 'C0',      \
+                                     "portals")
+
+    # Passive surfaces
+    if not opts.hide_passives:
+        passive_x, passive_y = plot_helpers.filter_data(
+                                                data      = df,
+                                                filter    = passive_range,
+                                                variables = ['x', 'y'])
+
+        plotFactory.highlight_region(hist_data, passive_x, passive_y, 'C2',    \
+                                     "passives")
+
+    # Refine legend
+    hist_data.lgd.legendHandles[0].set_visible(False)
+    for handle in hist_data.lgd.legendHandles[1:]:
+        handle.set_sizes([40])
+
+    # For this plot, move the legend ouside
+    hist_data.lgd.set_bbox_to_anchor((0.5, 1.11))
+
+    # Adjust spacing in box
+    for vpack in hist_data.lgd._legend_handle_box.get_children()[:1]:
+        for hpack in vpack.get_children():
+            hpack.get_children()[0].set_width(0)
+
+    detector_name = detector.replace(' ', '_')
+    plotFactory.write_plot(hist_data, f"{detector_name}_{scan_type}_scan_xy",  out_format)
+
+
+""" Plot the intersection points of the detector with the rays - rz view """
+def intersection_points_rz(opts, df, detector, scan_type, plotFactory,  out_format = "png"):
+
+    n_rays = np.max(df['index']) + 1
+    tracks =  "rays" if scan_type == "ray" else "helices"
+
+    # Reduce data to the requested z-range
+    sensitive_range = lambda data: (data['type'] == 1)
+    portal_range = lambda data: (data['type'] == 0)
+    passive_range = lambda data: (data['type'] == 2)
+
+    sensitive_x, sensitive_y, sensitive_z = plot_helpers.filter_data(
+                                                data      = df,
+                                                filter    = sensitive_range,
+                                                variables = ['x', 'y', 'z'])
+
+    # Plot the xy coordinates of the filtered intersections points
+    lgd_ops = legend_options('upper center', 4, 0.8, 0.005)
+    hist_data = plotFactory.scatter(
+                            figsize = (12, 6),
+                            x      = sensitive_z,
+                            y      = np.hypot(sensitive_x, sensitive_y),
+                            xLabel = r'$z\,\mathrm{[mm]}$',
+                            yLabel = r'$r\,\mathrm{[mm]}$',
+                            label  = "sensitives",
+                            color  = 'C5',
+                            showStats = lambda x, y: f"{n_rays} {tracks}",
+                            lgd_ops = lgd_ops)
+
+    # Portal surfaces
+    if not opts.hide_portals:
+        portal_x, portal_y, portal_z = plot_helpers.filter_data(
+                                                    data      = df,
+                                                    filter    = portal_range,
+                                                    variables = ['x', 'y', 'z'])
+
+        plotFactory.highlight_region(hist_data, portal_z,                      \
+                                     np.hypot(portal_x, portal_y),             \
+                                     'C0', "portals")
+
+    # Passive surfaces
+    if not opts.hide_passives:
+        passive_x, passive_y, passive_z = plot_helpers.filter_data(
+                                                    data      = df,
+                                                    filter    = passive_range,
+                                                    variables = ['x', 'y', 'z'])
+
+        plotFactory.highlight_region(hist_data, passive_z,                     \
+                                    np.hypot(passive_x, passive_y),            \
+                                    'C2', "passives")
+
+    # Refine legend
+    hist_data.lgd.legendHandles[0].set_visible(False)
+    for handle in hist_data.lgd.legendHandles[1:]:
+        handle.set_sizes([40])
+
+    # For this plot, move the legend ouside
+    hist_data.lgd.set_bbox_to_anchor((0.5, 1.15))
+
+    # Adjust spacing in box
+    for vpack in hist_data.lgd._legend_handle_box.get_children()[:1]:
+        for hpack in vpack.get_children():
+            hpack.get_children()[0].set_width(0)
+
+    detector_name = detector.replace(' ', '_')
+    plotFactory.write_plot(hist_data, f"{detector_name}_{scan_type}_scan_rz",  out_format)
diff --git a/tests/validation/python/pyplot_factory.py b/tests/validation/python/pyplot_factory.py
index 1784bb731..966a6d6fd 100644
--- a/tests/validation/python/pyplot_factory.py
+++ b/tests/validation/python/pyplot_factory.py
@@ -4,8 +4,6 @@
 #
 # Mozilla Public License Version 2.0
 
-# -*- coding: utf-8 -*-
-
 # python includes
 from collections import namedtuple
 import math
@@ -15,6 +13,16 @@
 import matplotlib.pyplot as plt
 import matplotlib.colors as mcolors
 
+import matplotlib.style as style
+style.use('tableau-colorblind10')
+#style.use('seaborn-colorblind')
+
+plt.rcParams.update({
+    'text.usetex': True,
+    'font.size': 20,
+    'font.family': 'serif',
+})
+
 #-------------------------------------------------------------------------------
 # Global identifiers
 #-------------------------------------------------------------------------------
@@ -22,6 +30,13 @@
 """ Pass plotting data between functions """
 plt_data  = namedtuple('plt_data', 'fig ax lgd data bins mu rms errors')
 
+""" Wrap the configuration for a legend """
+legend_options = namedtuple('legend_options', 'loc ncol colspacing handletextpad')
+
+""" Conveniently get the legend options """
+def get_legend_options():
+    return legend_options('upper right', 1, 1, 1)
+
 #-------------------------------------------------------------------------------
 # Data Plotting
 #-------------------------------------------------------------------------------
@@ -40,8 +55,11 @@ def __init__(self, outDir, logger, atlas_badge = ""):
 
 
     """ Add legend to a plot. Labbels must be defined. """
-    def add_legend(self, ax):
-        return ax.legend(loc="upper right")
+    def add_legend(self, ax, options = get_legend_options()):
+        return ax.legend(loc           = options.loc,
+                         ncol          = options.ncol,
+                         columnspacing = options.colspacing,
+                         handletextpad = options.handletextpad)
 
 
     """
@@ -56,7 +74,8 @@ def hist1D(self, x, w = None,
                setLog    = False,
                normalize = False,
                showError = False,
-               showStats = True):
+               showStats = True,
+               lgd_ops   = get_legend_options()):
 
         # Create fresh plot
         fig = plt.figure(figsize = (8, 6))
@@ -108,7 +127,7 @@ def hist1D(self, x, w = None,
         ax.grid(True, alpha = 0.25)
 
         # Add legend
-        lgd = self.add_legend(ax)
+        lgd = self.add_legend(ax, lgd_ops)
 
         # Calculate the bin error
         binCenters = 0.5 * (bins[1:] + bins[:-1])
@@ -167,11 +186,12 @@ def hist2D(self, x, y, z = None,
         # Fill data
         data, xbins, ybins, hist = ax.hist2d(
                                     x, y, weights = z,
-                                    range = [(xMin, xMax), (yMin, yMax)],
-                                    bins = (xBins, yBins),
+                                    range      = [(xMin, xMax), (yMin, yMax)],
+                                    bins       = (xBins, yBins),
                                     label=f"{label}  ({len(x)*len(y)} entries)",
-                                    facecolor = mcolors.to_rgba(color, alpha),
-                                    edgecolor = None)
+                                    facecolor  = mcolors.to_rgba(color, alpha),
+                                    edgecolor  = None,
+                                    rasterized = True)
 
         # Add some additional information
         if showStats:
@@ -198,6 +218,55 @@ def hist2D(self, x, y, z = None,
         return plt_data(fig, ax, None, data, None, None, None, None)
 
 
+    """ Create a 2D scatter plot """
+    def scatter(self, x, y, 
+                xLabel = "", yLabel = "", title = "", label = "",
+                color  = 'tab:blue', alpha = 1,
+                figsize   = (8, 6), 
+                showStats = lambda x, _: f"{len(x)} entries", 
+                lgd_ops   = get_legend_options()):
+
+        fig = plt.figure(figsize = figsize)
+        ax = fig.add_subplot(1, 1, 1)
+
+        # Create empty plot with blank marker containing the extra label
+        ax.plot([], [], ' ', label=showStats(x, y))
+        scatter = ax.scatter(x, y,
+                             label = label,
+                             c     = color,
+                             s     = 0.1,
+                             alpha = alpha,
+                             rasterized=True)
+
+        # Refine plot
+        ax.set_title(title)
+        ax.set_xlabel(xLabel)
+        ax.set_ylabel(yLabel)
+        ax.grid(True, alpha = 0.25)
+
+        # Add legend
+        lgd = self.add_legend(ax, lgd_ops)
+
+        return plt_data(fig, ax, lgd, scatter, None, None, None, None)
+
+
+    """ Add new data in a different color to a scatter plot """
+    def highlight_region(self, plotData, x, y, color, label = ""):
+
+        if label == "":
+            plotData.ax.scatter(x, y, c = color, s = 0.1)
+        else:
+            plotData.ax.scatter(x, y, c = color, s = 0.1, label=label)
+
+            # Update legend
+            lgd = plotData.lgd
+            handles, labels = lgd.axes.get_legend_handles_labels()
+            lgd._legend_box = None
+            lgd._init_legend_box(handles, labels)
+            lgd._set_loc(lgd._loc)
+            lgd.set_title(lgd.get_title().get_text())
+
+
     """ Safe a plot to disk """
     def write_plot(self, plot_data, name = "plot", file_format = "svg",
                    outPrefix = ""):
diff --git a/tests/validation/python/run_material_validation.py b/tests/validation/python/run_material_validation.py
index e93a5b0f8..069a881c7 100644
--- a/tests/validation/python/run_material_validation.py
+++ b/tests/validation/python/run_material_validation.py
@@ -99,6 +99,11 @@ def __main__():
 
 #----------------------------------------------------------------prepare data
 
+    # Get detector name
+    detector_name = mat_scan_file.removeprefix('material_scan_')
+    detector_name = detector_name.removesuffix('.csv')
+    detector_name = detector_name.replace('_', ' ')
+
     df = pd.read_csv(mat_scan_file)
 
     plot_factory = pyplot_factory(outdir + "material_", logging)
@@ -107,10 +112,10 @@ def __main__():
 
     # The histograms are not re-weighted (if the rays are not evenly distributed
     # the material in some bins might be artificially high)!
-    plot_material_scan.X0_vs_eta_phi(df, "toy detector", plot_factory, out_format)
-    plot_material_scan.L0_vs_eta_phi(df, "toy detector", plot_factory, out_format)
-    plot_material_scan.X0_vs_eta(df, "toy detector", plot_factory, out_format)
-    plot_material_scan.L0_vs_eta(df, "toy detector", plot_factory, out_format)
+    plot_material_scan.X0_vs_eta_phi(df, detector_name, plot_factory, out_format)
+    plot_material_scan.L0_vs_eta_phi(df, detector_name, plot_factory, out_format)
+    plot_material_scan.X0_vs_eta(df, detector_name, plot_factory, out_format)
+    plot_material_scan.L0_vs_eta(df, detector_name, plot_factory, out_format)
 
 #-------------------------------------------------------------------------------
 
diff --git a/tests/validation/python/run_ray_scan_validation.py b/tests/validation/python/run_ray_scan_validation.py
new file mode 100644
index 000000000..ca10cc894
--- /dev/null
+++ b/tests/validation/python/run_ray_scan_validation.py
@@ -0,0 +1,137 @@
+# Detray library, part of the ACTS project (R&D line)
+#
+# (c) 2023 CERN for the benefit of the ACTS project
+#
+# Mozilla Public License Version 2.0
+
+import plot_ray_scan
+from pyplot_factory import pyplot_factory
+
+# python includes
+import argparse
+import logging
+import numpy as np
+import pandas as pd
+import os
+import sys
+from datetime import datetime
+import matplotlib.pyplot as plt
+
+
+plt.rc('text', usetex=True)
+plt.rc('text.latex', preamble=r'\usepackage{amsmath}')
+
+
+def __main__():
+
+#----------------------------------------------------------------arg parsing
+
+    parser = argparse.ArgumentParser(description = "Detray Ray Scan")
+    parser.add_argument("--debug", "-d",
+                        help=("Enables debug logging"), 
+                        action="store_true")
+    parser.add_argument("--logfile",
+                        help=("Write log in file"), 
+                        default = "", type=str)
+    parser.add_argument("--input", "-i",
+                        help=("Input ray scan data file."),
+                        default = "", type=str, required=True)
+    parser.add_argument("--outdir", "-o",
+                        help=("Output directory for plots."),
+                        default = "./geometry_plots/", type=str)
+    parser.add_argument("--output_format", "-of",
+                        help=("Format of the plot files (svg|png|pdf)."),
+                        default = "png", type=str)
+    parser.add_argument("--z_range", "-zrng", nargs=2,
+                        help=("z range for the xy-view."),
+                        default = [-50, 50], type=float)
+    parser.add_argument("--hide_portals",
+                        action="store_true", default=False)
+    parser.add_argument("--hide_passives",
+                        action="store_true", default=False)
+
+    args = parser.parse_args()
+
+#---------------------------------------------------------------------config
+
+    # Check output path
+    if not os.path.isdir(args.outdir):
+        os.mkdir(args.outdir, 0o755)
+    outdir = args.outdir
+
+    # Set log level
+    logLevel = logging.INFO
+    if args.debug:
+        logLevel = logging.DEBUG
+
+    # Check logfile path
+    if args.logfile != "":
+        logDirName  = os.path.dirname(args.logfile)
+
+        if logDirName != "" and not os.path.isdir(logDirName):
+            os.mkdir(logDirName, 0o755)
+
+        if not os.path.isfile(args.logfile):
+            with open(args.logfile, 'x'): pass
+
+        # Write log in logfile
+        logging.basicConfig(filename=args.logfile, 
+                            format=("%(levelname)s (%(module)s):"
+                                    " %(message)s"), level=logLevel)
+    else:
+        # Write log to terminal
+        logging.basicConfig(format=("%(levelname)s (%(module)s):"
+                                    " %(message)s"), level=logLevel)
+
+    logging.info("\n--------------------------------------------------------\n"
+                 "Running ray scan validation "+\
+                 str(datetime.now().strftime("%d/%m/%Y %H:%M"))+\
+                 "\n--------------------------------------------------------\n")
+
+    # Check input data files from material scan
+    if args.input == "":
+        logging.error(f"Please specify an input data file!")
+        sys.exit(1)
+
+    if not os.path.isfile(args.input):
+        logging.error(f"Data file does not exist! ({args.input})")
+        sys.exit(1)
+
+    if not args.output_format in ["svg", "png", "pdf"]:
+        logging.error(f"Unknown output file format: {out_format}")
+        sys.exit(1)
+
+    ray_scan_file = args.input
+    out_format = args.output_format
+
+#----------------------------------------------------------------prepare data
+
+    # Get detector name
+    if ray_scan_file.find('ray_scan_') != -1:
+        detector_name = ray_scan_file.removeprefix('ray_scan_')
+        scan_type = "ray"
+    elif ray_scan_file.find('helix_scan_') != -1:
+        detector_name = ray_scan_file.removeprefix('helix_scan_')
+        scan_type = "helix"
+    else:
+        logging.error('Input filename needs to contain \'ray_scan\' prefix')
+    detector_name = detector_name.removesuffix('.csv')
+    detector_name = detector_name.replace('_', ' ')
+
+    df = pd.read_csv(ray_scan_file)
+
+    plot_factory = pyplot_factory(outdir + "geometry_", logging)
+
+#------------------------------------------------------------------------run
+
+    plot_ray_scan.intersection_points_xy(args, df, detector_name,
+                                         scan_type, plot_factory, out_format)
+    plot_ray_scan.intersection_points_rz(args, df, detector_name, scan_type,
+                                         plot_factory, out_format)
+
+#-------------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    __main__()
+
+#------------------------------------------------------------------------------- 
diff --git a/tests/validation/src/detector_validation.cpp b/tests/validation/src/detector_validation.cpp
index e1eff3caa..ab1bc0ad1 100644
--- a/tests/validation/src/detector_validation.cpp
+++ b/tests/validation/src/detector_validation.cpp
@@ -43,24 +43,31 @@ int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
     // Options parsing
-    po::options_description desc("\ndetray validation options");
+    po::options_description desc("\ndetray detector validation options");
 
     desc.add_options()("help", "produce help message")(
         "write_volume_graph", "writes the volume graph to file")(
-        "write_ray_scan", "writes the ray scan intersections to file")(
+        "write_scan_data", "writes the ray/helix scan intersections to file")(
         "geometry_file", po::value<std::string>(), "geometry input file")(
         "material_file", po::value<std::string>(), "material input file")(
         "phi_steps", po::value<std::size_t>()->default_value(50u),
         "# phi steps for particle gun")(
         "theta_steps", po::value<std::size_t>()->default_value(50u),
         "# theta steps for particle gun")(
+        "theta_range", po::value<std::vector<scalar_t>>()->multitoken(),
+        "min, max range of theta values for particle gun")(
+        "origin", po::value<std::vector<scalar_t>>()->multitoken(),
+        "coordintates for particle gun origin position")(
         "p_mag", po::value<scalar_t>()->default_value(10.f),
         "absolute momentum of the test particle [GeV]")(
         "overstep_tol", po::value<scalar_t>()->default_value(-100.f),
         "overstepping tolerance [um] NOTE: Must be negative!");
 
     po::variables_map vm;
-    po::store(po::parse_command_line(argc, argv, desc), vm);
+    po::store(parse_command_line(argc, argv, desc,
+                                 po::command_line_style::unix_style ^
+                                     po::command_line_style::allow_short),
+              vm);
     po::notify(vm);
 
     // Help message
@@ -82,10 +89,9 @@ int main(int argc, char **argv) {
         con_chk_cfg.write_graph(true);
         throw std::invalid_argument("Writing of voume graph not implemented");
     }
-    if (vm.count("write_ray_scan")) {
+    if (vm.count("write_scan_data")) {
         ray_scan_cfg.write_intersections(true);
         hel_scan_cfg.write_intersections(true);
-        throw std::invalid_argument("Writing of ray scan not implemented");
     }
 
     // Input files
@@ -106,11 +112,36 @@ int main(int argc, char **argv) {
         const std::size_t phi_steps{vm["phi_steps"].as<std::size_t>()};
 
         ray_scan_cfg.track_generator().phi_steps(phi_steps);
+        hel_nav_cfg.track_generator().phi_steps(phi_steps);
     }
     if (vm.count("theta_steps")) {
         const std::size_t theta_steps{vm["theta_steps"].as<std::size_t>()};
 
         ray_scan_cfg.track_generator().theta_steps(theta_steps);
+        hel_nav_cfg.track_generator().theta_steps(theta_steps);
+    }
+    if (vm.count("theta_range")) {
+        const auto theta_range = vm["theta_range"].as<std::vector<scalar_t>>();
+        if (theta_range.size() == 2u) {
+            ray_scan_cfg.track_generator().theta_range(theta_range[0],
+                                                       theta_range[1]);
+            hel_nav_cfg.track_generator().theta_range(theta_range[0],
+                                                      theta_range[1]);
+        } else {
+            throw std::invalid_argument("Theta range needs two arguments");
+        }
+    }
+    if (vm.count("origin")) {
+        const auto origin = vm["origin"].as<std::vector<scalar_t>>();
+        if (origin.size() == 3u) {
+            ray_scan_cfg.track_generator().origin(
+                {origin[0], origin[1], origin[2]});
+            hel_nav_cfg.track_generator().origin(
+                {origin[0], origin[1], origin[2]});
+        } else {
+            throw std::invalid_argument(
+                "Particle gun origin needs three arguments");
+        }
     }
     if (vm.count("p_mag")) {
         const scalar_t p_mag{vm["p_mag"].as<scalar_t>()};
@@ -140,22 +171,21 @@ int main(int argc, char **argv) {
                                                                con_chk_cfg);
 
     // Navigation link consistency, discovered by ray intersection
+    ray_scan_cfg.name("ray_scan_" + names.at(0));
     detray::detail::register_checks<detray::ray_scan>(det, names, ray_scan_cfg);
 
     // Navigation link consistency, discovered by helix intersection
-    // Full number of helices only works in double precision
-    // hel_nav_cfg.track_generator().phi_steps(100u).theta_steps(100u);
-    hel_scan_cfg.track_generator().phi_steps(30u).theta_steps(30u);
+    hel_scan_cfg.name("helix_scan_" + names.at(0));
     detray::detail::register_checks<detray::helix_scan>(det, names,
                                                         hel_scan_cfg);
 
     // Comparision of straight line navigation with ray scan
+    str_nav_cfg.name("straight_line_navigation_" + names.at(0));
     detray::detail::register_checks<detray::straight_line_navigation>(
         det, names, str_nav_cfg);
 
     // Comparision of navigation in a constant B-field with helix
-    // For now, run with reduced number of helices, until helix test is fixed
-    hel_nav_cfg.track_generator().phi_steps(30u).theta_steps(30u);
+    hel_nav_cfg.name("helix_navigation_" + names.at(0));
     detray::detail::register_checks<detray::helix_navigation>(det, names,
                                                               hel_nav_cfg);
 
diff --git a/tests/validation/src/material_validation.cpp b/tests/validation/src/material_validation.cpp
index 9606204e0..06f5a8faa 100644
--- a/tests/validation/src/material_validation.cpp
+++ b/tests/validation/src/material_validation.cpp
@@ -33,12 +33,13 @@ int main(int argc, char **argv) {
 
     // Use the most general type to be able to read in all detector files
     using detector_t = detray::detector<>;
+    using scalar_t = detector_t::scalar_type;
 
     // Filter out the google test flags
     ::testing::InitGoogleTest(&argc, argv);
 
     // Options parsing
-    po::options_description desc("\ndetray validation options");
+    po::options_description desc("\ndetray material validation options");
 
     desc.add_options()("help", "produce help message")(
         "geometry_file", po::value<std::string>(), "geometry input file")(
@@ -46,10 +47,17 @@ int main(int argc, char **argv) {
         "phi_steps", po::value<std::size_t>()->default_value(50u),
         "# phi steps for particle gun")(
         "eta_steps", po::value<std::size_t>()->default_value(50u),
-        "# eta steps for particle gun");
+        "# eta steps for particle gun")(
+        "eta_range", po::value<std::vector<scalar_t>>()->multitoken(),
+        "min, max range of eta values for particle gun")(
+        "origin", po::value<std::vector<scalar_t>>()->multitoken(),
+        "coordintates for particle gun origin position");
 
     po::variables_map vm;
-    po::store(po::parse_command_line(argc, argv, desc), vm);
+    po::store(parse_command_line(argc, argv, desc,
+                                 po::command_line_style::unix_style ^
+                                     po::command_line_style::allow_short),
+              vm);
     po::notify(vm);
 
     // Help message
@@ -93,6 +101,25 @@ int main(int argc, char **argv) {
         mat_scan_cfg.track_generator().eta_steps(eta_steps);
         mat_scan_cfg.track_generator().eta_range(-4.f, 4.f);
     }
+    if (vm.count("eta_range")) {
+        const auto eta_range = vm["eta_range"].as<std::vector<scalar_t>>();
+        if (eta_range.size() == 2u) {
+            mat_scan_cfg.track_generator().eta_range(eta_range[0],
+                                                     eta_range[1]);
+        } else {
+            throw std::invalid_argument("Eta range needs two arguments");
+        }
+    }
+    if (vm.count("origin")) {
+        const auto origin = vm["origin"].as<std::vector<scalar_t>>();
+        if (origin.size() == 3u) {
+            mat_scan_cfg.track_generator().origin(
+                {origin[0], origin[1], -origin[2]});
+        } else {
+            throw std::invalid_argument(
+                "Particle gun origin needs three arguments");
+        }
+    }
 
     vecmem::host_memory_resource host_mr;
 

From e5bd0457014081320dd400b9b1f4ea3b2b946166 Mon Sep 17 00:00:00 2001
From: beomki-yeo <beomki.yeo@gmail.com>
Date: Tue, 24 Oct 2023 21:54:48 +0200
Subject: [PATCH 28/29] Remove unused varaible

---
 utils/include/detray/detectors/create_wire_chamber.hpp | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/utils/include/detray/detectors/create_wire_chamber.hpp b/utils/include/detray/detectors/create_wire_chamber.hpp
index e77cdc4b5..9c6396367 100644
--- a/utils/include/detray/detectors/create_wire_chamber.hpp
+++ b/utils/include/detray/detectors/create_wire_chamber.hpp
@@ -138,7 +138,6 @@ inline auto create_wire_chamber(vecmem::memory_resource &resource,
         // Wire center positions
         detray::dvector<point3> m_centers{};
 
-        unsigned int n_wires_per_layer{0u};
         scalar theta{0.f};
         while (theta <= 2.f * constant<scalar>::pi) {
 
@@ -147,8 +146,6 @@ inline auto create_wire_chamber(vecmem::memory_resource &resource,
             const scalar z = 0.f;
 
             m_centers.push_back({x, y, z});
-
-            n_wires_per_layer++;
             theta += delta;
         }
 

From 4ec52311775b08460fce47225db3f4dabcb61995 Mon Sep 17 00:00:00 2001
From: Fred <92879080+fredevb@users.noreply.github.com>
Date: Wed, 25 Oct 2023 15:06:04 +0200
Subject: [PATCH 29/29] feat: visualization of grids (#552)

Added visualization of acceleration grids. Furthermore simplified parts of the illustrator class. Note that I have added a webpage generation tool with detray in mind to ACTSVG which can be used for debugging purposes to easily merge and switch between svgs
---
 extern/actsvg/CMakeLists.txt                  |   2 +-
 .../plugins/svgtools/conversion/grid.hpp      | 164 ++++++++++++++++
 .../conversion/information_section.hpp        |   2 +
 .../conversion/intersection_record.hpp        |  26 ++-
 .../plugins/svgtools/conversion/landmark.hpp  |  17 +-
 .../plugins/svgtools/conversion/link.hpp      |   4 +-
 .../detray/plugins/svgtools/illustrator.hpp   | 184 ++++++++++--------
 .../plugins/svgtools/styling/styling.hpp      |  48 ++++-
 .../detray/plugins/svgtools/utils/groups.hpp  |  33 ++++
 .../svgtools/utils/intersection_utils.hpp     |  29 +++
 .../plugins/svgtools/utils/volume_utils.hpp   |  13 ++
 tests/unit_tests/svgtools/CMakeLists.txt      |  12 ++
 tests/unit_tests/svgtools/detectors.cpp       |  10 +-
 tests/unit_tests/svgtools/grids.cpp           |  56 ++++++
 tests/unit_tests/svgtools/groups.cpp          |  42 ++--
 tests/unit_tests/svgtools/intersections.cpp   |  25 ++-
 tests/unit_tests/svgtools/landmarks.cpp       |  53 +++++
 tests/unit_tests/svgtools/masks.cpp           |  11 +-
 tests/unit_tests/svgtools/surfaces.cpp        |  20 +-
 tests/unit_tests/svgtools/trajectories.cpp    |  54 +++--
 tests/unit_tests/svgtools/volumes.cpp         |  20 +-
 tests/unit_tests/svgtools/web.cpp             | 131 +++++++++++++
 22 files changed, 792 insertions(+), 164 deletions(-)
 create mode 100644 plugins/svgtools/include/detray/plugins/svgtools/conversion/grid.hpp
 create mode 100644 plugins/svgtools/include/detray/plugins/svgtools/utils/groups.hpp
 create mode 100644 plugins/svgtools/include/detray/plugins/svgtools/utils/intersection_utils.hpp
 create mode 100644 tests/unit_tests/svgtools/grids.cpp
 create mode 100644 tests/unit_tests/svgtools/landmarks.cpp
 create mode 100644 tests/unit_tests/svgtools/web.cpp

diff --git a/extern/actsvg/CMakeLists.txt b/extern/actsvg/CMakeLists.txt
index e4d17736c..9f79014bd 100644
--- a/extern/actsvg/CMakeLists.txt
+++ b/extern/actsvg/CMakeLists.txt
@@ -19,7 +19,7 @@ message( STATUS "Building actsvg as part of the Detray project" )
 # Declare where to get Actsvg from.
 set( DETRAY_ACTSVG_GIT_REPOSITORY "https://github.com/acts-project/actsvg.git"
    CACHE STRING "Git repository to take actsvg from" )
-set( DETRAY_ACTSVG_GIT_TAG "v0.4.35" CACHE STRING "Version of actsvg to build" )
+set( DETRAY_ACTSVG_GIT_TAG "v0.4.37" CACHE STRING "Version of actsvg to build" )
 mark_as_advanced( DETRAY_ACTSVG_GIT_REPOSITORY DETRAY_ACTSVG_GIT_TAG )
 FetchContent_Declare( actsvg
    GIT_REPOSITORY "${DETRAY_ACTSVG_GIT_REPOSITORY}"
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/conversion/grid.hpp b/plugins/svgtools/include/detray/plugins/svgtools/conversion/grid.hpp
new file mode 100644
index 000000000..a1bc5dde4
--- /dev/null
+++ b/plugins/svgtools/include/detray/plugins/svgtools/conversion/grid.hpp
@@ -0,0 +1,164 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/core/detector.hpp"
+#include "detray/definitions/units.hpp"
+#include "detray/grids/axis.hpp"
+
+// Actsvg include(s)
+#include "actsvg/proto/grid.hpp"
+
+// System include(s)
+#include <algorithm>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace detray::svgtools::conversion {
+
+/// A functor to access the bin edges.
+template <typename scalar_t, detray::n_axis::label axis_label>
+struct edge_getter {
+    template <typename group_t, typename index_t, typename... Args>
+    DETRAY_HOST_DEVICE inline auto operator()(
+        [[maybe_unused]] const group_t& group,
+        [[maybe_unused]] const index_t index) const {
+        using accel_t = typename group_t::value_type;
+        if constexpr (detray::detail::is_grid_v<accel_t>) {
+            const auto grid = group[index];
+            const auto axis_bin_edges =
+                grid.axes().template get_axis<axis_label>().bin_edges();
+            std::vector<scalar_t> edges;
+            std::copy(axis_bin_edges.cbegin(), axis_bin_edges.cend(),
+                      std::back_inserter(edges));
+            return edges;
+        }
+        return std::vector<scalar_t>{};
+    }
+};
+
+/// @return the bin edges of the grid.
+template <typename detray::n_axis::label axis_label, typename detector_t,
+          typename link_t>
+auto bin_edges(const detector_t& detector, const link_t& link) {
+    using d_scalar_t = typename detector_t::scalar_type;
+    return detector.accelerator_store()
+        .template visit<edge_getter<d_scalar_t, axis_label>>(link);
+}
+
+// Calculating r under the assumption that the cylinder grid is closed in phi:
+// (bin_edge_min - bin_edge_max) / (2*pi).
+template <typename d_scalar_t>
+auto r_phi_split(const std::vector<d_scalar_t>& edges_rphi) {
+    const auto r = edges_rphi.back() * detray::constant<d_scalar_t>::inv_pi;
+    std::vector<d_scalar_t> edges_phi;
+    std::transform(edges_rphi.cbegin(), edges_rphi.cend(),
+                   std::back_inserter(edges_phi),
+                   [r](d_scalar_t e) { return e / r; });
+    return std::tuple(edges_phi, r);
+}
+
+/// @returns the actsvg grid type and edge values for a detray cylinder
+/// grid.
+template <typename detector_t, typename link_t, typename view_t>
+auto cylinder2_grid_type_and_edges(const detector_t& detector,
+                                   const link_t& link, const view_t&) {
+    assert(link.id() == detector_t::accel::id::e_cylinder2_grid);
+    auto edges_rphi = bin_edges<detray::n_axis::label::e_rphi>(detector, link);
+    auto edges_z = bin_edges<detray::n_axis::label::e_cyl_z>(detector, link);
+    auto [edges_phi, r] = r_phi_split(edges_rphi);
+    std::vector edges_r{r, r};
+
+    if (std::is_same_v<view_t, actsvg::views::x_y>) {
+        return std::tuple(actsvg::proto::grid::e_r_phi, edges_r, edges_phi);
+    }
+    if (std::is_same_v<view_t, actsvg::views::z_r>) {
+        return std::tuple(actsvg::proto::grid::e_x_y, edges_z, edges_r);
+    }
+    if (std::is_same_v<view_t, actsvg::views::z_phi>) {
+        return std::tuple(actsvg::proto::grid::e_x_y, edges_z, edges_phi);
+    }
+    if (std::is_same_v<view_t, typename actsvg::views::z_rphi>) {
+        return std::tuple(actsvg::proto::grid::e_x_y, edges_z, edges_rphi);
+    }
+    using scalar_t = typename detector_t::scalar_type;
+    return std::tuple(actsvg::proto::grid::e_x_y, std::vector<scalar_t>{},
+                      std::vector<scalar_t>{});
+}
+
+/// @returns the actsvg grid type and edge values for a detray disc grid.
+template <typename detector_t, typename link_t, typename view_t>
+auto disc_grid_type_and_edges(const detector_t& detector, const link_t& link,
+                              const view_t&) {
+    assert(link.id() == detector_t::accel::id::e_disc_grid);
+    auto edges_r = bin_edges<detray::n_axis::label::e_r>(detector, link);
+    auto edges_phi = bin_edges<detray::n_axis::label::e_phi>(detector, link);
+
+    if (std::is_same_v<view_t, typename actsvg::views::x_y>) {
+        return std::tuple(actsvg::proto::grid::e_r_phi, edges_r, edges_phi);
+    }
+    using scalar_t = typename detector_t::scalar_type;
+    return std::tuple(actsvg::proto::grid::e_x_y, std::vector<scalar_t>{},
+                      std::vector<scalar_t>{});
+}
+
+/// @returns the detray grids respective actsvg grid type and edge
+/// values.
+template <typename detector_t, typename link_t, typename view_t>
+auto get_type_and_axes(const detector_t& detector, const link_t& link,
+                       const view_t& view) {
+    using accel_ids_t = typename detector_t::accel::id;
+    switch (link.id()) {
+        case accel_ids_t::e_cylinder2_grid: {
+            return cylinder2_grid_type_and_edges(detector, link, view);
+        }
+        case accel_ids_t::e_disc_grid: {
+            return disc_grid_type_and_edges(detector, link, view);
+        }
+        default: {
+            using scalar_t = typename detector_t::scalar_type;
+            return std::tuple(actsvg::proto::grid::e_x_y,
+                              std::vector<scalar_t>{}, std::vector<scalar_t>{});
+        }
+    }
+}
+
+/// @brief Converts a detray grid to a actsvg proto grid.
+/// @param detector the detector
+/// @param index the index of the grid's volume
+/// @param view the view
+/// @returns a proto grid
+template <typename a_scalar_t, typename detector_t, typename view_t>
+std::optional<actsvg::proto::grid> grid(const detector_t& detector,
+                                        const std::size_t index,
+                                        const view_t& view) {
+    using d_scalar_t = typename detector_t::scalar_type;
+    using geo_object_ids = typename detector_t::geo_obj_ids;
+
+    const auto vol_desc = detector.volumes()[index];
+    const auto link = vol_desc.template link<geo_object_ids::e_sensitive>();
+    actsvg::proto::grid p_grid;
+
+    if (not link.is_invalid()) {
+        const auto [type, edges0, edges1] =
+            get_type_and_axes(detector, link, view);
+        p_grid._type = type;
+        std::transform(edges0.cbegin(), edges0.cend(),
+                       std::back_inserter(p_grid._edges_0),
+                       [](d_scalar_t v) { return static_cast<a_scalar_t>(v); });
+        std::transform(edges1.cbegin(), edges1.cend(),
+                       std::back_inserter(p_grid._edges_1),
+                       [](d_scalar_t v) { return static_cast<a_scalar_t>(v); });
+        return p_grid;
+    }
+    return {};
+}
+
+}  // namespace detray::svgtools::conversion
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/conversion/information_section.hpp b/plugins/svgtools/include/detray/plugins/svgtools/conversion/information_section.hpp
index 85e17a929..83fd420c5 100644
--- a/plugins/svgtools/include/detray/plugins/svgtools/conversion/information_section.hpp
+++ b/plugins/svgtools/include/detray/plugins/svgtools/conversion/information_section.hpp
@@ -24,6 +24,7 @@
 
 namespace detray::svgtools::conversion {
 
+/// @returns a point as a string.
 template <typename point3_t>
 inline std::string point_to_string(point3_t point) {
 
@@ -33,6 +34,7 @@ inline std::string point_to_string(point3_t point) {
     return stream.str();
 }
 
+/// @returns the information section for a detray surface.
 template <typename point3_t, typename detector_t>
 inline auto information_section(
     const typename detector_t::geometry_context& context,
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/conversion/intersection_record.hpp b/plugins/svgtools/include/detray/plugins/svgtools/conversion/intersection_record.hpp
index 870a92afa..7344f3c4a 100644
--- a/plugins/svgtools/include/detray/plugins/svgtools/conversion/intersection_record.hpp
+++ b/plugins/svgtools/include/detray/plugins/svgtools/conversion/intersection_record.hpp
@@ -11,12 +11,26 @@
 #include "detray/intersection/intersection.hpp"
 #include "detray/plugins/svgtools/conversion/landmark.hpp"
 #include "detray/plugins/svgtools/meta/proto/intersection_record.hpp"
+#include "detray/plugins/svgtools/utils/intersection_utils.hpp"
 
 // System include(s)
 #include <vector>
 
 namespace detray::svgtools::conversion {
 
+/// @returns The proto intersection record from a list of points
+template <typename point3_t, typename container_t>
+inline auto intersection_record(const container_t& points) {
+    using p_intersection_record_t =
+        svgtools::meta::proto::intersection_record<point3_t>;
+    p_intersection_record_t p_ir;
+    for (const auto& point : points) {
+        const auto p_lm = svgtools::conversion::landmark<point3_t>(point);
+        p_ir._landmarks.push_back(p_lm);
+    }
+    return p_ir;
+}
+
 /// @returns The proto intersection record of a detray intersection record.
 template <typename point3_t, typename detector_t>
 inline auto intersection_record(
@@ -27,17 +41,13 @@ inline auto intersection_record(
                   detray::intersection2D<typename detector_t::surface_type,
                                          typename detector_t::transform3>>>&
         intersection_record) {
-    using p_intersection_record_t =
-        svgtools::meta::proto::intersection_record<point3_t>;
-    p_intersection_record_t p_ir;
-    std::vector<typename p_intersection_record_t::landmark_type> landmarks;
+    std::vector<typename detector_t::point3> points;
     for (const auto& record : intersection_record) {
-        const auto p_lm = svgtools::conversion::landmark<point3_t>(
+        const auto point = svgtools::utils::intersection_point(
             context, detector, record.second);
-        landmarks.push_back(p_lm);
+        points.push_back(point);
     }
-    p_ir._landmarks = landmarks;
-    return p_ir;
+    return svgtools::conversion::intersection_record<point3_t>(points);
 }
 
 }  // namespace detray::svgtools::conversion
\ No newline at end of file
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/conversion/landmark.hpp b/plugins/svgtools/include/detray/plugins/svgtools/conversion/landmark.hpp
index 9932527d6..16ae22f24 100644
--- a/plugins/svgtools/include/detray/plugins/svgtools/conversion/landmark.hpp
+++ b/plugins/svgtools/include/detray/plugins/svgtools/conversion/landmark.hpp
@@ -12,6 +12,7 @@
 #include "detray/intersection/intersection.hpp"
 #include "detray/plugins/svgtools/conversion/point.hpp"
 #include "detray/plugins/svgtools/meta/proto/landmark.hpp"
+#include "detray/plugins/svgtools/utils/intersection_utils.hpp"
 
 namespace detray::svgtools::conversion {
 
@@ -23,15 +24,17 @@ inline auto landmark(
     const detray::intersection2D<typename detector_t::surface_type,
                                  typename detector_t::transform3>&
         d_intersection) {
-    using p_landmark_t = svgtools::meta::proto::landmark<point3_t>;
-
-    const typename detector_t::vector3 dir{};
-    const detray::surface surface{detector, d_intersection.sf_desc};
-    const auto position = svgtools::conversion::point<point3_t>(
-        surface.local_to_global(context, d_intersection.local, dir));
+    const auto position =
+        svgtools::utils::intersection_point(context, detector, d_intersection);
+    return svgtools::conversion::landmark<point3>(position);
+}
 
+/// @returns The proto landmark of a detray point.
+template <typename point3_t, typename d_point3_t>
+inline auto landmark(d_point3_t& position) {
+    using p_landmark_t = svgtools::meta::proto::landmark<point3_t>;
     p_landmark_t p_lm;
-    p_lm._position = position;
+    p_lm._position = svgtools::conversion::point<point3_t>(position);
     return p_lm;
 }
 
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/conversion/link.hpp b/plugins/svgtools/include/detray/plugins/svgtools/conversion/link.hpp
index fb8a58866..3a9070604 100644
--- a/plugins/svgtools/include/detray/plugins/svgtools/conversion/link.hpp
+++ b/plugins/svgtools/include/detray/plugins/svgtools/conversion/link.hpp
@@ -29,8 +29,8 @@ inline auto link(const typename detector_t::geometry_context& context,
 
     typename detector_t::vector3 dir{};
 
-    // Length of link arrow is currently hardcoded to 3.
-    constexpr double link_length = 3.;
+    // Length of link arrow is currently hardcoded.
+    constexpr double link_length = 4.;
 
     const auto [start, end] = svgtools::utils::link_points(
         context, detector, d_portal, dir, link_length);
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/illustrator.hpp b/plugins/svgtools/include/detray/plugins/svgtools/illustrator.hpp
index 401e12365..75b57e5c9 100644
--- a/plugins/svgtools/include/detray/plugins/svgtools/illustrator.hpp
+++ b/plugins/svgtools/include/detray/plugins/svgtools/illustrator.hpp
@@ -9,6 +9,7 @@
 
 // Project include(s)
 #include "detray/geometry/surface.hpp"
+#include "detray/plugins/svgtools/conversion/grid.hpp"
 #include "detray/plugins/svgtools/conversion/information_section.hpp"
 #include "detray/plugins/svgtools/conversion/intersection_record.hpp"
 #include "detray/plugins/svgtools/conversion/landmark.hpp"
@@ -18,6 +19,7 @@
 #include "detray/plugins/svgtools/meta/display/geometry.hpp"
 #include "detray/plugins/svgtools/meta/display/information.hpp"
 #include "detray/plugins/svgtools/styling/styling.hpp"
+#include "detray/plugins/svgtools/utils/groups.hpp"
 #include "detray/plugins/svgtools/utils/volume_utils.hpp"
 #include "detray/utils/ranges.hpp"
 
@@ -26,56 +28,70 @@
 
 // System include(s)
 #include <array>
+#include <optional>
 #include <vector>
 
 namespace detray::svgtools {
 
-/// @brief SVG generator for a detector and related entities.
+/// @brief SVG generator for a detector and related entities. Provides an easy
+/// interface for displaying typical objects in a detector. For more
+/// flexibility, use the tools in svgtools::conversion to convert detray objects
+/// to their respective proto object. Use functions in svgtools::meta::display
+/// and actsvg::display to display the proto objects.
+/// @note Avoid using ids containing spaces or dashes as this seems to cause
+/// issues (for instance regarding information boxes). Furthermore, to view
+/// information boxes, they must be enabled in the constructor. Furthermore the
+/// svg viewer (opening the file after it is created) must support animations.
 template <typename detector_t>
 class illustrator {
 
     public:
     illustrator() = delete;
 
-    illustrator(const detector_t& detector,
-                const typename detector_t::name_map& name_map)
-        : _detector{detector}, _name_map{name_map} {}
+    /// @param detector the detector
+    /// @param context the geometry context
+    /// @note information boxes are enabled by default
+    illustrator(const detector_t& detector, const geometry_context& context)
+        : _detector{detector}, _context{context} {}
 
-    illustrator(const detector_t& detector,
-                const typename detector_t::name_map& name_map,
+    /// @param detector the detector
+    /// @param context the geometry context
+    /// @param show_info boolean to choose if information boxes should be
+    /// included
+    illustrator(const detector_t& detector, const geometry_context& context,
                 const bool show_info)
-        : _detector{detector}, _name_map{name_map}, _show_info{show_info} {}
+        : _detector{detector}, _context{context}, _show_info{show_info} {}
 
-    illustrator(const detector_t& detector,
-                const typename detector_t::name_map& name_map,
+    /// @param detector the detector
+    /// @param context the geometry context
+    /// @param show_info boolean to choose if information boxes should be
+    /// included
+    /// @param style the styling options to apply
+    illustrator(const detector_t& detector, const geometry_context& context,
                 const bool show_info, const styling::style& style)
         : _detector{detector},
-          _name_map{name_map},
+          _context{context},
           _show_info{show_info},
           _style{style} {}
 
     /// @brief Converts a detray surface in the detector to an svg.
     /// @param identification the id of the svg object.
-    /// @param context the geometry context.
     /// @param index the index of the surface in the detector.
     /// @param view the display view.
     /// @returns @c actsvg::svg::object of the detector's surface.
     template <typename view_t>
-    inline auto draw_surface(
-        const std::string& identification,
-        const typename detector_t::geometry_context& context,
-        const std::size_t index, const view_t& view) const {
+    inline auto draw_surface(const std::string& identification,
+                             const std::size_t index,
+                             const view_t& view) const {
         const auto surface = detray::surface{
             _detector,
             _detector.surface_lookup()[static_cast<detray::dindex>(index)]};
-        actsvg::svg::object ret;
-        ret._tag = "g";
-        ret._id = identification;
+        auto ret = svgtools::utils::group(identification);
         actsvg::svg::object svg_sur;
         std::array<int, 3> color;
         if (surface.is_portal()) {
             auto p_portal = svgtools::conversion::portal<point3_container>(
-                context, _detector, surface);
+                _context, _detector, surface);
             svgtools::styling::apply_style(p_portal,
                                            _style._volume_style._portal_style);
             std::copy(p_portal._surface._fill._fc._rgb.begin(),
@@ -83,7 +99,7 @@ class illustrator {
             svg_sur = actsvg::display::portal(identification, p_portal, view);
         } else {
             auto p_surface = svgtools::conversion::surface<point3_container>(
-                context, surface);
+                _context, surface);
             svgtools::styling::apply_style(p_surface,
                                            _style._volume_style._surface_style);
             std::copy(p_surface._fill._fc._rgb.begin(),
@@ -92,7 +108,7 @@ class illustrator {
         }
         if (_show_info) {
             auto p_information_section =
-                svgtools::conversion::information_section<point3>(context,
+                svgtools::conversion::information_section<point3>(_context,
                                                                   surface);
             std::copy(color.begin(), color.end(),
                       p_information_section._color.begin());
@@ -107,23 +123,19 @@ class illustrator {
     /// @brief Converts a collection of detray surfaces in the detector to an
     /// svg.
     /// @param identification the id of the svg object.
-    /// @param context the geometry context.
     /// @param indices the collection of surface indices in the detector to
     /// convert.
     /// @param view the display view.
     /// @returns @c actsvg::svg::object of the detector's surfaces.
     template <typename iterator_t, typename view_t>
-    inline auto draw_surfaces(
-        const std::string& identification,
-        const typename detector_t::geometry_context& context,
-        const iterator_t& indices, const view_t& view) const {
-        actsvg::svg::object ret;
-        ret._tag = "g";
-        ret._id = identification;
+    inline auto draw_surfaces(const std::string& identification,
+                              const iterator_t& indices,
+                              const view_t& view) const {
+        auto ret = svgtools::utils::group(identification);
         for (const auto index : indices) {
             const auto svg = draw_surface(
-                identification + "_surface" + std::to_string(index), context,
-                index, view);
+                identification + "_surface" + std::to_string(index), index,
+                view);
             ret.add_object(svg);
         }
         return ret;
@@ -131,51 +143,33 @@ class illustrator {
 
     /// @brief Converts a detray volume in the detector to an svg.
     /// @param identification the id of the svg object.
-    /// @param context the geometry context.
     /// @param index the index of the volume in the detector.
     /// @param view the display view.
     /// @returns @c actsvg::svg::object of the detector's volume.
     template <typename view_t>
-    inline auto draw_volume(
-        const std::string& identification,
-        const typename detector_t::geometry_context& context,
-        const std::size_t index, const view_t& view) const {
-        actsvg::svg::object ret;
-        ret._tag = "g";
-        ret._id = identification;
-        const auto d_volume =
-            _detector.volume_by_index(static_cast<detray::dindex>(index));
-        auto surface_descs =
-            svgtools::utils::surface_lookup(_detector, d_volume);
-        for (std::size_t i = 0; i < surface_descs.size(); i++) {
-            const auto surface_index = surface_descs[i].index();
-            ret.add_object(draw_surface(
-                identification + "_surface" + std::to_string(surface_index),
-                context, surface_index, view));
-        }
-        return ret;
+    inline auto draw_volume(const std::string& identification,
+                            const std::size_t index, const view_t& view) const {
+        const auto surface_indices =
+            svgtools::utils::surface_indices(_detector, index);
+        return draw_surfaces(identification, surface_indices, view);
     }
 
     /// @brief Converts a collection of detray volumes in the detector to an
     /// svg.
     /// @param identification the id of the svg object.
-    /// @param context the geometry context.
     /// @param indices the collection of volume indices in the detector to
     /// convert.
     /// @param view the display view.
     /// @returns @c actsvg::svg::object of the detector's volumes.
     template <typename iterator_t, typename view_t>
-    inline auto draw_volumes(
-        const std::string& identification,
-        const typename detector_t::geometry_context& context,
-        const iterator_t& indices, const view_t& view) const {
-        actsvg::svg::object ret;
-        ret._tag = "g";
-        ret._id = identification;
+    inline auto draw_volumes(const std::string& identification,
+                             const iterator_t& indices,
+                             const view_t& view) const {
+        auto ret = svgtools::utils::group(identification);
         for (const auto index : indices) {
             const auto svg =
                 draw_volume(identification + "_volume" + std::to_string(index),
-                            context, index, view);
+                            index, view);
             ret.add_object(svg);
         }
         return ret;
@@ -183,29 +177,38 @@ class illustrator {
 
     /// @brief Converts a detray detector to an svg.
     /// @param identification the id of the svg object.
-    /// @param context the geometry context.
     /// @param view the display view.
     /// @returns @c actsvg::svg::object of the detector.
     template <typename view_t>
-    inline auto draw_detector(
-        const std::string& identification,
-        const typename detector_t::geometry_context& context,
-        const view_t& view) const {
+    inline auto draw_detector(const std::string& identification,
+                              const view_t& view) const {
         auto indices =
             detray::views::iota(std::size_t{0u}, _detector.volumes().size());
-        return draw_volumes(identification, context, indices, view);
+        return draw_volumes(identification, indices, view);
+    }
+
+    /// @brief Converts a point to an svg.
+    /// @param identification the id of the svg object.
+    /// @param point the point.
+    /// @param view the display view.
+    /// @return actsvg::svg::object of the point.
+    template <typename view_t, typename point_t>
+    inline auto draw_landmark(const std::string& identification,
+                              const point_t& point, const view_t& view) const {
+        auto p_landmark = svgtools::conversion::landmark<point3>(point);
+        svgtools::styling::apply_style(p_landmark, _style._landmark_style);
+        return svgtools::meta::display::landmark(identification, p_landmark,
+                                                 view);
     }
 
     /// @brief Converts an intersection record to an svg.
     /// @param identification the id of the svg object.
-    /// @param context the geometry context.
     /// @param intersection_record the intersection record.
     /// @param view the display view.
     /// @return @c actsvg::svg::object of the intersectio record.
     template <typename view_t>
     inline auto draw_intersections(
         const std::string& identification,
-        const typename detector_t::geometry_context& context,
         const std::vector<
             std::pair<detray::dindex,
                       detray::intersection2D<typename detector_t::surface_type,
@@ -213,7 +216,7 @@ class illustrator {
             intersection_record,
         const view_t& view) const {
         auto p_ir = svgtools::conversion::intersection_record<point3>(
-            context, _detector, intersection_record);
+            _context, _detector, intersection_record);
         svgtools::styling::apply_style(p_ir, _style._intersection_style);
         return svgtools::meta::display::intersection_record(identification,
                                                             p_ir, view);
@@ -236,6 +239,21 @@ class illustrator {
                                                    view);
     }
 
+    /// @brief Converts a trajectory to an svg.
+    /// @param identification the id of the svg object.
+    /// @param trajectory the trajectory (eg. ray or helix).
+    /// @param view the display view.
+    /// @return actsvg::svg::object of the trajectory.
+    template <typename view_t, typename point3_container>
+    inline auto draw_trajectory(const std::string& identification,
+                                const point3_container& points,
+                                const view_t& view) const {
+        auto p_trajectory = svgtools::conversion::trajectory<point3>(points);
+        svgtools::styling::apply_style(p_trajectory, _style._trajectory_style);
+        return svgtools::meta::display::trajectory(identification, p_trajectory,
+                                                   view);
+    }
+
     /// @brief Converts a trajectory and its intersection record to an svg with
     /// a related coloring.
     /// @param identification the id of the svg object.
@@ -248,7 +266,6 @@ class illustrator {
               typename transform3_t>
     inline auto draw_intersections_and_trajectory(
         const std::string& identification,
-        const typename detector_t::geometry_context& context,
         std::vector<
             std::pair<detray::dindex,
                       detray::intersection2D<typename detector_t::surface_type,
@@ -257,29 +274,40 @@ class illustrator {
         const trajectory_t<transform3_t>& trajectory,
         const view_t& view) const {
 
-        actsvg::svg::object ret;
-        ret._tag = "g";
-        ret._id = identification;
+        auto ret = svgtools::utils::group(identification);
         auto i_style = svgtools::styling::copy_fill_colors(
             _style._intersection_style, _style._trajectory_style);
         auto p_ir = svgtools::conversion::intersection_record<point3>(
-            context, _detector, intersection_record);
+            _context, _detector, intersection_record);
         svgtools::styling::apply_style(p_ir, i_style);
-        ret.add_object(svgtools::meta::display::intersection_record(
-            identification + "_record", p_ir, view));
         ret.add_object(
             draw_trajectory(identification + "_trajectory", trajectory, view));
+        ret.add_object(svgtools::meta::display::intersection_record(
+            identification + "_record", p_ir, view));
         return ret;
     }
 
+    template <typename view_t>
+    std::optional<actsvg::svg::object> draw_grid(
+        const std::string& identification, const std::size_t index,
+        const view_t& view) const {
+        if (auto p_grid_ptr = svgtools::conversion::grid<actsvg::scalar>(
+                _detector, index, view)) {
+            svgtools::styling::apply_style(*p_grid_ptr, _style._grid_style);
+            return actsvg::display::grid(identification, *p_grid_ptr);
+        }
+        return {};
+    }
+
     private:
     using point3 = std::array<actsvg::scalar, 3>;
     using point3_container = std::vector<point3>;
+    using geometry_context = typename detector_t::geometry_context;
 
-    const actsvg::point2 _info_screen_offset{-400, 400};
+    const actsvg::point2 _info_screen_offset{-300, 300};
     const detector_t& _detector;
-    const typename detector_t::name_map& _name_map;
-    const bool _show_info = false;
+    const geometry_context& _context;
+    const bool _show_info = true;
     const styling::style _style = styling::style1;
 };
 
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/styling/styling.hpp b/plugins/svgtools/include/detray/plugins/svgtools/styling/styling.hpp
index 6fc29d024..8981c2be3 100644
--- a/plugins/svgtools/include/detray/plugins/svgtools/styling/styling.hpp
+++ b/plugins/svgtools/include/detray/plugins/svgtools/styling/styling.hpp
@@ -81,9 +81,15 @@ std::vector<actsvg::style::color> green_theme(const actsvg::scalar opacity) {
 
 }  // namespace colors
 
+struct grid_style {
+    actsvg::scalar _stroke_width;
+};
+
 struct landmark_style {
     std::vector<actsvg::style::color> _fill_colors;
+    actsvg::scalar _stroke_width;
     actsvg::scalar _marker_size;
+    std::string _marker_type;
 };
 
 struct trajectory_style {
@@ -115,11 +121,13 @@ struct style {
     volume_style _volume_style;
     landmark_style _intersection_style;
     trajectory_style _trajectory_style;
+    grid_style _grid_style;
+    landmark_style _landmark_style;
 };
 
-const surface_style surface_style1{colors::blue_theme(0.8f), 3.f};
+const surface_style surface_style1{colors::blue_theme(0.5f), 3.f};
 
-const surface_style surface_style2{colors::red_theme(0.8f), 3.f};
+const surface_style surface_style2{colors::red_theme(0.5f), 3.f};
 
 const link_style link_style1{1.2f};
 
@@ -127,11 +135,16 @@ const portal_style portal_style1{surface_style2, link_style1, false};
 
 const volume_style volume_style1{surface_style1, portal_style1};
 
-const landmark_style landmark_style1{colors::black_theme(0.8f), 5.f};
+const landmark_style landmark_style1{colors::black_theme(1.f), 1.f, 5.f, "x"};
 
-const trajectory_style trajectory_style1{colors::green_theme(1.f), 1.f};
+const landmark_style landmark_style2{colors::black_theme(1.f), 1.f, 3.f, "o"};
 
-const style style1{volume_style1, landmark_style1, trajectory_style1};
+const grid_style grid_style1{2.f};
+
+const trajectory_style trajectory_style1{colors::green_theme(1.f), 3.f};
+
+const style style1{volume_style1, landmark_style1, trajectory_style1,
+                   grid_style1, landmark_style2};
 
 /// @brief Sets the style of the proto surface.
 template <typename point3_container_t>
@@ -179,6 +192,19 @@ void apply_style(actsvg::proto::volume<point3_container_t>& p_volume,
     }
 }
 
+/// @brief Sets the style of the proto landmark.
+template <typename point3_t>
+void apply_style(meta::proto::landmark<point3_t>& p_landmark,
+                 const landmark_style& styling) {
+    const auto fill_color = colors::pick_random(styling._fill_colors);
+    const auto fill = actsvg::style::fill(fill_color);
+    const auto stroke =
+        actsvg::style::stroke(fill_color, styling._stroke_width);
+    const auto marker = actsvg::style::marker{
+        styling._marker_type, styling._marker_size, fill, stroke};
+    p_landmark._marker = marker;
+}
+
 /// @brief Sets the style of the proto intersection record.
 template <typename point3_t>
 void apply_style(
@@ -186,9 +212,10 @@ void apply_style(
     const landmark_style& styling) {
     const auto fill_color = colors::pick_random(styling._fill_colors);
     const auto fill = actsvg::style::fill(fill_color);
-    const auto stroke = actsvg::style::stroke(fill_color, 3.f);
-    const auto marker =
-        actsvg::style::marker{"x", styling._marker_size, fill, stroke};
+    const auto stroke =
+        actsvg::style::stroke(fill_color, styling._stroke_width);
+    const auto marker = actsvg::style::marker{
+        styling._marker_type, styling._marker_size, fill, stroke};
     for (auto& p_landmark : p_intersection_record._landmarks) {
         p_landmark._marker = marker;
     }
@@ -203,6 +230,11 @@ void apply_style(meta::proto::trajectory<point3_t>& p_trajectory,
         actsvg::style::stroke(fill_color, styling._stroke_width);
 }
 
+/// @brief Sets the style of the proto grid.
+void apply_style(actsvg::proto::grid& p_grid, const grid_style& styling) {
+    p_grid._stroke._width = styling._stroke_width;
+}
+
 template <typename style1_t, typename style2_t>
 auto copy_fill_colors(style1_t target, const style2_t& reference) {
     target._fill_colors = reference._fill_colors;
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/utils/groups.hpp b/plugins/svgtools/include/detray/plugins/svgtools/utils/groups.hpp
new file mode 100644
index 000000000..70b047b06
--- /dev/null
+++ b/plugins/svgtools/include/detray/plugins/svgtools/utils/groups.hpp
@@ -0,0 +1,33 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Actsvg include(s)
+#include "actsvg/core.hpp"
+
+// System include(s)
+#include <string>
+#include <vector>
+
+namespace detray::svgtools::utils {
+
+template <typename iterator_t>
+auto group(const std::string& identification, const iterator_t& iterator) {
+    actsvg::svg::object ret;
+    ret._tag = "g";
+    ret._id = identification;
+    for (const auto& item : iterator) {
+        ret.add_object(item);
+    }
+    return ret;
+}
+
+auto group(const std::string& identification) {
+    return group(identification, std::vector<actsvg::svg::object>{});
+}
+}  // namespace detray::svgtools::utils
\ No newline at end of file
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/utils/intersection_utils.hpp b/plugins/svgtools/include/detray/plugins/svgtools/utils/intersection_utils.hpp
new file mode 100644
index 000000000..dfbcc564e
--- /dev/null
+++ b/plugins/svgtools/include/detray/plugins/svgtools/utils/intersection_utils.hpp
@@ -0,0 +1,29 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s)
+#include "detray/geometry/surface.hpp"
+#include "detray/intersection/intersection.hpp"
+
+namespace detray::svgtools::utils {
+
+/// @returns detray point of an intersection.
+template <typename detector_t>
+inline auto intersection_point(
+    const typename detector_t::geometry_context& context,
+    const detector_t& detector,
+    const detray::intersection2D<typename detector_t::surface_type,
+                                 typename detector_t::transform3>&
+        d_intersection) {
+    const typename detector_t::vector3 dir{};
+    const detray::surface surface{detector, d_intersection.sf_desc};
+    return surface.local_to_global(context, d_intersection.local, dir);
+}
+
+}  // namespace detray::svgtools::utils
\ No newline at end of file
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/utils/volume_utils.hpp b/plugins/svgtools/include/detray/plugins/svgtools/utils/volume_utils.hpp
index 9b5bc4e1a..af08a6db2 100644
--- a/plugins/svgtools/include/detray/plugins/svgtools/utils/volume_utils.hpp
+++ b/plugins/svgtools/include/detray/plugins/svgtools/utils/volume_utils.hpp
@@ -23,4 +23,17 @@ auto surface_lookup(const detector_t& detector,
     }
     return descriptors;
 }
+
+template <typename detector_t, typename dindex>
+auto surface_indices(const detector_t& detector, const dindex volume_index) {
+    const auto d_volume =
+        detector.volume_by_index(static_cast<detray::dindex>(volume_index));
+    const auto descriptors = surface_lookup(detector, d_volume);
+    std::vector<dindex> ret;
+    for (const auto& desc : descriptors) {
+        ret.push_back(desc.index());
+    }
+    return ret;
+}
+
 }  // namespace detray::svgtools::utils
diff --git a/tests/unit_tests/svgtools/CMakeLists.txt b/tests/unit_tests/svgtools/CMakeLists.txt
index 1c6f7be92..b68ade4e3 100644
--- a/tests/unit_tests/svgtools/CMakeLists.txt
+++ b/tests/unit_tests/svgtools/CMakeLists.txt
@@ -36,3 +36,15 @@ detray_add_test( svgtools_intersections
 detray_add_test( svgtools_trajectories
    "trajectories.cpp"
    LINK_LIBRARIES GTest::gtest_main detray_tests_common detray::core_array actsvg::core actsvg::meta detray::svgtools)
+
+detray_add_test( svgtools_grids
+   "grids.cpp"
+   LINK_LIBRARIES GTest::gtest_main detray_tests_common detray::core_array actsvg::core actsvg::meta detray::svgtools)
+
+detray_add_test( svgtools_land_marks
+   "landmarks.cpp"
+   LINK_LIBRARIES GTest::gtest_main detray_tests_common detray::core_array actsvg::core actsvg::meta detray::svgtools)
+
+detray_add_test( svgtools_web
+   "web.cpp"
+   LINK_LIBRARIES GTest::gtest_main detray_tests_common detray::core_array actsvg::core actsvg::meta detray::svgtools actsvg::web)
diff --git a/tests/unit_tests/svgtools/detectors.cpp b/tests/unit_tests/svgtools/detectors.cpp
index 527913df3..26a9c10f8 100644
--- a/tests/unit_tests/svgtools/detectors.cpp
+++ b/tests/unit_tests/svgtools/detectors.cpp
@@ -36,22 +36,22 @@ int main(int, char**) {
     const actsvg::views::z_r zr;
 
     // Creating the detector and geomentry context.
-    using toy_detector_t = detray::detector<detray::toy_metadata>;
     vecmem::host_memory_resource host_mr;
     const auto [det, names] = detray::create_toy_geometry(host_mr);
-    toy_detector_t::geometry_context context{};
+    using detector_t = decltype(det);
+    detector_t::geometry_context context{};
 
     // Creating the svg generator for the detector.
-    detray::svgtools::illustrator il{det, names, true};
+    detray::svgtools::illustrator il{det, context};
 
     // Get the svg of the toy detetector in x-y view.
-    const auto svg_xy = il.draw_detector("detector_xy", context, xy);
+    const auto svg_xy = il.draw_detector("detector_xy", xy);
     // Write the svg of toy detector.
     detray::svgtools::write_svg("test_svgtools_detector_xy.svg",
                                 {xy_axis, svg_xy});
 
     // Get the svg of the toy detetector in z-r view.
-    const auto svg_zr = il.draw_detector("detector_zr", context, zr);
+    const auto svg_zr = il.draw_detector("detector_zr", zr);
     // Write the svg of toy detector in z-r view
     detray::svgtools::write_svg("test_svgtools_detector_zr.svg",
                                 {zr_axis, svg_zr});
diff --git a/tests/unit_tests/svgtools/grids.cpp b/tests/unit_tests/svgtools/grids.cpp
new file mode 100644
index 000000000..f2e9daa52
--- /dev/null
+++ b/tests/unit_tests/svgtools/grids.cpp
@@ -0,0 +1,56 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+// Project include(s)
+#include "detray/core/detector.hpp"
+#include "detray/detectors/create_toy_geometry.hpp"
+#include "detray/plugins/svgtools/illustrator.hpp"
+#include "detray/plugins/svgtools/writer.hpp"
+
+// Vecmem include(s)
+#include <vecmem/memory/host_memory_resource.hpp>
+
+int main(int, char**) {
+
+    // This test creates the visualization using the illustrator class.
+    // However, for full control over the process, it is also possible to use
+    // the tools in svgstools::conversion, svgstools::display, and
+    // actsvg::display by converting the object to a proto object, optionally
+    // styling it, and then displaying it.
+
+    // Creating the detector and geomentry context.
+    vecmem::host_memory_resource host_mr;
+    const auto [det, names] = detray::create_toy_geometry(host_mr);
+    using detector_t = decltype(det);
+    detector_t::geometry_context context{};
+
+    // Creating the view.
+    const actsvg::views::x_y view;
+
+    // Creating the svg generator for the detector.
+    detray::svgtools::illustrator il{det, context, true};
+
+    // In this example we want to draw the grids of the volumes with indices 0,
+    // 1, ... in the detector.
+    std::vector<std::size_t> indices = {
+        0UL,  1UL,  2UL,  3UL,  4UL,  5UL,  6UL,  7UL,  8UL,  9UL,
+        10UL, 11UL, 12UL, 13UL, 14UL, 15UL, 16UL, 17UL, 18UL, 19UL};
+
+    for (const auto i : indices) {
+        std::string name = "volume" + std::to_string(i) + "_grid";
+        // Draw the grid for volume i.
+        if (auto grid_svg_ptr = il.draw_grid(name, i, view)) {
+            // Draw volume i.
+            const auto volume_svg = il.draw_volume("volume", i, view);
+            // Write volume i and its grid
+            // (the grid is last in the list since we want it to be displayed on
+            // top of the volume).
+            detray::svgtools::write_svg(name + ".svg",
+                                        {volume_svg, *grid_svg_ptr});
+        }
+    }
+}
\ No newline at end of file
diff --git a/tests/unit_tests/svgtools/groups.cpp b/tests/unit_tests/svgtools/groups.cpp
index b540f945b..95cb21d7a 100644
--- a/tests/unit_tests/svgtools/groups.cpp
+++ b/tests/unit_tests/svgtools/groups.cpp
@@ -6,6 +6,8 @@
  */
 
 // Project include(s)
+#include "detray/plugins/svgtools/utils/groups.hpp"
+
 #include "detray/core/detector.hpp"
 #include "detray/detectors/create_toy_geometry.hpp"
 #include "detray/plugins/svgtools/illustrator.hpp"
@@ -32,44 +34,54 @@ int main(int, char**) {
     const actsvg::views::z_r zr;
 
     // Creating the detector and geomentry context.
-    using toy_detector_t = detray::detector<detray::toy_metadata>;
     vecmem::host_memory_resource host_mr;
     const auto [det, names] = detray::create_toy_geometry(host_mr);
-    toy_detector_t::geometry_context context{};
+    using detector_t = decltype(det);
+    detector_t::geometry_context context{};
 
     // Creating the svg generator for the detector.
-    const detray::svgtools::illustrator il{det, names};
+    const detray::svgtools::illustrator il{det, context};
 
     // Visualisation of a group of surfaces.
     const std::array surface_group_indices{1UL, 100UL, 10UL, 200UL};
 
-    const auto svg_surface_group_xy = il.draw_surfaces(
-        "my_surface_group1_xy", context, surface_group_indices, xy);
+    const auto svg_surface_group_xy =
+        il.draw_surfaces("my_surface_group1_xy", surface_group_indices, xy);
     detray::svgtools::write_svg("test_svgtools_surface_group_xy.svg",
                                 {axes, svg_surface_group_xy});
 
-    const auto svg_surface_group_zr = il.draw_surfaces(
-        "my_surface_group1_zr", context, surface_group_indices, zr);
+    const auto svg_surface_group_zr =
+        il.draw_surfaces("my_surface_group1_zr", surface_group_indices, zr);
     detray::svgtools::write_svg("test_svgtools_surface_group_zr.svg",
                                 {axes, svg_surface_group_zr});
 
     // Visualisation of a group of volumes.
     const std::array volume_group_indices{3UL, 5UL};
 
-    const auto svg_volume_group_xy = il.draw_volumes(
-        "my_volume_group1_xy", context, volume_group_indices, xy);
+    const auto svg_volume_group_xy =
+        il.draw_volumes("my_volume_group1_xy", volume_group_indices, xy);
     detray::svgtools::write_svg("test_svgtools_volume_group_xy.svg",
                                 {axes, svg_volume_group_xy});
 
-    const auto svg_volume_group_zr = il.draw_volumes(
-        "my_volume_group1_zr", context, volume_group_indices, zr);
+    const auto svg_volume_group_zr =
+        il.draw_volumes("my_volume_group1_zr", volume_group_indices, zr);
     detray::svgtools::write_svg("test_svgtools_volume_group_zr.svg",
                                 {axes, svg_volume_group_zr});
 
-    // Writing SVGs to a combined file.
-    // NOTE: The all svg object's identification must be unique in the
-    // file!
+    // We can also use the svgtools::utils to group actsvg::svg::objects into
+    // one.
+    auto svg_combined_group = detray::svgtools::utils::group("combined_group");
+    svg_combined_group.add_object(svg_surface_group_xy);
+    svg_combined_group.add_object(svg_volume_group_zr);
+
+    detray::svgtools::write_svg("test_svgtools_combined_group1.svg",
+                                {axes, svg_combined_group});
+
+    // Alternatively, this is equivalent to:
     detray::svgtools::write_svg(
-        "test_svgtools_volume_and_surface_group.svg",
+        "test_svgtools_combined_group2.svg",
         {axes, svg_surface_group_xy, svg_volume_group_zr});
+
+    // NOTE: The all svg object's identification must be unique in the
+    // file!
 }
diff --git a/tests/unit_tests/svgtools/intersections.cpp b/tests/unit_tests/svgtools/intersections.cpp
index 00efe6c5a..8c763b5d4 100644
--- a/tests/unit_tests/svgtools/intersections.cpp
+++ b/tests/unit_tests/svgtools/intersections.cpp
@@ -27,6 +27,12 @@
 
 int main(int, char**) {
 
+    // This test creates the visualization using the illustrator class.
+    // However, for full control over the process, it is also possible to use
+    // the tools in svgstools::conversion, svgstools::display, and
+    // actsvg::display by converting the object to a proto object, optionally
+    // styling it, and then displaying it.
+
     // Axes.
     const auto axes =
         actsvg::draw::x_y_axes("axes", {-250, 250}, {-250, 250},
@@ -36,16 +42,18 @@ int main(int, char**) {
     const actsvg::views::z_r view;
 
     // Creating the detector and geomentry context.
-    using detector_t = detray::detector<detray::toy_metadata>;
     vecmem::host_memory_resource host_mr;
     const auto [det, names] = detray::create_toy_geometry(host_mr);
+    using detector_t = decltype(det);
     detector_t::geometry_context context{};
 
     using transform3_t = typename detector_t::transform3;
 
-    // Svg for the detector.
-    const detray::svgtools::illustrator il{det, names};
-    const auto svg_det = il.draw_detector("detector", context, view);
+    // Creating the illustrator.
+    const detray::svgtools::illustrator il{det, context};
+
+    // Drawing the detector.
+    const auto svg_det = il.draw_detector("detector", view);
 
     // Creating the rays.
     using generator_t =
@@ -61,11 +69,14 @@ int main(int, char**) {
         const auto intersection_record =
             detray::particle_gun::shoot_particle(det, test_ray);
 
-        const std::string name = "record" + std::to_string(index);
+        const std::string name =
+            "test_svgtools_intersection_record" + std::to_string(index);
+
+        // Drawing the intersections.
         const auto svg_ir =
-            il.draw_intersections(name, context, intersection_record, view);
+            il.draw_intersections(name, intersection_record, view);
 
-        detray::svgtools::write_svg(name + ".svg", {svg_det, svg_ir});
+        detray::svgtools::write_svg(name + ".svg", {axes, svg_det, svg_ir});
 
         index++;
     }
diff --git a/tests/unit_tests/svgtools/landmarks.cpp b/tests/unit_tests/svgtools/landmarks.cpp
new file mode 100644
index 000000000..792e84c44
--- /dev/null
+++ b/tests/unit_tests/svgtools/landmarks.cpp
@@ -0,0 +1,53 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+// Project include(s)
+#include "detray/core/detector.hpp"
+#include "detray/detectors/create_toy_geometry.hpp"
+#include "detray/plugins/svgtools/illustrator.hpp"
+#include "detray/plugins/svgtools/writer.hpp"
+
+// Vecmem include(s)
+#include <vecmem/memory/host_memory_resource.hpp>
+
+// Actsvg include(s)
+#include "actsvg/core.hpp"
+
+// System include(s)
+#include <string>
+
+int main(int, char**) {
+
+    // Axes.
+    const auto axes =
+        actsvg::draw::x_y_axes("axes", {-250, 250}, {-250, 250},
+                               actsvg::style::stroke(), "axis1", "axis2");
+
+    // Creating the view.
+    const actsvg::views::x_y xy;
+    const actsvg::views::z_r zr;
+
+    // Creating the detector and geomentry context.
+    vecmem::host_memory_resource host_mr;
+    const auto [det, names] = detray::create_toy_geometry(host_mr);
+    using detector_t = decltype(det);
+    detector_t::geometry_context context{};
+
+    using point = typename detector_t::point3;
+
+    // Creating the illustrator class.
+    const detray::svgtools::illustrator il{det, context};
+
+    // Sometimes its useful to be able to just draw a point while debugging.
+    // For this the draw_landmark function is available.
+    const point test_point{100, 50, 20};
+
+    const auto svg_xy = il.draw_landmark("landmark", test_point, xy);
+    const auto svg_zr = il.draw_landmark("landmark", test_point, zr);
+    detray::svgtools::write_svg("test_svgtools_landmark.svg",
+                                {svg_xy, svg_zr, axes});
+}
\ No newline at end of file
diff --git a/tests/unit_tests/svgtools/masks.cpp b/tests/unit_tests/svgtools/masks.cpp
index 7b1d1b635..9b18c3251 100644
--- a/tests/unit_tests/svgtools/masks.cpp
+++ b/tests/unit_tests/svgtools/masks.cpp
@@ -25,8 +25,9 @@
 #include <string>
 
 int main(int, char**) {
+    // This tests demonstrate the different masks that can be visualized.
 
-    // Axes.
+    // Create the axes.
     const auto axes = actsvg::draw::x_y_axes("axes", {-250, 250}, {-250, 250},
                                              actsvg::style::stroke());
 
@@ -38,8 +39,9 @@ int main(int, char**) {
 
     const typename transform_t::vector3 tr{0.f, 150.f, 0.f};
     const typename toy_detector_t::transform3 transform(tr);
-    const actsvg::views::x_y view{};
+    const actsvg::views::z_phi view{};
 
+    // Visualize a 2D annulus.
     // e_min_r, e_max_r, e_min_phi_rel, e_max_phi_rel, e_average_phi, e_shift_x,
     // e_shift_y, e_size
     detray::mask<detray::annulus2D<>> ann2D{0u,  100.f, 200.f, -1.f,
@@ -51,6 +53,7 @@ int main(int, char**) {
     detray::svgtools::write_svg("test_svgtools_annulus2D.svg",
                                 {axes, ann2D_svg});
 
+    // Visualize a 2D cylinder.
     // e_r, e_n_half_z, e_p_half_z, e_size
     detray::mask<detray::cylinder2D<>> cyl2D{0u, 100.f, -10.f, 10.f};
     const auto cyl2D_proto =
@@ -60,6 +63,7 @@ int main(int, char**) {
     detray::svgtools::write_svg("test_svgtools_cylinder2D.svg",
                                 {axes, cyl2D_svg});
 
+    // Visualize a 2D rectangle.
     // e_half_x, e_half_y, e_size
     detray::mask<detray::rectangle2D<>> rec2D{0u, 100.f, 100.f};
     const auto rec2D_proto =
@@ -69,6 +73,7 @@ int main(int, char**) {
     detray::svgtools::write_svg("test_svgtools_rectangle2D.svg",
                                 {axes, rec2D_svg});
 
+    // Visualize a 2D ring.
     // e_inner_r, e_outer_r, e_size
     detray::mask<detray::ring2D<>> rin2D{0u, 50.f, 100.f};
     const auto rin2D_proto =
@@ -77,6 +82,7 @@ int main(int, char**) {
     const auto rin2D_svg = actsvg::display::surface("", rin2D_proto, view);
     detray::svgtools::write_svg("test_svgtools_ring2D.svg", {axes, rin2D_svg});
 
+    // Visualize a 2D trapezoid.
     // e_half_length_0, e_half_length_1, e_half_length_2, e_divisor, e_size
     detray::mask<detray::trapezoid2D<>> tra2D{0u, 100.f, 50.f, 200.f};
     const auto tra2D_proto =
@@ -86,6 +92,7 @@ int main(int, char**) {
     detray::svgtools::write_svg("test_svgtools_trapezoid2D.svg",
                                 {axes, tra2D_svg});
 
+    // Visualize a line.
     // e_cross_section, e_half_z
     detray::mask<detray::line<>> lin2D{0u, 1.f, 100.f};
     const auto lin2D_proto =
diff --git a/tests/unit_tests/svgtools/surfaces.cpp b/tests/unit_tests/svgtools/surfaces.cpp
index b0be55ca9..457464fd1 100644
--- a/tests/unit_tests/svgtools/surfaces.cpp
+++ b/tests/unit_tests/svgtools/surfaces.cpp
@@ -23,6 +23,12 @@
 
 int main(int, char**) {
 
+    // This test creates the visualization using the illustrator class.
+    // However, for full control over the process, it is also possible to use
+    // the tools in svgstools::conversion, svgstools::display, and
+    // actsvg::display by converting the object to a proto object, optionally
+    // styling it, and then displaying it.
+
     // Axes.
     const auto axes = actsvg::draw::x_y_axes("axes", {-250, 250}, {-250, 250},
                                              actsvg::style::stroke());
@@ -32,23 +38,23 @@ int main(int, char**) {
     const actsvg::views::z_r zr;
 
     // Creating the detector and geomentry context.
-    using toy_detector_t = detray::detector<detray::toy_metadata>;
     vecmem::host_memory_resource host_mr;
     const auto [det, names] = detray::create_toy_geometry(host_mr);
-    toy_detector_t::geometry_context context{};
+    using detector_t = decltype(det);
+    detector_t::geometry_context context{};
 
     // Creating the svg generator for the detector.
-    const detray::svgtools::illustrator il{det, names};
+    const detray::svgtools::illustrator il{det, context};
 
     // Indexes of the surfaces in the detector to be visualized.
-    std::array indices{0UL, 1UL, 2UL, 3UL};
+    std::array indices{200UL, 201UL, 202UL, 203UL, 204UL};
 
     for (std::size_t i : indices) {
         std::string name = "test_svgtools_surface" + std::to_string(i);
-        // Visualization of portal i:
-        const auto svg_xy = il.draw_surface(name, context, i, xy);
+        // Visualization of surface/portal i:
+        const auto svg_xy = il.draw_surface(name, i, xy);
         detray::svgtools::write_svg(name + "_xy.svg", {axes, svg_xy});
-        const auto svg_zr = il.draw_surface(name, context, i, zr);
+        const auto svg_zr = il.draw_surface(name, i, zr);
         detray::svgtools::write_svg(name + "_zr.svg", {axes, svg_zr});
     }
 }
diff --git a/tests/unit_tests/svgtools/trajectories.cpp b/tests/unit_tests/svgtools/trajectories.cpp
index 96bcfeba7..11dd009a5 100644
--- a/tests/unit_tests/svgtools/trajectories.cpp
+++ b/tests/unit_tests/svgtools/trajectories.cpp
@@ -27,50 +27,68 @@
 
 int main(int, char**) {
 
-    // Axes.
+    // This test creates the visualization using the illustrator class.
+    // However, for full control over the process, it is also possible to use
+    // the tools in svgstools::conversion, svgstools::display, and
+    // actsvg::display by converting the object to a proto object, optionally
+    // styling it, and then displaying it.
+
+    // Creating the axes.
     const auto axes =
         actsvg::draw::x_y_axes("axes", {-250, 250}, {-250, 250},
                                actsvg::style::stroke(), "axis1", "axis2");
 
     // Creating the view.
-    const actsvg::views::z_r view;
+    const actsvg::views::x_y view;
 
     // Creating the detector and geomentry context.
-    using detector_t = detray::detector<detray::toy_metadata>;
     vecmem::host_memory_resource host_mr;
     const auto [det, names] = detray::create_toy_geometry(host_mr);
+    using detector_t = decltype(det);
     detector_t::geometry_context context{};
 
-    // Svg for the detector.
-    const detray::svgtools::illustrator il{det, names};
-    const auto svg_det = il.draw_detector("detector", context, view);
+    // Creating the illustrator.
+    const detray::svgtools::illustrator il{det, context, true};
+
+    // Show the relevant volumes in the detector.
+    const auto svg_volumes =
+        il.draw_volumes("detector", std::vector{7UL, 9UL, 11UL, 13UL}, view);
 
-    // Creating the rays.
+    // Creating a ray.
     using transform3_t = typename detector_t::transform3;
     using vector3 = typename detector_t::vector3;
 
-    const typename detector_t::point3 ori{0.f, 0.f, 100.f};
+    const typename detector_t::point3 ori{0.f, 0.f, 80.f};
     const typename detector_t::point3 dir{0, 1, 1};
 
     const detray::detail::ray<transform3_t> ray(ori, 0.f, dir, 0.f);
     const auto ray_ir = detray::particle_gun::shoot_particle(det, ray);
 
+    // Draw the trajectory.
     const auto svg_ray = il.draw_trajectory("trajectory", ray, view);
-    const auto svg_ray_ir =
-        il.draw_intersections("record", context, ray_ir, view);
-    detray::svgtools::write_svg("ray.svg", {svg_det, svg_ray, svg_ray_ir});
+
+    // Draw the intersections.
+    const auto svg_ray_ir = il.draw_intersections("record", ray_ir, view);
+
+    detray::svgtools::write_svg("test_svgtools_ray.svg",
+                                {svg_volumes, svg_ray, svg_ray_ir});
+
+    // Creating a helix trajectory.
 
     // Constant magnetic field
-    vector3 B{1.f * detray::unit<detray::scalar>::T,
-              1.f * detray::unit<detray::scalar>::T,
+    vector3 B{0.f * detray::unit<detray::scalar>::T,
+              0.f * detray::unit<detray::scalar>::T,
               1.f * detray::unit<detray::scalar>::T};
 
-    const detray::detail::helix<transform3_t> helix(ori, 0.f, dir, -500.f, &B);
+    const detray::detail::helix<transform3_t> helix(ori, 0.f, dir, -8.f, &B);
     const auto helix_ir = detray::particle_gun::shoot_particle(det, helix);
 
+    // Draw the trajectory.
     const auto svg_helix = il.draw_trajectory("trajectory", helix, view);
-    const auto svg_helix_ir =
-        il.draw_intersections("record", context, helix_ir, view);
-    detray::svgtools::write_svg("helix.svg",
-                                {svg_det, svg_helix, svg_helix_ir});
+
+    // Draw the intersections.
+    const auto svg_helix_ir = il.draw_intersections("record", helix_ir, view);
+
+    detray::svgtools::write_svg("test_svgtools_helix.svg",
+                                {svg_volumes, svg_helix, svg_helix_ir});
 }
\ No newline at end of file
diff --git a/tests/unit_tests/svgtools/volumes.cpp b/tests/unit_tests/svgtools/volumes.cpp
index 4c5050f28..22325eb10 100644
--- a/tests/unit_tests/svgtools/volumes.cpp
+++ b/tests/unit_tests/svgtools/volumes.cpp
@@ -23,6 +23,12 @@
 
 int main(int, char**) {
 
+    // This test creates the visualization using the illustrator class.
+    // However, for full control over the process, it is also possible to use
+    // the tools in svgstools::conversion, svgstools::display, and
+    // actsvg::display by converting the object to a proto object, optionally
+    // styling it, and then displaying it.
+
     // Axes.
     const auto axes = actsvg::draw::x_y_axes("axes", {-250, 250}, {-250, 250},
                                              actsvg::style::stroke());
@@ -32,22 +38,24 @@ int main(int, char**) {
     const actsvg::views::z_r zr;
 
     // Creating the detector and geomentry context.
-    using toy_detector_t = detray::detector<detray::toy_metadata>;
     vecmem::host_memory_resource host_mr;
     const auto [det, names] = detray::create_toy_geometry(host_mr);
-    toy_detector_t::geometry_context context{};
+    using detector_t = decltype(det);
+    detector_t::geometry_context context{};
 
     // Creating the svg generator for the detector.
-    const detray::svgtools::illustrator il{det, names};
+    const detray::svgtools::illustrator il{det, context};
 
     // Indexes of the volumes in the detector to be visualized.
-    std::array indices{0UL, 1UL, 2UL, 3UL};
+    std::array indices{0UL,  1UL,  2UL,  3UL,  4UL,  5UL,  6UL,
+                       7UL,  8UL,  9UL,  10UL, 11UL, 12UL, 13UL,
+                       14UL, 15UL, 16UL, 17UL, 18UL, 19UL};
     for (std::size_t i : indices) {
         std::string name = "test_svgtools_volume" + std::to_string(i);
         // Visualization of volume i:
-        const auto svg_xy = il.draw_volume(name, context, i, xy);
+        const auto svg_xy = il.draw_volume(name, i, xy);
         detray::svgtools::write_svg(name + "_xy.svg", {axes, svg_xy});
-        const auto svg_zr = il.draw_volume(name, context, i, zr);
+        const auto svg_zr = il.draw_volume(name, i, zr);
         detray::svgtools::write_svg(name + "_zr.svg", {axes, svg_zr});
     }
 }
diff --git a/tests/unit_tests/svgtools/web.cpp b/tests/unit_tests/svgtools/web.cpp
new file mode 100644
index 000000000..5223d16b7
--- /dev/null
+++ b/tests/unit_tests/svgtools/web.cpp
@@ -0,0 +1,131 @@
+/** Detray library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+// Project include(s)
+#include "detray/core/detector.hpp"
+#include "detray/detectors/create_toy_geometry.hpp"
+#include "detray/intersection/detail/trajectories.hpp"
+#include "detray/plugins/svgtools/illustrator.hpp"
+#include "detray/plugins/svgtools/utils/groups.hpp"
+#include "detray/plugins/svgtools/writer.hpp"
+#include "tests/common/tools/particle_gun.hpp"
+
+// Vecmem include(s)
+#include <vecmem/memory/host_memory_resource.hpp>
+
+// Actsvg include(s)
+#include "actsvg/core.hpp"
+#include "actsvg/web/web_builder.hpp"
+
+// System include(s)
+#include <array>
+#include <filesystem>
+#include <string>
+
+int main(int, char**) {
+
+    // In this test we will create a web page to show the detector geometry and
+    // more. We will start by creating the svgs we want to include in the web
+    // page.
+
+    // Axes.
+    const auto axes = actsvg::draw::x_y_axes("axes", {-250, 250}, {-250, 250},
+                                             actsvg::style::stroke());
+
+    // Creating the views.
+    const actsvg::views::x_y view;
+
+    // Creating the detector and geomentry context.
+    vecmem::host_memory_resource host_mr;
+    const auto [det, names] = detray::create_toy_geometry(host_mr);
+    using detector_t = decltype(det);
+    detector_t::geometry_context context{};
+
+    using transform3_t = typename detector_t::transform3;
+    using vector3 = typename detector_t::vector3;
+
+    // Creating the svg generator for the detector.
+    const detray::svgtools::illustrator il{det, context};
+
+    // The vector of svgs that we want to include on the webpage.
+    std::vector<actsvg::svg::object> svgs;
+
+    // Indexes of the volumes in the detector to be visualized.
+    std::array indices{0UL,  1UL,  2UL,  3UL,  4UL,  5UL,  6UL,
+                       7UL,  8UL,  9UL,  10UL, 11UL, 12UL, 13UL,
+                       14UL, 15UL, 16UL, 17UL, 18UL, 19UL};
+
+    // Draw the volumes and include them in the svg vector.
+    for (std::size_t i : indices) {
+        std::string name = "Volume_" + std::to_string(i);
+        const auto svg = il.draw_volume(name, i, view);
+        svgs.push_back(svg);
+    }
+
+    // Draw the grids and include them in the svg vector.
+    for (const auto i : indices) {
+        std::string name = "Grid_" + std::to_string(i);
+        if (auto svg_ptr = il.draw_grid(name, i, view)) {
+            svgs.push_back(*svg_ptr);
+        }
+    }
+
+    // Draw some example trajectories and include them in the svg vector (along
+    // with their intersections).
+    for (const auto qop : std::vector{-4, -8, -16}) {
+        std::string name = "Helix_qop_" + std::to_string(qop) + ")";
+
+        const typename detector_t::point3 ori{0.f, 0.f, 80.f};
+        const typename detector_t::point3 dir{0.f, 1.f, 1.f};
+
+        // Create the helix trajectory.
+        // Constant magnetic field
+        vector3 B{0.f * detray::unit<detray::scalar>::T,
+                  0.f * detray::unit<detray::scalar>::T,
+                  1.f * detray::unit<detray::scalar>::T};
+
+        const detray::detail::helix<transform3_t> helix(
+            ori, 0.f, dir, static_cast<float>(qop), &B);
+        const auto helix_ir = detray::particle_gun::shoot_particle(det, helix);
+
+        // Draw the helix trajectory.
+        const auto svg_helix =
+            il.draw_trajectory(name + "_trajectory", helix, view);
+
+        // Draw the intersection record.
+        const auto svg_helix_ir =
+            il.draw_intersections(name + "_record", helix_ir, view);
+
+        // We one the trajectory and intersection record to be considered as one
+        // svg. Thus we group them together before adding the group to the svg
+        // vector.
+        const auto svg_group = detray::svgtools::utils::group(
+            name, std::vector{svg_helix, svg_helix_ir});
+        svgs.push_back(svg_group);
+    }
+
+    // The output directory for the web page.
+    const auto current_directory = std::filesystem::current_path();
+
+    // Create the web page builder.
+    actsvg::web::web_builder builder{};
+
+    // To visualize the svg objects in a specific order we need to pass a
+    // comparator before we build the page. For instance we might want to
+    // display helices on top on the volumes (rather than the other way around).
+    // In this example we will alphanumeric_compare which renderes the svgs such
+    // that the id of the svg object with the greatest id alphanumerically will
+    // be displayed on top. Build the web page.
+    auto alphanum_cmp = actsvg::web::compare::alphanumeric;
+    builder.build(current_directory / "test_svgtools_website", svgs,
+                  alphanum_cmp);
+
+    // Once the direcroy has been created, run the server using "python3 -m
+    // http.server" in the directory. Subsequently connect to localhost using
+    // the respective port. On the web page, click and drag to move the view
+    // box. Use the scroll wheel to zoom.
+}